@riaskov/nevo-messaging 1.0.1 → 1.1.1

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

@@ -0,0 +1,54 @@
+import { Subscription, SubscriptionContext, SubscriptionOptions } from "../../common";
+export interface NevoHttpClientOptions {
+    timeoutMs?: number;
+    debug?: boolean;
+    serviceName?: string;
+    authToken?: string;
+    discoveryUrl?: string;
+    backoff?: {
+        enabled?: boolean;
+        baseMs?: number;
+        maxMs?: number;
+        maxAttempts?: number;
+        jitter?: boolean;
+    };
+    discovery?: {
+        enabled?: boolean;
+        heartbeatIntervalMs?: number;
+        ttlMs?: number;
+    };
+}
+export declare class NevoHttpClient {
+    private readonly serviceUrls;
+    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 readonly discoveryUrl?;
+    private discoveryTimer?;
+    private discoveryAbort?;
+    constructor(serviceUrls: Record<string, string>, options?: NevoHttpClientOptions);
+    private createMessagePayload;
+    private waitForInFlightSlot;
+    private getServiceUrl;
+    private postJson;
+    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;
+}

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

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NevoHttpClient = void 0;
+const common_1 = require("../../common");
+const node_crypto_1 = require("node:crypto");
+class NevoHttpClient {
+    constructor(serviceUrls, options) {
+        this.inFlight = new Set();
+        this.discoveryRegistry = new common_1.DiscoveryRegistry();
+        this.serviceUrls = new Map(Object.entries(serviceUrls).map(([k, v]) => [k.toLowerCase(), v]));
+        this.timeoutMs = options?.timeoutMs || 20000;
+        this.debug = options?.debug || false;
+        this.serviceName = options?.serviceName;
+        this.authToken = options?.authToken;
+        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 === true && !!options?.discoveryUrl;
+        this.discoveryHeartbeatIntervalMs = options?.discovery?.heartbeatIntervalMs || 5000;
+        this.discoveryTtlMs = options?.discovery?.ttlMs || 15000;
+        this.discoveryUrl = options?.discoveryUrl;
+        if (this.discoveryEnabled) {
+            void this.initDiscovery();
+        }
+    }
+    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 { 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);
+        }
+    }
+    getServiceUrl(serviceName) {
+        const normalized = serviceName.toLowerCase();
+        const url = this.serviceUrls.get(normalized);
+        if (!url) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                message: `Service "${serviceName}" is not registered in nevo http client`,
+                availableServices: [...this.serviceUrls.keys()]
+            });
+        }
+        return url.replace(/\/+$/, "");
+    }
+    async postJson(url, payload) {
+        const fetchFn = globalThis.fetch;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetchFn(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: (0, common_1.stringifyWithBigInt)(payload),
+                signal: controller.signal
+            });
+            const text = await response.text();
+            if (!text) {
+                return undefined;
+            }
+            return (0, common_1.parseWithBigInt)(text);
+        }
+        catch (error) {
+            if (error?.name === "AbortError") {
+                throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                    message: `HTTP request timed out after ${this.timeoutMs}ms`
+                });
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async query(serviceName, method, params) {
+        const url = this.getServiceUrl(serviceName);
+        const endpoint = `${url}/${serviceName.toLowerCase()}${common_1.DEFAULT_EVENTS_SUFFIX}`;
+        const payload = this.createMessagePayload(method, params, "query");
+        const inFlightKey = `${serviceName.toLowerCase()}:${method}`;
+        if (this.debug) {
+            console.log(`[NevoHttpClient] Sending query to ${endpoint}:`, { method, params });
+        }
+        let inFlightAcquired = false;
+        await this.waitForInFlightSlot(inFlightKey);
+        this.inFlight.add(inFlightKey);
+        inFlightAcquired = true;
+        try {
+            const response = await this.postJson(endpoint, payload);
+            if (response?.params?.result === "error" && response?.params?.error) {
+                const errorData = response.params.error;
+                const error = new common_1.MessagingError(errorData.code, errorData.details, errorData.service || serviceName);
+                if (process.env["MODE"] !== "production" && errorData.stack) {
+                    error.stack = errorData.stack;
+                }
+                throw error;
+            }
+            return response?.params?.result;
+        }
+        finally {
+            if (inFlightAcquired) {
+                this.inFlight.delete(inFlightKey);
+            }
+        }
+    }
+    async emit(serviceName, method, params) {
+        const url = this.getServiceUrl(serviceName);
+        const endpoint = `${url}/${serviceName.toLowerCase()}${common_1.DEFAULT_EVENTS_SUFFIX}`;
+        const payload = this.createMessagePayload(method, params, "emit");
+        if (this.debug) {
+            console.log(`[NevoHttpClient] Emitting to ${endpoint}:`, { method, params });
+        }
+        await this.postJson(endpoint, payload);
+    }
+    async publish(serviceName, method, params) {
+        const url = this.getServiceUrl(serviceName);
+        const endpoint = `${url}/__nevo/publish`;
+        const payload = this.createMessagePayload(method, params, "sub");
+        const body = {
+            serviceName,
+            ...payload
+        };
+        if (this.debug) {
+            console.log(`[NevoHttpClient] Publishing to ${endpoint}:`, { method, params });
+        }
+        await this.postJson(endpoint, body);
+    }
+    async broadcast(method, params) {
+        const url = this.discoveryUrl || [...this.serviceUrls.values()][0];
+        if (!url) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, { message: "No base URL available for broadcast" });
+        }
+        const endpoint = `${url.replace(/\/+$/, "")}/${common_1.DEFAULT_BROADCAST_TOPIC}`;
+        const payload = this.createMessagePayload(method, params, "broadcast");
+        if (this.debug) {
+            console.log(`[NevoHttpClient] Broadcasting to ${endpoint}:`, { method, params });
+        }
+        await this.postJson(endpoint, payload);
+    }
+    async subscribe(serviceName, method, options, handler) {
+        const normalized = serviceName.toLowerCase();
+        const isBroadcast = normalized === common_1.DEFAULT_BROADCAST_TOPIC;
+        const baseUrl = isBroadcast ? this.discoveryUrl || [...this.serviceUrls.values()][0] : this.getServiceUrl(serviceName);
+        if (!baseUrl) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, { message: "No base URL available for subscription" });
+        }
+        const endpoint = isBroadcast
+            ? `${baseUrl.replace(/\/+$/, "")}/${common_1.DEFAULT_BROADCAST_TOPIC}`
+            : `${baseUrl.replace(/\/+$/, "")}/__nevo/subscribe?service=${encodeURIComponent(serviceName)}`;
+        const controller = new AbortController();
+        const fetchFn = globalThis.fetch;
+        const response = await fetchFn(endpoint, {
+            headers: { Accept: "text/event-stream" },
+            signal: controller.signal
+        });
+        if (!response.ok || !response.body) {
+            throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, { message: `Failed to subscribe via SSE: ${response.status}` });
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const readLoop = async () => {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value);
+                const parts = buffer.split("\n\n");
+                buffer = parts.pop() || "";
+                for (const part of parts) {
+                    const line = part.split("\n").find((l) => l.startsWith("data:"));
+                    if (!line)
+                        continue;
+                    const raw = line.replace(/^data:\s*/, "");
+                    const payload = (0, common_1.parseWithBigInt)(raw);
+                    if (method && payload.method !== method) {
+                        continue;
+                    }
+                    const context = {
+                        meta: payload.meta || {},
+                        ack: async () => {
+                            return;
+                        },
+                        nack: async () => {
+                            return;
+                        }
+                    };
+                    await handler(payload.params, context);
+                }
+            }
+        };
+        void readLoop();
+        return {
+            unsubscribe: async () => {
+                controller.abort();
+            }
+        };
+    }
+    getAvailableServices() {
+        return [...this.serviceUrls.keys()];
+    }
+    getDiscoveredServices() {
+        this.discoveryRegistry.prune(this.discoveryTtlMs);
+        return this.discoveryRegistry.list();
+    }
+    isServiceAvailable(serviceName) {
+        return this.discoveryRegistry.isAvailable(serviceName, this.discoveryTtlMs);
+    }
+    async initDiscovery() {
+        if (!this.discoveryUrl) {
+            return;
+        }
+        this.discoveryAbort = new AbortController();
+        const discoveryEndpoint = `${this.discoveryUrl.replace(/\/+$/, "")}/${common_1.DEFAULT_DISCOVERY_TOPIC}`;
+        const fetchFn = globalThis.fetch;
+        const response = await fetchFn(discoveryEndpoint, {
+            headers: { Accept: "text/event-stream" },
+            signal: this.discoveryAbort.signal
+        });
+        if (response.ok && response.body) {
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            (async () => {
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    buffer += decoder.decode(value);
+                    const parts = buffer.split("\n\n");
+                    buffer = parts.pop() || "";
+                    for (const part of parts) {
+                        const line = part.split("\n").find((l) => l.startsWith("data:"));
+                        if (!line)
+                            continue;
+                        const raw = line.replace(/^data:\s*/, "");
+                        const payload = (0, common_1.parseWithBigInt)(raw);
+                        if (payload?.serviceName) {
+                            this.discoveryRegistry.update(payload);
+                        }
+                    }
+                }
+            })();
+        }
+        this.discoveryTimer = setInterval(() => {
+            const announcement = {
+                serviceName: this.serviceName || "unknown",
+                clientId: this.serviceName,
+                transport: "http",
+                ts: Date.now()
+            };
+            void this.postJson(discoveryEndpoint, announcement);
+        }, this.discoveryHeartbeatIntervalMs);
+    }
+}
+exports.NevoHttpClient = NevoHttpClient;

package/dist/transports/index.d.ts

@@ -1 +1,4 @@
 export * from "./kafka";
+export * from "./nats";
+export * from "./http";
+export * from "./socket-io";

package/dist/transports/index.js

@@ -15,3 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./kafka"), exports);
+__exportStar(require("./nats"), exports);
+__exportStar(require("./http"), exports);
+__exportStar(require("./socket-io"), exports);

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

@@ -4,5 +4,10 @@ export declare abstract class KafkaClientBase {
     protected constructor(universalClient: NevoKafkaClient);
     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<NevoKafkaClient["subscribe"]>[2], handler: Parameters<NevoKafkaClient["subscribe"]>[3]): Promise<import("../..").Subscription>;
     protected getAvailableServices(): string[];
+    protected getDiscoveredServices(): import("../..").DiscoveryEntry[];
+    protected isServiceAvailable(serviceName: string): boolean;
 }

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

@@ -11,8 +11,23 @@ class KafkaClientBase {
     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.KafkaClientBase = KafkaClientBase;

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

@@ -2,6 +2,7 @@ import { NevoKafkaClient } from "./nevo-kafka.client";
 export interface KafkaClientFactoryOptions {
     clientIdPrefix: string;
     groupIdPrefix?: string;
+    serviceName?: string;
     sessionTimeout?: number;
     allowAutoTopicCreation?: boolean;
     retryAttempts?: number;
@@ -9,6 +10,12 @@ export interface KafkaClientFactoryOptions {
     kafkaHost?: string;
     kafkaPort?: string;
     debug?: boolean;
+    authToken?: string;
+    discovery?: {
+        enabled?: boolean;
+        heartbeatIntervalMs?: number;
+        ttlMs?: number;
+    };
 }
 export declare const createNevoKafkaClient: (serviceNames: string[], options: KafkaClientFactoryOptions) => {
     provide: string;

package/dist/transports/kafka/kafka.config.js

@@ -37,6 +37,7 @@ exports.createNevoKafkaClient = void 0;
 const microservices_1 = require("@nestjs/microservices");
 const kafkajs_1 = require("kafkajs");
 const nevo_kafka_client_1 = require("./nevo-kafka.client");
+const common_1 = require("../../common");
 async function createKafkaTopics(serviceNames, options) {
     const host = process.env[options.kafkaHost || "KAFKA_HOST"] || "localhost";
     const port = parseInt(process.env[options.kafkaPort || "KAFKA_PORT"] || "9092");
@@ -62,6 +63,7 @@ async function createKafkaTopics(serviceNames, options) {
             const normalizedServiceName = serviceName.toLowerCase();
             const eventsTopic = `${normalizedServiceName}-events`;
             const replyTopic = `${eventsTopic}.reply`;
+            const subscriptionTopic = `${normalizedServiceName}${common_1.DEFAULT_SUBSCRIPTION_SUFFIX}`;
             const topics = [];
             if (!existingTopics.includes(eventsTopic)) {
                 topics.push({
@@ -87,8 +89,43 @@ async function createKafkaTopics(serviceNames, options) {
                     ]
                 });
             }
+            if (!existingTopics.includes(subscriptionTopic)) {
+                topics.push({
+                    topic: subscriptionTopic,
+                    numPartitions: 3,
+                    replicationFactor: 1,
+                    configEntries: [
+                        { name: "cleanup.policy", value: "delete" },
+                        { name: "retention.ms", value: "86400000" },
+                        { name: "max.message.bytes", value: "1000012" }
+                    ]
+                });
+            }
             return topics;
         });
+        if (!existingTopics.includes(common_1.DEFAULT_BROADCAST_TOPIC)) {
+            topicsToCreate.push({
+                topic: common_1.DEFAULT_BROADCAST_TOPIC,
+                numPartitions: 3,
+                replicationFactor: 1,
+                configEntries: [
+                    { name: "cleanup.policy", value: "delete" },
+                    { name: "retention.ms", value: "86400000" },
+                    { name: "max.message.bytes", value: "1000012" }
+                ]
+            });
+        }
+        if (!existingTopics.includes(common_1.DEFAULT_DISCOVERY_TOPIC)) {
+            topicsToCreate.push({
+                topic: common_1.DEFAULT_DISCOVERY_TOPIC,
+                numPartitions: 1,
+                replicationFactor: 1,
+                configEntries: [
+                    { name: "cleanup.policy", value: "compact" },
+                    { name: "retention.ms", value: "86400000" }
+                ]
+            });
+        }
         if (topicsToCreate.length > 0) {
             console.log(`[KafkaAdmin] Creating ${topicsToCreate.length} topics:`, topicsToCreate.map((t) => t.topic));
             await admin.createTopics({
@@ -141,7 +178,12 @@ const createNevoKafkaClient = (serviceNames, options) => {
         retryAttempts: 3,
         brokerRetryTimeout: 1000,
         debug: false,
-        timeoutMs: 20000
+        timeoutMs: 20000,
+        discovery: {
+            enabled: true,
+            heartbeatIntervalMs: 5000,
+            ttlMs: 15000
+        }
     };
     const mergedOptions = { ...defaultOptions, ...options };
     return {
@@ -202,7 +244,11 @@ const createNevoKafkaClient = (serviceNames, options) => {
             console.log(`[NevoKafkaClient] Created client for services: ${serviceNames.join(", ")}`);
             return new nevo_kafka_client_1.NevoKafkaClient(kafkaClient, serviceNames, {
                 timeoutMs: mergedOptions.timeoutMs,
-                debug: mergedOptions.debug
+                debug: mergedOptions.debug,
+                serviceName: mergedOptions.serviceName || mergedOptions.clientIdPrefix,
+                authToken: mergedOptions.authToken,
+                brokers: [`${host}:${port}`],
+                discovery: mergedOptions.discovery
             });
         }
     };

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

@@ -19,7 +19,8 @@ function KafkaSignalRouter(serviceType, options) {
         return {
             method: messageData.method,
             params: messageData.params,
-            uuid: messageData.uuid
+            uuid: messageData.uuid,
+            meta: messageData.meta
         };
     }, (target, eventPattern, handlerName) => {
         const originalMethod = target.prototype[handlerName];

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