@jetit/publisher 1.7.2 → 2.0.0

package/package.json

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

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

@@ -4,7 +4,7 @@ export type RedisType = Redis | Cluster;
 export declare class RedisRegistry {
     private static registry;
     private static options;
-    static attemptConnection(connectionKey: string, storeRef?: number): Redis;
+    static attemptConnection(connectionKey: string, storeRef?: number): RedisType;
     static getConnection(connectionType?: string, storeRef?: number): RedisType;
     static setOptions(options: IOptions): void;
     static _getOptions(): IOptions;

package/src/lib/redis/registry.js

@@ -7,11 +7,10 @@ class RedisRegistry {
     static attemptConnection(connectionKey, storeRef = 0) {
         let ref;
         if (RedisRegistry.options.cluster) {
-            ref = new ioredis_1.Cluster(RedisRegistry.options.cluster.nodes, Object.assign(Object.assign({}, RedisRegistry.options.cluster.options), { redisOptions: {
-                    db: storeRef,
-                } }));
+            ref = new ioredis_1.Cluster(RedisRegistry.options.cluster.nodes, Object.assign(Object.assign({}, RedisRegistry.options.cluster.options), { redisOptions: Object.assign(Object.assign({}, RedisRegistry.options.cluster.options.redisOptions), { db: storeRef }) }));
         }
-        ref = new ioredis_1.default(Object.assign(Object.assign({}, RedisRegistry.options.redis), { db: storeRef }));
+        else
+            ref = new ioredis_1.default(Object.assign(Object.assign({}, RedisRegistry.options.redis), { db: storeRef }));
         RedisRegistry.registry.set(connectionKey, ref);
         return ref;
     }
@@ -20,11 +19,10 @@ class RedisRegistry {
         let ref = this.registry.get(connectionKey);
         if (!ref) {
             if (RedisRegistry.options.cluster) {
-                ref = new ioredis_1.Cluster(RedisRegistry.options.cluster.nodes, Object.assign(Object.assign({}, RedisRegistry.options.cluster.options), { redisOptions: {
-                        db: storeRef,
-                    } }));
+                ref = new ioredis_1.Cluster(RedisRegistry.options.cluster.nodes, Object.assign(Object.assign({}, RedisRegistry.options.cluster.options), { redisOptions: Object.assign(Object.assign({}, RedisRegistry.options.cluster.options.redisOptions), { db: storeRef }) }));
             }
-            ref = new ioredis_1.default(Object.assign(Object.assign({}, RedisRegistry.options.redis), { db: storeRef }));
+            else
+                ref = new ioredis_1.default(Object.assign(Object.assign({}, RedisRegistry.options.redis), { db: storeRef }));
         }
         return ref;
     }

package/src/lib/redis/scheduler.js

@@ -51,23 +51,21 @@ class ScheduledProcessor {
                  * Instead of using the publish method directly, the entire logic is
                  * copy pasted to reduce the case of failure.
                  */
-                const transaction = this.redisPublisher.multi({ pipeline: true });
                 eventData.eventId = (0, id_1.generateID)('HEX', 'FF');
-                transaction.zrem('se', eventString);
+                yield this.redisPublisher.zrem('se', eventString);
                 const consumerGroups = yield (0, groups_1.getAllConsumerGroups)(eventData.eventName, this.redisPublisher);
                 console.log('Scheduled Publishing to consumer groups: ', consumerGroups, 'with id ', eventData.eventId, '...');
                 for (const consumerGroup of consumerGroups) {
                     // Publish the event to each consumer group's stream
                     const streamName = `${eventData.eventName}:${consumerGroup}`;
-                    transaction.xadd(streamName, '*', 'data', JSON.stringify(eventData));
+                    yield this.redisPublisher.xadd(streamName, '*', 'data', JSON.stringify(eventData));
                 }
                 if (eventData.repeatInterval) {
                     const nextEventTime = currentTime + eventData.repeatInterval;
                     const nextEventString = JSON.stringify(Object.assign({}, eventData));
-                    transaction.zadd('se', nextEventTime, nextEventString);
+                    yield this.redisPublisher.zadd('se', nextEventTime, nextEventString);
                 }
-                transaction.publish(eventData.eventName, '');
-                yield transaction.exec();
+                yield this.redisPublisher.publish(eventData.eventName, '');
             }
         });
     }

package/src/lib/redis/streams.js

@@ -82,16 +82,14 @@ class Streams {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const processedMessagesKeyPattern = `pm:${this.consumerGroupName}:*`;
             let cursor = '0';
-            const transaction = this.redisGroups.pipeline();
             do {
                 const [nextCursor, keys] = yield this.redisGroups.scan(cursor, 'MATCH', processedMessagesKeyPattern);
                 cursor = nextCursor;
                 for (const key of keys) {
                     const oneHourAgo = Date.now() - 60 * 60 * 1000;
-                    transaction.zremrangebyscore(key, '-inf', oneHourAgo);
+                    yield this.redisGroups.zremrangebyscore(key, '-inf', oneHourAgo);
                 }
             } while (cursor !== '0');
-            yield transaction.exec();
         });
     }
     publish(data) {
@@ -101,20 +99,21 @@ class Streams {
             data.eventId = (0, id_1.generateID)('HEX', 'FF');
             if (!data.createdAt)
                 data.createdAt = Date.now();
-            const transaction = this.redisPublisher.multi({ pipeline: true });
             const consumerGroups = yield (0, groups_1.getAllConsumerGroups)(data.eventName, this.redisPublisher);
             if (consumerGroups.length > 0) {
                 console.log(`PUBLISHER: Publishing event ${data.eventName} to consumer groups: ${consumerGroups.join(', ')}`);
-                for (const consumerGroup of consumerGroups) {
-                    // Publish the event to each consumer group's stream
-                    const streamName = `${data.eventName}:${consumerGroup}`;
-                    transaction.xadd(streamName, '*', 'data', JSON.stringify(data));
+                try {
+                    for (const consumerGroup of consumerGroups) {
+                        // Publish the event to each consumer group's stream
+                        const streamName = `${data.eventName}:${consumerGroup}`;
+                        yield this.redisPublisher.xadd(streamName, '*', 'data', JSON.stringify(data));
+                    }
+                    yield this.redisPublisher.publish(data.eventName, '');
                 }
-                transaction.publish(data.eventName, '');
-                yield transaction.exec().catch((error) => {
+                catch (error) {
                     console.error(`PUBLISHER: Error while publishing event for service ${this.consumerGroupName} with instance ${this.instanceId}: `, error);
                     throw new Error('Publisher Error');
-                });
+                }
             }
             else
                 console.log(`PUBLISHER: Event publish failed for event ${data.eventName}, reason: no consumers ${consumerGroups}`);
@@ -187,19 +186,24 @@ class Streams {
     }
     createConsumerAndRegister(eventName) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const pipeline = this.redisGroups.multi();
             const streamName = `${eventName}:${this.consumerGroupName}`;
             const key = `instance:${this.instanceId}:subscribedEvents`;
             const setKeyForK8sHandling = `instance:${this.instanceUniqueId}:consumerGroupName`;
             this.eventsListened.push(eventName);
-            pipeline.xgroup('CREATE', streamName, this.consumerGroupName, '0', 'MKSTREAM');
-            pipeline.xgroup('CREATECONSUMER', streamName, this.consumerGroupName, this.instanceId);
-            pipeline.sadd(key, eventName);
-            pipeline.sadd(`${eventName}`, this.consumerGroupName);
-            pipeline.set(setKeyForK8sHandling, this.consumerGroupName);
-            const [, createConsumerStatus, addToCGSet, addToFlushSet] = (yield pipeline.exec());
-            console.log(`PUBLISHER: Consumer Registered and created with ${this.instanceId} under ${this.consumerGroupName} with ${createConsumerStatus[1]} consumers and with the following status ${JSON.stringify({ addToCGSet, addToFlushSet })}`);
-            return createConsumerStatus[1] === 0 || createConsumerStatus[1] === 1;
+            yield this.redisGroups
+                .xgroup('CREATE', streamName, this.consumerGroupName, '0', 'MKSTREAM')
+                .then((v) => {
+                console.log(`Group created created for ${JSON.stringify({ streamName, cgn: this.consumerGroupName })}`);
+            })
+                .catch((e) => {
+                console.log(`Group creation failed with error ${e.message} for ${JSON.stringify({ streamName, cgn: this.consumerGroupName })}`);
+            });
+            const createConsumerStatus = (yield this.redisGroups.xgroup('CREATECONSUMER', streamName, this.consumerGroupName, this.instanceId));
+            yield this.redisGroups.sadd(key, eventName);
+            const addToCGSet = yield this.redisGroups.sadd(`${eventName}`, this.consumerGroupName);
+            const addToFlushSet = yield this.redisGroups.set(setKeyForK8sHandling, this.consumerGroupName);
+            console.log(`PUBLISHER: Consumer Registered and created with ${this.instanceId} under ${this.consumerGroupName} with ${createConsumerStatus} consumers and with the following status ${JSON.stringify({ addToCGSet, addToFlushSet })}`);
+            return createConsumerStatus === 0 || createConsumerStatus === 1;
         });
     }
     listenInternals(eventName) {
@@ -237,11 +241,9 @@ class Streams {
                         bs.next(eventData);
                         const pmKey = `pm:${this.consumerGroupName}:${streamName}`;
                         const currentTime = Date.now();
-                        const transaction = redisClient.multi({ pipeline: true });
-                        transaction.zadd(pmKey, currentTime, messageId);
-                        transaction.xack(streamName, this.consumerGroupName, id);
-                        transaction.zadd(`ack:${streamName}`, Date.now(), id);
-                        yield transaction.exec();
+                        yield redisClient.zadd(pmKey, currentTime, messageId);
+                        yield redisClient.xack(streamName, this.consumerGroupName, id);
+                        yield redisClient.zadd(`ack:${streamName}`, Date.now(), id);
                     }
                 }
                 this.scanAndClaimAUnclaimedMessage(streamName)
@@ -333,14 +335,12 @@ class Streams {
             const cleanupThreshold = Date.now() - interval;
             const acknowledgedMessages = yield this.redisGroups.zrangebyscore(`ack:${streamName}`, '-inf', cleanupThreshold);
             if (acknowledgedMessages && acknowledgedMessages.length > 0) {
-                const transaction = this.redisGroups.pipeline();
                 // Remove acknowledged messages from the stream
                 for (const messageId of acknowledgedMessages) {
-                    transaction.xdel(streamName, messageId);
+                    yield this.redisGroups.xdel(streamName, messageId);
                 }
                 // Remove acknowledged messages from the Sorted Set
-                transaction.zremrangebyscore(`ack:${streamName}`, '-inf', cleanupThreshold);
-                yield transaction.exec();
+                yield this.redisGroups.zremrangebyscore(`ack:${streamName}`, '-inf', cleanupThreshold);
             }
         });
     }