awilix

constructor

constructor(
    name: string | symbol,
    resolutionStack: ResolutionStack,
    message?: string
);

• Constructor, takes the registered modules and unresolved tokens to create a message.

  Parameter name

  The name of the module that could not be resolved.

  Parameter resolutionStack

  The current resolution stack

constructor

constructor(
    funcDescription: string,
    paramName: string,
    expectedType: string,
    givenType: any
);

• Constructor, takes the function name, expected and given type to produce an error.

  Parameter funcDescription

  Name of the function being guarded.

  Parameter paramName

  The parameter there was an issue with.

  Parameter expectedType

  Name of the expected type.

  Parameter givenType

  Name of the given type.

method assert

static assert: <T>(
    condition: T,
    funcDescription: string,
    paramName: string,
    expectedType: string,
    givenType: any
) => NonNullable<T>;

• Asserts the given condition, throws an error otherwise.

  Parameter condition

  The condition to check

  Parameter funcDescription

  Name of the function being guarded.

  Parameter paramName

  The parameter there was an issue with.

  Parameter expectedType

  Name of the expected type.

  Parameter givenType

  Name of the given type.

constructor

constructor(message: string);

• Constructor for the error.

  Parameter message

  The error message.

property cache

readonly cache: Map<string | symbol, CacheEntry>;

• Resolved modules cache.

property cradle

readonly cradle: Cradle;

• The proxy injected when using PROXY injection mode. Can be used as-is.

property options

options: ContainerOptions;

• Options the container was configured with.

property registrations

readonly registrations: RegistrationHash;

• Getter for the rolled up registrations that merges the container family tree.

method build

build: <T>(
    targetOrResolver: ClassOrFunctionReturning<T> | Resolver<T>,
    opts?: BuildResolverOptions<T>
) => T;

• Given a resolver, class or function, builds it up and returns it. Does not cache it, this means that any lifetime configured in case of passing a resolver will not be used.

  Parameter targetOrResolver

  Parameter opts

method createScope

createScope: <T extends object = object>() => AwilixContainer<Cradle & T>;

• Creates a scoped container with this one as the parent.

method dispose

dispose: () => Promise<void>;

• Disposes this container and it's children, calling the disposer on all disposable registrations and clearing the cache. Only applies to registrations with SCOPED or SINGLETON lifetime.

method getRegistration

getRegistration: {
    <K extends keyof Cradle>(name: K): Resolver<Cradle[K]> | null;
    <T = unknown>(name: string | symbol): Resolver<T>;
};

• Recursively gets a registration by name if it exists in the current container or any of its' parents.

  Parameter name

  The registration name.

method hasRegistration

hasRegistration: (name: string | symbol) => boolean;

• Checks if the registration with the given name exists.

  Parameter name

  The name of the registration to resolve.

  {boolean} Whether or not the registration exists.

method inspect

inspect: (depth: number, opts?: any) => string;

• Used by util.inspect.

method loadModules

loadModules: <ESM extends boolean = false>(
    globPatterns: Array<string | GlobWithOptions>,
    options?: LoadModulesOptions<ESM>
) => ESM extends false ? this : Promise<this>;

• Binds lib/loadModules to this container, and provides real implementations of it's dependencies.

  Additionally, any modules using the dependsOn API will be resolved.

  See Also

  • src/load-modules.ts documentation.

method register

register: {
    <T>(name: string | symbol, registration: Resolver<T>): this;
    (nameAndRegistrationPair: NameAndRegistrationPair<Cradle>): this;
};

• Adds a single registration that using a pre-constructed resolver.

• Pairs resolvers to registration names and registers them.

method resolve

resolve: {
    <K extends keyof Cradle>(
        name: K,
        resolveOptions?: ResolveOptions
    ): Cradle[K];
    <T>(name: string | symbol, resolveOptions?: ResolveOptions): T;
};

• Resolves the registration with the given name.

  Parameter name

  The name of the registration to resolve.

  {*} Whatever was resolved.

property injectionMode

injectionMode?: InjectionModeType;

property injector

injector?: InjectorFunction;

method classic

classic: () => this;

method inject

inject: (injector: InjectorFunction) => this;

method proxy

proxy: () => this;

method scoped

scoped: () => this;

method setInjectionMode

setInjectionMode: (mode: InjectionModeType) => this;

method setLifetime

setLifetime: (lifetime: LifetimeType) => this;

method singleton

singleton: () => this;

method transient

transient: () => this;

property injectionMode

injectionMode?: InjectionModeType;

• Resolution mode.

property injector

injector?: InjectorFunction;

• Injector function to provide additional parameters.

property resolver

resolver: Resolver<T>;

• The resolver that resolved the value.

property value

value: T;

• The resolved value.

property injectionMode

injectionMode?: InjectionModeType;

property require

require?: (id: string) => any;

method disposer

disposer: (dispose: Disposer<T>) => this;

property dispose

dispose?: Disposer<T>;

property cwd

cwd?: string;

property glob

glob?: typeof glob.sync;

property name

name: string;

property opts

opts: any;

property path

path: string;

property allowUnregistered

allowUnregistered?: boolean;

• If true and resolve cannot find the requested dependency, returns undefined rather than throwing an error.

method resolve

resolve: <U extends object>(container: AwilixContainer<U>) => T;

property lifetime

lifetime?: LifetimeType;

• Lifetime setting.

property name

name?: string;

• Only used for inline configuration with loadModules.

property register

register?: (...args: any[]) => Resolver<T>;

• Registration function to use. Only used for inline configuration with loadModules.