awilixify 2.2.1 → 3.0.0

package/dist/lib/di/contexts/di-context-async.js

@@ -0,0 +1,112 @@
+import * as GUARGS from "../type-guards.js";
+import { DIContextBase } from "./di-context-base.js";
+export class AsyncDIContext extends DIContextBase {
+    moduleTreePromiseMap = new WeakMap();
+    constructor(options) {
+        super(options);
+    }
+    static async create(module, options) {
+        return new AsyncDIContext(options ?? {}).bootstrap(module);
+    }
+    async bootstrap(module) {
+        const rootModule = await module;
+        await this.initializeGlobalModulesAsync();
+        const moduleTree = await this.registerModuleWithScopeAsync(rootModule, this.createContainer(rootModule), []);
+        this.overridesProcessor.ensureAllModuleOverridesApplied();
+        return moduleTree;
+    }
+    async initializeGlobalModulesAsync() {
+        const globalModules = this.options.globalModules || [];
+        const globalModuleImports = (await Promise.all(globalModules.map(async (module) => (await this.resolveImportsAsync(module)).map((importedModule) => ({
+            module,
+            importedModule,
+        }))))).flat();
+        this.moduleGraphEnsurer.ensureGlobalModulesDoNotImportGlobalModules({
+            globalModules,
+            globalModuleImports,
+        });
+        this.globalModulesWithScope = [];
+        for (const module of globalModules) {
+            const moduleTree = await this.registerModuleWithScopeAsync(module, this.createContainer(module), []);
+            this.globalModulesWithScope.push({
+                module: this.overridesProcessor.getModuleWithOverrides(module),
+                moduleScope: moduleTree,
+            });
+        }
+    }
+    async registerModuleWithScopeAsync(m, scope, moduleChain) {
+        const existingTree = this.moduleTreeMap.get(m);
+        if (existingTree) {
+            return existingTree;
+        }
+        const imports = await this.resolveImportsAsync(m);
+        const moduleWithOverrides = this.overridesProcessor.applyModuleOverrides(m);
+        this.moduleGraphEnsurer.ensureImportedModulesUniqueness({
+            module: moduleWithOverrides,
+            resolvedImports: imports,
+            globalModules: this.globalModulesWithScope.map((el) => el.module),
+        });
+        this.moduleGraphEnsurer.ensureNoProviderNameConflicts({
+            module: moduleWithOverrides,
+            resolvedImports: imports,
+            globalModules: this.globalModulesWithScope.map((el) => el.module),
+            getExportedProviderKeys: (module) => this.getExportedProviderKeys(module),
+        });
+        this.markModuleIfImportsUseForwardRef(moduleWithOverrides);
+        const isCircular = moduleChain.includes(m);
+        if (isCircular) {
+            this.moduleGraphEnsurer.ensureCircularDependencyHasForwardRef({
+                module: m,
+                moduleChain,
+                forwardRefModules: this.forwardRefModules,
+            });
+            return this.createModuleScope(m.name, this.moduleScopeMap.get(m), []);
+        }
+        const pendingTree = this.moduleTreePromiseMap.get(m);
+        if (pendingTree) {
+            return pendingTree;
+        }
+        const moduleTreePromise = this.registerNewModuleWithScopeAsync(m, moduleWithOverrides, scope, imports, moduleChain);
+        this.moduleTreePromiseMap.set(m, moduleTreePromise);
+        return moduleTreePromise;
+    }
+    async registerNewModuleWithScopeAsync(m, moduleWithOverrides, scope, imports, moduleChain) {
+        this.moduleScopeMap.set(m, scope);
+        const importedModulesWithScope = [
+            ...this.globalModulesWithScope,
+            ...(await Promise.all(imports.map(async (module) => {
+                const moduleTree = await this.registerModuleWithScopeAsync(module, this.createContainer(module), [...moduleChain, m]);
+                return {
+                    module: this.overridesProcessor.getModuleWithOverrides(module),
+                    moduleScope: moduleTree,
+                };
+            }))),
+        ];
+        this.registerExportedProviders(scope, importedModulesWithScope);
+        const moduleForSorting = {
+            ...moduleWithOverrides,
+            imports: importedModulesWithScope.map((el) => el.module),
+        };
+        this.interceptorProcessor.processInterceptors(moduleWithOverrides, scope, importedModulesWithScope);
+        const providers = this.sorter.sortByDependencies(moduleForSorting);
+        for (const [key, provider] of Object.entries(providers)) {
+            scope.register({
+                [key]: await this.providerResolver.resolveProviderAsync({
+                    key,
+                    provider,
+                    resolutionScope: scope,
+                    module: moduleWithOverrides,
+                }),
+            });
+        }
+        this.lifecycleProcessor.collectEagerProviders(moduleWithOverrides, scope);
+        this.afterRegisterProviders(moduleWithOverrides, scope, importedModulesWithScope);
+        const moduleTree = this.createModuleScope(m.name, scope, importedModulesWithScope);
+        this.moduleTreeMap.set(m, moduleTree);
+        this.moduleTreePromiseMap.delete(m);
+        return moduleTree;
+    }
+    async resolveImportsAsync(m) {
+        return Promise.all((m.imports || []).map((importItem) => GUARGS.isForwardRef(importItem) ? importItem.resolve() : importItem));
+    }
+}

package/dist/lib/di/contexts/di-context-base.d.ts

@@ -0,0 +1,19 @@
+import type * as Awilix from "awilix";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import { ControllerProcessor } from "../processors/controller-processor.js";
+import { HandlerProcessor } from "../processors/handler-processor.js";
+import { InitializerProcessor } from "../processors/initializer-processor.js";
+import { InterceptorProcessor } from "../processors/interceptor-processor.js";
+import { ContainerContextBase, type ContainerContextOptions, type RegisteredModuleScope } from "./container-context-base.js";
+export interface DiContextOptions extends ContainerContextOptions {
+    skipRegisterRoutes?: boolean;
+}
+export declare class DIContextBase extends ContainerContextBase<DiContextOptions> {
+    protected readonly controllerProcessor: ControllerProcessor;
+    protected readonly handlerProcessor: HandlerProcessor;
+    protected readonly interceptorProcessor: InterceptorProcessor;
+    protected readonly initializerProcessor: InitializerProcessor;
+    protected constructor(options: DiContextOptions);
+    protected beforeRegisterProviders(m: M, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): void;
+    protected afterRegisterProviders(m: M, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): void;
+}

package/dist/lib/di/contexts/di-context-base.js

@@ -0,0 +1,32 @@
+import { ControllerProcessor } from "../processors/controller-processor.js";
+import { HandlerProcessor, HandlerType, } from "../processors/handler-processor.js";
+import { InitializerProcessor } from "../processors/initializer-processor.js";
+import { InterceptorProcessor } from "../processors/interceptor-processor.js";
+import { ProviderResolver } from "../providers/provider-resolver.js";
+import { getOrCreateRequestScope, hasRequestScopeContext, resolveFromRequestScope, } from "../request-scope-context.js";
+import { ContainerContextBase, } from "./container-context-base.js";
+export class DIContextBase extends ContainerContextBase {
+    controllerProcessor;
+    handlerProcessor;
+    interceptorProcessor;
+    initializerProcessor = new InitializerProcessor();
+    constructor(options) {
+        super(options, {
+            hasScopeContext: hasRequestScopeContext,
+            resolveFromScope: resolveFromRequestScope,
+        });
+        this.handlerProcessor = new HandlerProcessor(this.options.providerOptions || {});
+        this.interceptorProcessor = new InterceptorProcessor(this.options.providerOptions || {});
+        this.controllerProcessor = new ControllerProcessor(this.interceptorProcessor, this.options.providerOptions || {}, this.options.skipRegisterRoutes === true);
+        this.providerResolver = new ProviderResolver(this.interceptorProcessor, this.options.providerOptions || {}, getOrCreateRequestScope);
+    }
+    beforeRegisterProviders(m, scope, importedModulesWithScope) {
+        this.interceptorProcessor.processInterceptors(m, scope, importedModulesWithScope);
+    }
+    afterRegisterProviders(m, scope, importedModulesWithScope) {
+        this.handlerProcessor.processHandlers(m, scope, importedModulesWithScope, HandlerType.Query);
+        this.handlerProcessor.processHandlers(m, scope, importedModulesWithScope, HandlerType.Command);
+        const controllers = this.controllerProcessor.processControllers(m, scope);
+        this.lifecycleProcessor.addInitializerTask(this.initializerProcessor.collectInitializers(m, scope, importedModulesWithScope, controllers));
+    }
+}

package/dist/lib/di/contexts/di-context.d.ts

@@ -0,0 +1,7 @@
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { DiContextOptions } from "./di-context-base.js";
+import { DIContextBase } from "./di-context-base.js";
+export declare class DIContext extends DIContextBase {
+    private constructor();
+    static create(module: M, options?: DiContextOptions): import("./container-context-base.js").ModuleScope<import("awilix").AwilixContainer<{}>>;
+}

package/dist/lib/di/contexts/di-context.js

@@ -0,0 +1,9 @@
+import { DIContextBase } from "./di-context-base.js";
+export class DIContext extends DIContextBase {
+    constructor(options) {
+        super(options);
+    }
+    static create(module, options) {
+        return new DIContext(options ?? {}).bootstrapModule(module);
+    }
+}

package/dist/lib/di/contexts/module-graph-ensurer.d.ts

@@ -0,0 +1,31 @@
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+type EnsureImportedModulesUniquenessParams = {
+    module: M;
+    resolvedImports: M[];
+    globalModules: M[];
+};
+type EnsureGlobalModulesDoNotImportGlobalModulesParams = {
+    globalModules: readonly M[];
+    globalModuleImports: readonly {
+        module: M;
+        importedModule: M;
+    }[];
+};
+type EnsureNoProviderNameConflictsParams = {
+    module: M;
+    resolvedImports: M[];
+    globalModules: M[];
+    getExportedProviderKeys(module: M): string[];
+};
+type EnsureCircularDependencyHasForwardRefParams = {
+    module: M;
+    moduleChain: M[];
+    forwardRefModules: WeakSet<M>;
+};
+export declare class ModuleGraphEnsurer {
+    ensureImportedModulesUniqueness({ module, resolvedImports, globalModules, }: EnsureImportedModulesUniquenessParams): void;
+    ensureGlobalModulesDoNotImportGlobalModules({ globalModules, globalModuleImports, }: EnsureGlobalModulesDoNotImportGlobalModulesParams): void;
+    ensureNoProviderNameConflicts({ module, resolvedImports, globalModules, getExportedProviderKeys, }: EnsureNoProviderNameConflictsParams): void;
+    ensureCircularDependencyHasForwardRef({ module, moduleChain, forwardRefModules, }: EnsureCircularDependencyHasForwardRefParams): void;
+}
+export {};

package/dist/lib/di/contexts/module-graph-ensurer.js

@@ -0,0 +1,45 @@
+import * as ERRORS from "../errors.js";
+export class ModuleGraphEnsurer {
+    ensureImportedModulesUniqueness({ module, resolvedImports, globalModules, }) {
+        const importedNames = new Set();
+        const imports = [...globalModules, ...resolvedImports];
+        for (const imported of imports) {
+            if (importedNames.has(imported.name)) {
+                throw new ERRORS.DuplicateModuleImportError(module.name, imported.name);
+            }
+            importedNames.add(imported.name);
+        }
+    }
+    ensureGlobalModulesDoNotImportGlobalModules({ globalModules, globalModuleImports, }) {
+        const globalModuleNames = new Set();
+        for (const globalModule of globalModules) {
+            if (globalModuleNames.has(globalModule.name)) {
+                throw new ERRORS.DuplicateModuleImportError("globalModules", globalModule.name);
+            }
+            globalModuleNames.add(globalModule.name);
+        }
+        for (const { module, importedModule } of globalModuleImports) {
+            if (globalModuleNames.has(importedModule.name)) {
+                throw new ERRORS.GlobalModuleImportsGlobalModuleError(module.name, importedModule.name);
+            }
+        }
+    }
+    ensureNoProviderNameConflicts({ module, resolvedImports, globalModules, getExportedProviderKeys, }) {
+        const moduleProviderKeys = Object.keys(module.providers || {});
+        const importConflicts = [
+            ...globalModules.flatMap((globalModule) => getExportedProviderKeys(globalModule)),
+            ...resolvedImports.flatMap((importItem) => getExportedProviderKeys(importItem)),
+        ].filter((key) => moduleProviderKeys.includes(key));
+        if (importConflicts.length > 0) {
+            throw new ERRORS.ProviderNameConflictError(module.name, importConflicts);
+        }
+    }
+    ensureCircularDependencyHasForwardRef({ module, moduleChain, forwardRefModules, }) {
+        const hasForwardRefInCycle = forwardRefModules.has(module) ||
+            moduleChain.some((chainModule) => forwardRefModules.has(chainModule));
+        if (hasForwardRefInCycle)
+            return;
+        const chainNames = moduleChain.map((chainModule) => chainModule.name);
+        throw new ERRORS.CircularModuleDependencyError(module.name, chainNames);
+    }
+}

package/dist/lib/di/contexts/module-overrides.d.ts

@@ -0,0 +1,70 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { EmptyObject } from "../common.types.js";
+import type { RawValueObject } from "../modules/module.types.js";
+import type { InternalModuleLike } from "../modules/runtime-module.types.js";
+import type { AnyInitializer, AnyInterceptor, DefInitializerMap, DefInterceptorMap, DefPreHandlerMap, DefProviderMap, Provider } from "../providers/provider.types.js";
+type OwnProviderMap<TModule> = TModule extends {
+    providers: infer TProviders extends DefProviderMap;
+} ? TProviders : EmptyObject;
+type OwnQueryPreHandlerMap<TModule> = TModule extends {
+    queryPreHandlers: infer TPreHandlers extends DefPreHandlerMap;
+} ? TPreHandlers : EmptyObject;
+type OwnCommandPreHandlerMap<TModule> = TModule extends {
+    commandPreHandlers: infer TPreHandlers extends DefPreHandlerMap;
+} ? TPreHandlers : EmptyObject;
+type OwnInterceptorMap<TModule> = TModule extends {
+    interceptors: infer TInterceptors extends DefInterceptorMap;
+} ? TInterceptors : EmptyObject;
+type OwnInitializerMap<TModule> = TModule extends {
+    initializers: infer TInitializers extends DefInitializerMap;
+} ? TInitializers : EmptyObject;
+type ModuleDeps<TModule> = TModule extends {
+    deps: infer TDeps extends Record<string, unknown>;
+} ? TDeps : Record<string, unknown>;
+type RuntimeProviderValue<T> = T extends {
+    useFactory: (...args: any[]) => infer R;
+} ? Awaited<R> : T extends {
+    useClass: infer C extends new (...args: any[]) => any;
+} ? InstanceType<C> : T extends new (...args: any[]) => infer I ? I : T;
+type PublicShape<T> = Pick<T, keyof T>;
+type ProviderOverride<TValue, TDeps extends Record<string, unknown>> = RuntimeProviderValue<TValue> extends object ? (Provider<PublicShape<RuntimeProviderValue<TValue>>, TDeps> & {
+    initAfter?: readonly Extract<keyof TDeps, string>[];
+}) | RawValueObject<PublicShape<RuntimeProviderValue<TValue>>> : RuntimeProviderValue<TValue>;
+type ProviderOverridesFor<TModule> = {
+    [K in Extract<keyof OwnProviderMap<TModule>, string>]?: ProviderOverride<OwnProviderMap<TModule>[K], ModuleDeps<TModule>>;
+};
+type MiddlewareOverride<TValue> = TValue extends object ? Constructor<PublicShape<RuntimeProviderValue<TValue>>> | ({
+    useClass: Constructor<PublicShape<RuntimeProviderValue<TValue>>>;
+} & BuildResolverOptions<any>) : RuntimeProviderValue<TValue> extends object ? never : RuntimeProviderValue<TValue>;
+type PreHandlerOverridesFor<TMap> = {
+    [K in Extract<keyof TMap, string>]?: MiddlewareOverride<TMap[K]>;
+};
+type InterceptorOverridesFor<TModule> = {
+    [K in Extract<keyof OwnInterceptorMap<TModule>, string>]?: AnyInterceptor;
+};
+type InitializerOverridesFor<TModule> = {
+    [K in Extract<keyof OwnInitializerMap<TModule>, string>]?: AnyInitializer;
+};
+export type ModuleFeatureOverridesFor<TModule> = {
+    providers?: ProviderOverridesFor<TModule>;
+    queryPreHandlers?: PreHandlerOverridesFor<OwnQueryPreHandlerMap<TModule>>;
+    commandPreHandlers?: PreHandlerOverridesFor<OwnCommandPreHandlerMap<TModule>>;
+    interceptors?: InterceptorOverridesFor<TModule>;
+    initializers?: InitializerOverridesFor<TModule>;
+};
+export type ModuleOverride<TModule extends InternalModuleLike = InternalModuleLike> = {
+    module: TModule;
+    overrides: ModuleFeatureOverridesFor<TModule>;
+};
+export type AnyModuleOverride = {
+    module: InternalModuleLike;
+    overrides: {
+        providers?: Record<string, unknown>;
+        queryPreHandlers?: Record<string, unknown>;
+        commandPreHandlers?: Record<string, unknown>;
+        interceptors?: Record<string, unknown>;
+        initializers?: Record<string, unknown>;
+    };
+};
+export declare function overrideModule<TModule extends InternalModuleLike>(module: TModule, overrides: ModuleFeatureOverridesFor<TModule>): ModuleOverride<TModule>;
+export {};

package/dist/lib/di/contexts/module-overrides.js

@@ -0,0 +1,3 @@
+export function overrideModule(module, overrides) {
+    return { module, overrides };
+}

package/dist/lib/di/contexts/override-value.types.d.ts

@@ -0,0 +1,6 @@
+export type PublicShape<T> = [keyof T] extends [never] ? T : Pick<T, keyof T>;
+export type RuntimeProviderValue<T> = T extends {
+    useFactory: (...args: any[]) => infer R;
+} ? Awaited<R> : T extends {
+    useClass: infer C extends new (...args: any[]) => any;
+} ? InstanceType<C> : T extends new (...args: any[]) => infer I ? I : T;

package/dist/lib/di/contexts/override-value.types.js

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

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

@@ -0,0 +1,22 @@
+import type { InternalModuleLike } from "../modules/runtime-module.types.js";
+import type { AnyModuleOverride } from "./module-overrides.js";
+import type { AnyProviderOverrides } from "./provider-overrides.types.js";
+type OverrideOptions = {
+    providerOverrides?: AnyProviderOverrides;
+    moduleOverrides?: readonly AnyModuleOverride[];
+};
+export declare class OverridesProcessor<M extends InternalModuleLike> {
+    private readonly options;
+    private readonly effectiveModuleMap;
+    private readonly appliedModuleOverrides;
+    private rootModule?;
+    constructor(options: OverrideOptions);
+    setRootModule(module: M): void;
+    applyModuleOverrides(module: M): M;
+    getEffectiveModule(module: M): M;
+    ensureAllModuleOverridesApplied(): void;
+    applyRootProviderOverrides(module: M, moduleForSorting: M): M;
+    private ensureModuleOverrideKeysExist;
+    private ensureFeatureOverrideKeysExist;
+}
+export {};

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

@@ -0,0 +1,93 @@
+import * as ERRORS from "../errors.js";
+export class OverridesProcessor {
+    options;
+    effectiveModuleMap = new WeakMap();
+    appliedModuleOverrides = new WeakSet();
+    rootModule;
+    constructor(options) {
+        this.options = options;
+    }
+    setRootModule(module) {
+        this.rootModule = module;
+    }
+    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 effectiveModule = {
+            ...module,
+            providers: {
+                ...module.providers,
+                ...moduleOverride.overrides.providers,
+            },
+            queryPreHandlers: {
+                ...module.queryPreHandlers,
+                ...moduleOverride.overrides.queryPreHandlers,
+            },
+            commandPreHandlers: {
+                ...module.commandPreHandlers,
+                ...moduleOverride.overrides.commandPreHandlers,
+            },
+            interceptors: {
+                ...module.interceptors,
+                ...moduleOverride.overrides.interceptors,
+            },
+            initializers: {
+                ...module.initializers,
+                ...moduleOverride.overrides.initializers,
+            },
+        };
+        this.effectiveModuleMap.set(module, effectiveModule);
+        return effectiveModule;
+    }
+    getEffectiveModule(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);
+            }
+        }
+    }
+    applyRootProviderOverrides(module, moduleForSorting) {
+        const overrides = this.options.providerOverrides;
+        if (module !== this.rootModule || !overrides) {
+            return moduleForSorting;
+        }
+        const providerKeys = new Set(Object.keys(module.providers || {}));
+        for (const key of Object.keys(overrides)) {
+            if (!providerKeys.has(key)) {
+                throw new ERRORS.ProviderOverrideNotFoundError(module.name, key);
+            }
+        }
+        return {
+            ...moduleForSorting,
+            providers: {
+                ...moduleForSorting.providers,
+                ...overrides,
+            },
+        };
+    }
+    ensureModuleOverrideKeysExist(module, moduleOverride) {
+        this.ensureFeatureOverrideKeysExist(module, "providers", moduleOverride.overrides.providers);
+        this.ensureFeatureOverrideKeysExist(module, "queryPreHandlers", moduleOverride.overrides.queryPreHandlers);
+        this.ensureFeatureOverrideKeysExist(module, "commandPreHandlers", moduleOverride.overrides.commandPreHandlers);
+        this.ensureFeatureOverrideKeysExist(module, "interceptors", moduleOverride.overrides.interceptors);
+        this.ensureFeatureOverrideKeysExist(module, "initializers", moduleOverride.overrides.initializers);
+    }
+    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/contexts/provider-overrides.types.d.ts

@@ -0,0 +1,19 @@
+import type { EmptyObject } from "../common.types.js";
+import type { Module, ModuleDefinition, RawValueObject } from "../modules/module.types.js";
+import type { AnyProvider, DefProviderMap, Provider } from "../providers/provider.types.js";
+type ModuleDefFrom<TModule> = TModule extends Module<infer TDef extends ModuleDefinition> ? TDef : never;
+type OwnProviderMap<TModule> = ModuleDefFrom<TModule> extends {
+    providers: infer TProviders extends DefProviderMap;
+} ? TProviders : EmptyObject;
+type ModuleDeps<TModule> = ModuleDefFrom<TModule> extends {
+    deps: infer TDeps extends Record<string, unknown>;
+} ? TDeps : Record<string, unknown>;
+type PublicShape<T> = Pick<T, keyof T>;
+type ProviderOverride<TValue, TDeps extends Record<string, unknown>> = TValue extends object ? (Provider<PublicShape<TValue>, TDeps> & {
+    initAfter?: readonly Extract<keyof TDeps, string>[];
+}) | RawValueObject<PublicShape<TValue>> : TValue;
+export type ProviderOverridesFor<TModule> = {
+    [K in Extract<keyof OwnProviderMap<TModule>, string>]?: ProviderOverride<OwnProviderMap<TModule>[K], ModuleDeps<TModule>>;
+};
+export type AnyProviderOverrides = Record<string, AnyProvider>;
+export {};

package/dist/lib/di/contexts/provider-overrides.types.js

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

package/dist/lib/di/errors.d.ts

@@ -0,0 +1,66 @@
+export declare class DuplicateControllersInModuleError extends Error {
+    constructor(moduleName: string);
+}
+export declare class ControllerAlreadyRegisteredError extends Error {
+    constructor(controllerName: string, moduleName: string);
+}
+export declare class DependencyNotFoundError extends Error {
+    constructor(dependencyKey: string, moduleName: string);
+}
+export declare class CircularDependencyError extends Error {
+    constructor(moduleName: string, providerKeys: string[]);
+}
+export declare class DuplicateModuleImportError extends Error {
+    constructor(parentModuleName: string, importedModuleName: string);
+}
+export declare class ProviderNameConflictError extends Error {
+    constructor(moduleName: string, conflictingKeys: string[]);
+}
+export declare class ModuleFeatureOverrideNotFoundError extends Error {
+    constructor(moduleName: string, featureKind: string, featureKey: string);
+}
+export declare class ModuleOverrideTargetNotFoundError extends Error {
+    constructor(moduleName: string);
+}
+export declare class CircularModuleDependencyError extends Error {
+    constructor(moduleName: string, chain: string[]);
+}
+export declare class GlobalModuleImportsGlobalModuleError extends Error {
+    constructor(moduleName: string, importedGlobalModuleName: string);
+}
+export declare class HandlerMissingStaticKeyError extends Error {
+    constructor(handlerName: string);
+}
+export declare class FeatureNameConflictError extends Error {
+    constructor(moduleName: string, featureName: string, featureKey: string, existingModuleName: string);
+}
+export declare class InvalidProviderDefinitionError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}
+export declare class AsyncFactoryRequiresAsyncCreateError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}
+export declare class AsyncEagerFactoryRequiresInitError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}
+export declare class AsyncFactoryRequiresSingletonLifetimeError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}
+export declare class EagerProviderRequiresSingletonLifetimeError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}
+export declare class EagerProviderInitDependencyNotFoundError extends Error {
+    constructor(moduleName: string, providerKey: string, dependencyKey: string);
+}
+export declare class CircularProviderInitDependencyError extends Error {
+    constructor(providerKeys: string[]);
+}
+export declare class AsyncModuleRequiresAsyncCreateError extends Error {
+    constructor(moduleName: string);
+}
+export declare class DuplicateInitializerTokenError extends Error {
+    constructor(moduleName: string, initializerName: string, existingModuleName: string);
+}
+export declare class MultipleInvokeInitializersPerMethodError extends Error {
+    constructor(moduleName: string, controllerName: string, methodName: string, initializerNames: string[]);
+}