awilixify 3.0.0 → 3.1.0

package/README.md

@@ -7,8 +7,11 @@ Transport-agnostic, type-safe, modular DI and CQRS framework on top of [Awilix](
 [![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)
 
-> [!WARNING]
-> This project is in active development and is not production-ready yet.
+> [!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)
 
 📚 Documentation: https://wildstyles.github.io/awilixify/
 

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 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";
@@ -7,7 +8,7 @@ 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 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";

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/contexts/container-context-base.d.ts

@@ -1,4 +1,5 @@
 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";
@@ -9,9 +10,9 @@ interface ScopeContext {
     hasScopeContext: () => boolean;
     resolveFromScope: <T>(scope: Awilix.AwilixContainer, key: string | symbol) => T;
 }
-export interface ContainerContextOptions extends OverrideOptions {
+export interface ContainerContextOptions<Options extends Awilix.BuildResolverOptions<any> = Awilix.BuildResolverOptions<any>> extends OverrideOptions {
     containerOptions?: Awilix.ContainerOptions;
-    providerOptions?: Partial<Awilix.BuildResolverOptions<any>>;
+    providerOptions?: Options;
     globalModules?: readonly M[];
 }
 export interface ModuleScope<S extends Awilix.AwilixContainer = Awilix.AwilixContainer> extends LifecycleMethods {
@@ -27,6 +28,7 @@ export declare abstract class ContainerContextBase<TOptions extends ContainerCon
     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;
@@ -39,15 +41,23 @@ export declare abstract class ContainerContextBase<TOptions extends ContainerCon
     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 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

@@ -1,4 +1,5 @@
 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";
@@ -9,6 +10,7 @@ export class ContainerContextBase {
     scopeContext;
     forwardRefModules = new WeakSet();
     moduleScopeMap = new WeakMap();
+    devtoolsProcessorRef = {};
     moduleTreeMap = new WeakMap();
     options;
     sorter = new ProviderDependencySorter();
@@ -37,7 +39,7 @@ export class ContainerContextBase {
         this.lifecycleProcessor = new LifecycleProcessor(this.options.providerOptions || {});
     }
     bootstrapModule(module) {
-        this.initializeGlobalModules();
+        this.initializeGlobalModules(module);
         const moduleTree = this.registerModuleWithScope(module, this.createContainer(module), []);
         this.overridesProcessor.ensureAllModuleOverridesApplied();
         return moduleTree;
@@ -57,6 +59,11 @@ export class ContainerContextBase {
         }
         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,
@@ -100,6 +107,7 @@ export class ContainerContextBase {
             scope.register({
                 [key]: this.providerResolver.resolveProvider({
                     key,
+                    moduleId,
                     provider,
                     resolutionScope: scope,
                     module: moduleWithOverrides,
@@ -112,21 +120,21 @@ export class ContainerContextBase {
         this.moduleTreeMap.set(m, moduleTree);
         return moduleTree;
     }
-    initializeGlobalModules() {
-        const globalModules = this.options.globalModules || [];
-        const globalModuleImports = globalModules.flatMap((module) => this.resolveImports(module).map((importedModule) => ({
+    initializeGlobalModules(rootModule) {
+        const globalModuleImports = this.globalModules.flatMap((module) => this.resolveImports(module).map((importedModule) => ({
             module,
             importedModule,
         })));
         this.moduleGraphEnsurer.ensureGlobalModulesDoNotImportGlobalModules({
-            globalModules,
+            globalModules: this.globalModules,
             globalModuleImports,
         });
         this.globalModulesWithScope = [];
-        for (const module of globalModules) {
+        this.attachDevtools(rootModule);
+        for (const module of this.globalModules) {
             const moduleTree = this.registerModuleWithScope(module, this.createContainer(module), []);
             this.globalModulesWithScope.push({
-                module: this.overridesProcessor.getModuleWithOverrides(module),
+                module,
                 moduleScope: moduleTree,
             });
         }
@@ -188,7 +196,37 @@ export class ContainerContextBase {
             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.js

@@ -10,26 +10,26 @@ export class AsyncDIContext extends DIContextBase {
     }
     async bootstrap(module) {
         const rootModule = await module;
-        await this.initializeGlobalModulesAsync();
+        await this.initializeGlobalModulesAsync(rootModule);
         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) => ({
+    async initializeGlobalModulesAsync(rootModule) {
+        const globalModuleImports = (await Promise.all(this.globalModules.map(async (module) => (await this.resolveImportsAsync(module)).map((importedModule) => ({
             module,
             importedModule,
         }))))).flat();
         this.moduleGraphEnsurer.ensureGlobalModulesDoNotImportGlobalModules({
-            globalModules,
+            globalModules: this.globalModules,
             globalModuleImports,
         });
         this.globalModulesWithScope = [];
-        for (const module of globalModules) {
+        this.attachDevtools(rootModule);
+        for (const module of this.globalModules) {
             const moduleTree = await this.registerModuleWithScopeAsync(module, this.createContainer(module), []);
             this.globalModulesWithScope.push({
-                module: this.overridesProcessor.getModuleWithOverrides(module),
+                module,
                 moduleScope: moduleTree,
             });
         }
@@ -41,6 +41,11 @@ export class AsyncDIContext extends DIContextBase {
         }
         const imports = await this.resolveImportsAsync(m);
         const moduleWithOverrides = this.overridesProcessor.applyModuleOverrides(m);
+        const moduleId = this.registerModuleInGraph({
+            module: moduleWithOverrides,
+            scope,
+            importedModules: imports,
+        });
         this.moduleGraphEnsurer.ensureImportedModulesUniqueness({
             module: moduleWithOverrides,
             resolvedImports: imports,
@@ -66,11 +71,11 @@ export class AsyncDIContext extends DIContextBase {
         if (pendingTree) {
             return pendingTree;
         }
-        const moduleTreePromise = this.registerNewModuleWithScopeAsync(m, moduleWithOverrides, scope, imports, moduleChain);
+        const moduleTreePromise = this.registerNewModuleWithScopeAsync(m, moduleWithOverrides, moduleId, scope, imports, moduleChain);
         this.moduleTreePromiseMap.set(m, moduleTreePromise);
         return moduleTreePromise;
     }
-    async registerNewModuleWithScopeAsync(m, moduleWithOverrides, scope, imports, moduleChain) {
+    async registerNewModuleWithScopeAsync(m, moduleWithOverrides, moduleId, scope, imports, moduleChain) {
         this.moduleScopeMap.set(m, scope);
         const importedModulesWithScope = [
             ...this.globalModulesWithScope,
@@ -93,6 +98,7 @@ export class AsyncDIContext extends DIContextBase {
             scope.register({
                 [key]: await this.providerResolver.resolveProviderAsync({
                     key,
+                    moduleId,
                     provider,
                     resolutionScope: scope,
                     module: moduleWithOverrides,

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

@@ -9,16 +9,17 @@ export class DIContextBase extends ContainerContextBase {
     controllerProcessor;
     handlerProcessor;
     interceptorProcessor;
-    initializerProcessor = new InitializerProcessor();
+    initializerProcessor;
     constructor(options) {
         super(options, {
             hasScopeContext: hasRequestScopeContext,
             resolveFromScope: resolveFromRequestScope,
         });
-        this.handlerProcessor = new HandlerProcessor(this.options.providerOptions || {});
-        this.interceptorProcessor = new InterceptorProcessor(this.options.providerOptions || {});
+        this.handlerProcessor = new HandlerProcessor(this.options.providerOptions || {}, this.devtoolsProcessorRef);
+        this.interceptorProcessor = new InterceptorProcessor(this.options.providerOptions || {}, this.devtoolsProcessorRef);
+        this.initializerProcessor = new InitializerProcessor(this.devtoolsProcessorRef);
         this.controllerProcessor = new ControllerProcessor(this.interceptorProcessor, this.options.providerOptions || {}, this.options.skipRegisterRoutes === true);
-        this.providerResolver = new ProviderResolver(this.interceptorProcessor, this.options.providerOptions || {}, getOrCreateRequestScope);
+        this.providerResolver = new ProviderResolver(this.interceptorProcessor, this.options.providerOptions || {}, this.devtoolsProcessorRef, getOrCreateRequestScope);
     }
     beforeRegisterProviders(m, scope, importedModulesWithScope) {
         this.interceptorProcessor.processInterceptors(m, scope, importedModulesWithScope);

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

@@ -27,5 +27,6 @@ export declare class ModuleGraphEnsurer {
     ensureGlobalModulesDoNotImportGlobalModules({ globalModules, globalModuleImports, }: EnsureGlobalModulesDoNotImportGlobalModulesParams): void;
     ensureNoProviderNameConflicts({ module, resolvedImports, globalModules, getExportedProviderKeys, }: EnsureNoProviderNameConflictsParams): void;
     ensureCircularDependencyHasForwardRef({ module, moduleChain, forwardRefModules, }: EnsureCircularDependencyHasForwardRefParams): void;
+    ensureSingleDevtoolsModule(devtoolsModules: M[]): M | undefined;
 }
 export {};

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

@@ -42,4 +42,9 @@ export class ModuleGraphEnsurer {
         const chainNames = moduleChain.map((chainModule) => chainModule.name);
         throw new ERRORS.CircularModuleDependencyError(module.name, chainNames);
     }
+    ensureSingleDevtoolsModule(devtoolsModules) {
+        if (devtoolsModules.length <= 1)
+            return devtoolsModules[0];
+        throw new ERRORS.DuplicateDevtoolsModuleError(devtoolsModules.map((module) => module.name));
+    }
 }

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

@@ -13,6 +13,9 @@ export declare class CircularDependencyError extends Error {
 export declare class DuplicateModuleImportError extends Error {
     constructor(parentModuleName: string, importedModuleName: string);
 }
+export declare class DuplicateDevtoolsModuleError extends Error {
+    constructor(moduleNames: string[]);
+}
 export declare class ProviderNameConflictError extends Error {
     constructor(moduleName: string, conflictingKeys: string[]);
 }

package/dist/lib/di/errors.js

@@ -30,6 +30,12 @@ export class DuplicateModuleImportError extends Error {
         this.name = "DuplicateModuleImportError";
     }
 }
+export class DuplicateDevtoolsModuleError extends Error {
+    constructor(moduleNames) {
+        super(`Only one devtools module can be registered. Found: ${moduleNames.join(", ")}`);
+        this.name = "DuplicateDevtoolsModuleError";
+    }
+}
 export class ProviderNameConflictError extends Error {
     constructor(moduleName, conflictingKeys) {
         super(`Module "${moduleName}" has provider name conflicts with imported modules: ${conflictingKeys.join(", ")}`);

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

@@ -18,13 +18,21 @@ export function createModule(module, options) {
     if (options?.hashNameFrom === undefined) {
         return withOptions;
     }
+    const hashSource = stableStringify(options.hashNameFrom);
     const hash = createHash("sha256")
-        .update(stableStringify(options.hashNameFrom))
+        .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) {

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

@@ -3,6 +3,13 @@ import type { AnyController, AnyInitializer, AnyInterceptor, AnyMiddleware, AnyP
 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[];

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

@@ -1,4 +1,5 @@
 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: {
@@ -8,8 +9,11 @@ export declare const HandlerType: {
 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>>);
+    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

@@ -11,6 +11,7 @@ export const HandlerType = {
 };
 export class HandlerProcessor {
     providerOptions;
+    devtoolsProcessorRef;
     keyedFeatureRegistrar;
     static handlerConfig = {
         query: {
@@ -24,8 +25,9 @@ export class HandlerProcessor {
             mediatorKey: "commandMediator",
         },
     };
-    constructor(providerOptions) {
+    constructor(providerOptions, devtoolsProcessorRef) {
         this.providerOptions = providerOptions;
+        this.devtoolsProcessorRef = devtoolsProcessorRef;
         this.keyedFeatureRegistrar = new KeyedFeatureRegistrar(providerOptions);
     }
     processHandlers(m, scope, importedModulesWithScope, handlerType) {
@@ -39,7 +41,7 @@ export class HandlerProcessor {
         const handlers = m[handlersKey];
         if (!handlers?.length)
             return;
-        const mediator = new Mediator(middlewareResolvers, m.name);
+        const mediator = new Mediator(middlewareResolvers, m.name, handlerType, this.devtoolsProcessorRef);
         for (const h of handlers) {
             const { useClass: HandlerClass, ...handlerOptions } = hasUseClass(h)
                 ? h
@@ -50,20 +52,52 @@ export class HandlerProcessor {
             }
             const options = ProviderResolver.mergeResolverOptions(m, this.providerOptions, handlerOptions);
             const handlerSymbol = Symbol(`${handlerKey}_${HandlerClass.name}`);
+            const handlerResolver = Awilix.asClass(HandlerClass, options);
             scope.register({
-                [handlerSymbol]: Awilix.asClass(HandlerClass, options),
+                [handlerSymbol]: this.createTracedHandlerResolver({
+                    handlerClassName: HandlerClass.name,
+                    module: m,
+                    options,
+                    resolver: handlerResolver,
+                }),
             });
-            mediator.register(handlerKey, (payload, context) => {
+            mediator.register(handlerKey, async (payload, context) => {
                 const requestScope = options.lifetime === Awilix.Lifetime.SINGLETON
                     ? scope
                     : getOrCreateRequestScope(scope);
-                return requestScope
-                    .resolve(handlerSymbol)
-                    .executor(payload, context);
+                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

@@ -1,4 +1,5 @@
 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";
@@ -9,11 +10,11 @@ export type ControllerRuntimeEntry = {
 };
 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;
-    private processInitializerResolvers;
-    private getControllerMethodNames;
 }