@car-parts/common 1.0.4 → 1.0.6

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

@@ -1,21 +1,18 @@
-import { Consumer, Kafka, ConsumerConfig, KafkaMessage, TopicPartitionOffsetAndMetadata } from 'kafkajs';
+import { Message, Stan } from 'node-nats-streaming';
 import { Subjects } from './subjects';
 interface Event {
     subject: Subjects;
     data: any;
 }
-export declare abstract class KafkaListener<T extends Event> {
+export declare abstract class Listener<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>;
+    abstract queueGroupName: string;
+    abstract onMessage(data: T['data'], msg: Message): void;
+    protected client: Stan;
+    protected ackWait: number;
+    constructor(client: Stan);
+    subscriptionOptions(): import("node-nats-streaming").SubscriptionOptions;
+    listen(): void;
+    parseMessage(msg: Message): any;
 }
 export {};

package/build/events/base-listener.js

@@ -1,78 +1,35 @@
 "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;
+exports.Listener = void 0;
+class Listener {
+    constructor(client) {
+        this.ackWait = 5 * 1000;
+        this.client = client;
     }
-    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);
+    subscriptionOptions() {
+        return this.client
+            .subscriptionOptions()
+            .setDeliverAllAvailable()
+            .setManualAckMode(true)
+            .setAckWait(this.ackWait)
+            .setDurableName(this.queueGroupName);
     }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.consumer.disconnect();
-            console.log('Kafka consumer disconnected');
+    // subscribe for event
+    listen() {
+        const subscription = this.client.subscribe(this.subject, this.queueGroupName, this.subscriptionOptions());
+        // msg.getSequence(); // returns event number
+        // msg.getData() // returns data | Buffer
+        subscription.on('message', (msg) => {
+            console.log(`Message received: ${this.subject} / ${this.queueGroupName}`);
+            const parsedData = this.parseMessage(msg);
+            this.onMessage(parsedData, msg);
         });
     }
-    // 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);
-        });
+    parseMessage(msg) {
+        const data = msg.getData(); // string | buffer
+        return typeof data === 'string'
+            ? JSON.parse(data)
+            : JSON.parse(data.toString('utf8'));
     }
 }
-exports.KafkaListener = KafkaListener;
+exports.Listener = Listener;

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

@@ -1,4 +1,4 @@
-import { Producer, RecordMetadata } from 'kafkajs';
+import { Stan } from 'node-nats-streaming';
 import { Subjects } from './subjects';
 interface Event {
     subject: Subjects;
@@ -6,11 +6,8 @@ interface Event {
 }
 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>;
+    protected client: Stan;
+    constructor(client: Stan);
+    publish(data: T['data']): Promise<void>;
 }
 export {};

package/build/events/base-publisher.js

@@ -1,90 +1,19 @@
 "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;
+    constructor(client) {
+        this.client = client;
     }
     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');
+        return new Promise((resolve, reject) => {
+            this.client.publish(this.subject, JSON.stringify(data), (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                console.log('Event published to subject', this.subject);
+                resolve();
+            });
         });
     }
 }

package/build/events/subjects.d.ts

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

package/build/events/subjects.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@car-parts/common",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [