awilixify 2.2.1 → 3.1.0

package/dist/lib/di/modules/module-factories.js

@@ -0,0 +1,54 @@
+import { createHash } from "node:crypto";
+export function forwardRef(getter) {
+    return {
+        __forward_ref__: true,
+        resolve: getter,
+    };
+}
+export function createFactoryProvider() {
+    return (provider) => {
+        return provider;
+    };
+}
+export function createModule(module, options) {
+    const withOptions = {
+        ...module,
+        registerControllers: options?.registerControllers ?? true,
+    };
+    if (options?.hashNameFrom === undefined) {
+        return withOptions;
+    }
+    const hashSource = stableStringify(options.hashNameFrom);
+    const hash = createHash("sha256")
+        .update(hashSource)
+        .digest("hex")
+        .slice(0, Math.max(4, options.hashLength ?? 8));
+    return {
+        ...withOptions,
+        name: `${withOptions.name}_${hash}`,
+        __devtools: {
+            baseName: withOptions.name,
+            dynamic: {
+                hash,
+                paramsPreview: hashSource,
+            },
+        },
+    };
+}
+function stableStringify(value) {
+    return JSON.stringify(sortRecursively(value));
+}
+function sortRecursively(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortRecursively);
+    }
+    if (value && typeof value === "object") {
+        return Object.keys(value)
+            .sort()
+            .reduce((acc, key) => {
+            acc[key] = sortRecursively(value[key]);
+            return acc;
+        }, {});
+    }
+    return value;
+}

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

@@ -0,0 +1,70 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { EmptyObject } from "../common.types.js";
+import type { AnyInitializer, AnyInterceptor, DefInitializerMap, DefInterceptorMap, DefPreHandlerMap, DefProviderMap, Provider } from "../providers/provider.types.js";
+import type { RawValueObject } from "./module.types.js";
+import type { InternalModuleLike } from "./runtime-module.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/modules/module-overrides.js

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

package/dist/lib/di/modules/module-ref.types.d.ts

@@ -0,0 +1,13 @@
+export type ForwardRef<T = any> = {
+    __forward_ref__: true;
+    resolve: () => T | Promise<T>;
+};
+declare const moduleRefMarker: unique symbol;
+export type ModuleRef<T> = {
+    [moduleRefMarker]: true;
+    exports: T extends {
+        exports: infer E;
+    } ? E : never;
+};
+export type AnyModuleRef = ModuleRef<any>;
+export {};

package/dist/lib/di/modules/module-ref.types.js

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

package/dist/lib/di/modules/module.types.d.ts

@@ -0,0 +1,178 @@
+import type { BuildResolverOptions, Constructor, ContainerOptions } from "awilix";
+import type { EmptyObject } from "../common.types.js";
+import type { AnyController, AnyInterceptor, ClassHandler, ClassMiddleware, DefInitializerMap, DefInterceptorMap, DefPreHandlerMap, DefProviderMap, Provider } from "../providers/provider.types.js";
+import type { ForwardRef, ModuleRef } from "./module-ref.types.js";
+import type { InternalModuleLike } from "./runtime-module.types.js";
+declare const importModuleDefMarker: unique symbol;
+export type ImportModule<TDef extends ModuleDefinition = ModuleDefinition> = {
+    name: string;
+    imports?: readonly unknown[];
+    exports?: readonly string[];
+    [importModuleDefMarker]?: TDef;
+};
+export type AnyModule = InternalModuleLike & ImportModule<any>;
+export type ModuleImport = AnyModule | Promise<AnyModule> | ModuleRef<any>;
+export type ModuleDefinition = {
+    providers?: DefProviderMap;
+    exports?: DefProviderMap;
+    imports?: ModuleImport[];
+    queryHandlers?: readonly any[];
+    commandHandlers?: readonly any[];
+    queryPreHandlers?: DefPreHandlerMap;
+    commandPreHandlers?: DefPreHandlerMap;
+    interceptors?: DefInterceptorMap;
+    initializers?: DefInitializerMap;
+    exportKeys?: readonly string[];
+    queryPreHandlerExportKeys?: readonly string[];
+    commandPreHandlerExportKeys?: readonly string[];
+    interceptorExportKeys?: readonly string[];
+    initializerExportKeys?: readonly string[];
+};
+type NormalizeModuleDef<Def extends ModuleDefinition> = {
+    deps: Def extends {
+        deps: infer D extends Record<string, unknown>;
+    } ? D : Record<string, unknown>;
+    providers: Def["providers"] extends DefProviderMap ? Def["providers"] : EmptyObject;
+    exports: Def["exports"] extends DefProviderMap ? Def["exports"] : EmptyObject;
+    imports: Def["imports"] extends readonly unknown[] ? Def["imports"] : readonly [];
+    queryHandlers: Def["queryHandlers"] extends readonly any[] ? Def["queryHandlers"] : readonly [];
+    commandHandlers: Def["commandHandlers"] extends readonly any[] ? Def["commandHandlers"] : readonly [];
+    queryPreHandlers: Def["queryPreHandlers"] extends DefPreHandlerMap ? Def["queryPreHandlers"] : EmptyObject;
+    commandPreHandlers: Def["commandPreHandlers"] extends DefPreHandlerMap ? Def["commandPreHandlers"] : EmptyObject;
+    initializers: Def["initializers"] extends DefInitializerMap ? Def["initializers"] : EmptyObject;
+    interceptors: Def["interceptors"] extends DefInterceptorMap ? Def["interceptors"] : EmptyObject;
+    exportKeys: Def["exportKeys"] extends readonly string[] ? Def["exportKeys"] : readonly [];
+    queryPreHandlerExportKeys: Def["queryPreHandlerExportKeys"] extends readonly string[] ? Def["queryPreHandlerExportKeys"] : readonly [];
+    commandPreHandlerExportKeys: Def["commandPreHandlerExportKeys"] extends readonly string[] ? Def["commandPreHandlerExportKeys"] : readonly [];
+    initializerExportKeys: Def["initializerExportKeys"] extends readonly string[] ? Def["initializerExportKeys"] : readonly [];
+    interceptorExportKeys: Def["interceptorExportKeys"] extends readonly string[] ? Def["interceptorExportKeys"] : readonly [];
+};
+export type Module<Def extends ModuleDefinition> = {
+    name: string;
+    controllers?: AnyController[];
+    containerOptions?: ContainerOptions;
+    providerOptions?: Partial<BuildResolverOptions<any>>;
+    [importModuleDefMarker]?: Def;
+} & ModuleFromNormalized<NormalizeModuleDef<Def>>;
+type ModuleFromNormalized<Def extends {
+    deps: Record<string, unknown>;
+    providers: DefProviderMap | EmptyObject;
+    exports: DefProviderMap | EmptyObject;
+    imports: readonly unknown[];
+    queryHandlers: readonly any[];
+    commandHandlers: readonly any[];
+    interceptors: DefInterceptorMap | EmptyObject;
+    initializers: DefInitializerMap | EmptyObject;
+    queryPreHandlers: DefPreHandlerMap | EmptyObject;
+    commandPreHandlers: DefPreHandlerMap | EmptyObject;
+    exportKeys: readonly string[];
+    queryPreHandlerExportKeys: readonly string[];
+    commandPreHandlerExportKeys: readonly string[];
+    initializerExportKeys: readonly string[];
+    interceptorExportKeys: readonly string[];
+}> = WithProviders<Def["providers"], Def["deps"]> & WithImports<Def["imports"]> & WithQueryHandlers<Def["queryHandlers"]> & WithCommandHandlers<Def["commandHandlers"]> & WithQueryPreHandlers<Def["queryPreHandlers"]> & WithCommandPreHandlers<Def["commandPreHandlers"]> & WithInitializers<Def["initializers"]> & WithInterceptors<Def["interceptors"]> & WithExports<Def["exportKeys"]> & WithQueryPreHandlerExports<Def["queryPreHandlerExportKeys"]> & WithCommandPreHandlerExports<Def["commandPreHandlerExportKeys"]> & WithInitializerExports<Def["initializerExportKeys"]> & WithInterceptorExports<Def["interceptorExportKeys"]>;
+type WithProviders<TProviders extends DefProviderMap | EmptyObject, TDeps extends Record<string, unknown>> = TProviders extends EmptyObject ? {
+    providers?: EmptyObject;
+} : {
+    providers: ToModuleProviderMap<TProviders, TDeps>;
+};
+type WithExports<TKeys extends readonly string[]> = TKeys extends readonly [] ? {
+    exports?: readonly [];
+} : {
+    exports: TKeys;
+};
+type ToModuleProviderMap<T extends DefProviderMap, DepsMap extends Record<string, unknown> = Record<string, unknown>> = [keyof T] extends [never] ? EmptyObject : {
+    [K in keyof T]: T[K] extends object ? (Provider<T[K], DepsMap> & {
+        initAfter?: readonly Extract<keyof DepsMap, string>[];
+    }) | RawValueObject<T[K]> : T[K];
+};
+export type RawValueObject<T> = T & {
+    useClass?: never;
+    useFactory?: never;
+    lifetime?: never;
+    allowCircular?: never;
+    eager?: never;
+    initAfter?: never;
+};
+type WithQueryHandlers<THandlers extends readonly any[]> = THandlers extends readonly [] ? {
+    queryHandlers?: readonly [];
+} : {
+    queryHandlers: ToModuleHandlerArray<THandlers>;
+};
+type WithCommandHandlers<THandlers extends readonly any[]> = THandlers extends readonly [] ? {
+    commandHandlers?: readonly [];
+} : {
+    commandHandlers: ToModuleHandlerArray<THandlers>;
+};
+type ToModuleHandlerArray<T extends readonly any[]> = T extends readonly [] ? readonly [] : {
+    readonly [K in keyof T]: Constructor<T[K]> | ClassHandler<Constructor<T[K]>>;
+};
+type ToModulePreHandlerMap<T extends DefPreHandlerMap> = [keyof T] extends [
+    never
+] ? EmptyObject : {
+    [K in keyof T]: Constructor<T[K]> | ClassMiddleware<Constructor<T[K]>>;
+};
+type WithQueryPreHandlers<TPreHandlers extends DefPreHandlerMap | EmptyObject> = TPreHandlers extends EmptyObject ? {
+    queryPreHandlers?: EmptyObject;
+} : {
+    queryPreHandlers: ToModulePreHandlerMap<TPreHandlers>;
+};
+type WithCommandPreHandlers<TPreHandlers extends DefPreHandlerMap | EmptyObject> = TPreHandlers extends EmptyObject ? {
+    commandPreHandlers?: EmptyObject;
+} : {
+    commandPreHandlers: ToModulePreHandlerMap<TPreHandlers>;
+};
+type WithQueryPreHandlerExports<TKeys extends readonly string[]> = TKeys extends readonly [] ? {
+    queryPreHandlerExports?: readonly [];
+} : {
+    queryPreHandlerExports: TKeys;
+};
+type WithCommandPreHandlerExports<TKeys extends readonly string[]> = TKeys extends readonly [] ? {
+    commandPreHandlerExports?: readonly [];
+} : {
+    commandPreHandlerExports: TKeys;
+};
+type WithInitializers<TInitializers extends DefInitializerMap | EmptyObject> = TInitializers extends EmptyObject ? {
+    initializers?: EmptyObject;
+} : {
+    initializers: TInitializers;
+};
+type WithInitializerExports<TKeys extends readonly string[]> = TKeys extends readonly [] ? {
+    initializerExports?: readonly [];
+} : {
+    initializerExports: TKeys;
+};
+type ToModuleInterceptorMap<T extends DefInterceptorMap> = [keyof T] extends [
+    never
+] ? EmptyObject : {
+    [K in keyof T]: AnyInterceptor;
+};
+type WithInterceptors<TInterceptors extends DefInterceptorMap | EmptyObject> = TInterceptors extends EmptyObject ? {
+    interceptors?: EmptyObject;
+} : {
+    interceptors: ToModuleInterceptorMap<TInterceptors>;
+};
+type WithInterceptorExports<TKeys extends readonly string[]> = TKeys extends readonly [] ? {
+    interceptorExports?: readonly [];
+} : {
+    interceptorExports: TKeys;
+};
+type WithImports<TImports extends readonly unknown[]> = 0 extends 1 & TImports ? {
+    imports?: (AnyModule | Promise<AnyModule> | ForwardRef)[];
+} : TImports extends readonly [] ? {
+    imports?: [];
+} : {
+    imports: WithForwardRefImports<TImports>;
+};
+type WithForwardRefImports<T extends readonly unknown[]> = {
+    [K in keyof T]: T[K] extends ModuleRef<infer MDef> ? ForwardRef<ForwardRefModule<MDef>> : Awaited<T[K]> extends ImportModule<any> ? T[K] : T[K];
+};
+type ForwardRefModule<MDef> = MDef extends {
+    exports: infer E extends DefProviderMap;
+    providers: infer P extends DefProviderMap;
+} ? {
+    name: string;
+    exports: readonly Extract<keyof E, string>[];
+    providers: ToModuleProviderMap<P, any>;
+} : AnyModule;
+export {};

package/dist/lib/di/modules/module.types.js

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

package/dist/lib/di/modules/runtime-module.types.d.ts

@@ -0,0 +1,32 @@
+import type { BuildResolverOptions, ContainerOptions } from "awilix";
+import type { AnyController, AnyInitializer, AnyInterceptor, AnyMiddleware, AnyProvider } from "../providers/provider.types.js";
+import type { ForwardRef } from "./module-ref.types.js";
+export interface InternalModuleLike {
+    name: string;
+    __devtools?: {
+        baseName?: string;
+        dynamic?: {
+            hash: string;
+            paramsPreview: string;
+        };
+    };
+    imports?: readonly (InternalModuleLike | Promise<InternalModuleLike> | ForwardRef<InternalModuleLike>)[];
+    providers?: Record<string, AnyProvider>;
+    exports?: readonly string[];
+    components?: Record<string, (...args: any[]) => unknown>;
+    componentExports?: readonly string[];
+    controllers?: AnyController[];
+    registerControllers?: boolean;
+    containerOptions?: ContainerOptions;
+    providerOptions?: Partial<BuildResolverOptions<any>>;
+    queryHandlers?: readonly any[];
+    commandHandlers?: readonly any[];
+    queryPreHandlers?: Record<string, AnyMiddleware>;
+    commandPreHandlers?: Record<string, AnyMiddleware>;
+    queryPreHandlerExports?: readonly string[];
+    commandPreHandlerExports?: readonly string[];
+    interceptors?: Record<string, AnyInterceptor>;
+    interceptorExports?: readonly string[];
+    initializers?: Record<string, AnyInitializer>;
+    initializerExports?: readonly string[];
+}

package/dist/lib/di/modules/runtime-module.types.js

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

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

@@ -0,0 +1,13 @@
+import * as Awilix from "awilix";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { ControllerRuntimeEntry } from "./initializer-processor.js";
+import type { InterceptorProcessor } from "./interceptor-processor.js";
+export declare class ControllerProcessor {
+    private readonly interceptorProcessor;
+    private readonly providerOptions;
+    private readonly skipRegisterRoutes;
+    private readonly registeredControllers;
+    constructor(interceptorProcessor: InterceptorProcessor, providerOptions: Partial<Awilix.BuildResolverOptions<any>>, skipRegisterRoutes: boolean);
+    processControllers(m: M, diScope: Awilix.AwilixContainer): ControllerRuntimeEntry[];
+    private resolveBySymbol;
+}

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

@@ -0,0 +1,76 @@
+import * as Awilix from "awilix";
+import * as ERRORS from "../errors.js";
+import { resolveFromRequestScope } from "../request-scope-context.js";
+import { hasUseClass } from "../type-guards.js";
+export class ControllerProcessor {
+    interceptorProcessor;
+    providerOptions;
+    skipRegisterRoutes;
+    registeredControllers = new WeakMap();
+    constructor(interceptorProcessor, providerOptions, skipRegisterRoutes) {
+        this.interceptorProcessor = interceptorProcessor;
+        this.providerOptions = providerOptions;
+        this.skipRegisterRoutes = skipRegisterRoutes;
+    }
+    processControllers(m, diScope) {
+        if (!m.controllers?.length)
+            return [];
+        if (m.registerControllers === false)
+            return [];
+        const runtimeEntries = [];
+        if (new Set(m.controllers).size !== m.controllers.length) {
+            throw new ERRORS.DuplicateControllersInModuleError(m.name);
+        }
+        for (const c of m.controllers) {
+            const { useClass, ...awilixOptions } = hasUseClass(c)
+                ? c
+                : { useClass: c };
+            const existingModule = this.registeredControllers.get(useClass);
+            if (!existingModule) {
+                this.registeredControllers.set(useClass, m);
+                const controllerSymbol = Symbol(`controller_${useClass.name}`);
+                const options = {
+                    ...this.providerOptions,
+                    ...m.providerOptions,
+                    ...awilixOptions,
+                };
+                const isWithNewScope = options.lifetime !== Awilix.Lifetime.SINGLETON;
+                const baseResolver = Awilix.asClass(useClass, {
+                    ...options,
+                    ...(isWithNewScope && {
+                        injector: () => ({
+                            resolveSelf: () => this.resolveBySymbol(controllerSymbol, diScope, isWithNewScope),
+                        }),
+                    }),
+                });
+                diScope.register({
+                    [controllerSymbol]: this.interceptorProcessor.createInterceptedProviderResolver({
+                        module: m,
+                        useClass,
+                        options,
+                        resolver: baseResolver,
+                    }),
+                });
+                if (!this.skipRegisterRoutes &&
+                    typeof useClass.prototype.registerRoutes === "function") {
+                    baseResolver.resolve(diScope).registerRoutes();
+                }
+                runtimeEntries.push({
+                    controllerClass: useClass,
+                    resolve: () => this.resolveBySymbol(controllerSymbol, diScope, isWithNewScope),
+                });
+                continue;
+            }
+            if (existingModule === m) {
+                continue;
+            }
+            throw new ERRORS.ControllerAlreadyRegisteredError(useClass.name, existingModule.name);
+        }
+        return runtimeEntries;
+    }
+    resolveBySymbol(symbol, scope, withNewScope) {
+        if (withNewScope)
+            return resolveFromRequestScope(scope, symbol);
+        return scope.resolve(symbol);
+    }
+}

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

@@ -0,0 +1,19 @@
+import * as Awilix from "awilix";
+import type { DevtoolsProcessorRef } from "../../devtools/devtools.types.js";
+import type { RegisteredModuleScope } from "../contexts/container-context-base.js";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+export declare const HandlerType: {
+    readonly Query: "query";
+    readonly Command: "command";
+};
+export type HandlerType = (typeof HandlerType)[keyof typeof HandlerType];
+export declare class HandlerProcessor {
+    private readonly providerOptions;
+    private readonly devtoolsProcessorRef;
+    private readonly keyedFeatureRegistrar;
+    private static readonly handlerConfig;
+    constructor(providerOptions: Partial<Awilix.BuildResolverOptions<any>>, devtoolsProcessorRef: DevtoolsProcessorRef);
+    processHandlers(m: M, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[], handlerType: HandlerType): void;
+    private createTracedHandlerResolver;
+    private get devtoolsTracer();
+}

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

@@ -0,0 +1,103 @@
+import * as Awilix from "awilix";
+import { Mediator } from "../../mediator/mediator.js";
+import * as ERRORS from "../errors.js";
+import { ProviderResolver } from "../providers/provider-resolver.js";
+import { getOrCreateRequestScope } from "../request-scope-context.js";
+import { hasUseClass } from "../type-guards.js";
+import { KeyedFeatureRegistrar } from "./keyed-feature-registrar.js";
+export const HandlerType = {
+    Query: "query",
+    Command: "command",
+};
+export class HandlerProcessor {
+    providerOptions;
+    devtoolsProcessorRef;
+    keyedFeatureRegistrar;
+    static handlerConfig = {
+        query: {
+            handlersKey: "queryHandlers",
+            preHandlersKey: "queryPreHandlers",
+            mediatorKey: "queryMediator",
+        },
+        command: {
+            handlersKey: "commandHandlers",
+            preHandlersKey: "commandPreHandlers",
+            mediatorKey: "commandMediator",
+        },
+    };
+    constructor(providerOptions, devtoolsProcessorRef) {
+        this.providerOptions = providerOptions;
+        this.devtoolsProcessorRef = devtoolsProcessorRef;
+        this.keyedFeatureRegistrar = new KeyedFeatureRegistrar(providerOptions);
+    }
+    processHandlers(m, scope, importedModulesWithScope, handlerType) {
+        const { handlersKey, mediatorKey, preHandlersKey } = HandlerProcessor.handlerConfig[handlerType];
+        const middlewareResolvers = this.keyedFeatureRegistrar.register({
+            featureKind: preHandlersKey,
+            module: m,
+            scope,
+            importedModulesWithScope,
+        });
+        const handlers = m[handlersKey];
+        if (!handlers?.length)
+            return;
+        const mediator = new Mediator(middlewareResolvers, m.name, handlerType, this.devtoolsProcessorRef);
+        for (const h of handlers) {
+            const { useClass: HandlerClass, ...handlerOptions } = hasUseClass(h)
+                ? h
+                : { useClass: h };
+            const handlerKey = HandlerClass.key;
+            if (typeof handlerKey !== "string" || !handlerKey.length) {
+                throw new ERRORS.HandlerMissingStaticKeyError(HandlerClass.name);
+            }
+            const options = ProviderResolver.mergeResolverOptions(m, this.providerOptions, handlerOptions);
+            const handlerSymbol = Symbol(`${handlerKey}_${HandlerClass.name}`);
+            const handlerResolver = Awilix.asClass(HandlerClass, options);
+            scope.register({
+                [handlerSymbol]: this.createTracedHandlerResolver({
+                    handlerClassName: HandlerClass.name,
+                    module: m,
+                    options,
+                    resolver: handlerResolver,
+                }),
+            });
+            mediator.register(handlerKey, async (payload, context) => {
+                const requestScope = options.lifetime === Awilix.Lifetime.SINGLETON
+                    ? scope
+                    : getOrCreateRequestScope(scope);
+                if (!this.devtoolsTracer) {
+                    return requestScope
+                        .resolve(handlerSymbol)
+                        .executor(payload, context);
+                }
+                return this.devtoolsTracer.recordSpan({
+                    kind: "handler",
+                    moduleName: m.name,
+                    providerKey: `${handlerType}:${handlerKey}`,
+                    methodName: "executor",
+                    args: [payload, context],
+                    callback: () => requestScope
+                        .resolve(handlerSymbol)
+                        .executor(payload, context),
+                });
+            });
+        }
+        scope.register({
+            [mediatorKey]: Awilix.asValue(mediator),
+        });
+    }
+    createTracedHandlerResolver({ handlerClassName, module, options, resolver, }) {
+        if (!this.devtoolsTracer)
+            return resolver;
+        return this.devtoolsTracer.wrapResolver({
+            kind: "handler",
+            module,
+            options,
+            providerKey: handlerClassName,
+            resolver,
+        });
+    }
+    get devtoolsTracer() {
+        return this.devtoolsProcessorRef.current?.tracer;
+    }
+}

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

@@ -0,0 +1,20 @@
+import type * as Awilix from "awilix";
+import type { DevtoolsProcessorRef } from "../../devtools/devtools.types.js";
+import type { RegisteredModuleScope } from "../contexts/container-context-base.js";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { ConstructorController } from "../providers/provider.types.js";
+import type { ModuleInitOptions } from "./lifecycle-processor.js";
+export type ControllerRuntimeEntry = {
+    controllerClass: ConstructorController;
+    resolve: () => any;
+};
+export type InitializerTask = (options?: ModuleInitOptions) => Promise<void>;
+export declare class InitializerProcessor {
+    private readonly devtoolsProcessorRef;
+    private readonly keyedFeatureRegistrar;
+    private readonly resolversByModule;
+    constructor(devtoolsProcessorRef: DevtoolsProcessorRef);
+    collectInitializers(m: M, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[], controllers: ControllerRuntimeEntry[]): InitializerTask | null;
+    private ensureNoMultiInvokableInitializersPerMethod;
+    private filterActiveInitializers;
+}