@zlink-systems/nestjs 0.30.0 → 0.30.2

package/dist/contracts.d.ts

@@ -217,7 +217,7 @@ export interface ZLinkNestMeshObjectRoleBuilder extends ZLinkNestFrameworkOption
 export interface ZLinkNestMeshObjectClientBuilder extends ZLinkNestFrameworkOptionsBuilder {
 }
 export interface ZLinkNestMeshObjectServerBuilder extends ZLinkNestFrameworkOptionsBuilder {
-    addEntrySpot<TEntrySpot extends ZLinkEntrySpot>(entrySpotType: Type<TEntrySpot>): this;
+    addEntrySpot<TEntrySpot extends ZLinkEntrySpot>(entrySpotType: Type<TEntrySpot>, actorType: string): this;
     addSpotFactory<TSpot extends ZLinkSpot>(spotType: string, implementation: Type<TSpot>, configure: (builder: ZLinkUserSpotFactoryBuilder<TSpot>) => void): this;
     addInstanceSpotFactory<TSpot extends ZLinkInstanceSpot>(instanceSpotType: string, implementation: Type<TSpot>, configure: (builder: ZLinkInstanceSpotFactoryBuilder<TSpot>) => void): this;
     addActorFactory<TActor extends ZLinkActor>(actorType: string, implementation: Type<ZLinkActorFactory<TActor>>, configure: (builder: ZLinkActorFactoryBuilder<TActor>) => void): this;

package/dist/framework-integration-contracts.d.ts

@@ -194,6 +194,7 @@ export interface ZLinkSpotNodeOptions {
     readonly router?: ZLinkSpotRouterCapabilityOptions;
     readonly pubSub?: ZLinkSpotPubSubCapabilityOptions;
     readonly entrySpotType?: Type<ZLinkEntrySpot>;
+    readonly entrySpotActorType?: string;
     readonly spotFactories?: readonly Type<ZLinkSpot>[];
     readonly spotFactoryRegistrations?: Readonly<Record<string, ZLinkObjectFactoryRegistration<ZLinkSpot, ZLinkSpot, ZLinkUserSpotFactoryConfiguration>>>;
     readonly instanceSpotFactories?: Readonly<Record<string, Type<ZLinkInstanceSpot>>>;

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;
@@ -50,7 +59,8 @@ interface FrameworkIntegrationModule {
     isValidCapacity(value: number): boolean;
     registerEntrySpot(options: {
         entrySpotType?: Type<ZLinkEntrySpot>;
-    }, entrySpotType: Type<ZLinkEntrySpot>): void;
+        entrySpotActorType?: string;
+    }, entrySpotType: Type<ZLinkEntrySpot>, actorType: string): void;
     registerSpotFactory(options: {
         spotFactories?: Type<ZLinkSpot>[];
     }, spotType: Type<ZLinkSpot>): void;
@@ -60,9 +70,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/options-builder.js

@@ -757,8 +757,8 @@ class DefaultZLinkNestMeshObjectServerBuilder extends ZLinkNestOptionsBuilder {
         this.meshName = meshName;
         this.node = node;
     }
-    addEntrySpot(entrySpotType) {
-        framework_loader_1.framework.registerEntrySpot(this.node, entrySpotType);
+    addEntrySpot(entrySpotType, actorType) {
+        framework_loader_1.framework.registerEntrySpot(this.node, entrySpotType, actorType);
         return this;
     }
     addSpotFactory(spotType, implementation, configure) {

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