@car-parts/common 1.0.2 → 1.0.4

package/build/events/base-listener.d.ts

@@ -0,0 +1,21 @@
+import { Consumer, Kafka, ConsumerConfig, KafkaMessage, TopicPartitionOffsetAndMetadata } from 'kafkajs';
+import { Subjects } from './subjects';
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class KafkaListener<T extends Event> {
+    abstract subject: T['subject'];
+    abstract groupId: string;
+    abstract onMessage(data: T['data'], message: KafkaMessage): Promise<void>;
+    protected kafka: Kafka;
+    protected consumer: Consumer;
+    protected sessionTimeout: number;
+    protected consumerConfig?: Partial<ConsumerConfig>;
+    constructor(kafka: Kafka, consumerConfig?: Partial<ConsumerConfig>);
+    listen(): Promise<void>;
+    parseMessage(message: KafkaMessage): any;
+    disconnect(): Promise<void>;
+    commitOffsets(offsets: Array<TopicPartitionOffsetAndMetadata>): Promise<void>;
+}
+export {};

package/build/events/base-listener.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaListener = void 0;
+class KafkaListener {
+    constructor(kafka, consumerConfig) {
+        this.sessionTimeout = 30000; // 30 seconds
+        this.kafka = kafka;
+        this.consumerConfig = consumerConfig;
+    }
+    listen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize consumer here where groupId is available
+            this.consumer = this.kafka.consumer(Object.assign({ groupId: this.groupId, sessionTimeout: this.sessionTimeout }, this.consumerConfig));
+            yield this.consumer.connect();
+            console.log(`Kafka consumer connected: ${this.groupId}`);
+            yield this.consumer.subscribe({
+                topic: this.subject,
+                fromBeginning: true, // Similar to setDeliverAllAvailable in NATS
+            });
+            yield this.consumer.run({
+                eachMessage: (_a) => __awaiter(this, [_a], void 0, function* ({ topic, partition, message, }) {
+                    console.log(`Message received: ${topic} / ${this.groupId} / Partition: ${partition}`);
+                    try {
+                        const parsedData = this.parseMessage(message);
+                        yield this.onMessage(parsedData, message);
+                        // Kafka automatically commits offsets by default (autoCommit: true)
+                        // If you want manual commit, set autoCommit to false in run() options
+                    }
+                    catch (err) {
+                        console.error('Error processing message:', err);
+                        // Implement your error handling strategy here
+                        // You might want to:
+                        // 1. Skip the message and continue
+                        // 2. Send to dead letter queue
+                        // 3. Retry with backoff
+                        throw err; // This will pause the consumer
+                    }
+                }),
+            });
+            // Handle errors
+            this.consumer.on('consumer.crash', (event) => {
+                console.error('Consumer crashed:', event.payload.error);
+            });
+            this.consumer.on('consumer.disconnect', () => {
+                console.log('Consumer disconnected');
+            });
+        });
+    }
+    parseMessage(message) {
+        if (!message.value) {
+            throw new Error('Message value is null');
+        }
+        const data = message.value.toString('utf8');
+        return JSON.parse(data);
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.consumer.disconnect();
+            console.log('Kafka consumer disconnected');
+        });
+    }
+    // Manual commit if needed (set autoCommit: false in consumer.run())
+    commitOffsets(offsets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.consumer.commitOffsets(offsets);
+        });
+    }
+}
+exports.KafkaListener = KafkaListener;

package/build/events/base-publisher.d.ts

@@ -0,0 +1,16 @@
+import { Producer, RecordMetadata } from 'kafkajs';
+import { Subjects } from './subjects';
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class Publisher<T extends Event> {
+    abstract subject: T['subject'];
+    protected producer: Producer;
+    constructor(producer: Producer);
+    publish(data: T['data']): Promise<RecordMetadata[]>;
+    publishBatch(dataArray: T['data'][]): Promise<RecordMetadata[]>;
+    publishWithKey(data: T['data'], key: string): Promise<RecordMetadata[]>;
+    disconnect(): Promise<void>;
+}
+export {};

package/build/events/base-publisher.js

@@ -0,0 +1,91 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Publisher = void 0;
+class Publisher {
+    constructor(producer) {
+        this.producer = producer;
+    }
+    publish(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.producer.send({
+                    topic: this.subject,
+                    messages: [
+                        {
+                            value: JSON.stringify(data),
+                            // Optional: add key for partitioning
+                            // key: data.id,
+                            // Optional: add headers
+                            // headers: {
+                            //   'correlation-id': 'some-id',
+                            // },
+                        },
+                    ],
+                });
+                console.log('Event published to topic:', this.subject);
+                return result;
+            }
+            catch (err) {
+                console.error('Error publishing event:', err);
+                throw err;
+            }
+        });
+    }
+    // Publish multiple messages at once (batch)
+    publishBatch(dataArray) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.producer.send({
+                    topic: this.subject,
+                    messages: dataArray.map((data) => ({
+                        value: JSON.stringify(data),
+                    })),
+                });
+                console.log(`${dataArray.length} events published to topic:`, this.subject);
+                return result;
+            }
+            catch (err) {
+                console.error('Error publishing batch events:', err);
+                throw err;
+            }
+        });
+    }
+    // Publish with custom partition key
+    publishWithKey(data, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.producer.send({
+                    topic: this.subject,
+                    messages: [
+                        {
+                            key: key,
+                            value: JSON.stringify(data),
+                        },
+                    ],
+                });
+                console.log('Event published to topic:', this.subject, 'with key:', key);
+                return result;
+            }
+            catch (err) {
+                console.error('Error publishing event:', err);
+                throw err;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.producer.disconnect();
+            console.log('Kafka producer disconnected');
+        });
+    }
+}
+exports.Publisher = Publisher;

package/build/events/subjects.d.ts

@@ -0,0 +1,3 @@
+export declare enum Subjects {
+    UserCreated = "user:created"
+}

package/build/events/subjects.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subjects = void 0;
+var Subjects;
+(function (Subjects) {
+    Subjects["UserCreated"] = "user:created";
+})(Subjects || (exports.Subjects = Subjects = {}));
+// interface to make sure event names are consistent

package/build/events/user-created-event.d.ts

@@ -0,0 +1,9 @@
+import { Subjects } from './subjects';
+export interface UserCreatedEvent {
+    subject: Subjects.UserCreated;
+    data: {
+        id: string;
+        name: string;
+        email: string;
+    };
+}

package/build/events/user-created-event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/index.d.ts

@@ -10,3 +10,7 @@ export * from './middlewares/error-handler';
 export * from './middlewares/require-auth';
 export * from './middlewares/validate-request';
 export * from './middlewares/restrinct-to';
+export * from './events/base-listener';
+export * from './events/base-publisher';
+export * from './events/subjects';
+export * from './events/user-created-event';

package/build/index.js

@@ -26,3 +26,7 @@ __exportStar(require("./middlewares/error-handler"), exports);
 __exportStar(require("./middlewares/require-auth"), exports);
 __exportStar(require("./middlewares/validate-request"), exports);
 __exportStar(require("./middlewares/restrinct-to"), exports);
+__exportStar(require("./events/base-listener"), exports);
+__exportStar(require("./events/base-publisher"), exports);
+__exportStar(require("./events/subjects"), exports);
+__exportStar(require("./events/user-created-event"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@car-parts/common",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [
@@ -28,6 +28,7 @@
     "express": "^5.1.0",
     "express-validator": "^7.2.1",
     "jsonwebtoken": "^9.0.2",
+    "kafkajs": "^2.2.4",
     "node-nats-streaming": "^0.3.2"
   }
 }