@riaskov/nevo-messaging 1.0.0

package/dist/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("./signal.decorator"), exports);
+__exportStar(require("./signal-router.utils"), exports);
+__exportStar(require("./transports"), exports);
+__exportStar(require("./common"), exports);

package/dist/signal-router.utils.d.ts

@@ -0,0 +1,28 @@
+import { Type } from "@nestjs/common";
+import { BeforeHook, AfterHook } from "./common";
+export interface SignalRouterOptions {
+    before?: BeforeHook;
+    after?: AfterHook;
+    debug?: boolean;
+    eventPattern?: string;
+}
+export interface MessageData {
+    method: string;
+    params: any;
+    uuid: string;
+}
+export type MessageExtractor = (data: any) => MessageData;
+export declare function findPropertyByType(obj: any, type: Type<any>): string | null;
+export declare function findServiceInstances(instance: any, serviceType: Type<any> | Type<any>[]): any[];
+export declare function createErrorResponse(message: string, uuid?: string, method?: string, code?: number): {
+    uuid: string | undefined;
+    method: string | undefined;
+    params: {
+        result: string;
+        error: {
+            message: string;
+            code: number;
+        };
+    };
+};
+export declare function createSignalRouterDecorator(serviceType: Type<any> | Type<any>[], options: SignalRouterOptions | undefined, messageExtractor: MessageExtractor, registerHandler: (target: any, eventPattern: string, handlerName: string, context?: any) => void): (target: any) => any;

package/dist/signal-router.utils.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPropertyByType = findPropertyByType;
+exports.findServiceInstances = findServiceInstances;
+exports.createErrorResponse = createErrorResponse;
+exports.createSignalRouterDecorator = createSignalRouterDecorator;
+const common_1 = require("./common");
+const signal_decorator_1 = require("./signal.decorator");
+function findPropertyByType(obj, type) {
+    for (const prop in obj) {
+        if (obj[prop] instanceof type) {
+            return prop;
+        }
+    }
+    return null;
+}
+function findServiceInstances(instance, serviceType) {
+    return Array.isArray(serviceType)
+        ? // @ts-ignore
+            serviceType.map((type) => instance[findPropertyByType(instance, type)]).filter(Boolean)
+        : // @ts-ignore
+            [instance[findPropertyByType(instance, serviceType)]].filter(Boolean);
+}
+function createErrorResponse(message, uuid, method, code = 0) {
+    return {
+        uuid,
+        method,
+        params: {
+            result: "error",
+            error: {
+                message,
+                code
+            }
+        }
+    };
+}
+function createSignalRouterDecorator(serviceType, options = {}, messageExtractor, registerHandler) {
+    const debug = options?.debug || process.env["NODE_ENV"] !== "production";
+    return function (target) {
+        const eventPattern = options?.eventPattern || target.name.toLowerCase().replace("controller", "") + "-events";
+        const handlerName = "handleSignalMessage";
+        target.prototype[handlerName] = async function (data) {
+            try {
+                if (debug) {
+                    console.log(`[${eventPattern}] Received message:`, (0, common_1.stringifyWithBigInt)(data));
+                }
+                const messageData = messageExtractor(data);
+                const { method, params, uuid } = messageData;
+                if (!method) {
+                    console.error("Missing 'method' field in message");
+                    return createErrorResponse("Invalid message format");
+                }
+                if (debug) {
+                    console.log(`[${eventPattern}] Invoking method:`, method);
+                }
+                const serviceInstances = findServiceInstances(this, serviceType);
+                if (serviceInstances.length === 0) {
+                    console.error(`No service instances found for:`, serviceType);
+                    return createErrorResponse("Service not found", uuid, method);
+                }
+                let processedParams = params;
+                if (options.before) {
+                    const hookResult = await options.before({
+                        method,
+                        serviceName: eventPattern,
+                        uuid,
+                        rawData: data,
+                        params
+                    });
+                    if (hookResult !== undefined) {
+                        processedParams = hookResult;
+                    }
+                }
+                const signals = (0, signal_decorator_1.getClassSignals)(target);
+                const signalHandler = signals.find((s) => s.signalName === method);
+                if (!signalHandler) {
+                    console.error(`No handler found for method:`, method);
+                    return createErrorResponse(`Method ${method} not found`, uuid, method);
+                }
+                let serviceInstance = null;
+                const serviceMethod = signalHandler.methodName;
+                for (let s of serviceInstances) {
+                    if (s[serviceMethod]) {
+                        serviceInstance = s;
+                    }
+                }
+                if (!serviceInstance[serviceMethod]) {
+                    console.error(`Method ${serviceMethod} not found in service`);
+                    return createErrorResponse(`Method ${serviceMethod} does not exist`, uuid, method);
+                }
+                const args = signalHandler.paramTransformer ? signalHandler.paramTransformer(processedParams) : [processedParams];
+                if (debug) {
+                    console.log(`[${eventPattern}] Calling ${serviceMethod} with parameters:`, (0, common_1.stringifyWithBigInt)(args));
+                }
+                const result = await serviceInstance[serviceMethod](...args);
+                const transformedResult = signalHandler.resultTransformer ? signalHandler.resultTransformer(result) : result;
+                const serializedResult = (0, common_1.serializeBigInt)(transformedResult);
+                if (debug) {
+                    console.log(`[${eventPattern}] Result:`, (0, common_1.stringifyWithBigInt)(serializedResult));
+                }
+                let response = {
+                    uuid,
+                    method,
+                    params: { result: serializedResult }
+                };
+                if (options.after) {
+                    const hookResponse = await options.after({
+                        method,
+                        serviceName: eventPattern,
+                        uuid,
+                        rawData: data,
+                        params: processedParams,
+                        result: serializedResult,
+                        response
+                    });
+                    if (hookResponse !== undefined) {
+                        response = hookResponse;
+                    }
+                }
+                return response;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                console.error(`[${eventPattern}] Processing error:`, error);
+                return createErrorResponse(errorMessage, data.uuid, data.method, error.code);
+            }
+        };
+        registerHandler(target, eventPattern, handlerName);
+        return target;
+    };
+}

package/dist/signal.decorator.d.ts

@@ -0,0 +1,15 @@
+import "reflect-metadata";
+export declare const SIGNALS_METADATA_KEY = "kafka:signals";
+export interface SignalOptions {
+    [key: string]: any;
+}
+export interface SignalMetadata {
+    signalName: string;
+    methodName: string;
+    paramTransformer?: (data: any) => any[];
+    resultTransformer?: (result: any) => any;
+    options?: SignalOptions;
+}
+export declare function addSignalMetadata(target: any, signalName: string, methodName: string, paramTransformer?: (data: any) => any[], resultTransformer?: (result: any) => any, options?: SignalOptions): void;
+export declare function Signal(signalName: string, methodNameOrParamTransformer?: string | ((data: any) => any[]), paramTransformerOrOptions?: ((data: any) => any[]) | ((result: any) => any) | SignalOptions, resultTransformerOrOptions?: ((result: any) => any) | SignalOptions, options?: SignalOptions): MethodDecorator;
+export declare function getClassSignals(target: any): SignalMetadata[];

package/dist/signal.decorator.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIGNALS_METADATA_KEY = void 0;
+exports.addSignalMetadata = addSignalMetadata;
+exports.Signal = Signal;
+exports.getClassSignals = getClassSignals;
+require("reflect-metadata");
+// FIXME
+exports.SIGNALS_METADATA_KEY = "kafka:signals";
+function addSignalMetadata(target, signalName, methodName, paramTransformer, resultTransformer, options) {
+    const existingSignals = Reflect.getMetadata(exports.SIGNALS_METADATA_KEY, target) || [];
+    existingSignals.push({
+        signalName,
+        methodName,
+        paramTransformer,
+        resultTransformer,
+        options
+    });
+    Reflect.defineMetadata(exports.SIGNALS_METADATA_KEY, existingSignals, target);
+}
+function Signal(signalName, methodNameOrParamTransformer, paramTransformerOrOptions, resultTransformerOrOptions, options) {
+    // @ts-ignore
+    return function (target, propertyKey, descriptor) {
+        let methodName;
+        let paramTransformer;
+        let resultTransformer;
+        let signalOptions;
+        // Case 1: @Signal("create", (data) => [data.id, data.param2])
+        if (typeof methodNameOrParamTransformer === "function") {
+            methodName = signalName;
+            paramTransformer = methodNameOrParamTransformer;
+            if (typeof paramTransformerOrOptions === "function") {
+                resultTransformer = paramTransformerOrOptions;
+                signalOptions = resultTransformerOrOptions;
+            }
+            else {
+                signalOptions = paramTransformerOrOptions;
+            }
+        }
+        // Case 2, 3, 4: @Signal("modify", "modifyInvoice", ...)
+        else if (typeof methodNameOrParamTransformer === "string") {
+            methodName = methodNameOrParamTransformer;
+            if (typeof paramTransformerOrOptions === "function") {
+                paramTransformer = paramTransformerOrOptions;
+                if (typeof resultTransformerOrOptions === "function") {
+                    resultTransformer = resultTransformerOrOptions;
+                    signalOptions = options;
+                }
+                else {
+                    signalOptions = resultTransformerOrOptions;
+                }
+            }
+            else {
+                signalOptions = paramTransformerOrOptions;
+            }
+        }
+        // Default case: @Signal("create")
+        else {
+            methodName = signalName;
+        }
+        addSignalMetadata(target.constructor, signalName, methodName, paramTransformer, resultTransformer, signalOptions);
+        return descriptor;
+    };
+}
+function getClassSignals(target) {
+    return Reflect.getMetadata(exports.SIGNALS_METADATA_KEY, target) || [];
+}

package/dist/transports/index.d.ts

@@ -0,0 +1 @@
+export * from "./kafka";

package/dist/transports/index.js

@@ -0,0 +1,17 @@
+"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("./kafka"), exports);

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

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

package/dist/transports/kafka/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("./kafka.client-base"), exports);
+__exportStar(require("./nevo-kafka.client"), exports);
+__exportStar(require("./kafka.config"), exports);
+__exportStar(require("./microservice.config"), exports);
+__exportStar(require("./kafka.signal-router.decorator"), exports);

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

@@ -0,0 +1,8 @@
+import { NevoKafkaClient } from "./nevo-kafka.client";
+export declare abstract class KafkaClientBase {
+    protected readonly universalClient: NevoKafkaClient;
+    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 getAvailableServices(): string[];
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaClientBase = void 0;
+class KafkaClientBase {
+    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);
+    }
+    getAvailableServices() {
+        return this.universalClient.getAvailableServices();
+    }
+}
+exports.KafkaClientBase = KafkaClientBase;

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

@@ -0,0 +1,16 @@
+import { NevoKafkaClient } from "./nevo-kafka.client";
+export interface KafkaClientFactoryOptions {
+    clientIdPrefix: string;
+    groupIdPrefix?: string;
+    sessionTimeout?: number;
+    allowAutoTopicCreation?: boolean;
+    retryAttempts?: number;
+    brokerRetryTimeout?: number;
+    kafkaHost?: string;
+    kafkaPort?: string;
+    debug?: boolean;
+}
+export declare const createNevoKafkaClient: (serviceNames: string[], options: KafkaClientFactoryOptions) => {
+    provide: string;
+    useFactory: () => Promise<NevoKafkaClient>;
+};

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

@@ -0,0 +1,210 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNevoKafkaClient = void 0;
+const microservices_1 = require("@nestjs/microservices");
+const kafkajs_1 = require("kafkajs");
+const nevo_kafka_client_1 = require("./nevo-kafka.client");
+async function createKafkaTopics(serviceNames, options) {
+    const host = process.env[options.kafkaHost || "KAFKA_HOST"] || "localhost";
+    const port = parseInt(process.env[options.kafkaPort || "KAFKA_PORT"] || "9092");
+    const { Kafka } = await Promise.resolve().then(() => __importStar(require("kafkajs")));
+    const kafka = new Kafka({
+        clientId: `${options.clientIdPrefix}-admin`,
+        brokers: [`${host}:${port}`],
+        connectionTimeout: 10000,
+        requestTimeout: 30000,
+        retry: {
+            retries: 5,
+            initialRetryTime: 300,
+            maxRetryTime: 30000
+        }
+    });
+    const admin = kafka.admin();
+    try {
+        await admin.connect();
+        console.log(`[KafkaAdmin] Connected to Kafka broker at ${host}:${port}`);
+        const existingTopics = await admin.listTopics();
+        console.log(`[KafkaAdmin] Existing topics:`, existingTopics);
+        const topicsToCreate = serviceNames.flatMap((serviceName) => {
+            const normalizedServiceName = serviceName.toLowerCase();
+            const eventsTopic = `${normalizedServiceName}-events`;
+            const replyTopic = `${eventsTopic}.reply`;
+            const topics = [];
+            if (!existingTopics.includes(eventsTopic)) {
+                topics.push({
+                    topic: eventsTopic,
+                    numPartitions: 3,
+                    replicationFactor: 1,
+                    configEntries: [
+                        { name: "cleanup.policy", value: "delete" },
+                        { name: "retention.ms", value: "86400000" }, // 24 hours
+                        { name: "max.message.bytes", value: "1000012" }
+                    ]
+                });
+            }
+            if (!existingTopics.includes(replyTopic)) {
+                topics.push({
+                    topic: replyTopic,
+                    numPartitions: 3,
+                    replicationFactor: 1,
+                    configEntries: [
+                        { name: "cleanup.policy", value: "delete" },
+                        { name: "retention.ms", value: "3600000" }, // 1 hour for reply topics
+                        { name: "max.message.bytes", value: "1000012" }
+                    ]
+                });
+            }
+            return topics;
+        });
+        if (topicsToCreate.length > 0) {
+            console.log(`[KafkaAdmin] Creating ${topicsToCreate.length} topics:`, topicsToCreate.map((t) => t.topic));
+            await admin.createTopics({
+                topics: topicsToCreate,
+                waitForLeaders: true,
+                timeout: 30000
+            });
+            console.log(`[KafkaAdmin] Successfully created topics:`, topicsToCreate.map((t) => t.topic));
+            // Wait a bit for topics to be fully initialized
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            // Verify topics were created
+            const updatedTopics = await admin.listTopics();
+            const createdTopics = topicsToCreate.map((t) => t.topic);
+            const missingTopics = createdTopics.filter((topic) => !updatedTopics.includes(topic));
+            if (missingTopics.length > 0) {
+                console.error(`[KafkaAdmin] Failed to create topics:`, missingTopics);
+                throw new Error(`Failed to create topics: ${missingTopics.join(", ")}`);
+            }
+            console.log(`[KafkaAdmin] Verified all topics created successfully`);
+        }
+        else {
+            console.log(`[KafkaAdmin] All topics already exist, skipping creation`);
+        }
+    }
+    catch (error) {
+        console.error(`[KafkaAdmin] Error managing topics:`, error.message);
+        // If it's a topic exists error, that's actually OK
+        if (error.message && error.message.includes("already exists")) {
+            console.log(`[KafkaAdmin] Topics already exist, continuing...`);
+        }
+        else {
+            throw error;
+        }
+    }
+    finally {
+        try {
+            await admin.disconnect();
+            console.log(`[KafkaAdmin] Disconnected from Kafka`);
+        }
+        catch (disconnectError) {
+            console.warn(`[KafkaAdmin] Warning during disconnect:`, disconnectError);
+        }
+    }
+}
+const createNevoKafkaClient = (serviceNames, options) => {
+    const defaultOptions = {
+        groupIdPrefix: options.clientIdPrefix,
+        sessionTimeout: 15000,
+        allowAutoTopicCreation: true,
+        retryAttempts: 3,
+        brokerRetryTimeout: 1000,
+        debug: false,
+        timeoutMs: 20000
+    };
+    const mergedOptions = { ...defaultOptions, ...options };
+    return {
+        provide: "NEVO_KAFKA_CLIENT",
+        useFactory: async () => {
+            const host = process.env[mergedOptions.kafkaHost || "KAFKA_HOST"] || "localhost";
+            const port = parseInt(process.env[mergedOptions.kafkaPort || "KAFKA_PORT"] || "9092");
+            console.log(`[NevoKafkaClient] Initializing for services: ${serviceNames.join(", ")}`);
+            let topicCreationAttempts = 0;
+            const maxTopicCreationAttempts = 3;
+            while (topicCreationAttempts < maxTopicCreationAttempts) {
+                try {
+                    await createKafkaTopics(serviceNames, { ...mergedOptions, kafkaHost: "KAFKA_HOST", kafkaPort: "KAFKA_PORT" });
+                    break;
+                }
+                catch (error) {
+                    topicCreationAttempts++;
+                    console.warn(`[NevoKafkaClient] Topic creation attempt ${topicCreationAttempts} failed:`, error.message);
+                    if (topicCreationAttempts >= maxTopicCreationAttempts) {
+                        console.error(`[NevoKafkaClient] Failed to create topics after ${maxTopicCreationAttempts} attempts`);
+                        throw error;
+                    }
+                    // Wait before retrying
+                    await new Promise((resolve) => setTimeout(resolve, 2000 * topicCreationAttempts));
+                }
+            }
+            const kafkaClientConfig = {
+                transport: microservices_1.Transport.KAFKA,
+                options: {
+                    client: {
+                        clientId: `${mergedOptions.clientIdPrefix}-nevo`,
+                        brokers: [`${host}:${port}`],
+                        connectionTimeout: 10000,
+                        requestTimeout: 30000,
+                        retry: {
+                            retries: mergedOptions.retryAttempts,
+                            initialRetryTime: 300,
+                            maxRetryTime: mergedOptions.brokerRetryTimeout
+                        }
+                    },
+                    consumer: {
+                        groupId: `${mergedOptions.groupIdPrefix}-nevo-consumer`,
+                        allowAutoTopicCreation: mergedOptions.allowAutoTopicCreation,
+                        sessionTimeout: mergedOptions.sessionTimeout,
+                        maxWaitTimeInMs: 5000,
+                        heartbeatInterval: 3000
+                    },
+                    producer: {
+                        createPartitioner: kafkajs_1.Partitioners.DefaultPartitioner,
+                        allowAutoTopicCreation: mergedOptions.allowAutoTopicCreation,
+                        idempotent: true,
+                        maxInFlightRequests: 1
+                    }
+                }
+            };
+            const { ClientKafka } = await Promise.resolve().then(() => __importStar(require("@nestjs/microservices")));
+            const kafkaClient = new ClientKafka(kafkaClientConfig.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
+            });
+        }
+    };
+};
+exports.createNevoKafkaClient = createNevoKafkaClient;

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

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

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaSignalRouter = KafkaSignalRouter;
+const microservices_1 = require("@nestjs/microservices");
+const signal_router_utils_1 = require("../../signal-router.utils");
+const common_1 = require("../../common");
+const kafkajs_1 = require("kafkajs");
+function KafkaSignalRouter(serviceType, options) {
+    return (0, signal_router_utils_1.createSignalRouterDecorator)(serviceType, options, (data) => {
+        let messageData = data;
+        if (data && data.value && typeof data.value === "string") {
+            try {
+                messageData = (0, common_1.parseWithBigInt)(data.value);
+            }
+            catch (e) {
+                console.error("Failed to parse JSON from message:", e);
+            }
+        }
+        return {
+            method: messageData.method,
+            params: messageData.params,
+            uuid: messageData.uuid
+        };
+    }, (target, eventPattern, handlerName) => {
+        const originalMethod = target.prototype[handlerName];
+        target.prototype.producer = null;
+        const originalOnModuleInit = target.prototype.onModuleInit || function () { };
+        target.prototype.onModuleInit = async function () {
+            await originalOnModuleInit.call(this);
+            const kafkaHost = process.env["KAFKA_HOST"] || "localhost";
+            const kafkaPort = process.env["KAFKA_PORT"] || "9092";
+            const kafka = new kafkajs_1.Kafka({
+                clientId: `${eventPattern}-producer`,
+                brokers: [`${kafkaHost}:${kafkaPort}`]
+            });
+            this.producer = kafka.producer();
+            await this.producer.connect();
+            if (options?.debug) {
+                console.log(`[${eventPattern}] Kafka Producer connected for reply topics`);
+            }
+        };
+        const originalOnModuleDestroy = target.prototype.onModuleDestroy || function () { };
+        target.prototype.onModuleDestroy = async function () {
+            await originalOnModuleDestroy.call(this);
+            if (this.producer) {
+                await this.producer.disconnect();
+                if (options?.debug) {
+                    console.log(`[${eventPattern}] Kafka Producer disconnected`);
+                }
+            }
+        };
+        target.prototype[handlerName] = async function (data) {
+            const result = await originalMethod.call(this, data);
+            if (result && this.producer) {
+                try {
+                    const replyTopic = `${eventPattern}.reply`;
+                    await this.producer.send({
+                        topic: replyTopic,
+                        messages: [
+                            {
+                                key: result.uuid || "",
+                                value: (0, common_1.stringifyWithBigInt)(result)
+                            }
+                        ]
+                    });
+                    if (options?.debug) {
+                        console.log(`[${eventPattern}] Sent response to ${replyTopic}:`, (0, common_1.stringifyWithBigInt)(result));
+                    }
+                }
+                catch (error) {
+                    console.error(`[${eventPattern}] Failed to send to reply topic:`, error);
+                }
+            }
+            return result;
+        };
+        (0, microservices_1.MessagePattern)(eventPattern)(target.prototype, handlerName, Object.getOwnPropertyDescriptor(target.prototype, handlerName));
+    });
+}

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

@@ -0,0 +1,10 @@
+import { INestApplication, Type } from "@nestjs/common";
+export interface NestApplicationOptions {
+    microserviceName: string;
+    module: Type<any>;
+    port?: number;
+    host?: string;
+    debug?: boolean;
+    onInit?: (app: INestApplication) => Promise<void>;
+}
+export declare function createKafkaMicroservice(options: NestApplicationOptions): Promise<INestApplication>;