awilixify 2.2.1 → 3.0.0

package/README.md

@@ -1,19 +1,25 @@
-# awilixify
+<div align="center">
+  <img src="./logo.png" alt="awilixify logo" width="220" />
+</div>
+
+Transport-agnostic, type-safe, modular DI and CQRS framework on top of [Awilix](https://github.com/jeffijoe/awilix) that brings module architecture with powerful CQRS capabilities to Node.js applications and React 🚀 frontends.
 
 [![Build Status](https://github.com/wildstyles/awilixify/workflows/ci/badge.svg)](https://github.com/wildstyles/awilixify/actions)
 [![codecov](https://codecov.io/gh/wildstyles/awilixify/branch/main/graph/badge.svg)](https://codecov.io/gh/wildstyles/awilixify)
 
-📚 Documentation: https://wildstyles.github.io/awilixify/
-
-A type-safe, modular DI and CQRS framework on top of [Awilix](https://github.com/jeffijoe/awilix) that brings NestJS-like module architecture with powerful CQRS capabilities to any Node.js application.
+> [!WARNING]
+> This project is in active development and is not production-ready yet.
 
-🚀 **includes native ES decorators (TC39 Stage 3) for routing - no `reflect-metadata` or `experimentalDecorators` required!**
+📚 Documentation: https://wildstyles.github.io/awilixify/
 
 ## Features
 
 - **Type-Safe Module System** - Complete type safety for each provider in module
-- **HTTP Framework Agnostic** - Works with Express, Fastify, Hono, Koa, or any other framework
+- **Transport Agnostic** - Works with Express, Fastify, Queues, Rabbit or any other tranport
+- **Fullstack Module Model** - Reuse the same DI module mechanism in Node.js and React applications
 - **Powerful CQRS** - Type-safe query/command handlers with middleware pipeline, per-module mediators, and contract-based execution
+- **Type-Level Middleware Composition** - Compose and inherit middleware with end-to-end type safety
+- **No Experimental Decorators Required** - Uses native ES decorators (TC39 Stage 3) for routing without `reflect-metadata`
 - **NestJS-Inspired Architecture** - Familiar module/controller/provider patterns
 - **Less Import Boilerplate For Typing** - Define module dependencies once - reuse in all providers
 - **Lightweight** - Minimal overhead, built on proven Awilix foundation

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./lib/decorators/decorator-state.js";
+export type { ModuleScope } from "./lib/di/contexts/container-context-base.js";
+export * from "./lib/di/contexts/di-context.js";
+export * from "./lib/di/contexts/di-context-async.js";
+export * from "./lib/di/modules/module.types.js";
+export * from "./lib/di/modules/module-def.types.js";
+export * from "./lib/di/modules/module-factories.js";
+export * from "./lib/di/modules/module-overrides.js";
+export * from "./lib/di/modules/module-ref.types.js";
+export type { Controller, InitializerContext, InterceptContext, Interceptor, ProviderInit, } from "./lib/di/providers/provider.types.js";
+export { Initializer } from "./lib/di/providers/provider.types.js";
+export { isResultLike } from "./lib/di/type-guards.js";
+export * from "./lib/mediator/contract.types.js";
+export * from "./lib/mediator/global-middlewares.types.js";
+export * from "./lib/mediator/handler.types.js";
+export type { ExecutionContext, Middleware, MiddlewareContract, } from "./lib/mediator/middleware.types.js";
+export * from "./lib/mediator/middleware.types.js";
+export { Result } from "./lib/mediator/result.js";

package/dist/index.js

@@ -0,0 +1,15 @@
+export * from "./lib/decorators/decorator-state.js";
+export * from "./lib/di/contexts/di-context.js";
+export * from "./lib/di/contexts/di-context-async.js";
+export * from "./lib/di/modules/module.types.js";
+export * from "./lib/di/modules/module-def.types.js";
+export * from "./lib/di/modules/module-factories.js";
+export * from "./lib/di/modules/module-overrides.js";
+export * from "./lib/di/modules/module-ref.types.js";
+export { Initializer } from "./lib/di/providers/provider.types.js";
+export { isResultLike } from "./lib/di/type-guards.js";
+export * from "./lib/mediator/contract.types.js";
+export * from "./lib/mediator/global-middlewares.types.js";
+export * from "./lib/mediator/handler.types.js";
+export * from "./lib/mediator/middleware.types.js";
+export { Result } from "./lib/mediator/result.js";

package/dist/lib/decorators/decorator-state.d.ts

@@ -0,0 +1,15 @@
+import type { DecoratorState, DecoratorToken, MethodStateFrom, MethodUpdate, RootStateFrom, RootUpdate } from "./decorator-state.types.js";
+export declare function createDecoratorStateUpdater<TInitializers extends {
+    method: () => unknown;
+    root?: () => unknown;
+} = {
+    method: () => unknown;
+}>(description: string, initializers: TInitializers): {
+    token: DecoratorToken<DecoratorState<MethodStateFrom<TInitializers>, RootStateFrom<TInitializers>>>;
+    update: {
+        (context: ClassDecoratorContext<any>, updater: RootUpdate<DecoratorState<MethodStateFrom<TInitializers>, RootStateFrom<TInitializers>>>): void;
+        (context: ClassMethodDecoratorContext<any, any>, updater: MethodUpdate<DecoratorState<MethodStateFrom<TInitializers>, RootStateFrom<TInitializers>>>): void;
+    };
+};
+export declare function resolveDecoratorState<TState extends DecoratorState<any, any>>(target: unknown, token: DecoratorToken<TState>): TState | null;
+export declare function hasDecoratorMethodMetadata(target: unknown): boolean;

package/dist/lib/decorators/decorator-state.js

@@ -0,0 +1,72 @@
+export function createDecoratorStateUpdater(description, initializers) {
+    const token = {
+        stateSymbol: Symbol(`DecoratorState:${description}`),
+    };
+    return {
+        token,
+        update: createUpdater(token, {
+            ...initializers,
+            root: initializers.root ?? (() => null),
+        }),
+    };
+}
+export function resolveDecoratorState(target, token) {
+    const metadataSymbol = (typeof Symbol !== "undefined" && Symbol.metadata) ||
+        Object.getOwnPropertySymbols(target).find((s) => s.toString() === "Symbol(Symbol.metadata)");
+    if (!metadataSymbol)
+        return null;
+    return (target[metadataSymbol]?.[token.stateSymbol] || null);
+}
+export function hasDecoratorMethodMetadata(target) {
+    return [target, target?.prototype].some((value) => hasOwnDecoratorMethodMetadata(value));
+}
+function hasOwnDecoratorMethodMetadata(target) {
+    if (target === null ||
+        (typeof target !== "object" && typeof target !== "function")) {
+        return false;
+    }
+    const metadataSymbol = (typeof Symbol !== "undefined" && Symbol.metadata) ||
+        Object.getOwnPropertySymbols(target).find((s) => s.toString() === "Symbol(Symbol.metadata)");
+    if (!metadataSymbol)
+        return false;
+    const metadata = target[metadataSymbol];
+    if (!metadata || typeof metadata !== "object")
+        return false;
+    return [
+        ...Object.getOwnPropertyNames(metadata).map((key) => metadata[key]),
+        ...Object.getOwnPropertySymbols(metadata).map((key) => metadata[key]),
+    ].some((state) => typeof state === "object" &&
+        state !== null &&
+        "methods" in state &&
+        state.methods instanceof Map &&
+        state.methods.size > 0);
+}
+function createUpdater(token, initializers) {
+    const initializeState = () => ({
+        root: initializers.root(),
+        methods: new Map(),
+    });
+    function update(context, updater) {
+        if (!context.metadata)
+            return;
+        const state = context.metadata[token.stateSymbol] || initializeState();
+        if (context.kind === "class") {
+            if (!("root" in updater))
+                return;
+            context.metadata[token.stateSymbol] = {
+                ...state,
+                root: updater.root(state.root),
+            };
+            return;
+        }
+        if (!("method" in updater))
+            return;
+        const nextMethods = new Map(state.methods);
+        nextMethods.set(context.name, updater.method(nextMethods.get(context.name) ?? initializers.method()));
+        context.metadata[token.stateSymbol] = {
+            ...state,
+            methods: nextMethods,
+        };
+    }
+    return update;
+}

package/dist/lib/decorators/decorator-state.types.d.ts

@@ -0,0 +1,35 @@
+export type MethodName = string | symbol;
+export type DecoratorState<TMethod, TRoot = null> = {
+    root: TRoot;
+    methods: Map<MethodName, TMethod>;
+};
+export type DecoratorMethodState<TState> = TState extends DecoratorState<infer TMethod, any> ? TMethod : never;
+export type DecoratorRootState<TState> = TState extends DecoratorState<any, infer TRoot> ? TRoot : never;
+export type StateInitializers<TState extends DecoratorState<any, any>> = {
+    method: () => DecoratorMethodState<TState>;
+    root: () => DecoratorRootState<TState>;
+};
+type StateUpdater<T> = (previous: T) => T;
+export type RootUpdate<TState extends DecoratorState<any, any>> = {
+    root: StateUpdater<DecoratorRootState<TState>>;
+};
+export type MethodUpdate<TState extends DecoratorState<any, any>> = {
+    method: StateUpdater<DecoratorMethodState<TState>>;
+};
+export type StateUpdate<TState extends DecoratorState<any, any>> = RootUpdate<TState> | MethodUpdate<TState>;
+export type DecoratorToken<TState extends DecoratorState<any, any>> = {
+    stateSymbol: symbol;
+    readonly state: TState;
+};
+export type MethodStateFrom<TInitializers> = TInitializers extends {
+    method: () => infer TMethod;
+} ? TMethod : never;
+export type RootStateFrom<TInitializers> = TInitializers extends {
+    root: () => infer TRoot;
+} ? TRoot : null;
+declare global {
+    interface SymbolConstructor {
+        readonly metadata: unique symbol;
+    }
+}
+export {};

package/dist/lib/decorators/decorator-state.types.js

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

package/dist/lib/di/common.types.d.ts

@@ -0,0 +1,6 @@
+export type UnknownRecord = Record<PropertyKey, unknown>;
+declare const emptyObjectSymbol: unique symbol;
+export type EmptyObject = {
+    [emptyObjectSymbol]?: never;
+};
+export {};

package/dist/lib/di/common.types.js

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

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

@@ -0,0 +1,53 @@
+import * as Awilix from "awilix";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import { type LifecycleMethods, LifecycleProcessor } from "../processors/lifecycle-processor.js";
+import { type OverrideOptions, OverridesProcessor } from "../processors/overrides-processor.js";
+import { ProviderDependencySorter } from "../providers/provider-dependency-sorter.js";
+import type { ProviderResolver } from "../providers/provider-resolver.js";
+import { ModuleGraphEnsurer } from "./module-graph-ensurer.js";
+interface ScopeContext {
+    hasScopeContext: () => boolean;
+    resolveFromScope: <T>(scope: Awilix.AwilixContainer, key: string | symbol) => T;
+}
+export interface ContainerContextOptions extends OverrideOptions {
+    containerOptions?: Awilix.ContainerOptions;
+    providerOptions?: Partial<Awilix.BuildResolverOptions<any>>;
+    globalModules?: readonly M[];
+}
+export interface ModuleScope<S extends Awilix.AwilixContainer = Awilix.AwilixContainer> extends LifecycleMethods {
+    name: string;
+    scope: S;
+    importedScopes: Map<string, ModuleScope>;
+}
+export type RegisteredModuleScope = {
+    module: M;
+    moduleScope: ModuleScope;
+};
+export declare abstract class ContainerContextBase<TOptions extends ContainerContextOptions = ContainerContextOptions> {
+    private readonly scopeContext?;
+    protected readonly forwardRefModules: WeakSet<M>;
+    protected readonly moduleScopeMap: WeakMap<M, Awilix.AwilixContainer<{}>>;
+    protected readonly moduleTreeMap: WeakMap<M, ModuleScope<Awilix.AwilixContainer<{}>>>;
+    protected readonly options: TOptions;
+    protected readonly sorter: ProviderDependencySorter;
+    protected readonly moduleGraphEnsurer: ModuleGraphEnsurer;
+    protected readonly lifecycleProcessor: LifecycleProcessor;
+    protected readonly overridesProcessor: OverridesProcessor<M>;
+    protected providerResolver: ProviderResolver;
+    protected globalModulesWithScope: RegisteredModuleScope[];
+    protected constructor(options: TOptions, scopeContext?: ScopeContext | undefined);
+    protected bootstrapModule(module: M): ModuleScope;
+    protected createContainer(module?: M): Awilix.AwilixContainer;
+    protected registerModuleWithScope(m: M, scope: Awilix.AwilixContainer, moduleChain: M[]): ModuleScope;
+    protected initializeGlobalModules(): void;
+    protected registerImportedFeatures(scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): void;
+    protected registerExportedProviders(scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): void;
+    protected getExportedProviderKeys(module: M): string[];
+    protected markModuleIfImportsUseForwardRef(m: M): void;
+    protected createModuleScope(name: string, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): ModuleScope;
+    protected resolveImports(m: M): M[];
+    protected ensureAdditionalNameConflicts(_module: M, _resolvedImports: M[]): void;
+    protected beforeRegisterProviders(_module: M, _scope: Awilix.AwilixContainer, _importedModulesWithScope: RegisteredModuleScope[]): void;
+    protected afterRegisterProviders(_module: M, _scope: Awilix.AwilixContainer, _importedModulesWithScope: RegisteredModuleScope[]): void;
+}
+export {};

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

@@ -0,0 +1,194 @@
+import * as Awilix from "awilix";
+import * as ERRORS from "../errors.js";
+import { LifecycleProcessor, } from "../processors/lifecycle-processor.js";
+import { OverridesProcessor, } from "../processors/overrides-processor.js";
+import { ProviderDependencySorter } from "../providers/provider-dependency-sorter.js";
+import * as GUARGS from "../type-guards.js";
+import { ModuleGraphEnsurer } from "./module-graph-ensurer.js";
+export class ContainerContextBase {
+    scopeContext;
+    forwardRefModules = new WeakSet();
+    moduleScopeMap = new WeakMap();
+    moduleTreeMap = new WeakMap();
+    options;
+    sorter = new ProviderDependencySorter();
+    moduleGraphEnsurer = new ModuleGraphEnsurer();
+    lifecycleProcessor;
+    overridesProcessor;
+    providerResolver;
+    globalModulesWithScope = [];
+    constructor(options, scopeContext) {
+        this.scopeContext = scopeContext;
+        this.options = {
+            ...options,
+            containerOptions: {
+                strict: true,
+                injectionMode: Awilix.InjectionMode.CLASSIC,
+                ...options.containerOptions,
+            },
+            providerOptions: {
+                lifetime: Awilix.Lifetime.SINGLETON,
+                ...options.providerOptions,
+            },
+        };
+        this.overridesProcessor = new OverridesProcessor({
+            moduleOverrides: this.options.moduleOverrides,
+        });
+        this.lifecycleProcessor = new LifecycleProcessor(this.options.providerOptions || {});
+    }
+    bootstrapModule(module) {
+        this.initializeGlobalModules();
+        const moduleTree = this.registerModuleWithScope(module, this.createContainer(module), []);
+        this.overridesProcessor.ensureAllModuleOverridesApplied();
+        return moduleTree;
+    }
+    createContainer(module) {
+        const scope = Awilix.createContainer({
+            ...this.options.containerOptions,
+            ...module?.containerOptions,
+        });
+        this.lifecycleProcessor.trackScope(scope);
+        return scope;
+    }
+    registerModuleWithScope(m, scope, moduleChain) {
+        const existingTree = this.moduleTreeMap.get(m);
+        if (existingTree) {
+            return existingTree;
+        }
+        const imports = this.resolveImports(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.ensureAdditionalNameConflicts(moduleWithOverrides, imports);
+        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), []);
+        }
+        this.moduleScopeMap.set(m, scope);
+        const importedModulesWithScope = [
+            ...this.globalModulesWithScope,
+            ...imports.map((module) => {
+                const moduleTree = this.registerModuleWithScope(module, this.createContainer(module), [...moduleChain, m]);
+                return {
+                    module: this.overridesProcessor.getModuleWithOverrides(module),
+                    moduleScope: moduleTree,
+                };
+            }),
+        ];
+        this.registerImportedFeatures(scope, importedModulesWithScope);
+        const moduleForSorting = {
+            ...moduleWithOverrides,
+            imports: importedModulesWithScope.map((el) => el.module),
+        };
+        this.beforeRegisterProviders(moduleWithOverrides, scope, importedModulesWithScope);
+        for (const [key, provider] of Object.entries(this.sorter.sortByDependencies(moduleForSorting))) {
+            scope.register({
+                [key]: this.providerResolver.resolveProvider({
+                    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);
+        return moduleTree;
+    }
+    initializeGlobalModules() {
+        const globalModules = this.options.globalModules || [];
+        const globalModuleImports = globalModules.flatMap((module) => this.resolveImports(module).map((importedModule) => ({
+            module,
+            importedModule,
+        })));
+        this.moduleGraphEnsurer.ensureGlobalModulesDoNotImportGlobalModules({
+            globalModules,
+            globalModuleImports,
+        });
+        this.globalModulesWithScope = [];
+        for (const module of globalModules) {
+            const moduleTree = this.registerModuleWithScope(module, this.createContainer(module), []);
+            this.globalModulesWithScope.push({
+                module: this.overridesProcessor.getModuleWithOverrides(module),
+                moduleScope: moduleTree,
+            });
+        }
+    }
+    registerImportedFeatures(scope, importedModulesWithScope) {
+        this.registerExportedProviders(scope, importedModulesWithScope);
+    }
+    registerExportedProviders(scope, importedModulesWithScope) {
+        for (const { module: importedModule, moduleScope: importedModuleScope, } of importedModulesWithScope) {
+            for (const key of this.getExportedProviderKeys(importedModule)) {
+                if (!importedModule.providers?.[key]) {
+                    throw new ERRORS.InvalidProviderDefinitionError(importedModule.name, key);
+                }
+                scope.register({
+                    [key]: Awilix.asFunction(() => {
+                        const registration = importedModuleScope.scope.registrations[key];
+                        return registration.lifetime === Awilix.Lifetime.SINGLETON
+                            ? importedModuleScope.scope.resolve(key)
+                            : this.scopeContext?.hasScopeContext()
+                                ? this.scopeContext.resolveFromScope(importedModuleScope.scope, key)
+                                : importedModuleScope.scope.resolve(key);
+                    }, {
+                        lifetime: Awilix.Lifetime.TRANSIENT,
+                        isLeakSafe: true,
+                    }),
+                });
+            }
+        }
+    }
+    getExportedProviderKeys(module) {
+        return module.exports ? [...module.exports] : [];
+    }
+    markModuleIfImportsUseForwardRef(m) {
+        if ((m.imports || []).some(GUARGS.isForwardRef)) {
+            this.forwardRefModules.add(m);
+        }
+    }
+    createModuleScope(name, scope, importedModulesWithScope) {
+        const importedScopes = importedModulesWithScope.reduce((acc, { moduleScope }) => {
+            acc.set(moduleScope.name, moduleScope);
+            return acc;
+        }, new Map());
+        return {
+            name,
+            scope,
+            importedScopes,
+            init: (options) => this.lifecycleProcessor.init(options),
+            dispose: () => this.lifecycleProcessor.dispose(),
+        };
+    }
+    resolveImports(m) {
+        return (m.imports || []).map((importItem) => {
+            const resolvedImport = GUARGS.isForwardRef(importItem)
+                ? importItem.resolve()
+                : importItem;
+            if (GUARGS.isPromiseLike(resolvedImport)) {
+                throw new ERRORS.AsyncModuleRequiresAsyncCreateError(m.name);
+            }
+            return resolvedImport;
+        });
+    }
+    ensureAdditionalNameConflicts(_module, _resolvedImports) { }
+    beforeRegisterProviders(_module, _scope, _importedModulesWithScope) { }
+    afterRegisterProviders(_module, _scope, _importedModulesWithScope) { }
+}

package/dist/lib/di/contexts/context-overrides.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 ContextOverrides<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/context-overrides.js

@@ -0,0 +1,93 @@
+import * as ERRORS from "../errors.js";
+export class ContextOverrides {
+    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/di-context-async.d.ts

@@ -0,0 +1,14 @@
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { ModuleScope } from "./container-context-base.js";
+import type { DiContextOptions } from "./di-context-base.js";
+import { DIContextBase } from "./di-context-base.js";
+export declare class AsyncDIContext extends DIContextBase {
+    private readonly moduleTreePromiseMap;
+    private constructor();
+    static create(module: M | Promise<M>, options?: DiContextOptions): Promise<ModuleScope>;
+    private bootstrap;
+    private initializeGlobalModulesAsync;
+    private registerModuleWithScopeAsync;
+    private registerNewModuleWithScopeAsync;
+    private resolveImportsAsync;
+}