@riaskov/nevo-messaging 1.0.0

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKafkaMicroservice = createKafkaMicroservice;
+const core_1 = require("@nestjs/core");
+const platform_fastify_1 = require("@nestjs/platform-fastify");
+const microservices_1 = require("@nestjs/microservices");
+async function createKafkaMicroservice(options) {
+    // @ts-ignore
+    const { microserviceName, module, port = 3000, host = "0.0.0.0", debug = process.env["NODE_ENV"] !== "production", onInit } = options;
+    const app = await core_1.NestFactory.create(module, new platform_fastify_1.FastifyAdapter());
+    app.connectMicroservice({
+        transport: microservices_1.Transport.KAFKA,
+        options: {
+            client: {
+                clientId: `${microserviceName}-microservice`,
+                brokers: [process.env["KAFKA_HOST"] ? `${process.env["KAFKA_HOST"]}:${process.env["KAFKA_PORT"] || 9092}` : "127.0.0.1:9092"],
+                connectionTimeout: 3000,
+                requestTimeout: 15000,
+                retry: {
+                    retries: 3
+                }
+            },
+            consumer: {
+                groupId: `${microserviceName}-events`,
+                allowAutoTopicCreation: true,
+                sessionTimeout: 15000,
+                maxWaitTimeInMs: 1000,
+                heartbeatInterval: 1000
+            },
+            subscribe: {
+                fromBeginning: true
+            },
+            producer: {
+                idempotent: true,
+                maxInFlightRequests: 1
+            }
+        }
+    });
+    await app.startAllMicroservices();
+    if (onInit) {
+        await onInit(app);
+    }
+    await app.listen(port, host);
+    console.log(`Service started on http://${host === "0.0.0.0" ? "localhost" : host}:${port}`);
+    return app;
+}

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

@@ -0,0 +1,16 @@
+import { ClientKafka } from "@nestjs/microservices";
+export interface NevoKafkaClientOptions {
+    timeoutMs?: number;
+    debug?: boolean;
+}
+export declare class NevoKafkaClient {
+    private readonly kafkaClient;
+    private readonly serviceNames;
+    private readonly timeoutMs;
+    private readonly debug;
+    constructor(kafkaClient: ClientKafka, serviceNames: string[], options?: NevoKafkaClientOptions);
+    private createMessagePayload;
+    query<T = any>(serviceName: string, method: string, params: any): Promise<T>;
+    emit(serviceName: string, method: string, params: any): Promise<void>;
+    getAvailableServices(): string[];
+}

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NevoKafkaClient = void 0;
+const rxjs_1 = require("rxjs");
+const common_1 = require("../../common");
+const node_crypto_1 = require("node:crypto");
+class NevoKafkaClient {
+    constructor(kafkaClient, serviceNames, options) {
+        this.kafkaClient = kafkaClient;
+        this.serviceNames = serviceNames.map((name) => name.toLowerCase());
+        this.timeoutMs = options?.timeoutMs || 20000;
+        this.debug = options?.debug || false;
+        this.serviceNames.forEach((serviceName) => {
+            const topicName = `${serviceName}-events`;
+            const replyTopicName = `${topicName}.reply`;
+            this.kafkaClient.subscribeToResponseOf(topicName);
+            this.kafkaClient.subscribeToResponseOf(replyTopicName);
+        });
+    }
+    createMessagePayload(method, params) {
+        const uuid = (0, node_crypto_1.randomUUID)();
+        return {
+            key: uuid,
+            value: (0, common_1.stringifyWithBigInt)({ uuid, method, params })
+        };
+    }
+    async query(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}-events`;
+        const payload = this.createMessagePayload(method, params);
+        if (this.debug) {
+            console.log(`[NevoKafkaClient] Sending query to ${topicName}:`, { method, params });
+        }
+        try {
+            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;
+                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;
+        }
+        catch (error) {
+            if (error instanceof rxjs_1.TimeoutError) {
+                console.error(`Kafka request timed out after ${this.timeoutMs}ms`);
+                throw new common_1.MessagingError(common_1.ErrorCode.UNKNOWN, {
+                    message: `Request to ${serviceName}.${method} timed out after ${this.timeoutMs}ms`
+                });
+            }
+            throw error;
+        }
+    }
+    async emit(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}-events`;
+        const payload = this.createMessagePayload(method, params);
+        if (this.debug) {
+            console.log(`[NevoKafkaClient] Emitting to ${topicName}:`, { method, params });
+        }
+        try {
+            this.kafkaClient.emit(topicName, payload);
+        }
+        catch (error) {
+            console.error(`Failed to emit event to ${serviceName}.${method}:`, error);
+            throw error;
+        }
+    }
+    getAvailableServices() {
+        return [...this.serviceNames];
+    }
+}
+exports.NevoKafkaClient = NevoKafkaClient;

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@riaskov/nevo-messaging",
+  "version": "1.0.0",
+  "description": "Microservices messaging framework for NestJS with Kafka transport",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write \"src/**/*.ts\" \"examples/**/*.ts\""
+  },
+  "keywords": [
+    "nestjs",
+    "microservices",
+    "kafka",
+    "messaging",
+    "signal-router",
+    "nevo"
+  ],
+  "author": "Andrei Riaskov <code@riaskov.com>",
+  "license": "MIT",
+  "peerDependencies": {
+    "@nestjs/common": "^11.1.0",
+    "@nestjs/core": "^11.1.0",
+    "@nestjs/microservices": "^11.1.0",
+    "@nestjs/config": "^4.0.0",
+    "@nestjs/platform-fastify": "^11.1.0",
+    "kafkajs": "^2.2.4",
+    "rxjs": "^7.8.2",
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "@nestjs/common": "11.1.0",
+    "@nestjs/core": "11.1.0",
+    "@nestjs/microservices": "11.1.0",
+    "@nestjs/config": "4.0.2",
+    "@nestjs/platform-fastify": "11.1.0",
+    "kafkajs": "2.2.4",
+    "rxjs": "7.8.2",
+    "reflect-metadata": "0.2.2",
+    "@types/node": "^22.15.30",
+    "@typescript-eslint/eslint-plugin": "6.21.0",
+    "@typescript-eslint/parser": "6.21.0",
+    "eslint": "8.57.1",
+    "jest": "29.7.0",
+    "prettier": "3.5.3",
+    "typescript": "5.9.2"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ARyaskov/nevo-messaging.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ARyaskov/nevo-messaging/issues"
+  },
+  "homepage": "https://github.com/ARyaskov/nevo-messaging#readme"
+}