awilixify 2.2.1 → 3.0.0

package/dist/lib/di/processors/lifecycle-processor.js

@@ -0,0 +1,178 @@
+import * as Awilix from "awilix";
+import * as ERRORS from "../errors.js";
+import * as GUARGS from "../type-guards.js";
+export class LifecycleProcessor {
+    providerOptions;
+    eagerProviderRefs = [];
+    initializerTasks = [];
+    createdScopes = [];
+    initPromise;
+    disposePromise;
+    constructor(providerOptions) {
+        this.providerOptions = providerOptions;
+    }
+    collectEagerProviders(m, scope) {
+        for (const key of this.getEagerProviderKeys(m)) {
+            this.eagerProviderRefs.push({
+                module: m,
+                scope,
+                key,
+            });
+        }
+    }
+    trackScope(scope) {
+        this.createdScopes.push(scope);
+    }
+    addInitializerTask(task) {
+        if (!task)
+            return;
+        this.initializerTasks.push(task);
+    }
+    init(options) {
+        this.initPromise ??= this.executeInit(options);
+        return this.initPromise;
+    }
+    dispose() {
+        this.disposePromise ??= this.executeDispose();
+        return this.disposePromise;
+    }
+    async executeInit(options) {
+        const initializedProviders = [];
+        for (const { module, scope, key } of this.sortEagerProviderRefs()) {
+            this.ensureEagerProviderUsesSingletonLifetime(module, scope, key);
+            const instance = await this.resolveEagerProvider({
+                module,
+                scope,
+                key,
+            });
+            initializedProviders.push({ module, scope, key, instance });
+            await this.callProviderInitAsync(instance);
+        }
+        for (const initialize of this.initializerTasks) {
+            await initialize(options);
+        }
+        for (const { key, instance } of initializedProviders) {
+            if (this.shouldSkipProviderPostInit(key, options))
+                continue;
+            await this.callProviderPostInitAsync(instance);
+        }
+    }
+    async executeDispose() {
+        const uniqueScopes = Array.from(new Set(this.createdScopes)).reverse();
+        for (const scope of uniqueScopes) {
+            await scope.dispose();
+        }
+    }
+    shouldSkipProviderPostInit(key, options) {
+        if (options?.excludePostInit === true)
+            return true;
+        if (!Array.isArray(options?.excludePostInit))
+            return false;
+        return new Set(options.excludePostInit).has(key);
+    }
+    getEagerProviderKeys(m) {
+        return Object.entries(m.providers || {})
+            .filter(([, provider]) => GUARGS.isEagerProvider(provider))
+            .map(([key]) => key);
+    }
+    ensureEagerProviderUsesSingletonLifetime(m, scope, key) {
+        if (scope.registrations[key]?.lifetime !== Awilix.Lifetime.SINGLETON) {
+            throw new ERRORS.EagerProviderRequiresSingletonLifetimeError(m.name, key);
+        }
+    }
+    async resolveEagerProvider({ module, scope, key, }) {
+        const provider = module.providers?.[key];
+        if (!provider ||
+            !GUARGS.isFactoryProvider(provider) ||
+            !GUARGS.isAsyncFactoryProvider(provider)) {
+            return scope.resolve(key);
+        }
+        const factoryDeps = (provider.inject || []).map((dependencyKey) => scope.registrations[dependencyKey].resolve(scope));
+        const resolvedValue = await provider.useFactory(...factoryDeps);
+        const { eager, initAfter, inject, useFactory, ...providerResolverOptions } = provider;
+        const resolverOptions = {
+            ...this.providerOptions,
+            ...module.providerOptions,
+            ...providerResolverOptions,
+        };
+        scope.register({
+            [key]: Awilix.asFunction(() => resolvedValue, resolverOptions),
+        });
+        return scope.resolve(key);
+    }
+    async callProviderInitAsync(instance) {
+        if (!GUARGS.hasProviderInit(instance))
+            return;
+        await instance.init();
+    }
+    async callProviderPostInitAsync(instance) {
+        if (!GUARGS.hasProviderPostInit(instance))
+            return;
+        await instance.postInit();
+    }
+    sortEagerProviderRefs() {
+        const nodes = this.eagerProviderRefs.map((ref) => ({
+            ...ref,
+            id: LifecycleProcessor.createEagerProviderId(ref.module.name, ref.key),
+            initAfter: this.getProviderInitAfter(ref.module, ref.key),
+        }));
+        const nodeById = new Map(nodes.map((node) => [node.id, node]));
+        const nodeByKey = LifecycleProcessor.buildEagerProviderNodeKeyMap(nodes);
+        const graph = new Map(nodes.map((node) => [node.id, []]));
+        const inDegree = new Map(nodes.map((node) => [node.id, 0]));
+        for (const node of nodes) {
+            for (const dependencyKey of node.initAfter) {
+                const dependencyNode = nodeByKey.get(dependencyKey);
+                if (!dependencyNode) {
+                    throw new ERRORS.EagerProviderInitDependencyNotFoundError(node.module.name, node.key, dependencyKey);
+                }
+                const dependencies = graph.get(dependencyNode.id);
+                if (!dependencies)
+                    continue;
+                dependencies.push(node.id);
+                inDegree.set(node.id, (inDegree.get(node.id) || 0) + 1);
+            }
+        }
+        const sortedIds = this.sortEagerProviderIds(graph, inDegree);
+        if (sortedIds.length !== nodes.length) {
+            throw new ERRORS.CircularProviderInitDependencyError(nodes.map((node) => node.key));
+        }
+        return sortedIds.map((id) => {
+            const { module, scope, key } = nodeById.get(id);
+            return { module, scope, key };
+        });
+    }
+    getProviderInitAfter(module, key) {
+        const provider = module.providers?.[key];
+        if (!GUARGS.hasInitAfter(provider))
+            return [];
+        return [...provider.initAfter];
+    }
+    sortEagerProviderIds(graph, inDegree) {
+        const queue = Array.from(inDegree.entries())
+            .filter(([, degree]) => degree === 0)
+            .map(([id]) => id);
+        const sortedIds = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            sortedIds.push(current);
+            for (const dependent of graph.get(current) || []) {
+                const nextDegree = (inDegree.get(dependent) || 0) - 1;
+                inDegree.set(dependent, nextDegree);
+                if (nextDegree === 0)
+                    queue.push(dependent);
+            }
+        }
+        return sortedIds;
+    }
+    static buildEagerProviderNodeKeyMap(nodes) {
+        const nodeByKey = new Map();
+        for (const node of nodes) {
+            nodeByKey.set(node.key, node);
+        }
+        return nodeByKey;
+    }
+    static createEagerProviderId(moduleName, key) {
+        return `${moduleName}:${key}`;
+    }
+}

package/dist/lib/di/processors/overrides-processor.d.ts

@@ -0,0 +1,24 @@
+import type { AnyModuleOverride } from "../modules/module-overrides.js";
+import type { InternalModuleLike } from "../modules/runtime-module.types.js";
+export type OverrideOptions = {
+    moduleOverrides?: readonly AnyModuleOverride[];
+};
+export declare const FeatureKind: {
+    readonly Providers: "providers";
+    readonly QueryPreHandlers: "queryPreHandlers";
+    readonly CommandPreHandlers: "commandPreHandlers";
+    readonly Interceptors: "interceptors";
+    readonly Initializers: "initializers";
+};
+export declare class OverridesProcessor<M extends InternalModuleLike> {
+    private readonly options;
+    private readonly effectiveModuleMap;
+    private readonly appliedModuleOverrides;
+    constructor(options: OverrideOptions);
+    applyModuleOverrides(module: M): M;
+    getModuleWithOverrides(module: M): M;
+    ensureAllModuleOverridesApplied(): void;
+    private ensureModuleOverrideKeysExist;
+    private remapFeatureOverrides;
+    private ensureFeatureOverrideKeysExist;
+}

package/dist/lib/di/processors/overrides-processor.js

@@ -0,0 +1,69 @@
+import * as ERRORS from "../errors.js";
+export const FeatureKind = {
+    Providers: "providers",
+    QueryPreHandlers: "queryPreHandlers",
+    CommandPreHandlers: "commandPreHandlers",
+    Interceptors: "interceptors",
+    Initializers: "initializers",
+};
+const FEATURE_KINDS = Object.values(FeatureKind);
+export class OverridesProcessor {
+    options;
+    effectiveModuleMap = new WeakMap();
+    appliedModuleOverrides = new WeakSet();
+    constructor(options) {
+        this.options = options;
+    }
+    applyModuleOverrides(module) {
+        const moduleOverride = this.options.moduleOverrides?.find((override) => override.module === module);
+        if (!moduleOverride) {
+            this.effectiveModuleMap.set(module, module);
+            return module;
+        }
+        this.ensureModuleOverrideKeysExist(module, moduleOverride);
+        this.appliedModuleOverrides.add(module);
+        const remappedFeatures = FEATURE_KINDS.reduce((acc, featureKind) => {
+            Object.assign(acc, this.remapFeatureOverrides(module, moduleOverride, featureKind));
+            return acc;
+        }, {});
+        const effectiveModule = {
+            ...module,
+            ...remappedFeatures,
+        };
+        this.effectiveModuleMap.set(module, effectiveModule);
+        return effectiveModule;
+    }
+    getModuleWithOverrides(module) {
+        return this.effectiveModuleMap.get(module) ?? module;
+    }
+    ensureAllModuleOverridesApplied() {
+        for (const override of this.options.moduleOverrides ?? []) {
+            if (!this.appliedModuleOverrides.has(override.module)) {
+                throw new ERRORS.ModuleOverrideTargetNotFoundError(override.module.name);
+            }
+        }
+    }
+    ensureModuleOverrideKeysExist(module, moduleOverride) {
+        for (const featureKind of FEATURE_KINDS) {
+            this.ensureFeatureOverrideKeysExist(module, featureKind, moduleOverride.overrides[featureKind]);
+        }
+    }
+    remapFeatureOverrides(module, moduleOverride, featureKind) {
+        return {
+            [featureKind]: {
+                ...module[featureKind],
+                ...moduleOverride.overrides[featureKind],
+            },
+        };
+    }
+    ensureFeatureOverrideKeysExist(module, featureKind, overrides) {
+        if (!overrides)
+            return;
+        const featureKeys = new Set(Object.keys(module[featureKind] || {}));
+        for (const key of Object.keys(overrides)) {
+            if (!featureKeys.has(key)) {
+                throw new ERRORS.ModuleFeatureOverrideNotFoundError(module.name, featureKind, key);
+            }
+        }
+    }
+}

package/dist/lib/di/providers/basic-provider-resolver.d.ts

@@ -0,0 +1,35 @@
+import * as Awilix from "awilix";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { AnyProvider } from "./provider.types.js";
+export type ResolveProviderParams = {
+    key: string;
+    provider: AnyProvider;
+    resolutionScope: Awilix.AwilixContainer;
+    module: M;
+};
+export declare class BasicProviderResolver {
+    protected readonly providerOptions: Partial<Awilix.BuildResolverOptions<any>>;
+    constructor(providerOptions: Partial<Awilix.BuildResolverOptions<any>>);
+    static mergeResolverOptions(module: M, providerOptions: Partial<Awilix.BuildResolverOptions<any>>, options?: Partial<Awilix.BuildResolverOptions<any>>): Awilix.BuildResolverOptions<any>;
+    resolveProvider({ key, provider, resolutionScope, module, }: ResolveProviderParams): Awilix.Resolver<any>;
+    resolveProviderAsync({ key, provider, resolutionScope, module, }: ResolveProviderParams): Promise<Awilix.Resolver<any>>;
+    protected resolveConstructorProvider({ provider, resolverOptions, }: {
+        provider: Awilix.Constructor<any>;
+        resolverOptions: Awilix.BuildResolverOptions<any>;
+        module: M;
+    }): Awilix.Resolver<any>;
+    protected resolveUseClassProvider({ provider, resolverOptions, }: {
+        provider: Extract<AnyProvider, {
+            useClass: Awilix.Constructor<any>;
+        }>;
+        resolverOptions: Awilix.BuildResolverOptions<any>;
+        module: M;
+    }): Awilix.Resolver<any>;
+    protected resolveAsyncFactoryInSyncContext({ key, module, }: {
+        key: string;
+        provider: AnyProvider;
+        resolverOptions: Awilix.BuildResolverOptions<any>;
+        module: M;
+    }): Awilix.Resolver<any>;
+    protected extractResolverOptions(module: M, provider: AnyProvider): Awilix.BuildResolverOptions<any>;
+}

package/dist/lib/di/providers/basic-provider-resolver.js

@@ -0,0 +1,88 @@
+import * as Awilix from "awilix";
+import * as ERRORS from "../errors.js";
+import * as GUARGS from "../type-guards.js";
+export class BasicProviderResolver {
+    providerOptions;
+    constructor(providerOptions) {
+        this.providerOptions = providerOptions;
+    }
+    static mergeResolverOptions(module, providerOptions, options) {
+        return {
+            ...providerOptions,
+            ...module.providerOptions,
+            ...options,
+        };
+    }
+    resolveProvider({ key, provider, resolutionScope, module, }) {
+        if (GUARGS.isPrimitive(provider)) {
+            return Awilix.asValue(provider);
+        }
+        if (GUARGS.isPlainFunction(provider) &&
+            !GUARGS.isCostructorProvider(provider)) {
+            return Awilix.asValue(provider);
+        }
+        if (typeof provider === "object" &&
+            !GUARGS.isCostructorProvider(provider) &&
+            !GUARGS.isFactoryProvider(provider) &&
+            !GUARGS.hasUseClass(provider)) {
+            return Awilix.asValue(provider);
+        }
+        const resolverOptions = this.extractResolverOptions(module, provider);
+        if (GUARGS.isCostructorProvider(provider)) {
+            return this.resolveConstructorProvider({
+                provider,
+                resolverOptions,
+                module,
+            });
+        }
+        if (GUARGS.isFactoryProvider(provider)) {
+            if (GUARGS.isAsyncFactoryProvider(provider)) {
+                return this.resolveAsyncFactoryInSyncContext({
+                    key,
+                    provider,
+                    resolverOptions,
+                    module,
+                });
+            }
+            const factoryDeps = (provider.inject || []).map((dependencyKey) => resolutionScope.registrations[dependencyKey].resolve(resolutionScope));
+            return Awilix.asFunction(() => provider.useFactory(...factoryDeps), resolverOptions);
+        }
+        return this.resolveUseClassProvider({
+            provider,
+            resolverOptions,
+            module,
+        });
+    }
+    async resolveProviderAsync({ key, provider, resolutionScope, module, }) {
+        if (!GUARGS.isFactoryProvider(provider) ||
+            !GUARGS.isAsyncFactoryProvider(provider)) {
+            return this.resolveProvider({ provider, resolutionScope, module, key });
+        }
+        const resolverOptions = this.extractResolverOptions(module, provider);
+        if (resolverOptions.lifetime !== Awilix.Lifetime.SINGLETON) {
+            throw new ERRORS.AsyncFactoryRequiresSingletonLifetimeError(module.name, key);
+        }
+        const factoryDeps = (provider.inject || []).map((dependencyKey) => resolutionScope.registrations[dependencyKey].resolve(resolutionScope));
+        return Awilix.asValue(await provider.useFactory(...factoryDeps));
+    }
+    resolveConstructorProvider({ provider, resolverOptions, }) {
+        return Awilix.asClass(provider, resolverOptions);
+    }
+    resolveUseClassProvider({ provider, resolverOptions, }) {
+        return Awilix.asClass(provider.useClass, resolverOptions);
+    }
+    resolveAsyncFactoryInSyncContext({ key, module, }) {
+        throw new ERRORS.AsyncFactoryRequiresAsyncCreateError(module.name, key);
+    }
+    extractResolverOptions(module, provider) {
+        if (GUARGS.hasUseClass(provider)) {
+            const { useClass, allowCircular, eager, initAfter, ...options } = provider;
+            return BasicProviderResolver.mergeResolverOptions(module, this.providerOptions, options);
+        }
+        if (GUARGS.isFactoryProvider(provider)) {
+            const { eager, initAfter, inject, useFactory, ...options } = provider;
+            return BasicProviderResolver.mergeResolverOptions(module, this.providerOptions, options);
+        }
+        return BasicProviderResolver.mergeResolverOptions(module, this.providerOptions);
+    }
+}

package/dist/lib/di/providers/provider-dependency-sorter.d.ts

@@ -0,0 +1,9 @@
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+export declare class ProviderDependencySorter {
+    sortByDependencies(m: M): NonNullable<typeof m.providers>;
+    private initializeDepGraph;
+    private buildDepGraph;
+    private sortTopologically;
+    private initializeQueue;
+    private ensureNoCyclicDependencies;
+}

package/dist/lib/di/providers/provider-dependency-sorter.js

@@ -0,0 +1,76 @@
+import * as ERRORS from "../errors.js";
+import { isFactoryProvider, isForwardRef, isPromiseLike, } from "../type-guards.js";
+export class ProviderDependencySorter {
+    sortByDependencies(m) {
+        const depsGraph = this.buildDepGraph(m, this.initializeDepGraph(m));
+        const initialQueue = this.initializeQueue(depsGraph.inDegree);
+        const sortedKeys = this.sortTopologically(depsGraph, initialQueue);
+        this.ensureNoCyclicDependencies(m, sortedKeys);
+        return sortedKeys.reduce((acc, key) => {
+            const provider = m.providers?.[key];
+            if (provider !== undefined)
+                acc[key] = provider;
+            return acc;
+        }, {});
+    }
+    initializeDepGraph(m) {
+        return Object.keys(m.providers || {}).reduce((acc, curr) => {
+            acc.graph.set(curr, []);
+            acc.inDegree.set(curr, 0);
+            return acc;
+        }, {
+            graph: new Map(),
+            inDegree: new Map(),
+        });
+    }
+    buildDepGraph(m, depsGraph) {
+        const importedProviderKeys = new Set((m.imports || []).flatMap((importItem) => {
+            const importedModule = isForwardRef(importItem)
+                ? importItem.resolve()
+                : importItem;
+            if (isPromiseLike(importedModule)) {
+                throw new Error(`Async module import in "${m.name}" was not resolved before provider dependency sorting.`);
+            }
+            return importedModule.exports ? [...importedModule.exports] : [];
+        }));
+        return Object.entries(m.providers || {}).reduce((acc, [key, provider]) => {
+            if (!isFactoryProvider(provider) || !provider.inject)
+                return acc;
+            provider.inject.forEach((dep) => {
+                const depList = acc.graph.get(dep);
+                if (depList) {
+                    depList.push(key);
+                    acc.inDegree.set(key, (acc.inDegree.get(key) || 0) + 1);
+                    return;
+                }
+                if (!depList && !importedProviderKeys.has(dep)) {
+                    throw new ERRORS.DependencyNotFoundError(dep, m.name);
+                }
+            });
+            return acc;
+        }, { ...depsGraph });
+    }
+    sortTopologically(depsGraph, queue, result = []) {
+        const [current, ...restQueue] = queue;
+        if (!current)
+            return result;
+        const deps = depsGraph.graph.get(current) || [];
+        const inDegree = deps.reduce((acc, curr) => {
+            acc.set(curr, (acc.get(curr) || 0) - 1);
+            return acc;
+        }, new Map(depsGraph.inDegree));
+        return this.sortTopologically({ ...depsGraph, inDegree }, [...restQueue, ...deps.filter((dep) => inDegree.get(dep) === 0)], [...result, current]);
+    }
+    initializeQueue(inDegree) {
+        return Array.from(inDegree.entries())
+            .filter(([_, degree]) => degree === 0)
+            .map(([key]) => key);
+    }
+    ensureNoCyclicDependencies(m, sortedKeys) {
+        const providerKeys = Object.keys(m.providers || {});
+        if (sortedKeys.length !== providerKeys.length) {
+            const remaining = providerKeys.filter((key) => !sortedKeys.includes(key));
+            throw new ERRORS.CircularDependencyError(m.name, remaining);
+        }
+    }
+}

package/dist/lib/di/providers/provider-resolver.d.ts

@@ -0,0 +1,31 @@
+import * as Awilix from "awilix";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { InterceptorProcessor } from "../processors/interceptor-processor.js";
+import type { AnyProvider } from "./provider.types.js";
+export type RequestScopeResolver = (scope: Awilix.AwilixContainer) => Awilix.AwilixContainer;
+type ResolveProviderParams = {
+    key: string;
+    provider: AnyProvider;
+    resolutionScope: Awilix.AwilixContainer;
+    module: M;
+};
+type ResolveClassProviderParams = {
+    provider: unknown;
+    resolutionScope: Awilix.AwilixContainer;
+    module: M;
+    providerOptions?: Partial<Awilix.BuildResolverOptions<any>>;
+    wrapForExport?: boolean;
+};
+export declare class ProviderResolver {
+    private readonly interceptorProcessor;
+    private readonly providerOptions;
+    private readonly requestScopeResolver?;
+    constructor(interceptorProcessor: InterceptorProcessor | undefined, providerOptions: Partial<Awilix.BuildResolverOptions<any>>, requestScopeResolver?: RequestScopeResolver | undefined);
+    static mergeResolverOptions(module: M, providerOptions: Partial<Awilix.BuildResolverOptions<any>>, options?: Partial<Awilix.BuildResolverOptions<any>>): Awilix.BuildResolverOptions<any>;
+    resolveClassProvider({ provider, resolutionScope, module, wrapForExport, }: ResolveClassProviderParams): Awilix.Resolver<any>;
+    resolveProvider({ key, provider, resolutionScope, module, }: ResolveProviderParams): Awilix.Resolver<any>;
+    resolveProviderAsync({ key, provider, resolutionScope, module, }: ResolveProviderParams): Promise<Awilix.Resolver<any>>;
+    private extractResolverOptions;
+    private createProxyResolver;
+}
+export {};

package/dist/lib/di/providers/provider-resolver.js

@@ -0,0 +1,128 @@
+import * as Awilix from "awilix";
+import * as ERRORS from "../errors.js";
+import * as GUARGS from "../type-guards.js";
+export class ProviderResolver {
+    interceptorProcessor;
+    providerOptions;
+    requestScopeResolver;
+    constructor(interceptorProcessor, providerOptions, requestScopeResolver) {
+        this.interceptorProcessor = interceptorProcessor;
+        this.providerOptions = providerOptions;
+        this.requestScopeResolver = requestScopeResolver;
+    }
+    static mergeResolverOptions(module, providerOptions, options) {
+        return {
+            ...providerOptions,
+            ...module.providerOptions,
+            ...options,
+        };
+    }
+    resolveClassProvider({ provider, resolutionScope, module, wrapForExport, }) {
+        const { useClass, ...featureOptions } = GUARGS.hasUseClass(provider)
+            ? provider
+            : { useClass: provider };
+        const resolverOptions = {
+            ...this.providerOptions,
+            ...module.providerOptions,
+            ...featureOptions,
+        };
+        const resolver = Awilix.asClass(useClass, resolverOptions);
+        if (!wrapForExport)
+            return resolver;
+        return Awilix.asFunction(() => resolver.resolve(resolverOptions.lifetime === Awilix.Lifetime.SINGLETON
+            ? resolutionScope
+            : this.requestScopeResolver
+                ? this.requestScopeResolver(resolutionScope)
+                : resolutionScope), resolverOptions);
+    }
+    resolveProvider({ key, provider, resolutionScope, module, }) {
+        if (GUARGS.isPrimitive(provider)) {
+            return Awilix.asValue(provider);
+        }
+        if (GUARGS.isPlainFunction(provider) &&
+            !GUARGS.isCostructorProvider(provider)) {
+            return Awilix.asValue(provider);
+        }
+        if (typeof provider === "object" &&
+            !GUARGS.isCostructorProvider(provider) &&
+            !GUARGS.isFactoryProvider(provider) &&
+            !GUARGS.hasUseClass(provider)) {
+            return Awilix.asValue(provider);
+        }
+        const resolverOptions = this.extractResolverOptions(module, provider);
+        if (GUARGS.isCostructorProvider(provider)) {
+            if (!this.interceptorProcessor) {
+                return Awilix.asClass(provider, resolverOptions);
+            }
+            return this.interceptorProcessor.createInterceptedProviderResolver({
+                module,
+                useClass: provider,
+                options: resolverOptions,
+            });
+        }
+        if (GUARGS.isFactoryProvider(provider)) {
+            if (GUARGS.isAsyncFactoryProvider(provider)) {
+                if (GUARGS.isEagerProvider(provider)) {
+                    return Awilix.asFunction(() => {
+                        throw new ERRORS.AsyncEagerFactoryRequiresInitError(module.name, key ?? "unknown");
+                    }, resolverOptions);
+                }
+                throw new ERRORS.AsyncFactoryRequiresAsyncCreateError(module.name, key ?? "unknown");
+            }
+            const factoryDeps = (provider.inject || []).map((k) => resolutionScope.registrations[k].resolve(resolutionScope));
+            return Awilix.asFunction(() => provider.useFactory(...factoryDeps), resolverOptions);
+        }
+        const baseResolver = Awilix.asClass(provider.useClass, resolverOptions);
+        const classResolver = provider.allowCircular
+            ? this.createProxyResolver(baseResolver, resolverOptions)
+            : baseResolver;
+        if (!this.interceptorProcessor) {
+            return classResolver;
+        }
+        return this.interceptorProcessor.createInterceptedProviderResolver({
+            module,
+            useClass: provider.useClass,
+            options: resolverOptions,
+            resolver: classResolver,
+        });
+    }
+    async resolveProviderAsync({ key, provider, resolutionScope, module, }) {
+        if (!GUARGS.isFactoryProvider(provider) ||
+            !GUARGS.isAsyncFactoryProvider(provider)) {
+            return this.resolveProvider({ provider, resolutionScope, module, key });
+        }
+        const resolverOptions = this.extractResolverOptions(module, provider);
+        if (resolverOptions.lifetime !== Awilix.Lifetime.SINGLETON) {
+            throw new ERRORS.AsyncFactoryRequiresSingletonLifetimeError(module.name, key);
+        }
+        const factoryDeps = (provider.inject || []).map((k) => resolutionScope.registrations[k].resolve(resolutionScope));
+        return Awilix.asValue(await provider.useFactory(...factoryDeps));
+    }
+    extractResolverOptions(module, provider) {
+        if (GUARGS.hasUseClass(provider)) {
+            const { useClass, allowCircular, eager, initAfter, ...options } = provider;
+            return ProviderResolver.mergeResolverOptions(module, this.providerOptions, options);
+        }
+        if (GUARGS.isFactoryProvider(provider)) {
+            const { eager, initAfter, inject, useFactory, ...options } = provider;
+            return ProviderResolver.mergeResolverOptions(module, this.providerOptions, options);
+        }
+        return ProviderResolver.mergeResolverOptions(module, this.providerOptions);
+    }
+    createProxyResolver(resolver, options) {
+        return Awilix.createBuildResolver({
+            ...options,
+            resolve(container) {
+                let resolved = null;
+                return new Proxy({}, {
+                    get(_, name) {
+                        if (!resolved) {
+                            resolved = resolver.resolve(container);
+                        }
+                        return resolved[name];
+                    },
+                });
+            },
+        });
+    }
+}

package/dist/lib/di/providers/provider.types.d.ts

@@ -0,0 +1 @@
+export * from "./types/index.js";

package/dist/lib/di/providers/provider.types.js

@@ -0,0 +1 @@
+export * from "./types/index.js";

package/dist/lib/di/providers/types/controller.types.d.ts

@@ -0,0 +1,9 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+export type ConstructorController = Constructor<Controller>;
+export type ClassController = {
+    useClass: ConstructorController | Constructor<any>;
+} & BuildResolverOptions<any>;
+export type AnyController = ConstructorController | ClassController | Constructor<any>;
+export interface Controller {
+    registerRoutes: () => void;
+}

package/dist/lib/di/providers/types/controller.types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/di/providers/types/decorator-context.types.d.ts

@@ -0,0 +1,9 @@
+import type { DecoratorMethodState, DecoratorState, DecoratorToken, MethodName } from "../../../decorators/decorator-state.types.js";
+export type AnyDecoratorToken = DecoratorToken<DecoratorState<any, any>>;
+export type DecoratorExecutionContext<TToken extends AnyDecoratorToken = AnyDecoratorToken, TTarget extends object = object> = {
+    target: TTarget;
+    methodName: MethodName;
+    moduleName: string;
+    metadata: DecoratorMethodState<TToken["state"]>;
+    decoratorState: TToken["state"];
+};

package/dist/lib/di/providers/types/decorator-context.types.js

@@ -0,0 +1 @@
+export {};