Interface: AsyncDIContainer<S>

Defined in: src/async-container.ts:108

A container for async services: every dependency is awaited before a factory runs, so factories receive resolved values, and every resolution (get, call, injecute) returns a promise.

Its service types are the resolved types: a factory returning Promise<Pool> registers Pool, dependents receive a Pool, and get() returns Promise<Pool>. Singletons are created once, also under concurrent get() calls; a failed creation is retried on the next resolution; dispose() releases the resolved instances.

Modules for it take an AsyncServiceRegistry; hand an AsyncServiceProvider to code that only resolves services. The sync ServiceRegistry / ServiceProvider types don't accept it, because their get() returns values, not promises.

Example

import { AsyncDIContainer } from 'injecute';

const app = new AsyncDIContainer()
  .addSingleton('config', () => loadConfig()) // Promise<Config> → Config
  .addSingleton('db', (config) => connect(config.dbUrl), ['config']) // receives a Config
  .addSingleton('users', UserRepository, ['db']);

const users = await app.get('users'); // UserRepository
await app.dispose();

Extends

• AsyncServiceRegistry<{ }, S>

Type Parameters

S

S extends object = { }

Properties

keys

readonly keys: readonly ServiceKey[]

Defined in: src/types.ts:686

Keys visible from this container, including its parents'.

Inherited from

AsyncServiceRegistry.keys

---

ownKeys

readonly ownKeys: readonly ServiceKey[]

Defined in: src/types.ts:689

Keys registered in this container.

Inherited from

AsyncServiceRegistry.ownKeys

Methods

[asyncDispose]()

[asyncDispose](): Promise<void>

Defined in: src/async-container.ts:234

Same as dispose(); enables await using container = ….

Returns

Promise<void>

---

addAlias()

addAlias<K, T, R>(key, target, options?): AsyncDIContainer<Registered<S, { [P in ServiceKey]: ResolveDependency<T, {}, S> }, R>>

Defined in: src/async-container.ts:149

Makes key resolve to the service registered under target.

Type Parameters

K

K extends ServiceKey

T

T extends string | number | symbol

R

R extends boolean = false

Parameters

key

K

target

T

options?

AliasOptions<R>

Returns

AsyncDIContainer<Registered<S, { [P in ServiceKey]: ResolveDependency<T, {}, S> }, R>>

Overrides

AsyncServiceRegistry.addAlias

---

addEventListener()

addEventListener<E>(event, handler): this

Defined in: src/async-container.ts:208

Subscribes to container events. In an async container the value of get and produce events may be a promise.

Type Parameters

E

E extends keyof ContainerEvents

Parameters

event

E

handler

(event) => void

Returns

this

---

addInstance()

addInstance<K, T, R>(key, value, options?): AsyncDIContainer<Registered<S, { [P in ServiceKey]: Awaited<T> }, R>>

Defined in: src/async-container.ts:137

Registers an existing value (or a promise of it).

Type Parameters

K

K extends ServiceKey

T

T extends unknown

R

R extends boolean = false

Parameters

key

K

value

T

options?

InstanceOptions<Awaited<T>, R>

Returns

AsyncDIContainer<Registered<S, { [P in ServiceKey]: Awaited<T> }, R>>

Overrides

AsyncServiceRegistry.addInstance

---

addSingleton()

addSingleton<K, F, D, R>(key, factory, dependencies?): AsyncDIContainer<Registered<S, { [P in ServiceKey]: Awaited<Produced<F>> }, R>>

Defined in: src/async-container.ts:111

Registers a service created once and cached. The factory receives resolved dependencies and may return a promise; the service type is the resolved value.

Type Parameters

K

K extends ServiceKey

F

F extends Factory<D, { }, S, AsyncExpectedService<K>>

D

D extends Dependency<{ }, S>[] = []

R

R extends boolean = false

Parameters

key

K

factory

F

dependencies?

[...D[]] | SingletonFactoryOptions<[...D[]], F, R>

Returns

AsyncDIContainer<Registered<S, { [P in ServiceKey]: Awaited<Produced<F>> }, R>>

Overrides

AsyncServiceRegistry.addSingleton

---

addTransient()

addTransient<K, F, D, R>(key, factory, dependencies?): AsyncDIContainer<Registered<S, { [P in ServiceKey]: Awaited<Produced<F>> }, R>>

Defined in: src/async-container.ts:124

Registers a service created on every resolution.

Type Parameters

K

K extends ServiceKey

F

F extends Factory<D, { }, S, AsyncExpectedService<K>>

D

D extends Dependency<{ }, S>[] = []

R

R extends boolean = false

Parameters

key

K

factory

F

dependencies?

[...D[]] | RegistrationOptions<[...D[]], R>

Returns

AsyncDIContainer<Registered<S, { [P in ServiceKey]: Awaited<Produced<F>> }, R>>

Overrides

AsyncServiceRegistry.addTransient

---

bind()

bind<D, R>(dependencies, factory): () => Promise<Awaited<R>>

Defined in: src/types.ts:845

Returns a function that runs factory with resolved dependencies each time it is called.

Type Parameters

D

D extends Dependency<{ }, S>[]

R

R

Parameters

dependencies

[...D[]]

factory

((...args) => R) | (new (...args) => R)

Returns

() => Promise<Awaited<R>>

Inherited from

AsyncServiceRegistry.bind

---

call()

call<K>(key, args, thisArg?): Promise<Awaited<ReturnType<Extract<ServiceType<S, K>, (...args) => any>>>>

Defined in: src/types.ts:677

Resolves a function service and calls it with args.

Type Parameters

K

K extends string | number | symbol

Parameters

key

K | TaggedKey<any, K>

args

Parameters<Extract<ServiceType<S, K>, (...args) => any>>

thisArg?

unknown

Returns

Promise<Awaited<ReturnType<Extract<ServiceType<S, K>, (...args) => any>>>>

Inherited from

AsyncServiceRegistry.call

---

createResolver()

createResolver<K>(key): () => Promise<ServiceType<S, K>>

Defined in: src/types.ts:672

Returns a function that resolves key when called.

Type Parameters

K

K extends string | number | symbol

Parameters

key

K | TaggedKey<any, K>

Returns

() => Promise<ServiceType<S, K>>

Inherited from

AsyncServiceRegistry.createResolver

---

dispose()

dispose(): Promise<void>

Defined in: src/async-container.ts:231

Disposes every instance this container owns, dependents first; see DIContainer.dispose().

Returns

Promise<void>

---

extend()

extend<EA, Req>(extension): AsyncDIContainer<S & { [K in string | number | symbol]: EA[K] }>

Defined in: src/async-container.ts:182

Applies a module function that registers services.

Type Parameters

EA

EA extends object

Req

Req extends object = S

Parameters

extension

[S] extends [Req] ? (registry) => AsyncServiceRegistry<any, EA> : object

Returns

AsyncDIContainer<S & { [K in string | number | symbol]: EA[K] }>

Overrides

AsyncServiceRegistry.extend

---

fork()

fork(options?): AsyncDIContainer<S>

Defined in: src/async-container.ts:225

Creates a child container; see DIContainer.fork(). Forks of an async container are async.

Parameters

options?

ForkOptions

Returns

AsyncDIContainer<S>

---

get()

get<K, O>(key, options?): Promise<O extends object ? ServiceType<S, K> | undefined : ServiceType<S, K>>

Defined in: src/types.ts:659

Resolves a service. Rejects when the key is not registered, unless { optional: true } is passed.

Type Parameters

K

K extends string | number | symbol

O

O extends GetOptions = { }

Parameters

key

K | TaggedKey<any, K>

options?

O

Returns

Promise<O extends object ? ServiceType<S, K> | undefined : ServiceType<S, K>>

Inherited from

AsyncServiceRegistry.get

---

getParent()

getParent(): AsyncServiceProvider<{ }> | undefined

Defined in: src/types.ts:692

The parent container (read-only view), if any.

Returns

AsyncServiceProvider<{ }> | undefined

Inherited from

AsyncServiceRegistry.getParent

---

getRegistration()

getRegistration(key): RegistrationInfo | undefined

Defined in: src/types.ts:695

Read-only metadata of the registration visible under key, or undefined.

Parameters

key

ServiceKey

Returns

RegistrationInfo | undefined

Inherited from

AsyncServiceRegistry.getRegistration

---

has()

has(key, options?): boolean

Defined in: src/types.ts:669

true when a service is registered under key (here or in a parent).

Parameters

key

ServiceKey

options?

HasOptions

Returns

boolean

Inherited from

AsyncServiceRegistry.has

---

injecute()

injecute<D, R>(factory, dependencies): Promise<Awaited<R>>

Defined in: src/types.ts:837

Runs a function (or class) with resolved dependencies, without registering it.

Type Parameters

D

D extends Dependency<{ }, S>[]

R

R

Parameters

factory

((...args) => R) | (new (...args) => R)

dependencies

[...D[]]

Returns

Promise<Awaited<R>>

Inherited from

AsyncServiceRegistry.injecute

---

namespace()

namespace<N, NA, Req>(name, extension): AsyncDIContainer<S & { [K in string | number | symbol]: AsyncNamespacedServices<N, NA>[K] }>

Defined in: src/async-container.ts:161

Registers the services added by extension under name.: name.key for each of them, and name for the namespace's provider. The extension receives a fork of this container.

Type Parameters

N

N extends string

NA

NA extends object

Req

Req extends object = S

Parameters

name

N

extension

[S] extends [Req] ? (registry) => AsyncServiceRegistry<any, NA> : object

Returns

AsyncDIContainer<S & { [K in string | number | symbol]: AsyncNamespacedServices<N, NA>[K] }>

Overrides

AsyncServiceRegistry.namespace

---

removeEventListener()

removeEventListener<E>(event, handler): this

Defined in: src/async-container.ts:214

Removes a listener added with addEventListener().

Type Parameters

E

E extends keyof ContainerEvents

Parameters

event

E

handler

(event) => void

Returns

this

---

reset()

reset(options?): this

Defined in: src/async-container.ts:228

Clears cached instances (all, or keys), so the next resolution creates them again.

Parameters

options?

ResetOptions<S>

Returns

this

---

seal()

seal(): SealedAsyncDIContainer<{ [K in string | number | symbol]: S[K] }>

Defined in: src/async-container.ts:222

Seals the container: no more registrations in it; forks stay open. See DIContainer.seal().

Returns

SealedAsyncDIContainer<{ [K in string | number | symbol]: S[K] }>

---

unuse()

unuse(middleware): this

Defined in: src/async-container.ts:202

Removes a middleware added with use().

Parameters

middleware

Middleware

Returns

this

---

use()

use(middleware): this

Defined in: src/async-container.ts:199

Adds a middleware around every resolution started from this container and its forks. In an async container next() may return a promise (for services created by a factory).

Parameters

middleware

Middleware

Returns

this