@zlink-systems/nestjs 0.10.0

package/dist/registration-composer.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNestHandlerDiscovery = hasNestHandlerDiscovery;
+exports.createDiscoveredOptions = createDiscoveredOptions;
+exports.createRegistrationOptions = createRegistrationOptions;
+exports.assertBuiltModuleOptions = assertBuiltModuleOptions;
+const contracts_1 = require("./contracts");
+const provider_discovery_1 = require("./provider-discovery");
+const handler_adapters_1 = require("./handler-adapters");
+const framework_loader_1 = require("./framework-loader");
+const spot_node_handler_registry_1 = require("./spot-node-handler-registry");
+function hasNestHandlerDiscovery(options) {
+    return hasConfiguredSpotNodes(options.spotNodes)
+        || Object.values(options.clientServerChannels ?? {}).some((channel) => (channel.handlerGroups ?? []).length > 0
+            || (channel.requestHandlerTypes ?? []).length > 0
+            || (channel.sendHandlerTypes ?? []).length > 0)
+        || Object.values(options.fanoutChannels ?? {}).some((channel) => (channel.handlerGroups ?? []).length > 0
+            || (channel.publishHandlerTypes ?? []).length > 0);
+}
+function hasConfiguredSpotNodes(value) {
+    if (value === undefined) {
+        return false;
+    }
+    return Array.isArray(value) ? value.length > 0 : Object.keys(value).length > 0;
+}
+function createDiscoveredOptions(options, discovery, moduleRef) {
+    const registrationOptions = createRegistrationOptions(options);
+    const channels = { ...(registrationOptions.channels ?? {}) };
+    const useImplicitHandlers = options.implicitHandlerAutoRegistration !== false;
+    const providerRefs = useImplicitHandlers ? (0, provider_discovery_1.discoverProviderRefs)(discovery, moduleRef) : [];
+    const spotActorProviderRefs = useImplicitHandlers ? (0, provider_discovery_1.discoverSpotActorProviderRefs)(discovery, moduleRef) : [];
+    const spotProviderRefs = useImplicitHandlers ? (0, provider_discovery_1.discoverSpotProviderRefs)(discovery, moduleRef) : [];
+    const spotTimerProviderRefs = useImplicitHandlers ? (0, provider_discovery_1.discoverSpotTimerProviderRefs)(discovery, moduleRef) : [];
+    const sessionProviderRefs = useImplicitHandlers ? (0, provider_discovery_1.discoverSessionProviderRefs)(discovery, moduleRef) : [];
+    const spotNodes = createDiscoveredMeshChannelOptions(createDiscoveredSpotNodeOptions(registrationOptions.spotNodes, spotActorProviderRefs, spotProviderRefs, spotTimerProviderRefs), providerRefs, moduleRef);
+    for (const [channelName, channel] of Object.entries(options.fanoutChannels ?? {})) {
+        const existingChannel = channels[channelName];
+        const publishHandlers = (0, handler_adapters_1.createDiscoveredPublishHandlers)(providerRefs, channel.handlerGroups, moduleRef);
+        const manualPublishHandlers = (0, handler_adapters_1.createManualPublishHandlers)(channel.publishHandlerTypes, moduleRef);
+        channels[channelName] = {
+            ...existingChannel,
+            publishHandlers: [
+                ...(existingChannel?.publishHandlers ?? []),
+                ...manualPublishHandlers,
+                ...publishHandlers
+            ]
+        };
+    }
+    for (const [channelName, channel] of Object.entries(options.clientServerChannels ?? {})) {
+        const existingChannel = channels[channelName];
+        channels[channelName] = {
+            ...existingChannel,
+            requestHandlers: [
+                ...(existingChannel.requestHandlers ?? []),
+                ...(0, handler_adapters_1.createManualRequestHandlers)(channel.requestHandlerTypes, moduleRef),
+                ...(0, handler_adapters_1.createDiscoveredRequestHandlers)(providerRefs, channel.handlerGroups, moduleRef)
+            ],
+            sendHandlers: [
+                ...(existingChannel.sendHandlers ?? []),
+                ...(0, handler_adapters_1.createManualSendHandlers)(channel.sendHandlerTypes, moduleRef),
+                ...(0, handler_adapters_1.createDiscoveredChannelSendHandlers)(providerRefs, channel.handlerGroups, moduleRef)
+            ]
+        };
+    }
+    return {
+        ...registrationOptions,
+        channels,
+        spotNodes,
+        streamNodes: attachDiscoveredSessionHandlers(registrationOptions.streamNodes, sessionProviderRefs.map((ref) => ref.handlerKey))
+    };
+}
+const ZLINK_SESSION_HANDLER_TYPES = Symbol.for('@zlink-systems/framework:session-handler-types');
+function attachDiscoveredSessionHandlers(streamNodes, handlerTypes) {
+    if (streamNodes === undefined || handlerTypes.length === 0) {
+        return streamNodes;
+    }
+    return Object.fromEntries(Object.entries(streamNodes).map(([name, stream]) => {
+        const configured = { ...stream };
+        configured[ZLINK_SESSION_HANDLER_TYPES] = handlerTypes;
+        return [name, configured];
+    }));
+}
+function createDiscoveredMeshChannelOptions(value, providerRefs, moduleRef) {
+    if (value === undefined || Array.isArray(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([meshName, mesh]) => [meshName, {
+            ...mesh,
+            meshChannels: mesh.meshChannels === undefined
+                ? undefined
+                : Object.fromEntries(Object.entries(mesh.meshChannels).map(([channelName, channel]) => [channelName, {
+                        ...channel,
+                        requestHandlers: [
+                            ...(0, handler_adapters_1.createManualRequestHandlers)(channel.requestHandlers, moduleRef),
+                            ...(0, handler_adapters_1.createDiscoveredRequestHandlers)(providerRefs, channel.handlerGroups, moduleRef)
+                        ],
+                        sendHandlers: [
+                            ...(0, handler_adapters_1.createManualSendHandlers)(channel.sendHandlers, moduleRef),
+                            ...(0, handler_adapters_1.createDiscoveredSendHandlers)(providerRefs, channel.handlerGroups, moduleRef)
+                        ]
+                    }]))
+        }]));
+}
+function createDiscoveredSpotNodeOptions(value, refs, spotRefs = [], timerRefs = []) {
+    if (refs.length === 0 && spotRefs.length === 0 && timerRefs.length === 0) {
+        return value;
+    }
+    const registry = spot_node_handler_registry_1.SpotNodeHandlerRegistry.from(value);
+    if (registry.isEmpty) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException('ZLink SPOT actor handlers require a registered SpotNode.');
+    }
+    addDiscoveredSpotTimers(registry, timerRefs);
+    addDiscoveredSpotHandlers(registry, spotRefs);
+    addDiscoveredSpotActorHandlers(registry, refs);
+    return registry.toOptions();
+}
+function addDiscoveredSpotTimers(registry, timerRefs) {
+    for (const ref of timerRefs) {
+        if (ref.metadata.entrySpot !== undefined) {
+            const entrySpotType = resolveNestType(ref.metadata.entrySpot, 'entrySpot');
+            const targets = registry.entrySpotTargets(entrySpotType, `ZLink Entry Spot timer handler '${ref.handlerName}' targets an Entry Spot that is not registered on any SpotNode.`);
+            for (const spotNode of targets) {
+                registry.addEntrySpotTimer(spotNode, {
+                    entrySpotType,
+                    handlerType: ref.handlerKey,
+                    name: ref.metadata.name,
+                    options: ref.metadata.options,
+                    periodMs: ref.metadata.periodMs
+                });
+            }
+            continue;
+        }
+        const spotType = resolveNestType(ref.metadata.spot, 'spot');
+        const targets = registry.spotTargets(spotType, `ZLink SPOT timer handler '${ref.handlerName}' targets a Spot type that is not registered on any SpotNode.`);
+        for (const spotNode of targets) {
+            registry.addSpotTimer(spotNode, {
+                handlerType: ref.handlerKey,
+                name: ref.metadata.name,
+                options: ref.metadata.options,
+                periodMs: ref.metadata.periodMs,
+                spotType
+            });
+        }
+    }
+}
+function addDiscoveredSpotHandlers(registry, spotRefs) {
+    for (const ref of spotRefs) {
+        if (ref.metadata.kind === 'entrySpotPacket' || ref.metadata.kind === 'entrySpotSubscription') {
+            const entrySpotType = resolveNestType(ref.metadata.entrySpot, 'entrySpot');
+            const targets = registry.entrySpotTargets(entrySpotType, `ZLink Entry Spot handler '${ref.handlerName}' targets an Entry Spot that is not registered on any SpotNode.`);
+            for (const spotNode of targets) {
+                if (ref.metadata.kind === 'entrySpotPacket') {
+                    registry.addEntrySpotPacket(spotNode, {
+                        entrySpotType,
+                        handlerType: ref.handlerKey,
+                        packetName: ref.metadata.packetName
+                    });
+                }
+                else {
+                    registry.addEntrySpotSubscription(spotNode, {
+                        entrySpotType,
+                        handlerType: ref.handlerKey,
+                        channelName: requireSpotSubscriptionChannelName(ref),
+                        topic: requireSpotSubscriptionTopic(ref)
+                    });
+                }
+            }
+            continue;
+        }
+        const spotType = resolveNestType(ref.metadata.spot, 'spot');
+        const targets = registry.spotTargets(spotType, `ZLink SPOT handler '${ref.handlerName}' targets a Spot type that is not registered on any SpotNode.`);
+        for (const spotNode of targets) {
+            if (ref.metadata.kind === 'spotPacket') {
+                registry.addSpotPacket(spotNode, {
+                    handlerType: ref.handlerKey,
+                    packetName: ref.metadata.packetName,
+                    spotType: spotType
+                });
+            }
+            else {
+                registry.addSpotSubscription(spotNode, {
+                    channelName: requireSpotSubscriptionChannelName(ref),
+                    handlerType: ref.handlerKey,
+                    spotType: spotType,
+                    topic: requireSpotSubscriptionTopic(ref)
+                });
+            }
+        }
+    }
+}
+function addDiscoveredSpotActorHandlers(registry, refs) {
+    for (const ref of refs) {
+        if (ref.metadata.kind === 'entrySpotActorSend' || ref.metadata.kind === 'entrySpotActorRequest') {
+            const entrySpotType = resolveNestType(ref.metadata.entrySpot, 'entrySpot');
+            const actorType = resolveNestType(ref.metadata.actor, 'actor');
+            const targets = registry.entrySpotTargets(entrySpotType, `ZLink Entry Spot actor handler '${ref.handlerName}' targets an Entry Spot that is not registered on any SpotNode.`);
+            for (const spotNode of targets) {
+                const next = {
+                    actorType,
+                    entrySpotType,
+                    handlerType: ref.handlerKey,
+                    packetName: ref.metadata.packetName
+                };
+                registry.addEntrySpotActor(spotNode, ref.metadata.kind === 'entrySpotActorSend' ? 'send' : 'request', next);
+            }
+            continue;
+        }
+        const spotType = resolveNestType(ref.metadata.spot, 'spot');
+        const actorType = resolveNestType(ref.metadata.actor, 'actor');
+        const targets = registry.spotTargets(spotType, `ZLink SPOT actor handler '${ref.handlerName}' targets a Spot type that is not registered on any SpotNode.`);
+        for (const spotNode of targets) {
+            const next = {
+                actorType,
+                handlerType: ref.handlerKey,
+                packetName: ref.metadata.packetName,
+                spotType
+            };
+            registry.addSpotActor(spotNode, ref.metadata.kind === 'spotActorSend' ? 'send' : 'request', next);
+        }
+    }
+}
+function resolveNestType(resolver, name) {
+    if (resolver === undefined) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`ZLink SPOT actor handler ${name} type is required.`);
+    }
+    if (isClassType(resolver)) {
+        return resolver;
+    }
+    const resolved = resolver();
+    if (!isClassType(resolved)) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`ZLink SPOT actor handler ${name} type resolver must return a class.`);
+    }
+    return resolved;
+}
+function isClassType(value) {
+    return typeof value === 'function' && /^class\s/.test(Function.prototype.toString.call(value));
+}
+function requireSpotSubscriptionTopic(ref) {
+    const topic = ref.metadata.topic;
+    if (topic === undefined || topic.trim().length === 0) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`ZLink SPOT subscription handler '${ref.handlerName}' requires a topic.`);
+    }
+    return topic;
+}
+function requireSpotSubscriptionChannelName(ref) {
+    const channelName = ref.metadata.channelName;
+    if (channelName === undefined || channelName.trim().length === 0) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`ZLink SPOT subscription handler '${ref.handlerName}' requires a channelName.`);
+    }
+    return channelName;
+}
+function createRegistrationOptions(options) {
+    const channels = {};
+    for (const [name, channel] of Object.entries(options.clientServerChannels ?? {})) {
+        assertChannelNameAvailable(channels, name, 'ClientServerChannel');
+        channels[name] = {
+            client: channel.client,
+            server: channel.server
+        };
+    }
+    for (const [name, channel] of Object.entries(options.fanoutChannels ?? {})) {
+        assertChannelNameAvailable(channels, name, 'FanoutChannel');
+        channels[name] = {
+            routingId: channel.routingId,
+            routingIdPrefix: channel.routingIdPrefix,
+            publishHandlers: channel.publishHandlers,
+            publisher: channel.publisher,
+            subscriber: channel.subscriber
+        };
+    }
+    return {
+        network: options.network,
+        applicationVersion: options.applicationVersion,
+        maintenanceWave: options.maintenanceWave,
+        actorTransferTimeoutMs: options.actorTransferTimeoutMs,
+        messageFollowDurationMs: options.messageFollowDurationMs,
+        sessionReplacementCallbackTimeoutMs: options.sessionReplacementCallbackTimeoutMs,
+        channels,
+        codecs: options.codecs,
+        coreHwm: options.coreHwm,
+        applicationJobQueue: options.applicationJobQueue,
+        dispatch: options.dispatch,
+        filters: options.filters,
+        locations: options.locations,
+        metrics: options.metrics,
+        requestTimeoutMs: options.requestTimeoutMs,
+        spotFactories: options.spotFactories,
+        spotNodes: options.spotNodes,
+        spotPublisherClients: options.spotPublisherClients,
+        streamCompression: options.streamCompression,
+        streamNodes: options.streams,
+        worker: options.worker
+    };
+}
+function assertChannelNameAvailable(channels, name, kind) {
+    if (Object.hasOwn(channels, name)) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`Channel '${name}' is already registered before ${kind}.`);
+    }
+}
+function assertBuiltModuleOptions(options) {
+    if (!isBuiltModuleOptions(options)) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException('NestJS ZLinkModule options must be created with zlinkFramework().build().');
+    }
+    return options;
+}
+function isBuiltModuleOptions(options) {
+    return typeof options === 'object'
+        && options !== null
+        && options[contracts_1.ZLINK_MODULE_OPTIONS_BRAND] === true;
+}

package/dist/spot-node-handler-registry.d.ts

@@ -0,0 +1,24 @@
+import type { ZLinkEntrySpotActorRequestHandlerRegistration, ZLinkEntrySpotActorSendHandlerRegistration, ZLinkEntrySpotPacketHandlerRegistration, ZLinkEntrySpotSubscriptionHandlerRegistration, ZLinkEntrySpotTimerHandlerRegistration, ZLinkFrameworkRegistrationOptions, ZLinkSpotActorRequestHandlerRegistration, ZLinkSpotActorSendHandlerRegistration, ZLinkSpotNodeOptions, ZLinkSpotPacketHandlerRegistration, ZLinkSpotSubscriptionHandlerRegistration, ZLinkSpotTimerHandlerRegistration } from './framework-integration-contracts';
+import type { Mutable } from './contracts';
+import type { Type, ZLinkInstanceSpot, ZLinkSpot } from '@zlink-systems/framework';
+type MutableSpotNode = Mutable<ZLinkSpotNodeOptions>;
+export declare class SpotNodeHandlerRegistry {
+    private readonly nodes;
+    private constructor();
+    static from(value: ZLinkFrameworkRegistrationOptions['spotNodes']): SpotNodeHandlerRegistry;
+    get isEmpty(): boolean;
+    toOptions(): ZLinkFrameworkRegistrationOptions['spotNodes'];
+    entrySpotTargets(entrySpotType: NonNullable<ZLinkSpotNodeOptions['entrySpotType']>, missingMessage: string): readonly MutableSpotNode[];
+    spotTargets(spotType: Type<ZLinkSpot | ZLinkInstanceSpot>, missingMessage: string): readonly MutableSpotNode[];
+    addEntrySpotTimer(node: MutableSpotNode, registration: ZLinkEntrySpotTimerHandlerRegistration): void;
+    addSpotTimer(node: MutableSpotNode, registration: ZLinkSpotTimerHandlerRegistration): void;
+    addEntrySpotPacket(node: MutableSpotNode, registration: ZLinkEntrySpotPacketHandlerRegistration): void;
+    addEntrySpotSubscription(node: MutableSpotNode, registration: ZLinkEntrySpotSubscriptionHandlerRegistration): void;
+    addSpotPacket(node: MutableSpotNode, registration: ZLinkSpotPacketHandlerRegistration): void;
+    addSpotSubscription(node: MutableSpotNode, registration: ZLinkSpotSubscriptionHandlerRegistration): void;
+    addEntrySpotActor(node: MutableSpotNode, kind: 'send' | 'request', registration: ZLinkEntrySpotActorSendHandlerRegistration | ZLinkEntrySpotActorRequestHandlerRegistration): void;
+    addSpotActor(node: MutableSpotNode, kind: 'send' | 'request', registration: ZLinkSpotActorSendHandlerRegistration | ZLinkSpotActorRequestHandlerRegistration): void;
+    private requireTargets;
+    private assertUnique;
+}
+export {};

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpotNodeHandlerRegistry = void 0;
+const framework_loader_1 = require("./framework-loader");
+class SpotNodeHandlerRegistry {
+    nodes;
+    constructor(nodes) {
+        this.nodes = nodes;
+    }
+    static from(value) {
+        if (value === undefined) {
+            return new SpotNodeHandlerRegistry({});
+        }
+        if (!Array.isArray(value)) {
+            return new SpotNodeHandlerRegistry(Object.fromEntries(Object.entries(value).map(([name, node]) => [name, { ...node }])));
+        }
+        return new SpotNodeHandlerRegistry(Object.fromEntries(value.map((node) => {
+            if (typeof node === 'string') {
+                return [node, {}];
+            }
+            const { name, ...options } = node;
+            return [name, { ...options }];
+        })));
+    }
+    get isEmpty() {
+        return Object.keys(this.nodes).length === 0;
+    }
+    toOptions() {
+        return this.nodes;
+    }
+    entrySpotTargets(entrySpotType, missingMessage) {
+        return this.requireTargets((node) => node.entrySpotType === entrySpotType, missingMessage);
+    }
+    spotTargets(spotType, missingMessage) {
+        return this.requireTargets((node) => (node.spotFactories ?? []).includes(spotType)
+            || Object.values(node.instanceSpotFactories ?? {}).includes(spotType), missingMessage);
+    }
+    addEntrySpotTimer(node, registration) {
+        node.entrySpotTimerHandlers = [...(node.entrySpotTimerHandlers ?? []), registration];
+    }
+    addSpotTimer(node, registration) {
+        node.spotTimerHandlers = [...(node.spotTimerHandlers ?? []), registration];
+    }
+    addEntrySpotPacket(node, registration) {
+        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];
+    }
+    addEntrySpotSubscription(node, registration) {
+        this.assertUnique(node.entrySpotSubscriptionHandlers, (existing) => existing.entrySpotType === registration.entrySpotType &&
+            existing.channelName === registration.channelName && existing.topic === registration.topic, `Duplicate Entry Spot subscription handler '${registration.entrySpotType.name}:${registration.channelName}:${registration.topic}'.`);
+        node.entrySpotSubscriptionHandlers = [...(node.entrySpotSubscriptionHandlers ?? []), 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];
+    }
+    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];
+    }
+    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}'.`);
+        if (kind === 'send') {
+            node.entrySpotActorSendHandlers = [...(node.entrySpotActorSendHandlers ?? []), registration];
+        }
+        else {
+            node.entrySpotActorRequestHandlers = [...(node.entrySpotActorRequestHandlers ?? []), registration];
+        }
+    }
+    addSpotActor(node, kind, registration) {
+        const existing = kind === 'send' ? node.spotActorSendHandlers : node.spotActorRequestHandlers;
+        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}'.`);
+        if (kind === 'send') {
+            node.spotActorSendHandlers = [...(node.spotActorSendHandlers ?? []), registration];
+        }
+        else {
+            node.spotActorRequestHandlers = [...(node.spotActorRequestHandlers ?? []), registration];
+        }
+    }
+    requireTargets(predicate, missingMessage) {
+        const matches = Object.values(this.nodes).filter(predicate);
+        if (matches.length === 0) {
+            throw new framework_loader_1.framework.ZLinkConfigurationException(missingMessage);
+        }
+        return matches;
+    }
+    assertUnique(existing, isDuplicate, duplicateMessage) {
+        if ((existing ?? []).some(isDuplicate)) {
+            throw new framework_loader_1.framework.ZLinkConfigurationException(duplicateMessage);
+        }
+    }
+}
+exports.SpotNodeHandlerRegistry = SpotNodeHandlerRegistry;

package/dist/tokens.d.ts

@@ -0,0 +1,19 @@
+export declare const ZLINK_NEST_HANDLER_GROUP: unique symbol;
+export declare const ZLINK_FRAMEWORK_REGISTRATION: unique symbol;
+export declare const ZLINK_FRAMEWORK_RUNTIME: unique symbol;
+export declare const ZLINK_CHANNEL_CLIENT: unique symbol;
+export declare const ZLINK_CHANNEL_RUNTIME_OPTIONS: unique symbol;
+export declare const ZLINK_CLIENT_SERVER_RUNTIME: unique symbol;
+export declare const ZLINK_ROUTE_MESH_RUNTIME_OPTIONS: unique symbol;
+export declare const ZLINK_ROUTE_CLIENT: unique symbol;
+export declare const ZLINK_FANOUT_CLIENT: unique symbol;
+export declare const ZLINK_FANOUT_RUNTIME: unique symbol;
+export declare const ZLINK_ACTOR_CLIENT: unique symbol;
+export declare const ZLINK_BOUND_SESSION_FACTORY: unique symbol;
+export declare const ZLINK_MESSAGE_METADATA_POLICY: unique symbol;
+export declare const ZLINK_SPOT_MANAGER: unique symbol;
+export declare const ZLINK_SPOT_OUTBOUND: unique symbol;
+export declare const ZLINK_SPOT_PUBLISHER_CLIENT: unique symbol;
+export declare const ZLINK_ACTOR_MANAGER: unique symbol;
+export declare const ZLINK_ROUTE_MESH_RUNTIME: unique symbol;
+export declare const ZLINK_LOCATION_RUNTIME_QUERY: unique symbol;

package/dist/tokens.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLINK_LOCATION_RUNTIME_QUERY = exports.ZLINK_ROUTE_MESH_RUNTIME = exports.ZLINK_ACTOR_MANAGER = exports.ZLINK_SPOT_PUBLISHER_CLIENT = exports.ZLINK_SPOT_OUTBOUND = exports.ZLINK_SPOT_MANAGER = exports.ZLINK_MESSAGE_METADATA_POLICY = exports.ZLINK_BOUND_SESSION_FACTORY = exports.ZLINK_ACTOR_CLIENT = exports.ZLINK_FANOUT_RUNTIME = exports.ZLINK_FANOUT_CLIENT = exports.ZLINK_ROUTE_CLIENT = exports.ZLINK_ROUTE_MESH_RUNTIME_OPTIONS = exports.ZLINK_CLIENT_SERVER_RUNTIME = exports.ZLINK_CHANNEL_RUNTIME_OPTIONS = exports.ZLINK_CHANNEL_CLIENT = exports.ZLINK_FRAMEWORK_RUNTIME = exports.ZLINK_FRAMEWORK_REGISTRATION = exports.ZLINK_NEST_HANDLER_GROUP = void 0;
+exports.ZLINK_NEST_HANDLER_GROUP = Symbol.for('@zlink-systems/nestjs:handler-group');
+exports.ZLINK_FRAMEWORK_REGISTRATION = Symbol.for('@zlink-systems/framework:registration');
+exports.ZLINK_FRAMEWORK_RUNTIME = Symbol.for('@zlink-systems/framework:runtime');
+exports.ZLINK_CHANNEL_CLIENT = Symbol.for('@zlink-systems/framework:channel-client');
+exports.ZLINK_CHANNEL_RUNTIME_OPTIONS = Symbol.for('@zlink-systems/framework:channel-runtime-options');
+exports.ZLINK_CLIENT_SERVER_RUNTIME = Symbol.for('@zlink-systems/framework:client-server-runtime');
+exports.ZLINK_ROUTE_MESH_RUNTIME_OPTIONS = Symbol.for('@zlink-systems/framework:route-mesh-runtime-options');
+exports.ZLINK_ROUTE_CLIENT = Symbol.for('@zlink-systems/framework:route-client');
+exports.ZLINK_FANOUT_CLIENT = Symbol.for('@zlink-systems/framework:fanout-client');
+exports.ZLINK_FANOUT_RUNTIME = Symbol.for('@zlink-systems/framework:fanout-runtime');
+exports.ZLINK_ACTOR_CLIENT = Symbol.for('@zlink-systems/framework:actor-client');
+exports.ZLINK_BOUND_SESSION_FACTORY = Symbol.for('@zlink-systems/framework:bound-session-factory');
+exports.ZLINK_MESSAGE_METADATA_POLICY = Symbol.for('@zlink-systems/framework:message-metadata-policy');
+exports.ZLINK_SPOT_MANAGER = Symbol.for('@zlink-systems/framework:spot-manager');
+exports.ZLINK_SPOT_OUTBOUND = Symbol.for('@zlink-systems/framework:spot-outbound');
+exports.ZLINK_SPOT_PUBLISHER_CLIENT = Symbol.for('@zlink-systems/framework:spot-publisher-client');
+exports.ZLINK_ACTOR_MANAGER = Symbol.for('@zlink-systems/framework:actor-manager');
+exports.ZLINK_ROUTE_MESH_RUNTIME = Symbol.for('@zlink-systems/framework:route-mesh-runtime');
+exports.ZLINK_LOCATION_RUNTIME_QUERY = Symbol.for('@zlink-systems/framework:location-runtime-query');

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@zlink-systems/nestjs",
+  "version": "0.10.0",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@nestjs/common": "^10.4.22",
+    "@zlink-systems/framework": "0.10.0",
+    "@zlink-systems/http-client": "0.10.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2"
+  },
+  "peerDependencies": {
+    "@nestjs/core": "^10.4.22"
+  }
+}