awilixify 2.2.1 → 3.1.0

package/README.md

@@ -1,19 +1,28 @@
-# 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.
+> [!TIP]
+> 🤔 “Another JS framework?” Here are my attempts to convince you to give Awilixify a try:
+>
+> - [Awilixify: NestJS-Like Modular DI for Legacy Applications](https://medium.com/@r.vanzhula/awilixify-nestjs-like-modular-di-for-legacy-applications-db2a1e29c7de)
+> - [Awilixify: Making Middlewares End-to-End Type-Safe](https://medium.com/@r.vanzhula/awilixify-making-middlewares-end-to-end-type-safe-b3f4dbfb6b42)
 
-🚀 **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,19 @@
+export * from "./lib/decorators/decorator-state.js";
+export type { DecoratorToken } from "./lib/decorators/decorator-state.types.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 { ConstructorController, 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/devtools/devtools.types.d.ts

@@ -0,0 +1,63 @@
+import type * as Awilix from "awilix";
+import type { InternalModuleLike } from "../di/modules/runtime-module.types.js";
+import type { ConstructorController, Initializer } from "../di/providers/provider.types.js";
+export declare const AWILIXIFY_DEVTOOLS_PROCESSOR = "__awilixifyDevtoolsProcessor";
+export type TraceSpanKind = "http" | "provider" | "handler" | "prehandler" | "interceptor" | "initializer";
+export type RecordSpanInput<T> = {
+    kind: TraceSpanKind;
+    moduleName: string;
+    providerKey: string;
+    methodName: string;
+    args: unknown[];
+    callback: () => T | Promise<T>;
+    moduleId?: string;
+};
+export type WrapResolverInput = {
+    kind: TraceSpanKind;
+    module: InternalModuleLike;
+    options: Awilix.BuildResolverOptions<any>;
+    providerKey: string;
+    resolver: Awilix.Resolver<any>;
+    moduleId?: string;
+    isFactory?: boolean;
+};
+export type TraceInitializerInput<T = unknown> = {
+    args: unknown[];
+    callback: () => T | Promise<T>;
+    controllerName: string;
+    getStatusCode: () => number | undefined;
+    methodName: string;
+    moduleName: string;
+};
+export interface Tracer {
+    recordSpan<T>(input: RecordSpanInput<T>): T | Promise<T>;
+    traceInitializer<T>(input: TraceInitializerInput<T>): T | Promise<T>;
+    wrapResolver(input: WrapResolverInput): Awilix.Resolver<any>;
+}
+export type ModuleDecoratorMetadata = {
+    module: InternalModuleLike;
+    controllers: readonly {
+        controllerClass: ConstructorController;
+    }[];
+    initializers: readonly [string, () => Initializer<any, boolean>][];
+};
+export interface GraphCollector {
+    registerModule(input: {
+        module: InternalModuleLike;
+        scope: Awilix.AwilixContainer;
+        importedModules: readonly InternalModuleLike[];
+    }): string;
+    collectModuleRoutes(metadata: ModuleDecoratorMetadata): void;
+}
+export type DevtoolsProcessorContext = {
+    rootModule: InternalModuleLike;
+    globalModules: readonly InternalModuleLike[];
+};
+export interface DevtoolsProcessor {
+    graphCollector: GraphCollector;
+    tracer: Tracer;
+    initialize(context: DevtoolsProcessorContext): void;
+}
+export type DevtoolsProcessorRef = {
+    current?: DevtoolsProcessor;
+};

package/dist/lib/devtools/devtools.types.js

@@ -0,0 +1 @@
+export const AWILIXIFY_DEVTOOLS_PROCESSOR = "__awilixifyDevtoolsProcessor";

package/dist/lib/devtools/helpers.d.ts

@@ -0,0 +1,2 @@
+import type { ConstructorController } from "../di/providers/provider.types.js";
+export declare function getControllerMethodNames(controllerClass: ConstructorController): Array<string | symbol>;

package/dist/lib/devtools/helpers.js

@@ -0,0 +1,18 @@
+export function getControllerMethodNames(controllerClass) {
+    const collected = new Set();
+    let proto = controllerClass.prototype;
+    while (proto && proto !== Object.prototype) {
+        Object.getOwnPropertyNames(proto)
+            .filter((name) => name !== "constructor" && typeof proto[name] === "function")
+            .forEach((name) => {
+            collected.add(name);
+        });
+        Object.getOwnPropertySymbols(proto)
+            .filter((symbol) => typeof proto[symbol] === "function")
+            .forEach((symbol) => {
+            collected.add(symbol);
+        });
+        proto = Object.getPrototypeOf(proto);
+    }
+    return [...collected];
+}

package/dist/lib/devtools/index.d.ts

@@ -0,0 +1,4 @@
+export type { InternalModuleLike } from "../di/modules/runtime-module.types.js";
+export { hasInitAfter, hasUseClass, isCostructorProvider, isCostructorProvider as isConstructorProvider, isEagerProvider, isPromiseLike, isResultLike, } from "../di/type-guards.js";
+export * from "./devtools.types.js";
+export { getControllerMethodNames } from "./helpers.js";

package/dist/lib/devtools/index.js

@@ -0,0 +1,3 @@
+export { hasInitAfter, hasUseClass, isCostructorProvider, isCostructorProvider as isConstructorProvider, isEagerProvider, isPromiseLike, isResultLike, } from "../di/type-guards.js";
+export * from "./devtools.types.js";
+export { getControllerMethodNames } from "./helpers.js";

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,63 @@
+import * as Awilix from "awilix";
+import { type DevtoolsProcessorRef } from "../../devtools/devtools.types.js";
+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<Options extends Awilix.BuildResolverOptions<any> = Awilix.BuildResolverOptions<any>> extends OverrideOptions {
+    containerOptions?: Awilix.ContainerOptions;
+    providerOptions?: Options;
+    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 devtoolsProcessorRef: DevtoolsProcessorRef;
+    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(rootModule: M): 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 registerModuleInGraph({ module, scope, importedModules, }: {
+        module: M;
+        scope: Awilix.AwilixContainer;
+        importedModules: readonly M[];
+    }): string | undefined;
+    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;
+    protected hasDevtoolsProcessorProvider(module: M): boolean;
+    protected get globalModules(): M[];
+    protected attachDevtools(rootModule: M): void;
+}
+export {};

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

@@ -0,0 +1,232 @@
+import * as Awilix from "awilix";
+import { AWILIXIFY_DEVTOOLS_PROCESSOR, } from "../../devtools/devtools.types.js";
+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();
+    devtoolsProcessorRef = {};
+    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(module);
+        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);
+        const moduleId = this.registerModuleInGraph({
+            module: moduleWithOverrides,
+            scope,
+            importedModules: imports,
+        });
+        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,
+                    moduleId,
+                    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(rootModule) {
+        const globalModuleImports = this.globalModules.flatMap((module) => this.resolveImports(module).map((importedModule) => ({
+            module,
+            importedModule,
+        })));
+        this.moduleGraphEnsurer.ensureGlobalModulesDoNotImportGlobalModules({
+            globalModules: this.globalModules,
+            globalModuleImports,
+        });
+        this.globalModulesWithScope = [];
+        this.attachDevtools(rootModule);
+        for (const module of this.globalModules) {
+            const moduleTree = this.registerModuleWithScope(module, this.createContainer(module), []);
+            this.globalModulesWithScope.push({
+                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;
+        });
+    }
+    registerModuleInGraph({ module, scope, importedModules, }) {
+        if (!this.devtoolsProcessorRef.current) {
+            return undefined;
+        }
+        const moduleId = this.devtoolsProcessorRef.current.graphCollector.registerModule({
+            module,
+            scope,
+            importedModules,
+        });
+        return moduleId;
+    }
+    ensureAdditionalNameConflicts(_module, _resolvedImports) { }
+    beforeRegisterProviders(_module, _scope, _importedModulesWithScope) { }
+    afterRegisterProviders(_module, _scope, _importedModulesWithScope) { }
+    hasDevtoolsProcessorProvider(module) {
+        return Boolean(module.providers?.[AWILIXIFY_DEVTOOLS_PROCESSOR]);
+    }
+    get globalModules() {
+        return (this.options.globalModules || [])
+            .filter((module) => !this.hasDevtoolsProcessorProvider(module))
+            .map((el) => this.overridesProcessor.getModuleWithOverrides(el));
+    }
+    attachDevtools(rootModule) {
+        const module = this.moduleGraphEnsurer.ensureSingleDevtoolsModule((this.options.globalModules || []).filter((module) => this.hasDevtoolsProcessorProvider(module)));
+        if (!module)
+            return;
+        const moduleTree = this.registerModuleWithScope(module, this.createContainer(module), []);
+        this.devtoolsProcessorRef.current = moduleTree.scope.resolve(AWILIXIFY_DEVTOOLS_PROCESSOR);
+        this.devtoolsProcessorRef.current.initialize({
+            rootModule,
+            globalModules: this.globalModules,
+        });
+    }
+}

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;
+}