@jetit/publisher 1.0.7 → 1.0.9

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@jetit/publisher",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "type": "commonjs",
   "dependencies": {
-    "@jetit/id": "0.0.6",
+    "@jetit/id": "0.0.11",
     "ioredis": "5.3.1",
-    "rxjs": "7.8.0"
+    "rxjs": "7.8.0",
+    "tslib": "2.5.0"
   },
   "peerDependencies": {
-    "@types/ioredis-mock": "8.2.1",
-    "tslib": "2.5.0"
+    "@types/ioredis-mock": "8.2.1"
   },
   "main": "./src/index.js",
   "types": "./src/index.d.ts"

package/src/index.d.ts

@@ -1 +1,2 @@
 export * from './lib/publisher';
+export { EventData } from './lib/redis/types';

package/src/lib/redis/groups.js

@@ -4,7 +4,7 @@ exports.getAllConsumerGroups = void 0;
 const tslib_1 = require("tslib");
 function getAllConsumerGroups(eventName, redisConnection) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const consumerGroups = yield redisConnection.smembers(`consumerGroups:${eventName}`);
+        const consumerGroups = yield redisConnection.smembers(`${eventName}`);
         return consumerGroups;
     });
 }

package/src/lib/redis/streams.d.ts

@@ -1,5 +1,5 @@
 import { RedisType } from './registry';
-import { EventData } from './types';
+import { EventData, PublishData } from './types';
 import { Observable } from 'rxjs';
 export declare class Streams {
     private _redisPublisher?;
@@ -47,7 +47,7 @@ export declare class Streams {
      * const eventData = { eventName: 'order.created', data: orderData };
      * await streams.publish(eventData);
      */
-    publish<T>(data: EventData<T>): Promise<void>;
+    publish<TData = unknown, TName extends string = string>(data: PublishData<TData, TName>): Promise<void>;
     /**
      * Schedules an event to be published at a specified future time. Thee event gets published if the
      * differnece between the current time and the scheduled time is less than 500ms.
@@ -69,7 +69,7 @@ export declare class Streams {
      *
      * await streams.scheduledPublish(futureTime, eventData);
      */
-    scheduledPublish<T>(scheduledTime: Date, eventData: EventData<T>, uniquePerInstance?: boolean): Promise<void>;
+    scheduledPublish<T, const TName extends string = string>(scheduledTime: Date, eventData: EventData<T, TName>, uniquePerInstance?: boolean): Promise<void>;
     /**
      * Listens for events with the given name and returns an Observable that emits an EventData<T> object
      * each time a new event is received.
@@ -97,7 +97,7 @@ export declare class Streams {
      *   console.log('New order created:', event.data);
      * });
      */
-    listen<T>(eventName: string, maxRetries?: number, initialDelay?: number): Observable<EventData<T>>;
+    listen<T = unknown, const TName extends string = string>(eventName: TName, maxRetries?: number, initialDelay?: number): Observable<EventData<T, TName>>;
     private listenInternals;
     /**
      * This method takes all messages allocated to this instance and republishes them so

package/src/lib/redis/streams.js

@@ -42,10 +42,13 @@ class Streams {
         this.instanceId = `${serviceName}:${(0, id_1.generateID)('HEX', 'FE')}`;
         this.consumerGroupName = `cg-${serviceName}`;
         const cleanUpInterval = (_a = parseInt(process.env['CLEANUP_INTERVAL'] || '1000 * 60 * 60', 10)) !== null && _a !== void 0 ? _a : 1000 * 60 * 60;
-        this.cleanUpTimer = (0, rxjs_1.interval)(cleanUpInterval).subscribe(() => {
+        this.cleanUpTimer = setInterval(() => {
             this.clearDuplicationCheckKeys();
-            this.eventsListened.forEach((eventName) => this.cleanupAcknowledgedMessages(eventName, cleanUpInterval));
-        });
+            this.eventsListened.forEach((eventName) => {
+                this.cleanupAcknowledgedMessages(eventName, cleanUpInterval);
+                this.republishUnprocessedEvents(eventName);
+            });
+        }, cleanUpInterval);
     }
     createConsumerGroup(eventName) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
@@ -85,28 +88,15 @@ class Streams {
             } while (cursor !== '0');
         });
     }
-    /**
-     * Publishes an event with the given data to the Redis event stream.
-     *
-     * The method generates a unique event ID for each event, and adds it to the event data to handle message
-     * deduplication.
-     *
-     * @param data - An EventData<T> object containing the data for the event.
-     *
-     * @returns A Promise that resolves when the event has been published to the Redis stream.
-     *
-     * @example
-     *
-     * // Publish an "order.created" event with the given order data
-     * const orderData = { id: '123', customerName: 'John Doe', amount: 100 };
-     * const eventData = { eventName: 'order.created', data: orderData };
-     * await streams.publish(eventData);
-     */
     publish(data) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            data.eventId = (0, id_1.generateID)('HEX', 'FF'); // Added a unique Id to handle Message deduplication
+            if (data.eventId)
+                data.republishEvent = data.eventId;
+            data.eventId = (0, id_1.generateID)('HEX', 'FF');
+            if (!data.createdAt)
+                data.createdAt = Date.now();
             const transaction = this.redisPublisher.multi();
-            const consumerGroups = yield (0, groups_1.getAllConsumerGroups)(data.eventName, this.redisGroups);
+            const consumerGroups = yield (0, groups_1.getAllConsumerGroups)(data.eventName, this.redisPublisher);
             if (consumerGroups.length > 0) {
                 console.log(`Publishing event ${data.eventName} to consumer groups: ${consumerGroups.join(', ')}`);
                 for (const consumerGroup of consumerGroups) {
@@ -268,15 +258,16 @@ class Streams {
             const result = yield this.redisGroups.xreadgroup('GROUP', this.consumerGroupName, this.instanceId, 'STREAMS', streamName, '>');
             if (result) {
                 const [, streamMessages] = result[0];
+                console.log(`Unprocessed events: ${streamMessages.length}`);
                 for (const [id, data] of streamMessages) {
                     const eventData = JSON.parse(data[1]);
-                    console.log(`Unprocessed event: ${id}, data:`, eventData);
                     const transaction = this.redisGroups.multi();
                     // Republishing the events
                     transaction.xadd(streamName, '*', 'data', JSON.stringify(eventData));
                     transaction.publish(eventName, '');
                     transaction.xack(streamName, this.consumerGroupName, id);
                     yield transaction.exec();
+                    console.log(`Event ${eventName} with ID: ${id} published`);
                 }
             }
         });
@@ -354,7 +345,7 @@ class Streams {
                 yield this.redisGroups.quit();
             }
             if (this.cleanUpTimer) {
-                this.cleanUpTimer.unsubscribe();
+                clearInterval(this.cleanUpTimer);
             }
         });
     }
@@ -362,13 +353,13 @@ class Streams {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             console.log(`${this.eventsListened.length} events to be cleared`);
             for (const eventName of this.eventsListened) {
-                yield this.redisGroups.srem(`consumerGroups:${eventName}`, this.consumerGroupName);
+                yield this.redisGroups.srem(`${eventName}`, this.consumerGroupName);
             }
         });
     }
     registerConsumerGroup(eventName) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            yield this.redisGroups.sadd(`consumerGroups:${eventName}`, this.consumerGroupName);
+            yield this.redisGroups.sadd(`${eventName}`, this.consumerGroupName);
         });
     }
     cleanupAcknowledgedMessages(eventName, interval = 60 * 60 * 1000) {

package/src/lib/redis/types.d.ts

@@ -1,7 +1,13 @@
-export type EventData<T> = {
-    data: T;
-    eventName: string;
+export type EventData<TData, TName extends string> = {
+    data: TData;
+    eventName: TName;
     eventId?: string;
+    createdAt?: number;
+    republishEvent?: string;
+};
+export type PublishData<TData, TName extends string> = {
+    data: TData;
+    eventName: TName;
 };
 export type PendingMessages = [never, never, string, string, Array<[string, number]>];
 export type ClaimedMessages = Array<[never, string]>;