@aichatwar/shared 1.0.90 → 1.0.94

package/build/events/kafka/baseListener.d.ts

@@ -5,6 +5,9 @@ export declare abstract class Listener<T extends BaseEvent> {
     abstract groupId: string;
     abstract onMessage(data: T['data'], payload: EachMessagePayload): Promise<void>;
     protected consumer: Consumer;
+    protected ackDeadline: number;
+    private currentPayload?;
     constructor(consumer: Consumer);
+    protected ack(): Promise<void>;
     listen(): Promise<void>;
 }

package/build/events/kafka/baseListener.js

@@ -10,25 +10,55 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Listener = void 0;
-// Updated event to base
 class Listener {
     constructor(consumer) {
+        this.ackDeadline = 5 * 1000; // 5 seconds
         this.consumer = consumer;
     }
+    // Manual acknowledgment method
+    ack() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.currentPayload) {
+                throw new Error('No current payload to acknowledge');
+            }
+            yield this.consumer.commitOffsets([{
+                    topic: this.currentPayload.topic,
+                    partition: this.currentPayload.partition,
+                    offset: (BigInt(this.currentPayload.message.offset) + BigInt(1)).toString()
+                }]);
+            console.log(`Message manually acknowledged for topic: ${this.topic}`);
+        });
+    }
     listen() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.consumer.connect(); // ✅ connect once
+            yield this.consumer.connect();
             yield this.consumer.subscribe({
                 topic: this.topic,
                 fromBeginning: false,
             });
-            console.log(`👂 Listening to topic: ${this.topic}`);
+            console.log(`Listening to topic: ${this.topic} with groupId: ${this.groupId}`);
             yield this.consumer.run({
                 eachMessage: (payload) => __awaiter(this, void 0, void 0, function* () {
                     if (!payload.message.value)
                         return;
-                    const data = JSON.parse(payload.message.value.toString());
-                    yield this.onMessage(data, payload);
+                    console.log(`Message received -> topic: ${this.topic}, groupId: ${this.groupId}`);
+                    // Store current payload for manual ack
+                    this.currentPayload = payload;
+                    try {
+                        const data = JSON.parse(payload.message.value.toString());
+                        yield this.onMessage(data, payload);
+                        // Note: Child listeners must call this.ack() manually after successful processing
+                        // If they don't call ack(), the message will be redelivered
+                    }
+                    catch (error) {
+                        console.error(`Error processing message for topic: ${this.topic}`, error);
+                        // In case of error, we don't commit the offset, so the message will be redelivered
+                        throw error;
+                    }
+                    finally {
+                        // Clear the current payload
+                        this.currentPayload = undefined;
+                    }
                 })
             });
         });

package/build/events/kafka/basePublisher.d.ts

@@ -3,6 +3,8 @@ import { BaseEvent } from '../baseEvent';
 export declare abstract class Publisher<T extends BaseEvent> {
     abstract topic: T['subject'];
     protected producer: Producer;
+    protected maxRetries: number;
+    protected retryDelay: number;
     constructor(producer: Producer);
     publish(data: T['data']): Promise<void>;
 }

package/build/events/kafka/basePublisher.js

@@ -12,22 +12,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Publisher = void 0;
 class Publisher {
     constructor(producer) {
+        this.maxRetries = 3;
+        this.retryDelay = 1000; // 1 second
         this.producer = producer;
     }
     publish(data) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.producer)
                 throw new Error('Producer not defined');
-            try {
-                yield this.producer.send({
-                    topic: this.topic,
-                    messages: [{ value: JSON.stringify(data) }],
-                });
-            }
-            catch (err) {
-                console.error(`❌ Publish failed on first try for ${this.topic}`, err);
-                throw err;
+            let lastError = null;
+            for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+                try {
+                    yield this.producer.send({
+                        topic: this.topic,
+                        messages: [{
+                                value: JSON.stringify(data),
+                                key: data.id || undefined, // Use id as key for partitioning if available
+                                timestamp: Date.now().toString()
+                            }],
+                    });
+                    console.log(`Event published successfully: ${this.topic}`, data);
+                    return; // Success, exit retry loop
+                }
+                catch (err) {
+                    lastError = err;
+                    console.error(`❌ Publish attempt ${attempt}/${this.maxRetries} failed for ${this.topic}`, err);
+                    if (attempt < this.maxRetries) {
+                        console.log(`Retrying in ${this.retryDelay}ms...`);
+                        yield new Promise(resolve => setTimeout(resolve, this.retryDelay));
+                        this.retryDelay *= 2; // Exponential backoff
+                    }
+                }
             }
+            // All retries failed
+            console.error(`❌ Publish failed after ${this.maxRetries} attempts for ${this.topic}`);
+            throw lastError || new Error(`Failed to publish to ${this.topic} after ${this.maxRetries} attempts`);
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aichatwar/shared",
-  "version": "1.0.90",
+  "version": "1.0.94",
   "main": "./build/index.js",
   "typs": "./build/index.d.ts",
   "files": [