@riaskov/nevo-messaging 1.0.1 → 1.1.2

package/dist/transports/kafka/nevo-kafka.client.d.ts

@@ -1,16 +1,58 @@
 import { ClientKafka } from "@nestjs/microservices";
+import { Subscription, SubscriptionContext, SubscriptionOptions } from "../../common";
 export interface NevoKafkaClientOptions {
     timeoutMs?: number;
     debug?: boolean;
+    serviceName?: string;
+    authToken?: string;
+    brokers?: string[];
+    backoff?: {
+        enabled?: boolean;
+        baseMs?: number;
+        maxMs?: number;
+        maxAttempts?: number;
+        jitter?: boolean;
+    };
+    discovery?: {
+        enabled?: boolean;
+        heartbeatIntervalMs?: number;
+        ttlMs?: number;
+    };
 }
 export declare class NevoKafkaClient {
     private readonly kafkaClient;
     private readonly serviceNames;
     private readonly timeoutMs;
     private readonly debug;
+    private readonly serviceName?;
+    private readonly authToken?;
+    private readonly brokers;
+    private readonly backoffEnabled;
+    private readonly backoffBaseMs;
+    private readonly backoffMaxMs;
+    private readonly backoffMaxAttempts;
+    private readonly backoffJitter;
+    private readonly inFlight;
+    private readonly discoveryTopic;
+    private readonly broadcastTopic;
+    private readonly discoveryRegistry;
+    private readonly discoveryEnabled;
+    private readonly discoveryHeartbeatIntervalMs;
+    private readonly discoveryTtlMs;
+    private discoveryProducer?;
+    private discoveryConsumer?;
+    private discoveryTimer?;
+    private readonly subscriptionConsumers;
     constructor(kafkaClient: ClientKafka, serviceNames: string[], options?: NevoKafkaClientOptions);
     private createMessagePayload;
+    private waitForInFlightSlot;
     query<T = any>(serviceName: string, method: string, params: any): Promise<T>;
     emit(serviceName: string, method: string, params: any): Promise<void>;
     getAvailableServices(): string[];
+    publish(serviceName: string, method: string, params: any): Promise<void>;
+    broadcast(method: string, params: any): Promise<void>;
+    subscribe<T = any>(serviceName: string, method: string, options: SubscriptionOptions | undefined, handler: (data: T, context: SubscriptionContext) => Promise<void> | void): Promise<Subscription>;
+    getDiscoveredServices(): import("../../common").DiscoveryEntry[];
+    isServiceAvailable(serviceName: string): boolean;
+    private initDiscovery;
 }

package/dist/transports/kafka/nevo-kafka.client.js

@@ -4,26 +4,70 @@ exports.NevoKafkaClient = void 0;
 const rxjs_1 = require("rxjs");
 const common_1 = require("../../common");
 const node_crypto_1 = require("node:crypto");
+const kafkajs_1 = require("kafkajs");
 class NevoKafkaClient {
     constructor(kafkaClient, serviceNames, options) {
+        this.inFlight = new Set();
+        this.discoveryTopic = common_1.DEFAULT_DISCOVERY_TOPIC;
+        this.broadcastTopic = common_1.DEFAULT_BROADCAST_TOPIC;
+        this.discoveryRegistry = new common_1.DiscoveryRegistry();
+        this.subscriptionConsumers = new Set();
         this.kafkaClient = kafkaClient;
         this.serviceNames = serviceNames.map((name) => name.toLowerCase());
         this.timeoutMs = options?.timeoutMs || 20000;
         this.debug = options?.debug || false;
+        this.serviceName = options?.serviceName;
+        this.authToken = options?.authToken;
+        this.brokers = options?.brokers && options.brokers.length > 0 ? options.brokers : ["127.0.0.1:9092"];
+        this.backoffEnabled = options?.backoff?.enabled !== false;
+        this.backoffBaseMs = options?.backoff?.baseMs || 100;
+        this.backoffMaxMs = options?.backoff?.maxMs || 2000;
+        this.backoffMaxAttempts = options?.backoff?.maxAttempts || 0;
+        this.backoffJitter = options?.backoff?.jitter !== false;
+        this.discoveryEnabled = options?.discovery?.enabled !== false;
+        this.discoveryHeartbeatIntervalMs = options?.discovery?.heartbeatIntervalMs || 5000;
+        this.discoveryTtlMs = options?.discovery?.ttlMs || 15000;
         this.serviceNames.forEach((serviceName) => {
             const topicName = `${serviceName}-events`;
             const replyTopicName = `${topicName}.reply`;
             this.kafkaClient.subscribeToResponseOf(topicName);
             this.kafkaClient.subscribeToResponseOf(replyTopicName);
         });
+        if (this.discoveryEnabled) {
+            void this.initDiscovery();
+        }
     }
-    createMessagePayload(method, params) {
+    createMessagePayload(method, params, type) {
         const uuid = (0, node_crypto_1.randomUUID)();
+        const meta = {
+            type,
+            service: this.serviceName,
+            ts: Date.now(),
+            auth: { token: this.authToken }
+        };
         return {
             key: uuid,
-            value: (0, common_1.stringifyWithBigInt)({ uuid, method, params })
+            value: (0, common_1.stringifyWithBigInt)({ uuid, method, params, meta })
         };
     }
+    async waitForInFlightSlot(key) {
+        if (!this.backoffEnabled) {
+            return;
+        }
+        let attempt = 0;
+        let delay = this.backoffBaseMs;
+        while (this.inFlight.has(key)) {
+            attempt++;
+            if (this.backoffMaxAttempts > 0 && attempt > this.backoffMaxAttempts) {
+                throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                    message: `Backoff exceeded for ${key}`
+                });
+            }
+            const jitter = this.backoffJitter ? Math.floor(Math.random() * delay * 0.2) : 0;
+            await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+            delay = Math.min(this.backoffMaxMs, delay * 2);
+        }
+    }
     async query(serviceName, method, params) {
         const normalizedServiceName = serviceName.toLowerCase();
         if (!this.serviceNames.includes(normalizedServiceName)) {
@@ -33,11 +77,16 @@ class NevoKafkaClient {
             });
         }
         const topicName = `${normalizedServiceName}-events`;
-        const payload = this.createMessagePayload(method, params);
+        const payload = this.createMessagePayload(method, params, "query");
+        const inFlightKey = `${normalizedServiceName}:${method}`;
         if (this.debug) {
             console.log(`[NevoKafkaClient] Sending query to ${topicName}:`, { method, params });
         }
+        let inFlightAcquired = false;
         try {
+            await this.waitForInFlightSlot(inFlightKey);
+            this.inFlight.add(inFlightKey);
+            inFlightAcquired = true;
             const response = await (0, rxjs_1.lastValueFrom)(this.kafkaClient.send(topicName, payload).pipe((0, rxjs_1.timeout)(this.timeoutMs)));
             if (response?.params?.result === "error" && response?.params?.error) {
                 const errorData = response.params.error;
@@ -58,6 +107,11 @@ class NevoKafkaClient {
             }
             throw error;
         }
+        finally {
+            if (inFlightAcquired) {
+                this.inFlight.delete(inFlightKey);
+            }
+        }
     }
     async emit(serviceName, method, params) {
         const normalizedServiceName = serviceName.toLowerCase();
@@ -68,7 +122,7 @@ class NevoKafkaClient {
             });
         }
         const topicName = `${normalizedServiceName}-events`;
-        const payload = this.createMessagePayload(method, params);
+        const payload = this.createMessagePayload(method, params, "emit");
         if (this.debug) {
             console.log(`[NevoKafkaClient] Emitting to ${topicName}:`, { method, params });
         }
@@ -83,5 +137,157 @@ class NevoKafkaClient {
     getAvailableServices() {
         return [...this.serviceNames];
     }
+    async publish(serviceName, method, params) {
+        const normalizedServiceName = serviceName.toLowerCase();
+        if (!this.serviceNames.includes(normalizedServiceName)) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                message: `Service "${serviceName}" is not registered in nevo kafka client`,
+                availableServices: this.serviceNames
+            });
+        }
+        const topicName = `${normalizedServiceName}${common_1.DEFAULT_SUBSCRIPTION_SUFFIX}`;
+        const payload = this.createMessagePayload(method, params, "sub");
+        if (this.debug) {
+            console.log(`[NevoKafkaClient] Publishing to ${topicName}:`, { method, params });
+        }
+        try {
+            this.kafkaClient.emit(topicName, payload);
+        }
+        catch (error) {
+            console.error(`Failed to publish event to ${serviceName}.${method}:`, error);
+            throw error;
+        }
+    }
+    async broadcast(method, params) {
+        const payload = this.createMessagePayload(method, params, "broadcast");
+        if (this.debug) {
+            console.log(`[NevoKafkaClient] Broadcasting to ${this.broadcastTopic}:`, { method, params });
+        }
+        try {
+            this.kafkaClient.emit(this.broadcastTopic, payload);
+        }
+        catch (error) {
+            console.error(`Failed to broadcast ${method}:`, error);
+            throw error;
+        }
+    }
+    async subscribe(serviceName, method, options, handler) {
+        const normalizedServiceName = serviceName.toLowerCase();
+        const isBroadcast = normalizedServiceName === this.broadcastTopic;
+        if (!isBroadcast && !this.serviceNames.includes(normalizedServiceName)) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                message: `Service "${serviceName}" is not registered in nevo kafka client`,
+                availableServices: this.serviceNames
+            });
+        }
+        const kafka = new kafkajs_1.Kafka({
+            clientId: `${this.serviceName || "nevo"}-sub-${(0, node_crypto_1.randomUUID)()}`,
+            brokers: this.brokers
+        });
+        const groupId = options?.groupId || (options?.durableKey ? `nevo-sub-${options.durableKey}` : `nevo-sub-${this.serviceName || "client"}-${(0, node_crypto_1.randomUUID)()}`);
+        const consumer = kafka.consumer({
+            groupId,
+            allowAutoTopicCreation: true
+        });
+        await consumer.connect();
+        const topic = isBroadcast ? this.broadcastTopic : `${normalizedServiceName}${common_1.DEFAULT_SUBSCRIPTION_SUFFIX}`;
+        await consumer.subscribe({ topic, fromBeginning: options?.fromBeginning || false });
+        const manualAck = options?.ack === true;
+        await consumer.run({
+            autoCommit: !manualAck,
+            eachMessage: async ({ topic, partition, message }) => {
+                const raw = message.value?.toString();
+                if (!raw) {
+                    return;
+                }
+                let payload;
+                try {
+                    payload = (0, common_1.parseWithBigInt)(raw);
+                }
+                catch (error) {
+                    console.error(`[NevoKafkaClient] Failed to parse subscription message`, error);
+                    return;
+                }
+                if (method && payload.method !== method) {
+                    return;
+                }
+                const context = {
+                    meta: payload.meta || {},
+                    ack: async () => {
+                        if (!manualAck) {
+                            return;
+                        }
+                        const nextOffset = (Number(message.offset) + 1).toString();
+                        await consumer.commitOffsets([{ topic, partition, offset: nextOffset }]);
+                    },
+                    nack: async () => {
+                        return;
+                    }
+                };
+                await handler(payload.params, context);
+            }
+        });
+        this.subscriptionConsumers.add(consumer);
+        return {
+            unsubscribe: async () => {
+                this.subscriptionConsumers.delete(consumer);
+                await consumer.disconnect();
+            }
+        };
+    }
+    getDiscoveredServices() {
+        this.discoveryRegistry.prune(this.discoveryTtlMs);
+        return this.discoveryRegistry.list();
+    }
+    isServiceAvailable(serviceName) {
+        return this.discoveryRegistry.isAvailable(serviceName, this.discoveryTtlMs);
+    }
+    async initDiscovery() {
+        try {
+            const kafka = new kafkajs_1.Kafka({
+                clientId: `${this.serviceName || "nevo"}-discovery`,
+                brokers: this.brokers
+            });
+            this.discoveryProducer = kafka.producer();
+            this.discoveryConsumer = kafka.consumer({
+                groupId: `${this.serviceName || "nevo"}-discovery-${(0, node_crypto_1.randomUUID)()}`
+            });
+            await this.discoveryProducer.connect();
+            await this.discoveryConsumer.connect();
+            await this.discoveryConsumer.subscribe({ topic: this.discoveryTopic, fromBeginning: false });
+            await this.discoveryConsumer.run({
+                eachMessage: async ({ message }) => {
+                    const raw = message.value?.toString();
+                    if (!raw) {
+                        return;
+                    }
+                    try {
+                        const announcement = (0, common_1.parseWithBigInt)(raw);
+                        if (announcement?.serviceName) {
+                            this.discoveryRegistry.update(announcement);
+                        }
+                    }
+                    catch (error) {
+                        console.error("[NevoKafkaClient] Failed to parse discovery message", error);
+                    }
+                }
+            });
+            this.discoveryTimer = setInterval(() => {
+                const announcement = {
+                    serviceName: this.serviceName || "unknown",
+                    clientId: this.serviceName,
+                    transport: "kafka",
+                    ts: Date.now()
+                };
+                void this.discoveryProducer?.send({
+                    topic: this.discoveryTopic,
+                    messages: [{ key: announcement.serviceName, value: (0, common_1.stringifyWithBigInt)(announcement) }]
+                });
+            }, this.discoveryHeartbeatIntervalMs);
+        }
+        catch (error) {
+            console.error("[NevoKafkaClient] Discovery initialization failed:", error);
+        }
+    }
 }
 exports.NevoKafkaClient = NevoKafkaClient;

package/dist/transports/nats/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./nevo-nats.client";
+export * from "./nats.client-base";
+export * from "./nats.config";
+export * from "./nats.signal-router.decorator";

package/dist/transports/nats/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./nevo-nats.client"), exports);
+__exportStar(require("./nats.client-base"), exports);
+__exportStar(require("./nats.config"), exports);
+__exportStar(require("./nats.signal-router.decorator"), exports);

package/dist/transports/nats/nats.client-base.d.ts

@@ -0,0 +1,13 @@
+import { NevoNatsClient } from "./nevo-nats.client";
+export declare abstract class NatsClientBase {
+    protected readonly universalClient: NevoNatsClient;
+    protected constructor(universalClient: NevoNatsClient);
+    protected query<T = any>(serviceName: string, method: string, params: any): Promise<T>;
+    protected emit(serviceName: string, method: string, params: any): Promise<void>;
+    protected publish(serviceName: string, method: string, params: any): Promise<void>;
+    protected broadcast(method: string, params: any): Promise<void>;
+    protected subscribe<T = any>(serviceName: string, method: string, options: Parameters<NevoNatsClient["subscribe"]>[2], handler: Parameters<NevoNatsClient["subscribe"]>[3]): Promise<import("../..").Subscription>;
+    protected getAvailableServices(): string[];
+    protected getDiscoveredServices(): import("../..").DiscoveryEntry[];
+    protected isServiceAvailable(serviceName: string): boolean;
+}

package/dist/transports/nats/nats.client-base.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsClientBase = void 0;
+class NatsClientBase {
+    constructor(universalClient) {
+        this.universalClient = universalClient;
+    }
+    async query(serviceName, method, params) {
+        return this.universalClient.query(serviceName, method, params);
+    }
+    async emit(serviceName, method, params) {
+        return this.universalClient.emit(serviceName, method, params);
+    }
+    async publish(serviceName, method, params) {
+        return this.universalClient.publish(serviceName, method, params);
+    }
+    async broadcast(method, params) {
+        return this.universalClient.broadcast(method, params);
+    }
+    async subscribe(serviceName, method, options, handler) {
+        return this.universalClient.subscribe(serviceName, method, options, handler);
+    }
+    getAvailableServices() {
+        return this.universalClient.getAvailableServices();
+    }
+    getDiscoveredServices() {
+        return this.universalClient.getDiscoveredServices();
+    }
+    isServiceAvailable(serviceName) {
+        return this.universalClient.isServiceAvailable(serviceName);
+    }
+}
+exports.NatsClientBase = NatsClientBase;

package/dist/transports/nats/nats.config.d.ts

@@ -0,0 +1,8 @@
+import { NevoNatsClient, NevoNatsClientOptions } from "./nevo-nats.client";
+export interface NatsClientFactoryOptions extends NevoNatsClientOptions {
+    clientIdPrefix: string;
+}
+export declare const createNevoNatsClient: (serviceNames: string[], options: NatsClientFactoryOptions) => {
+    provide: string;
+    useFactory: () => Promise<NevoNatsClient>;
+};

package/dist/transports/nats/nats.config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNevoNatsClient = void 0;
+const nevo_nats_client_1 = require("./nevo-nats.client");
+const createNevoNatsClient = (serviceNames, options) => {
+    return {
+        provide: "NEVO_NATS_CLIENT",
+        useFactory: async () => {
+            return nevo_nats_client_1.NevoNatsClient.create(serviceNames, {
+                ...options,
+                serviceName: options.serviceName || options.clientIdPrefix
+            });
+        }
+    };
+};
+exports.createNevoNatsClient = createNevoNatsClient;

package/dist/transports/nats/nats.signal-router.decorator.d.ts

@@ -0,0 +1,6 @@
+import { Type } from "@nestjs/common";
+import { SignalRouterOptions } from "../../signal-router.utils";
+export interface NatsSignalRouterOptions extends SignalRouterOptions {
+    servers?: string[];
+}
+export declare function NatsSignalRouter(serviceType: Type<any> | Type<any>[], options?: NatsSignalRouterOptions): (target: any) => any;

package/dist/transports/nats/nats.signal-router.decorator.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsSignalRouter = NatsSignalRouter;
+const nats_1 = require("nats");
+const signal_router_utils_1 = require("../../signal-router.utils");
+const common_1 = require("../../common");
+function NatsSignalRouter(serviceType, options) {
+    return (0, signal_router_utils_1.createSignalRouterDecorator)(serviceType, options, (data) => {
+        const messageData = typeof data === "string" ? (0, common_1.parseWithBigInt)(data) : data;
+        return {
+            method: messageData.method,
+            params: messageData.params,
+            uuid: messageData.uuid,
+            meta: messageData.meta
+        };
+    }, (target, eventPattern, handlerName) => {
+        const codec = (0, nats_1.StringCodec)();
+        target.prototype.natsConnection = null;
+        target.prototype.natsSubscription = null;
+        const originalOnModuleInit = target.prototype.onModuleInit || function () { };
+        target.prototype.onModuleInit = async function () {
+            await originalOnModuleInit.call(this);
+            const servers = options?.servers && options.servers.length > 0 ? options.servers : ["nats://127.0.0.1:4222"];
+            const nc = await (0, nats_1.connect)({ servers });
+            this.natsConnection = nc;
+            const sub = nc.subscribe(eventPattern);
+            this.natsSubscription = sub;
+            (async () => {
+                for await (const msg of sub) {
+                    const payload = codec.decode(msg.data);
+                    const result = await this[handlerName](payload);
+                    if (msg.reply && result) {
+                        nc.publish(msg.reply, codec.encode((0, common_1.stringifyWithBigInt)(result)));
+                    }
+                }
+            })();
+        };
+        const originalOnModuleDestroy = target.prototype.onModuleDestroy || function () { };
+        target.prototype.onModuleDestroy = async function () {
+            await originalOnModuleDestroy.call(this);
+            if (this.natsSubscription) {
+                this.natsSubscription.unsubscribe();
+            }
+            if (this.natsConnection) {
+                await this.natsConnection.close();
+            }
+        };
+    });
+}

package/dist/transports/nats/nevo-nats.client.d.ts

@@ -0,0 +1,55 @@
+import { NatsConnection } from "nats";
+import { Subscription, SubscriptionContext, SubscriptionOptions } from "../../common";
+export interface NevoNatsClientOptions {
+    servers?: string[];
+    timeoutMs?: number;
+    debug?: boolean;
+    serviceName?: string;
+    authToken?: string;
+    backoff?: {
+        enabled?: boolean;
+        baseMs?: number;
+        maxMs?: number;
+        maxAttempts?: number;
+        jitter?: boolean;
+    };
+    discovery?: {
+        enabled?: boolean;
+        heartbeatIntervalMs?: number;
+        ttlMs?: number;
+    };
+}
+export declare class NevoNatsClient {
+    private readonly nc;
+    private readonly codec;
+    private readonly serviceNames;
+    private readonly timeoutMs;
+    private readonly debug;
+    private readonly serviceName?;
+    private readonly authToken?;
+    private readonly backoffEnabled;
+    private readonly backoffBaseMs;
+    private readonly backoffMaxMs;
+    private readonly backoffMaxAttempts;
+    private readonly backoffJitter;
+    private readonly inFlight;
+    private readonly discoveryRegistry;
+    private readonly discoveryEnabled;
+    private readonly discoveryHeartbeatIntervalMs;
+    private readonly discoveryTtlMs;
+    private discoveryTimer?;
+    private discoverySubscription?;
+    constructor(nc: NatsConnection, serviceNames: string[], options?: NevoNatsClientOptions);
+    static create(serviceNames: string[], options?: NevoNatsClientOptions): Promise<NevoNatsClient>;
+    private createMessagePayload;
+    private waitForInFlightSlot;
+    query<T = any>(serviceName: string, method: string, params: any): Promise<T>;
+    emit(serviceName: string, method: string, params: any): Promise<void>;
+    publish(serviceName: string, method: string, params: any): Promise<void>;
+    broadcast(method: string, params: any): Promise<void>;
+    subscribe<T = any>(serviceName: string, method: string, options: SubscriptionOptions | undefined, handler: (data: T, context: SubscriptionContext) => Promise<void> | void): Promise<Subscription>;
+    getAvailableServices(): string[];
+    getDiscoveredServices(): import("../../common").DiscoveryEntry[];
+    isServiceAvailable(serviceName: string): boolean;
+    private initDiscovery;
+}