@riaskov/nevo-messaging 1.0.1 → 1.1.2

package/dist/transports/http/http.transport.controller.js

@@ -0,0 +1,114 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpTransportController = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const common_2 = require("../../common");
+class HttpSseBroker {
+    constructor() {
+        this.channels = new Map();
+    }
+    stream(channel) {
+        const subject = this.getChannel(channel);
+        return subject.asObservable().pipe((0, operators_1.map)((data) => ({ data })));
+    }
+    publish(channel, payload) {
+        const subject = this.getChannel(channel);
+        subject.next((0, common_2.stringifyWithBigInt)(payload));
+    }
+    getChannel(channel) {
+        let subject = this.channels.get(channel);
+        if (!subject) {
+            subject = new rxjs_1.Subject();
+            this.channels.set(channel, subject);
+        }
+        return subject;
+    }
+}
+const broker = new HttpSseBroker();
+let HttpTransportController = class HttpTransportController {
+    streamDiscovery() {
+        return broker.stream(common_2.DEFAULT_DISCOVERY_TOPIC);
+    }
+    publishDiscovery(payload) {
+        broker.publish(common_2.DEFAULT_DISCOVERY_TOPIC, payload);
+        return { ok: true };
+    }
+    streamSubscription(service) {
+        const channel = `${service.toLowerCase()}${common_2.DEFAULT_SUBSCRIPTION_SUFFIX}`;
+        return broker.stream(channel);
+    }
+    publishSubscription(payload) {
+        const serviceName = payload?.serviceName;
+        if (!serviceName) {
+            return { ok: false };
+        }
+        const channel = `${serviceName.toLowerCase()}${common_2.DEFAULT_SUBSCRIPTION_SUFFIX}`;
+        broker.publish(channel, payload);
+        return { ok: true };
+    }
+    streamBroadcast() {
+        return broker.stream(common_2.DEFAULT_BROADCAST_TOPIC);
+    }
+    publishBroadcast(payload) {
+        broker.publish(common_2.DEFAULT_BROADCAST_TOPIC, payload);
+        return { ok: true };
+    }
+};
+exports.HttpTransportController = HttpTransportController;
+__decorate([
+    (0, common_1.Sse)(`/${common_2.DEFAULT_DISCOVERY_TOPIC}`),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", rxjs_1.Observable)
+], HttpTransportController.prototype, "streamDiscovery", null);
+__decorate([
+    (0, common_1.Post)(`/${common_2.DEFAULT_DISCOVERY_TOPIC}`),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], HttpTransportController.prototype, "publishDiscovery", null);
+__decorate([
+    (0, common_1.Sse)(`/__nevo/subscribe`),
+    __param(0, (0, common_1.Query)("service")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", rxjs_1.Observable)
+], HttpTransportController.prototype, "streamSubscription", null);
+__decorate([
+    (0, common_1.Post)(`/__nevo/publish`),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], HttpTransportController.prototype, "publishSubscription", null);
+__decorate([
+    (0, common_1.Sse)(`/${common_2.DEFAULT_BROADCAST_TOPIC}`),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", rxjs_1.Observable)
+], HttpTransportController.prototype, "streamBroadcast", null);
+__decorate([
+    (0, common_1.Post)(`/${common_2.DEFAULT_BROADCAST_TOPIC}`),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], HttpTransportController.prototype, "publishBroadcast", null);
+exports.HttpTransportController = HttpTransportController = __decorate([
+    (0, common_1.Controller)()
+], HttpTransportController);

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

@@ -0,0 +1,5 @@
+export * from "./nevo-http.client";
+export * from "./http.client-base";
+export * from "./http.signal-router.decorator";
+export * from "./http.transport.controller";
+export * from "./http.config";

package/dist/transports/http/index.js

@@ -0,0 +1,21 @@
+"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-http.client"), exports);
+__exportStar(require("./http.client-base"), exports);
+__exportStar(require("./http.signal-router.decorator"), exports);
+__exportStar(require("./http.transport.controller"), exports);
+__exportStar(require("./http.config"), exports);

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