@zlink-systems/nestjs 0.30.3 → 0.31.0

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

@@ -1,3 +1,4 @@
+export type ZLinkHandlerMessageType = NonNullable<ReturnType<typeof import('../../framework/dist/nest-integration').resolveHandlerMessageType>>;
 import type { RoutingId, Type, ZLinkActor, ZLinkActorFactory, ZLinkApplicationJobQueueOptions, ZLinkCoreHwmOptions, ZLinkDispatchOptions, ZLinkEntrySpot, ZLinkHandlerFilter, ZLinkLocationOptions, ZLinkLocationOptionValues, ZLinkLocationStore, ZLinkRelocationStore, ZLinkSpotRelocationCoordinationMode, ZLinkUserSpotExecutionMode, ZLinkInstanceSpot, ZLinkMessageSerializer, ZLinkMetricsOptions, ZLinkNetworkOptions, ZLinkMessageContext, ZLinkPublishMessageContext, ZLinkRouteMessageContext, ZLinkSpot, ZLinkStreamCompressionOptions, ZLinkTimerOptions } from '@zlink-systems/framework';
 /** Private composition bridge used only by the Nest companion package. */
 export interface ZLinkProviderResolver {
@@ -287,29 +288,35 @@ export interface ZLinkRouteChannelHandlerOptions {
     readonly kind: 'send' | 'request';
     readonly packetName: string;
     readonly handler: ZLinkRouteChannelSendHandler | ZLinkRouteChannelRequestHandler;
+    readonly messageType?: ZLinkHandlerMessageType;
 }
 export interface ZLinkRouteChannelSendHandlerRegistration {
     readonly packetName: string;
     readonly handler: ZLinkRouteChannelSendHandler;
+    readonly messageType?: ZLinkHandlerMessageType;
 }
 export interface ZLinkRouteChannelRequestHandlerRegistration {
     readonly packetName: string;
     readonly handler: ZLinkRouteChannelRequestHandler;
+    readonly messageType?: ZLinkHandlerMessageType;
 }
 export interface ZLinkChannelPublishHandlerRegistration {
     readonly packetName: string;
+    readonly messageType?: ZLinkHandlerMessageType;
     readonly handler: {
         handle(payload: unknown, context: ZLinkPublishMessageContext): Promise<void>;
     };
 }
 export interface ZLinkChannelRequestHandlerRegistration {
     readonly packetName: string;
+    readonly messageType?: ZLinkHandlerMessageType;
     readonly handler: {
         handle(payload: unknown, context: ZLinkMessageContext): Promise<unknown>;
     };
 }
 export interface ZLinkChannelSendHandlerRegistration {
     readonly packetName: string;
+    readonly messageType?: ZLinkHandlerMessageType;
     readonly handler: {
         handle(payload: unknown, context: ZLinkMessageContext): Promise<void>;
     };
@@ -325,18 +332,21 @@ export interface ZLinkEntrySpotPacketHandlerRegistration {
     readonly entrySpotType: Type<ZLinkEntrySpot>;
     readonly handlerType: Type;
     readonly packetName?: string;
+    readonly messageType?: ZLinkHandlerMessageType;
 }
 export interface ZLinkEntrySpotSubscriptionHandlerRegistration {
     readonly entrySpotType: Type<ZLinkEntrySpot>;
     readonly handlerType: Type;
     readonly channelName: string;
     readonly topic: string;
+    readonly messageType?: ZLinkHandlerMessageType;
 }
 export interface ZLinkEntrySpotActorSendHandlerRegistration {
     readonly entrySpotType: Type<ZLinkEntrySpot>;
     readonly actorType: Type<ZLinkActor>;
     readonly handlerType: Type;
     readonly packetName: string;
+    readonly messageType?: ZLinkHandlerMessageType;
 }
 export interface ZLinkEntrySpotActorRequestHandlerRegistration extends ZLinkEntrySpotActorSendHandlerRegistration {
 }
@@ -351,18 +361,21 @@ export interface ZLinkSpotPacketHandlerRegistration {
     readonly spotType: Type<ZLinkSpot>;
     readonly handlerType: Type;
     readonly packetName?: string;
+    readonly messageType?: ZLinkHandlerMessageType;
 }
 export interface ZLinkSpotSubscriptionHandlerRegistration {
     readonly spotType: Type<ZLinkSpot>;
     readonly handlerType: Type;
     readonly channelName: string;
     readonly topic: string;
+    readonly messageType?: ZLinkHandlerMessageType;
 }
 export interface ZLinkSpotActorSendHandlerRegistration {
     readonly spotType: Type<ZLinkSpot>;
     readonly actorType: Type<ZLinkActor>;
     readonly handlerType: Type;
     readonly packetName: string;
+    readonly messageType?: ZLinkHandlerMessageType;
 }
 export interface ZLinkSpotActorRequestHandlerRegistration extends ZLinkSpotActorSendHandlerRegistration {
 }

package/dist/framework-loader.d.ts

@@ -1,3 +1,4 @@
+import type { ZLinkHandlerMessageType } from './framework-integration-contracts';
 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';
@@ -6,6 +7,7 @@ interface HandlerResolver {
     resolve<T>(type: Type<T>): Promise<T>;
 }
 interface FrameworkIntegrationModule {
+    resolveHandlerMessageType(handlerType: Type): ZLinkHandlerMessageType | undefined;
     ZLinkSpotActorSend(packetName?: string): MethodDecorator;
     ZLinkSpotActorRequest(packetName?: string): MethodDecorator;
     disposeIntegrationHandler(instance: unknown): Promise<void>;

package/dist/handler-adapters.js

@@ -54,8 +54,10 @@ function createManualSendHandlers(handlerTypes, moduleRef, factories = new Map()
 function createManualHandlerRegistrations(handlerTypes, moduleRef, factories, result) {
     return (handlerTypes ?? []).map((registration) => {
         const factory = (0, providers_1.registeredNestHandlerFactory)(factories, registration.handlerType, moduleRef);
+        const messageType = framework_loader_1.framework.resolveHandlerMessageType(registration.handlerType);
         return {
             packetName: registration.packetName,
+            ...(messageType === undefined ? {} : { messageType }),
             handler: {
                 async handle(payload, context) {
                     return result(await invokeManualHandler(moduleRef, registration.handlerType, factory, payload, context));
@@ -67,8 +69,10 @@ function createManualHandlerRegistrations(handlerTypes, moduleRef, factories, re
 function createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, kind, moduleRef, factories, createHandler) {
     const descriptors = createDiscoveredHandlerDescriptors(providerRefs, handlerGroups, kind);
     return descriptors.map(({ ref, metadata }) => {
+        const messageType = framework_loader_1.framework.resolveHandlerMessageType(ref.handlerKey);
         return {
             packetName: metadata.packetName,
+            ...(messageType === undefined ? {} : { messageType }),
             handler: createHandler(ref, metadata, (0, providers_1.registeredNestHandlerFactory)(factories, ref.handlerKey, moduleRef))
         };
     });

package/dist/spot-node-handler-registry.js

@@ -45,7 +45,10 @@ class SpotNodeHandlerRegistry {
         const packetName = registration.packetName ?? registration.handlerType.name;
         this.assertUnique(node.entrySpotPacketHandlers, (existing) => existing.entrySpotType === registration.entrySpotType &&
             (existing.packetName ?? existing.handlerType.name) === packetName, `Duplicate Entry Spot packet handler '${registration.entrySpotType.name}:${packetName}'.`);
-        node.entrySpotPacketHandlers = [...(node.entrySpotPacketHandlers ?? []), registration];
+        node.entrySpotPacketHandlers = [
+            ...(node.entrySpotPacketHandlers ?? []),
+            ensureSpotRegistrationMessageType(registration)
+        ];
     }
     addEntrySpotSubscription(node, registration) {
         this.assertUnique(node.entrySpotSubscriptionHandlers, (existing) => existing.entrySpotType === registration.entrySpotType &&
@@ -53,33 +56,43 @@ class SpotNodeHandlerRegistry {
             existing.topic === registration.topic, `Duplicate Entry Spot subscription handler '${registration.entrySpotType.name}:${registration.channelName}:${registration.topic}'.`);
         node.entrySpotSubscriptionHandlers = [
             ...(node.entrySpotSubscriptionHandlers ?? []),
-            registration
+            ensureSpotRegistrationMessageType(registration)
         ];
     }
     addSpotPacket(node, registration) {
         const packetName = registration.packetName ?? registration.handlerType.name;
         this.assertUnique(node.spotPacketHandlers, (existing) => existing.spotType === registration.spotType &&
             (existing.packetName ?? existing.handlerType.name) === packetName, `Duplicate SPOT packet handler '${registration.spotType.name}:${packetName}'.`);
-        node.spotPacketHandlers = [...(node.spotPacketHandlers ?? []), registration];
+        node.spotPacketHandlers = [
+            ...(node.spotPacketHandlers ?? []),
+            ensureSpotRegistrationMessageType(registration)
+        ];
     }
     addSpotSubscription(node, registration) {
         this.assertUnique(node.spotSubscriptionHandlers, (existing) => existing.spotType === registration.spotType &&
             existing.channelName === registration.channelName &&
             existing.topic === registration.topic, `Duplicate SPOT subscription handler '${registration.spotType.name}:${registration.channelName}:${registration.topic}'.`);
-        node.spotSubscriptionHandlers = [...(node.spotSubscriptionHandlers ?? []), registration];
+        node.spotSubscriptionHandlers = [
+            ...(node.spotSubscriptionHandlers ?? []),
+            ensureSpotRegistrationMessageType(registration)
+        ];
     }
     addEntrySpotActor(node, kind, registration) {
         const existing = kind === 'send' ? node.entrySpotActorSendHandlers : node.entrySpotActorRequestHandlers;
         this.assertUnique(existing, (handler) => handler.entrySpotType === registration.entrySpotType &&
             handler.actorType === registration.actorType &&
             handler.packetName === registration.packetName, `Duplicate Entry Spot actor handler '${registration.entrySpotType.name}:${registration.actorType.name}:${registration.packetName}'.`);
+        const typedRegistration = ensureSpotRegistrationMessageType(registration);
         if (kind === 'send') {
-            node.entrySpotActorSendHandlers = [...(node.entrySpotActorSendHandlers ?? []), registration];
+            node.entrySpotActorSendHandlers = [
+                ...(node.entrySpotActorSendHandlers ?? []),
+                typedRegistration
+            ];
         }
         else {
             node.entrySpotActorRequestHandlers = [
                 ...(node.entrySpotActorRequestHandlers ?? []),
-                registration
+                typedRegistration
             ];
         }
     }
@@ -88,11 +101,12 @@ class SpotNodeHandlerRegistry {
         this.assertUnique(existing, (handler) => handler.spotType === registration.spotType &&
             handler.actorType === registration.actorType &&
             handler.packetName === registration.packetName, `Duplicate SPOT actor handler '${registration.spotType.name}:${registration.actorType.name}:${registration.packetName}'.`);
+        const typedRegistration = ensureSpotRegistrationMessageType(registration);
         if (kind === 'send') {
-            node.spotActorSendHandlers = [...(node.spotActorSendHandlers ?? []), registration];
+            node.spotActorSendHandlers = [...(node.spotActorSendHandlers ?? []), typedRegistration];
         }
         else {
-            node.spotActorRequestHandlers = [...(node.spotActorRequestHandlers ?? []), registration];
+            node.spotActorRequestHandlers = [...(node.spotActorRequestHandlers ?? []), typedRegistration];
         }
     }
     requireTargets(predicate, missingMessage) {
@@ -109,3 +123,10 @@ class SpotNodeHandlerRegistry {
     }
 }
 exports.SpotNodeHandlerRegistry = SpotNodeHandlerRegistry;
+function ensureSpotRegistrationMessageType(registration) {
+    const messageType = framework_loader_1.framework.resolveHandlerMessageType(registration.handlerType);
+    return {
+        ...registration,
+        ...(messageType === undefined ? {} : { messageType })
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/nestjs",
-  "version": "0.30.3",
+  "version": "0.31.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -21,8 +21,8 @@
   },
   "dependencies": {
     "@nestjs/common": "^10.4.22",
-    "@zlink-systems/framework": "0.30.3",
-    "@zlink-systems/http-client": "0.30.3",
+    "@zlink-systems/framework": "0.31.0",
+    "@zlink-systems/http-client": "0.31.0",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.2"
   },