@zlink-systems/nestjs 0.28.0 → 0.29.0

package/dist/contracts.d.ts

@@ -179,6 +179,8 @@ export interface ZLinkNestClientServerChannelServerBuilder extends ZLinkNestFram
     addHandlerGroup(groupName: string): this;
 }
 export interface ZLinkNestStreamNodeBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    setHeartbeat(intervalMs: number, timeoutMs: number): this;
+    setIdleTimeout(timeoutMs: number): this;
     bind(endpoint: string | undefined): this;
     bind(port?: number): this;
     setBindHost(bindHost: string): this;

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

@@ -163,6 +163,9 @@ export interface ZLinkRouteChannelOptions extends ZLinkRouteMeshChannelOptions {
     readonly routerChannelId: string;
 }
 export interface ZLinkStreamNodeOptions {
+    readonly heartbeatIntervalMs?: number;
+    readonly heartbeatTimeoutMs?: number;
+    readonly idleTimeoutMs?: number;
     readonly bind?: string;
     readonly bindHost?: string;
     readonly advertiseHost?: string;

package/dist/handler-adapters.js

@@ -12,7 +12,7 @@ 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', (ref, metadata) => ({
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'request', moduleRef, (ref, metadata) => ({
         async handle(payload, context) {
             const result = await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
             return metadata.encodeResult === undefined
@@ -22,21 +22,21 @@ function createDiscoveredRequestHandlers(providerRefs, handlerGroups, moduleRef)
     }));
 }
 function createDiscoveredSendHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', (ref, metadata) => ({
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', moduleRef, (ref, metadata) => ({
         async handle(payload, context) {
             await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
         }
     }));
 }
 function createDiscoveredChannelSendHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', (ref, metadata) => ({
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', moduleRef, (ref, metadata) => ({
         async handle(payload, context) {
             await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
         }
     }));
 }
 function createDiscoveredPublishHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'publish', (ref, metadata) => ({
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'publish', moduleRef, (ref, metadata) => ({
         async handle(payload, context) {
             await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
         }
@@ -52,21 +52,27 @@ function createManualSendHandlers(handlerTypes, moduleRef) {
     return createManualHandlerRegistrations(handlerTypes, moduleRef, () => undefined);
 }
 function createManualHandlerRegistrations(handlerTypes, moduleRef, result) {
-    return (handlerTypes ?? []).map((registration) => ({
-        packetName: registration.packetName,
-        handler: {
-            async handle(payload, context) {
-                return result(await invokeManualHandler(moduleRef, registration.handlerType, payload, context));
+    return (handlerTypes ?? []).map((registration) => {
+        (0, providers_1.validateNestConstructorDependencies)(moduleRef, registration.handlerType);
+        return {
+            packetName: registration.packetName,
+            handler: {
+                async handle(payload, context) {
+                    return result(await invokeManualHandler(moduleRef, registration.handlerType, payload, context));
+                }
             }
-        }
-    }));
+        };
+    });
 }
-function createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, kind, createHandler) {
+function createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, kind, moduleRef, createHandler) {
     const descriptors = createDiscoveredHandlerDescriptors(providerRefs, handlerGroups, kind);
-    return descriptors.map(({ ref, metadata }) => ({
-        packetName: metadata.packetName,
-        handler: createHandler(ref, metadata)
-    }));
+    return descriptors.map(({ ref, metadata }) => {
+        (0, providers_1.validateNestConstructorDependencies)(moduleRef, ref.handlerKey);
+        return {
+            packetName: metadata.packetName,
+            handler: createHandler(ref, metadata)
+        };
+    });
 }
 function createDiscoveredHandlerDescriptors(providerRefs, handlerGroups, kind) {
     if ((handlerGroups ?? []).length === 0) {

package/dist/options-builder.js

@@ -443,6 +443,15 @@ class DefaultZLinkNestStreamNodeBuilder extends ZLinkNestOptionsBuilder {
         super(state);
         this.streamOptions = streamOptions;
     }
+    setHeartbeat(intervalMs, timeoutMs) {
+        this.streamOptions.heartbeatIntervalMs = intervalMs;
+        this.streamOptions.heartbeatTimeoutMs = timeoutMs;
+        return this;
+    }
+    setIdleTimeout(timeoutMs) {
+        this.streamOptions.idleTimeoutMs = timeoutMs;
+        return this;
+    }
     bind(endpointOrPort) {
         if (typeof endpointOrPort === 'string') {
             this.streamOptions.bind = endpointOrPort;

package/dist/providers.d.ts

@@ -11,5 +11,6 @@ export declare function conditionalClientProvidersForFactory(registration?: ZLin
 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 declare function providerToken(provider: Provider): InjectionToken;
 export {};

package/dist/providers.js

@@ -7,9 +7,11 @@ exports.conditionalClientProvidersForFactory = conditionalClientProvidersForFact
 exports.conditionalClientTokens = conditionalClientTokens;
 exports.createRuntimeHost = createRuntimeHost;
 exports.createNestHandlerInstance = createNestHandlerInstance;
+exports.validateNestConstructorDependencies = validateNestConstructorDependencies;
 exports.providerToken = providerToken;
 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");
 const tokens_1 = require("./tokens");
 const internal_tokens_1 = require("./internal-tokens");
 const framework_loader_1 = require("./framework-loader");
@@ -223,6 +225,34 @@ function hasLocationStores(registration) {
     return (registration.locations.useInMemoryStores || registration.locations.storeInstance !== undefined);
 }
 function createRuntimeHost(registration, moduleRef, discovery) {
+    const types = new Set([...registration.spotFactories, ...registration.filterTypes]);
+    for (const node of registration.spotNodes.values()) {
+        if (node.entrySpotType !== undefined)
+            types.add(node.entrySpotType);
+        for (const type of node.spotFactories ?? [])
+            types.add(type);
+        for (const type of Object.values(node.instanceSpotFactories ?? {}))
+            types.add(type);
+        for (const value of Object.values(node.spotFactoryRegistrations ?? {}))
+            types.add(value.implementation);
+        for (const value of Object.values(node.instanceSpotFactoryRegistrations ?? {}))
+            types.add(value.implementation);
+        for (const handler of [
+            ...(node.entrySpotTimerHandlers ?? []),
+            ...(node.entrySpotPacketHandlers ?? []),
+            ...(node.entrySpotSubscriptionHandlers ?? []),
+            ...(node.entrySpotActorSendHandlers ?? []),
+            ...(node.entrySpotActorRequestHandlers ?? []),
+            ...(node.spotTimerHandlers ?? []),
+            ...(node.spotPacketHandlers ?? []),
+            ...(node.spotSubscriptionHandlers ?? []),
+            ...(node.spotActorSendHandlers ?? []),
+            ...(node.spotActorRequestHandlers ?? [])
+        ])
+            types.add(handler.handlerType);
+    }
+    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();
@@ -324,15 +354,7 @@ function createProviderResolver(moduleRef, discovery) {
     return resolver;
 }
 async function createNestHandlerInstance(moduleRef, contextId, dependencies, type) {
-    const reflected = [
-        ...(Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, type) ??
-            [])
-    ];
-    const declared = Reflect.getMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, type);
-    for (const dependency of declared ?? []) {
-        reflected[dependency.index] = dependency.param;
-    }
-    const optional = new Set(Reflect.getMetadata(constants_1.OPTIONAL_DEPS_METADATA, type) ?? []);
+    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);
@@ -345,13 +367,40 @@ async function createNestHandlerInstance(moduleRef, contextId, dependencies, typ
     }
     return instance;
 }
-async function resolveNestHandlerDependency(moduleRef, contextId, dependencies, token, optional) {
+function nestConstructorDependencies(type) {
+    const reflected = [
+        ...(Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, type) ??
+            [])
+    ];
+    const declared = Reflect.getMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, type);
+    for (const dependency of declared ?? []) {
+        reflected[dependency.index] = dependency.param;
+    }
+    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
         : undefined;
-    const resolvedToken = typeof forwardReference?.forwardRef === 'function'
+    return typeof forwardReference?.forwardRef === 'function'
         ? 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, {

package/package.json

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