@jetit/publisher 1.3.0 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jetit/publisher",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "type": "commonjs",
   "dependencies": {
     "@jetit/id": "0.0.11",

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

@@ -7,6 +7,7 @@ export declare class Streams {
     private _redisGroups?;
     private consumerGroupName;
     private instanceId;
+    private instanceUniqueId;
     private cleanUpTimer;
     private eventsListened;
     get redisPublisher(): RedisType;
@@ -148,7 +149,9 @@ export declare class Streams {
      */
     close(): Promise<void>;
     private clearSubscribedEvents;
+    private registerSubscribedEvent;
     private registerConsumerGroup;
-    releaseAllClaims(eventName: string): Promise<void>;
+    private registerConsumerGroupName;
+    releaseAllClaims(streamName: string): Promise<void>;
     private cleanupAcknowledgedMessages;
 }

package/src/lib/redis/streams.js

@@ -40,12 +40,13 @@ class Streams {
      * const streams = new Streams('POS');
      */
     constructor(serviceName) {
-        var _a;
+        var _a, _b;
         this.eventsListened = [];
-        this.instanceId = `${serviceName}:${(0, id_1.generateID)('HEX', 'FE')}`;
+        this.instanceUniqueId = (_a = process.env['INSTANCE_ID']) !== null && _a !== void 0 ? _a : (0, id_1.generateID)('HEX', 'FE');
+        this.instanceId = `${serviceName}:${this.instanceUniqueId}`;
         console.log(this.instanceId);
         this.consumerGroupName = `cg-${serviceName}`;
-        const cleanUpInterval = (_a = parseInt(process.env['CLEANUP_INTERVAL'] || `${1000 * 60 * 60}`, 10)) !== null && _a !== void 0 ? _a : 1000 * 60 * 60;
+        const cleanUpInterval = (_b = parseInt(process.env['CLEANUP_INTERVAL'] || `${1000 * 60 * 60}`, 10)) !== null && _b !== void 0 ? _b : 1000 * 60 * 60;
         setTimeout(() => this.runClear(cleanUpInterval), 60000);
         this.cleanUpTimer = setInterval(() => {
             this.runClear(cleanUpInterval);
@@ -199,6 +200,7 @@ class Streams {
      */
     listen(eventName, maxRetries = 5, initialDelay = 1000) {
         this.registerConsumerGroup(eventName); // Registers the consumer group for listening to the message
+        this.registerConsumerGroupName().then();
         this.eventsListened.push(eventName);
         return this.listenInternals(eventName).pipe((0, rxjs_1.retry)({
             count: maxRetries,
@@ -214,7 +216,8 @@ class Streams {
     }
     listenInternals(eventName) {
         try {
-            this.createConsumerGroup(eventName);
+            this.createConsumerGroup(eventName).then();
+            this.registerSubscribedEvent(eventName).then();
             const bs = new rxjs_1.BehaviorSubject(null);
             const observable = bs.asObservable().pipe((0, rxjs_1.skip)(1));
             const streamName = `${eventName}:${this.consumerGroupName}`;
@@ -383,36 +386,51 @@ class Streams {
             let x = this.eventsListened.length;
             for (const eventName of this.eventsListened) {
                 console.log(`${eventName} is being cleared in publisher`);
+                const streamName = `${eventName}:${this.consumerGroupName}`;
                 yield this.redisGroups.srem(`${eventName}`, this.consumerGroupName);
                 console.log(`${eventName} is removed from ${this.consumerGroupName}`);
                 // Releasing all claims based on info from: https://redis.io/commands/xgroup-delconsumer/
-                yield this.releaseAllClaims(eventName);
+                yield this.releaseAllClaims(streamName);
                 console.log(`${eventName} removes all claims`);
-                yield this.redisGroups.xgroup('DELCONSUMER', eventName, this.consumerGroupName, this.instanceId);
+                yield this.redisGroups.xgroup('DELCONSUMER', streamName, this.consumerGroupName, this.instanceId);
                 console.log(`${eventName} is deleted as a consumer from ${this.consumerGroupName}, ${this.instanceId}`);
                 console.log(x--);
             }
         });
     }
+    registerSubscribedEvent(eventName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const key = `instance:${this.instanceId}:subscribedEvents`;
+            console.log(`Registering event name for ${this.consumerGroupName} with key : ${key}`);
+            yield this.redisGroups.sadd(key, eventName);
+        });
+    }
     registerConsumerGroup(eventName) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             yield this.redisGroups.sadd(`${eventName}`, this.consumerGroupName);
         });
     }
-    releaseAllClaims(eventName) {
+    registerConsumerGroupName() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const key = `instance:${this.instanceUniqueId}:consumerGroupName`;
+            console.log(`Registering service name ${this.consumerGroupName} for key : ${key}`);
+            yield this.redisGroups.set(key, this.consumerGroupName);
+        });
+    }
+    releaseAllClaims(streamName) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             /**
              * Retrieve the pending messages for the consumer. Note this only fetches the last
              * 10000 events assigned to this consumer. This function has been modified to make sure
              * that there is a temp instance that claims all this messages
              */
-            const pendingMessages = (yield this.redisGroups.xpending(eventName, this.consumerGroupName, '-', '+', 10000, this.instanceId));
+            const pendingMessages = (yield this.redisGroups.xpending(streamName, this.consumerGroupName, '-', '+', 10000, this.instanceId));
             if (pendingMessages && pendingMessages.length > 0) {
                 console.log(`${pendingMessages.length} messages to clean up.`);
                 const transaction = this.redisGroups.multi({ pipeline: true });
                 const tempConsumerId = `${this.instanceId}-temp`;
                 for (const [messageId] of pendingMessages) {
-                    transaction.xclaim(eventName, this.consumerGroupName, tempConsumerId, 10, messageId);
+                    transaction.xclaim(streamName, this.consumerGroupName, tempConsumerId, 10, messageId);
                 }
                 yield transaction.exec();
             }