@zlink-systems/nestjs 0.30.0 → 0.30.1

package/dist/framework-loader.d.ts

@@ -1,12 +1,21 @@
-import type { Type, ZLinkActorClient, ZLinkActorManager, ZLinkChannelClient, ZLinkCodecRegistrar, ZLinkCodecRegistryBuilder, ZLinkDispatchOptions, ZLinkDispatchOptionsBuilder, ZLinkInboundDispatchOptions, ZLinkLocationOptionValues, ZLinkLocationOptions, ZLinkEntrySpot, ZLinkFanoutClient, ZLinkHandlerFilterContext, ZLinkRouteClient, ZLinkSpot, ZLinkSpotManager, ZLinkSpotOutbound, ZLinkSpotPublisherClient, ZLinkStreamCompressionBuilder, ZLinkStreamCompressionCodec } from '@zlink-systems/framework';
+import type { Type, ZLinkActorClient, ZLinkActorManager, ZLinkChannelClient, ZLinkCodecRegistrar, ZLinkCodecRegistryBuilder, ZLinkDispatchOptions, ZLinkDispatchOptionsBuilder, ZLinkInboundDispatchOptions, ZLinkLocationOptionValues, ZLinkLocationOptions, ZLinkMessageContext, ZLinkEntrySpot, ZLinkFanoutClient, ZLinkHandlerFilterContext, ZLinkRouteClient, ZLinkSpot, ZLinkSpotManager, ZLinkSpotOutbound, ZLinkSpotPublisherClient, ZLinkStreamCompressionBuilder, ZLinkStreamCompressionCodec } from '@zlink-systems/framework';
 import type { ZLinkHttpExecutionScheduler } from '@zlink-systems/http-client';
 import type { ZLinkCodecSerializerRegistration, ZLinkFrameworkRegistration, ZLinkFrameworkRegistrationOptions, ZLinkNestIntegrationRuntimeHost, ZLinkProviderResolver, ZLinkStreamCodecRegistration } from './framework-integration-contracts';
 export type FrameworkRuntimeHost = ZLinkNestIntegrationRuntimeHost;
+interface HandlerResolver {
+    resolve<T>(type: Type<T>): Promise<T>;
+}
 interface FrameworkIntegrationModule {
     ZLinkSpotActorSend(packetName?: string): MethodDecorator;
     ZLinkSpotActorRequest(packetName?: string): MethodDecorator;
     disposeIntegrationHandler(instance: unknown): Promise<void>;
     disposeIntegrationHandlers(instances: readonly unknown[]): Promise<void>;
+    registerIntegrationHandlerInstanceScopeFactory(resolver: ZLinkProviderResolver, factory: {
+        prepare?(type: Type): void;
+        create(context?: ZLinkMessageContext): HandlerResolver & {
+            dispose(): Promise<void>;
+        };
+    }): void;
     readonly MAX_LISTENER_PORT: number;
     readonly ZLINK_MAX_PUBLIC_WEIGHT: number;
     readonly ZLINK_MAX_CAPACITY: number;
@@ -60,9 +69,7 @@ interface FrameworkIntegrationModule {
     registerRelocationStore(options: {
         relocationStoreInstance?: import('@zlink-systems/framework').ZLinkRelocationStore;
     }, store: import('@zlink-systems/framework').ZLinkRelocationStore): void;
-    registerIntegrationHandlerFilterScope(resolver: ZLinkProviderResolver, runner: (context: ZLinkHandlerFilterContext, callback: (scope: {
-        resolve<T>(type: Type<T>): Promise<T>;
-    }) => Promise<unknown>) => Promise<unknown>): void;
+    registerIntegrationHandlerFilterScope(resolver: ZLinkProviderResolver, runner: (context: ZLinkHandlerFilterContext, callback: (scope: HandlerResolver) => Promise<unknown>) => Promise<unknown>): void;
 }
 export declare const framework: FrameworkIntegrationModule;
 export {};

package/dist/handler-adapters.d.ts

@@ -2,10 +2,11 @@ import { ModuleRef } from '@nestjs/core';
 import type { ZLinkChannelOptions } from './framework-integration-contracts';
 import type { ZLinkNestManualHandlerOptions } from './contracts';
 import type { DiscoveredNestProvider } from './provider-discovery';
-export declare function createDiscoveredRequestHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['requestHandlers']>;
-export declare function createDiscoveredSendHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef): NonNullable<NonNullable<ZLinkChannelOptions['routeMesh']>['sendHandlers']>;
-export declare function createDiscoveredChannelSendHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['sendHandlers']>;
-export declare function createDiscoveredPublishHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['publishHandlers']>;
-export declare function createManualRequestHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['requestHandlers']>;
-export declare function createManualPublishHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['publishHandlers']>;
-export declare function createManualSendHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['sendHandlers']>;
+import { type NestHandlerFactories } from './providers';
+export declare function createDiscoveredRequestHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['requestHandlers']>;
+export declare function createDiscoveredSendHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<NonNullable<ZLinkChannelOptions['routeMesh']>['sendHandlers']>;
+export declare function createDiscoveredChannelSendHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['sendHandlers']>;
+export declare function createDiscoveredPublishHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['publishHandlers']>;
+export declare function createManualRequestHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['requestHandlers']>;
+export declare function createManualPublishHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['publishHandlers']>;
+export declare function createManualSendHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['sendHandlers']>;

package/dist/handler-adapters.js

@@ -11,66 +11,65 @@ const core_1 = require("@nestjs/core");
 const framework_loader_1 = require("./framework-loader");
 const dispatch_scope_1 = require("./dispatch-scope");
 const providers_1 = require("./providers");
-function createDiscoveredRequestHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'request', moduleRef, (ref, metadata) => ({
+function createDiscoveredRequestHandlers(providerRefs, handlerGroups, moduleRef, factories = new Map()) {
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'request', moduleRef, factories, (ref, metadata, factory) => ({
         async handle(payload, context) {
-            const result = await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
+            const result = await invokeDiscoveredHandler(moduleRef, ref, metadata, factory, payload, context);
             return metadata.encodeResult === undefined
                 ? result
                 : metadata.encodeResult(result, context);
         }
     }));
 }
-function createDiscoveredSendHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', moduleRef, (ref, metadata) => ({
+function createDiscoveredSendHandlers(providerRefs, handlerGroups, moduleRef, factories = new Map()) {
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', moduleRef, factories, (ref, metadata, factory) => ({
         async handle(payload, context) {
-            await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
+            await invokeDiscoveredHandler(moduleRef, ref, metadata, factory, payload, context);
         }
     }));
 }
-function createDiscoveredChannelSendHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', moduleRef, (ref, metadata) => ({
+function createDiscoveredChannelSendHandlers(providerRefs, handlerGroups, moduleRef, factories = new Map()) {
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', moduleRef, factories, (ref, metadata, factory) => ({
         async handle(payload, context) {
-            await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
+            await invokeDiscoveredHandler(moduleRef, ref, metadata, factory, payload, context);
         }
     }));
 }
-function createDiscoveredPublishHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'publish', moduleRef, (ref, metadata) => ({
+function createDiscoveredPublishHandlers(providerRefs, handlerGroups, moduleRef, factories = new Map()) {
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'publish', moduleRef, factories, (ref, metadata, factory) => ({
         async handle(payload, context) {
-            await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
+            await invokeDiscoveredHandler(moduleRef, ref, metadata, factory, payload, context);
         }
     }));
 }
-function createManualRequestHandlers(handlerTypes, moduleRef) {
-    return createManualHandlerRegistrations(handlerTypes, moduleRef, (result) => result);
+function createManualRequestHandlers(handlerTypes, moduleRef, factories = new Map()) {
+    return createManualHandlerRegistrations(handlerTypes, moduleRef, factories, (result) => result);
 }
-function createManualPublishHandlers(handlerTypes, moduleRef) {
-    return createManualHandlerRegistrations(handlerTypes, moduleRef, () => undefined);
+function createManualPublishHandlers(handlerTypes, moduleRef, factories = new Map()) {
+    return createManualHandlerRegistrations(handlerTypes, moduleRef, factories, () => undefined);
 }
-function createManualSendHandlers(handlerTypes, moduleRef) {
-    return createManualHandlerRegistrations(handlerTypes, moduleRef, () => undefined);
+function createManualSendHandlers(handlerTypes, moduleRef, factories = new Map()) {
+    return createManualHandlerRegistrations(handlerTypes, moduleRef, factories, () => undefined);
 }
-function createManualHandlerRegistrations(handlerTypes, moduleRef, result) {
+function createManualHandlerRegistrations(handlerTypes, moduleRef, factories, result) {
     return (handlerTypes ?? []).map((registration) => {
-        (0, providers_1.validateNestConstructorDependencies)(moduleRef, registration.handlerType);
+        const factory = (0, providers_1.registeredNestHandlerFactory)(factories, registration.handlerType, moduleRef);
         return {
             packetName: registration.packetName,
             handler: {
                 async handle(payload, context) {
-                    return result(await invokeManualHandler(moduleRef, registration.handlerType, payload, context));
+                    return result(await invokeManualHandler(moduleRef, registration.handlerType, factory, payload, context));
                 }
             }
         };
     });
 }
-function createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, kind, moduleRef, createHandler) {
+function createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, kind, moduleRef, factories, createHandler) {
     const descriptors = createDiscoveredHandlerDescriptors(providerRefs, handlerGroups, kind);
     return descriptors.map(({ ref, metadata }) => {
-        (0, providers_1.validateNestConstructorDependencies)(moduleRef, ref.handlerKey);
         return {
             packetName: metadata.packetName,
-            handler: createHandler(ref, metadata)
+            handler: createHandler(ref, metadata, (0, providers_1.registeredNestHandlerFactory)(factories, ref.handlerKey, moduleRef))
         };
     });
 }
@@ -99,8 +98,8 @@ function createDiscoveredHandlerDescriptors(providerRefs, handlerGroups, kind) {
     }
     return selected;
 }
-async function invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context) {
-    const instance = await resolveHandlerInstance(moduleRef, ref.handlerKey, context);
+async function invokeDiscoveredHandler(moduleRef, ref, metadata, factory, payload, context) {
+    const instance = await resolveHandlerInstance(moduleRef, factory, context);
     try {
         const method = instance[metadata.methodName];
         if (typeof method !== 'function') {
@@ -112,8 +111,8 @@ async function invokeDiscoveredHandler(moduleRef, ref, metadata, payload, contex
         await framework_loader_1.framework.disposeIntegrationHandler(instance);
     }
 }
-async function invokeManualHandler(moduleRef, handlerType, payload, context) {
-    const instance = await resolveHandlerInstance(moduleRef, handlerType, context);
+async function invokeManualHandler(moduleRef, handlerType, factory, payload, context) {
+    const instance = await resolveHandlerInstance(moduleRef, factory, context);
     try {
         const method = instance.handle;
         if (typeof method !== 'function') {
@@ -125,13 +124,13 @@ async function invokeManualHandler(moduleRef, handlerType, payload, context) {
         await framework_loader_1.framework.disposeIntegrationHandler(instance);
     }
 }
-async function resolveHandlerInstance(moduleRef, handlerType, context) {
+async function resolveHandlerInstance(moduleRef, factory, context) {
     const currentContextId = (0, dispatch_scope_1.currentNestDispatchContext)();
     const contextId = currentContextId ?? core_1.ContextIdFactory.create();
     if (currentContextId === undefined) {
         moduleRef.registerRequestByContextId({ zlinkContext: context }, contextId);
     }
-    return (await (0, providers_1.createNestHandlerInstance)(moduleRef, contextId, new Map(), handlerType));
+    return (await factory(moduleRef, contextId, new Map()));
 }
 function decodePayload(metadata, payload, context) {
     if (Buffer.isBuffer(payload) || payload instanceof Uint8Array) {

package/dist/module.js

@@ -107,7 +107,7 @@ let ZLinkModule = ZLinkModule_1 = class ZLinkModule {
                 const moduleRef = args[args.length - 1];
                 const factoryArgs = args.slice(0, -2);
                 const resolvedOptions = (0, registration_composer_1.assertBuiltModuleOptions)(await options.useFactory(...factoryArgs));
-                return framework_loader_1.framework.createFrameworkRegistration((0, registration_composer_1.createDiscoveredOptions)(resolvedOptions, discovery, moduleRef));
+                return (0, registration_composer_1.createDiscoveredRegistration)(resolvedOptions, discovery, moduleRef);
             }
         };
         return {
@@ -158,7 +158,7 @@ function createDiscoveringZLinkDynamicModule(options) {
     const registrationProvider = {
         provide: tokens_1.ZLINK_FRAMEWORK_REGISTRATION,
         inject: [core_1.DiscoveryService, core_1.ModuleRef],
-        useFactory: (discovery, moduleRef) => framework_loader_1.framework.createFrameworkRegistration((0, registration_composer_1.createDiscoveredOptions)(options, discovery, moduleRef))
+        useFactory: (discovery, moduleRef) => (0, registration_composer_1.createDiscoveredRegistration)(options, discovery, moduleRef)
     };
     return {
         module: ZLinkModule,

package/dist/providers.d.ts

@@ -10,7 +10,12 @@ export declare function conditionalClientProviders(registration: ZLinkFrameworkR
 export declare function conditionalClientProvidersForFactory(registration?: ZLinkFrameworkRegistration): Provider[];
 export declare function conditionalClientTokens(): InjectionToken[];
 export declare function createRuntimeHost(registration: ZLinkFrameworkRegistration, moduleRef: ModuleRef, discovery: DiscoveryService): RuntimeHostWithNestLifecycle;
-export declare function createNestHandlerInstance<T>(moduleRef: ModuleRef, contextId: import('@nestjs/core').ContextId, dependencies: Map<unknown, Promise<unknown>>, type: Type<T>): Promise<T>;
-export declare function validateNestConstructorDependencies(moduleRef: ModuleRef, type: Type): void;
+export type NestHandlerFactories = Map<Type, NestHandlerFactory>;
+export declare function nestHandlerFactories(registration: ZLinkFrameworkRegistration, prepared?: NestHandlerFactories): NestHandlerFactories;
+export declare function registeredNestHandlerFactory<T>(factories: NestHandlerFactories, type: Type<T>, moduleRef: ModuleRef): NestHandlerFactory<T>;
+export type NestHandlerFactory<T = unknown> = ((moduleRef: ModuleRef, contextId: import('@nestjs/core').ContextId, dependencies: Map<unknown, unknown>) => T | Promise<T>) & {
+    readonly scopeFree?: () => T;
+};
+export declare function prepareNestHandlerFactory<T>(type: Type<T>, moduleRef?: ModuleRef): NestHandlerFactory<T>;
 export declare function providerToken(provider: Provider): InjectionToken;
 export {};

package/dist/providers.js

@@ -6,9 +6,11 @@ exports.conditionalClientProviders = conditionalClientProviders;
 exports.conditionalClientProvidersForFactory = conditionalClientProvidersForFactory;
 exports.conditionalClientTokens = conditionalClientTokens;
 exports.createRuntimeHost = createRuntimeHost;
-exports.createNestHandlerInstance = createNestHandlerInstance;
-exports.validateNestConstructorDependencies = validateNestConstructorDependencies;
+exports.nestHandlerFactories = nestHandlerFactories;
+exports.registeredNestHandlerFactory = registeredNestHandlerFactory;
+exports.prepareNestHandlerFactory = prepareNestHandlerFactory;
 exports.providerToken = providerToken;
+const common_1 = require("@nestjs/common");
 const constants_1 = require("@nestjs/common/constants");
 const core_1 = require("@nestjs/core");
 const unknown_element_exception_1 = require("@nestjs/core/errors/exceptions/unknown-element.exception");
@@ -126,7 +128,9 @@ const CONDITIONAL_CLIENT_PROVIDER_SPECS = [
         isEnabled: (registration) => framework_loader_1.framework.hasActorManager(registration),
         create: async (registration, runtime, moduleRef, discovery) => {
             const host = requireRuntime(runtime);
-            return framework_loader_1.framework.createIntegrationActorManager(registration, host, moduleRef === undefined ? undefined : createProviderResolver(moduleRef, discovery));
+            return framework_loader_1.framework.createIntegrationActorManager(registration, host, moduleRef === undefined
+                ? undefined
+                : createProviderResolver(moduleRef, discovery, registration));
         }
     },
     {
@@ -225,6 +229,18 @@ function hasLocationStores(registration) {
     return (registration.locations.useInMemoryStores || registration.locations.storeInstance !== undefined);
 }
 function createRuntimeHost(registration, moduleRef, discovery) {
+    const runtime = framework_loader_1.framework.createIntegrationRuntimeHost(registration, createProviderResolver(moduleRef, discovery, registration));
+    runtime.onModuleInit = async () => {
+        await runtime.start();
+    };
+    runtime.onModuleDestroy = async () => {
+        await runtime.shutdown();
+    };
+    runtime.onApplicationBootstrap = async () => { };
+    return runtime;
+}
+function createProviderResolver(moduleRef, discovery, registration) {
+    const factories = nestHandlerFactories(registration);
     const types = new Set([...registration.spotFactories, ...registration.filterTypes]);
     for (const node of registration.spotNodes.values()) {
         if (node.entrySpotType !== undefined)
@@ -238,6 +254,8 @@ function createRuntimeHost(registration, moduleRef, discovery) {
         for (const value of Object.values(node.instanceSpotFactoryRegistrations ?? {}))
             types.add(value.implementation);
         for (const handler of [
+            ...(node.routeSendHandlers ?? []),
+            ...(node.routeRequestHandlers ?? []),
             ...(node.entrySpotTimerHandlers ?? []),
             ...(node.entrySpotPacketHandlers ?? []),
             ...(node.entrySpotSubscriptionHandlers ?? []),
@@ -248,27 +266,34 @@ function createRuntimeHost(registration, moduleRef, discovery) {
             ...(node.spotSubscriptionHandlers ?? []),
             ...(node.spotActorSendHandlers ?? []),
             ...(node.spotActorRequestHandlers ?? [])
-        ])
-            types.add(handler.handlerType);
+        ]) {
+            const handlerType = handler.handlerType;
+            if (handlerType !== undefined)
+                types.add(handlerType);
+        }
+        for (const channel of Object.values(node.meshChannels ?? {})) {
+            for (const handler of [...(channel.sendHandlers ?? []), ...(channel.requestHandlers ?? [])]) {
+                const handlerType = handler.handlerType;
+                if (handlerType !== undefined)
+                    types.add(handlerType);
+            }
+        }
+    }
+    function prepareHandler(type) {
+        return registeredNestHandlerFactory(factories, type, moduleRef).scopeFree;
     }
     for (const type of types)
-        validateNestConstructorDependencies(moduleRef, type);
-    const runtime = framework_loader_1.framework.createIntegrationRuntimeHost(registration, createProviderResolver(moduleRef, discovery));
-    runtime.onModuleInit = async () => {
-        await runtime.start();
-    };
-    runtime.onModuleDestroy = async () => {
-        await runtime.shutdown();
-    };
-    runtime.onApplicationBootstrap = async () => { };
-    return runtime;
-}
-function createProviderResolver(moduleRef, discovery) {
+        prepareHandler(type);
+    function createHandler(contextId, dependencies, type) {
+        const factory = factories.get(type);
+        if (factory === undefined)
+            throw new Error(`Handler creation was not prepared: ${type.name}`);
+        return factory(moduleRef, contextId, dependencies);
+    }
     const resolver = {
         get(type) {
-            const discovered = findDiscoveredProvider(discovery, type)?.instance;
-            if (discovered !== undefined) {
-                return discovered;
+            if (discovery !== undefined) {
+                return findDiscoveredProvider(discovery, type)?.instance;
             }
             try {
                 return moduleRef.get(type, { strict: false });
@@ -283,56 +308,68 @@ function createProviderResolver(moduleRef, discovery) {
             return await creationModuleRef.create(type);
         }
     };
-    Object.defineProperty(resolver, Symbol.for('@zlink-systems/framework.handler-instance-scope-factory'), {
-        value: {
-            create(context) {
-                const currentContextId = (0, dispatch_scope_1.currentNestDispatchContext)();
-                const contextId = currentContextId ?? core_1.ContextIdFactory.create();
-                if (context !== undefined && currentContextId === undefined) {
-                    moduleRef.registerRequestByContextId({ zlinkContext: context }, contextId);
-                }
-                const instances = new Map();
-                const dependencies = new Map();
-                const owned = [];
-                let disposed = false;
-                return {
-                    async resolve(type) {
-                        if (disposed) {
-                            throw new Error('Handler instance scope is already disposed.');
-                        }
-                        let instance = instances.get(type);
-                        if (instance === undefined) {
-                            instance = createNestHandlerInstance(moduleRef, contextId, dependencies, type).then(async (created) => {
+    let freeScopeStorage;
+    framework_loader_1.framework.registerIntegrationHandlerInstanceScopeFactory(resolver, {
+        prepare: prepareHandler,
+        create(context) {
+            const currentContextId = (0, dispatch_scope_1.currentNestDispatchContext)();
+            const contextId = currentContextId ?? core_1.ContextIdFactory.create();
+            if (context !== undefined && currentContextId === undefined) {
+                moduleRef.registerRequestByContextId({ zlinkContext: context }, contextId);
+            }
+            const storage = freeScopeStorage ?? new NestHandlerScopeStorage();
+            freeScopeStorage = storage.next;
+            storage.next = undefined;
+            const { instances, dependencies, owned } = storage;
+            let disposed = false;
+            return {
+                resolve(type) {
+                    if (disposed) {
+                        return Promise.reject(new Error('Handler instance scope is already disposed.'));
+                    }
+                    let instance = instances.get(type);
+                    if (instance === undefined) {
+                        try {
+                            const finish = (created) => {
                                 if (disposed) {
-                                    await framework_loader_1.framework.disposeIntegrationHandler(created);
-                                    throw new Error('Handler instance scope was disposed during activation.');
+                                    return framework_loader_1.framework.disposeIntegrationHandler(created).then(() => {
+                                        throw new Error('Handler instance scope was disposed during activation.');
+                                    });
                                 }
                                 owned.push(created);
                                 return created;
-                            });
+                            };
+                            const created = createHandler(contextId, dependencies, type);
+                            instance = isNestPromiseLike(created)
+                                ? Promise.resolve(created).then(finish)
+                                : Promise.resolve(finish(created));
                             instances.set(type, instance);
                         }
-                        return (await instance);
-                    },
-                    async dispose() {
-                        if (disposed)
-                            return;
-                        disposed = true;
-                        const pending = [...instances.values()];
-                        await Promise.allSettled(pending);
-                        try {
-                            await framework_loader_1.framework.disposeIntegrationHandlers(owned);
-                        }
-                        finally {
-                            owned.length = 0;
-                            instances.clear();
-                            dependencies.clear();
+                        catch (error) {
+                            return Promise.reject(error);
                         }
                     }
-                };
-            }
-        },
-        enumerable: false
+                    return instance;
+                },
+                async dispose() {
+                    if (disposed)
+                        return;
+                    disposed = true;
+                    if (owned.length !== instances.size)
+                        await Promise.allSettled(instances.values());
+                    try {
+                        await framework_loader_1.framework.disposeIntegrationHandlers(owned);
+                    }
+                    finally {
+                        owned.length = 0;
+                        instances.clear();
+                        dependencies.clear();
+                        storage.next = freeScopeStorage;
+                        freeScopeStorage = storage;
+                    }
+                }
+            };
+        }
     });
     framework_loader_1.framework.registerIntegrationHandlerFilterScope(resolver, (context, callback) => (0, dispatch_scope_1.runInNestDispatchScope)(moduleRef, context, async () => {
         const contextId = (0, dispatch_scope_1.currentNestDispatchContext)();
@@ -341,7 +378,7 @@ function createProviderResolver(moduleRef, discovery) {
         try {
             return await callback({
                 async resolve(type) {
-                    const instance = await createNestHandlerInstance(moduleRef, contextId, dependencies, type);
+                    const instance = await createHandler(contextId, dependencies, type);
                     owned.push(instance);
                     return instance;
                 }
@@ -353,20 +390,86 @@ function createProviderResolver(moduleRef, discovery) {
     }));
     return resolver;
 }
-async function createNestHandlerInstance(moduleRef, contextId, dependencies, type) {
+const NEST_HANDLER_FACTORIES = Symbol('Nest handler factories');
+function nestHandlerFactories(registration, prepared) {
+    const owner = registration;
+    return (owner[NEST_HANDLER_FACTORIES] ??= prepared ?? new Map());
+}
+function registeredNestHandlerFactory(factories, type, moduleRef) {
+    let factory = factories.get(type);
+    if (factory === undefined) {
+        factory = prepareNestHandlerFactory(type, moduleRef);
+        factories.set(type, factory);
+    }
+    return factory;
+}
+class NestHandlerScopeStorage {
+    instances = new Map();
+    dependencies = new Map();
+    owned = [];
+    next;
+}
+function prepareNestHandlerFactory(type, moduleRef) {
     const { reflected, optional } = nestConstructorDependencies(type);
-    const parameters = await Promise.all(reflected.map((token, index) => resolveNestHandlerDependency(moduleRef, contextId, dependencies, token, optional.has(index))));
-    const instance = new type(...parameters);
-    const properties = Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, type);
+    const parameters = reflected.map((token, index) => prepareNestDependency(nestDependencyToken(token), optional.has(index), moduleRef));
     const optionalProperties = new Set(Reflect.getMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, type) ?? []);
-    for (const property of properties ?? []) {
-        const dependency = await resolveNestHandlerDependency(moduleRef, contextId, dependencies, property.type, optionalProperties.has(property.key));
-        if (dependency !== undefined) {
-            instance[property.key] = dependency;
+    const properties = (Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, type) ?? []).map((property) => ({
+        key: property.key,
+        resolve: prepareNestDependency(nestDependencyToken(property.type), optionalProperties.has(property.key), moduleRef)
+    }));
+    const Constructor = type;
+    if (parameters.length === 0 && properties.length === 0) {
+        const activate = () => new Constructor();
+        return Object.assign(activate, { scopeFree: activate });
+    }
+    return (moduleRef, contextId, dependencies) => {
+        const create = (arguments_) => injectNestHandlerProperties(new Constructor(...arguments_), properties, 0, moduleRef, contextId, dependencies);
+        const arguments_ = parameters.map((resolve) => resolve(moduleRef, contextId, dependencies));
+        return arguments_.some(isNestPromiseLike)
+            ? Promise.all(arguments_).then(create)
+            : create(arguments_);
+    };
+}
+function prepareNestDependency(token, optional, moduleRef) {
+    let lookup = (ref, contextId) => ref.resolve(token, contextId, { strict: false });
+    if (moduleRef !== undefined) {
+        try {
+            if (moduleRef.introspect(token).scope ===
+                common_1.Scope.DEFAULT) {
+                lookup = (ref) => ref.get(token, { strict: false });
+            }
+        }
+        catch (error) {
+            if (!(error instanceof unknown_element_exception_1.UnknownElementException) || !optional)
+                throw error;
         }
     }
+    return (ref, contextId, dependencies) => resolveNestHandlerDependency(dependencies, token, optional, lookup, ref, contextId);
+}
+function injectNestHandlerProperties(instance, properties, index, moduleRef, contextId, dependencies) {
+    for (; index < properties.length; index++) {
+        const property = properties[index];
+        const dependency = property.resolve(moduleRef, contextId, dependencies);
+        if (isNestPromiseLike(dependency)) {
+            const next = index + 1;
+            return Promise.resolve(dependency).then((value) => {
+                assignNestHandlerProperty(instance, property.key, value);
+                return injectNestHandlerProperties(instance, properties, next, moduleRef, contextId, dependencies);
+            });
+        }
+        assignNestHandlerProperty(instance, property.key, dependency);
+    }
     return instance;
 }
+function assignNestHandlerProperty(instance, key, dependency) {
+    if (dependency !== undefined)
+        instance[key] = dependency;
+}
+function isNestPromiseLike(value) {
+    return (value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof value.then === 'function');
+}
 function nestConstructorDependencies(type) {
     const reflected = [
         ...(Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, type) ??
@@ -379,18 +482,6 @@ function nestConstructorDependencies(type) {
     const optional = new Set(Reflect.getMetadata(constants_1.OPTIONAL_DEPS_METADATA, type) ?? []);
     return { reflected, optional };
 }
-function validateNestConstructorDependencies(moduleRef, type) {
-    const { reflected, optional } = nestConstructorDependencies(type);
-    for (const [index, token] of reflected.entries()) {
-        try {
-            moduleRef.introspect(nestDependencyToken(token));
-        }
-        catch (error) {
-            if (!(error instanceof unknown_element_exception_1.UnknownElementException) || !optional.has(index))
-                throw error;
-        }
-    }
-}
 function nestDependencyToken(token) {
     const forwardReference = typeof token === 'object' && token !== null && 'forwardRef' in token
         ? token
@@ -399,25 +490,30 @@ function nestDependencyToken(token) {
         ? forwardReference.forwardRef()
         : token;
 }
-async function resolveNestHandlerDependency(moduleRef, contextId, dependencies, token, optional) {
-    const resolvedToken = nestDependencyToken(token);
-    let dependency = dependencies.get(resolvedToken);
-    if (dependency === undefined) {
-        dependency = moduleRef.resolve(resolvedToken, contextId, {
-            strict: false
-        });
-        dependencies.set(resolvedToken, dependency);
-    }
+function resolveNestHandlerDependency(dependencies, token, optional, lookup, moduleRef, contextId) {
+    if (dependencies.has(token))
+        return dependencies.get(token);
     try {
-        return await dependency;
+        const dependency = lookup(moduleRef, contextId);
+        const result = isNestPromiseLike(dependency)
+            ? Promise.resolve(dependency).then((value) => {
+                dependencies.set(token, value);
+                return value;
+            }, (error) => nestDependencyFailure(dependencies, token, optional, error))
+            : dependency;
+        dependencies.set(token, result);
+        return result;
     }
     catch (error) {
-        dependencies.delete(resolvedToken);
-        if (optional)
-            return undefined;
-        throw error;
+        return nestDependencyFailure(dependencies, token, optional, error);
     }
 }
+function nestDependencyFailure(dependencies, token, optional, error) {
+    dependencies.delete(token);
+    if (optional)
+        return undefined;
+    throw error;
+}
 function findDiscoveredProvider(discovery, type) {
     for (const wrapper of discovery?.getProviders() ?? []) {
         if (wrapper.token === type ||
@@ -432,7 +528,7 @@ function providerToken(provider) {
     return typeof provider === 'function' ? provider : provider.provide;
 }
 async function createSpotManager(registration, runtime, moduleRef, discovery) {
-    return framework_loader_1.framework.createIntegrationSpotManager(registration, runtime, moduleRef === undefined ? undefined : createProviderResolver(moduleRef, discovery));
+    return framework_loader_1.framework.createIntegrationSpotManager(registration, runtime, moduleRef === undefined ? undefined : createProviderResolver(moduleRef, discovery, registration));
 }
 async function createSpotOutbound(_registration, runtime, _moduleRef, _discovery) {
     return framework_loader_1.framework.createIntegrationSpotOutbound(runtime);

package/dist/registration-composer.d.ts

@@ -1,6 +1,8 @@
 import type { DiscoveryService, ModuleRef } from '@nestjs/core';
 import type { ZLinkFrameworkRegistrationOptions } from './framework-integration-contracts';
 import { type ZLinkModuleOptions, type ZLinkNestModuleRegistrationOptions } from './contracts';
-export declare function createDiscoveredOptions(options: ZLinkNestModuleRegistrationOptions, discovery: DiscoveryService, moduleRef: ModuleRef): ZLinkFrameworkRegistrationOptions;
+import { type NestHandlerFactories } from './providers';
+export declare function createDiscoveredRegistration(options: ZLinkNestModuleRegistrationOptions, discovery: DiscoveryService, moduleRef: ModuleRef): import("./framework-integration-contracts").ZLinkFrameworkRegistration;
+export declare function createDiscoveredOptions(options: ZLinkNestModuleRegistrationOptions, discovery: DiscoveryService, moduleRef: ModuleRef, factories?: NestHandlerFactories): ZLinkFrameworkRegistrationOptions;
 export declare function createRegistrationOptions(options: ZLinkNestModuleRegistrationOptions): ZLinkFrameworkRegistrationOptions;
 export declare function assertBuiltModuleOptions(options: ZLinkModuleOptions): ZLinkNestModuleRegistrationOptions;