@jetit/publisher 1.5.0 → 1.6.0

package/package.json

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

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

@@ -1,18 +1,15 @@
-import { RedisType } from './registry';
 import { EventData, PublishData } from './types';
 import { Observable } from 'rxjs';
 export declare class Streams {
     private _redisPublisher?;
-    private _redisSubscriber?;
     private _redisGroups?;
     private consumerGroupName;
     private instanceId;
     private instanceUniqueId;
     private cleanUpTimer;
     private eventsListened;
-    get redisPublisher(): RedisType;
-    get redisSubscriber(): RedisType;
-    get redisGroups(): RedisType;
+    private get redisPublisher();
+    private get redisGroups();
     /**
      * Creates a new Streams instance for a given service.
      *
@@ -29,7 +26,6 @@ export declare class Streams {
      */
     constructor(serviceName: string);
     private runClear;
-    private createConsumerGroup;
     private isDuplicateMessage;
     private clearDuplicationCheckKeys;
     /**
@@ -100,33 +96,8 @@ export declare class Streams {
      * });
      */
     listen<T = unknown, const TName extends string = string>(eventName: TName, maxRetries?: number, initialDelay?: number): Observable<EventData<T, TName>>;
+    private createConsumerAndRegister;
     private listenInternals;
-    /**
-     * This method takes all messages allocated to this instance and republishes them so
-     * that other instances of this service can receive and process them.
-     *
-     * This needs to be handled every 1-2 minutes if the queue becomes too long and messages
-     * are not being processed.
-     *
-     * Ideal implementation would be to wrap this inside a setInterval
-     * @param streamName
-     */
-    republishUnprocessedEvents(eventName: string): Promise<void>;
-    /**
-     * This method is used to claim messages in the event of a service crash. This library currently
-     * does not detect a service crash. This needs to be built as an extension of Kubernetes and
-     * a standalone service that notifies this service to process the events that are marked as
-     * pending
-     *
-     * @param streamName
-     * @param idleTimeout
-     *
-     *  * @example
-     *
-     * // Attempt to recover messages from the "order.created" stream with an idle timeout of 10 seconds
-     * await streams.recoverCrashedConsumerMessages('order.created', 10000);
-     */
-    recoverCrashedConsumerMessages(eventName: string, idleTimeout?: number): Promise<void>;
     /**
      * This method allows the possibility of a graceful shutdown by cleaning up the
      * redis connections.
@@ -148,11 +119,6 @@ export declare class Streams {
      * }
      */
     close(): Promise<void>;
-    private clearSubscribedEvents;
-    private registerSubscribedEvent;
-    private registerConsumerGroup;
-    private registerConsumerGroupName;
     private scanAndClaimAUnclaimedMessage;
-    releaseAllClaims(streamName: string): Promise<void>;
     private cleanupAcknowledgedMessages;
 }

package/src/lib/redis/streams.js

@@ -7,7 +7,7 @@ const rxjs_1 = require("rxjs");
 const id_1 = require("@jetit/id");
 const groups_1 = require("./groups");
 function publisherErrorHandler(error) {
-    console.error('Publisher Error: ', error);
+    console.error('PUBLISHER UNHANDLED ERROR: ', error);
 }
 class Streams {
     get redisPublisher() {
@@ -15,11 +15,6 @@ class Streams {
             this._redisPublisher = registry_1.RedisRegistry.getConnection('publish');
         return this._redisPublisher;
     }
-    get redisSubscriber() {
-        if (!this._redisSubscriber)
-            this._redisSubscriber = registry_1.RedisRegistry.getConnection('subscriber');
-        return this._redisSubscriber;
-    }
     get redisGroups() {
         if (!this._redisGroups)
             this._redisGroups = registry_1.RedisRegistry.getConnection('groups');
@@ -44,8 +39,8 @@ class Streams {
         this.eventsListened = [];
         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}`;
+        console.log(`PUBLISHER: Instance ID: ${this.instanceId}`);
         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(() => {
@@ -54,30 +49,24 @@ class Streams {
     }
     runClear(cleanUpInterval) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            console.log('Running Publisher Clearance', this.eventsListened);
+            console.log('PUBLISHER: Running Clearance', this.eventsListened);
             this.clearDuplicationCheckKeys();
             for (const eventName of this.eventsListened) {
                 process.nextTick(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    /** This removes the messages from the stream after they have been processed according to cleanup interval */
                     yield this.cleanupAcknowledgedMessages(eventName, cleanUpInterval).catch(publisherErrorHandler);
-                    yield this.republishUnprocessedEvents(eventName).catch(publisherErrorHandler);
-                    yield this.recoverCrashedConsumerMessages(eventName).catch(publisherErrorHandler);
+                    console.log(`Cleanup process for Acknowledged messages completed for ${eventName}`);
+                    /**
+                     * This process scans and claims any unclaimed message according to the cleanup interval.
+                     * This triggers a cascaded reaction down the chain as message by message is claimed and processed
+                     */
+                    const streamName = `${eventName}:${this.consumerGroupName}`;
+                    yield this.scanAndClaimAUnclaimedMessage(streamName).catch(publisherErrorHandler);
+                    console.log(`Unclaimed messages for ${streamName}`);
                 }));
             }
         });
     }
-    createConsumerGroup(eventName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            try {
-                const streamName = `${eventName}:${this.consumerGroupName}`;
-                yield this.redisGroups.xgroup('CREATE', streamName, this.consumerGroupName, '0', 'MKSTREAM');
-            }
-            catch (error) {
-                if (error.message !== 'BUSYGROUP Consumer Group name already exists') {
-                    throw error;
-                }
-            }
-        });
-    }
     isDuplicateMessage(streamName, messageId) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const processedMessagesKey = `pm:${this.consumerGroupName}:${streamName}`;
@@ -115,7 +104,7 @@ class Streams {
             const transaction = this.redisPublisher.multi({ pipeline: true });
             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(', ')}`);
+                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}`;
@@ -123,7 +112,7 @@ class Streams {
                 }
                 transaction.publish(data.eventName, '');
                 yield transaction.exec().catch((error) => {
-                    console.error(`Error while publishing event for service ${this.consumerGroupName} with instance ${this.instanceId}: `, error);
+                    console.error(`PUBLISHER: Error while publishing event for service ${this.consumerGroupName} with instance ${this.instanceId}: `, error);
                     throw new Error('Publisher Error');
                 });
             }
@@ -154,7 +143,7 @@ class Streams {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const currentTime = new Date();
             if (scheduledTime < currentTime) {
-                throw new Error('Cannot schedule an event in the past');
+                throw new Error('PUBLISHER: Cannot schedule an event in the past');
             }
             else if (Math.abs(scheduledTime.getTime() - currentTime.getTime()) <= 500) {
                 yield this.publish(eventData);
@@ -163,7 +152,7 @@ class Streams {
                 if (uniquePerInstance === true) {
                     const existingJob = yield this.redisPublisher.zscore('se', JSON.stringify(eventData));
                     if (existingJob) {
-                        console.log(`Job with data '${eventData}' already exists. Skipping.`);
+                        console.log(`PUBLISHER: Job with data '${eventData}' already exists. Skipping.`);
                         return;
                     }
                 }
@@ -199,159 +188,99 @@ 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,
             delay: (error, retryAttempt) => {
                 const delay = initialDelay * Math.pow(2, retryAttempt);
-                console.error(`Error in listen: ${error.message}. Retrying in ${delay}ms (attempt ${retryAttempt + 1})`);
+                console.error(`PUBLISHER: Error in listen: ${error.message}. Retrying in ${delay}ms (attempt ${retryAttempt + 1})`);
                 return (0, rxjs_1.timer)(delay);
             },
         }), (0, rxjs_1.catchError)((error) => {
-            console.error(`Error in listen after ${maxRetries} retries: ${error.message}`);
+            console.error(`PUBLISHER: Error in listen after ${maxRetries} retries: ${error.message}`);
             return (0, rxjs_1.throwError)(() => new Error(error.message));
         }));
     }
-    listenInternals(eventName) {
-        try {
-            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}`;
-            this.redisSubscriber.subscribe(eventName);
-            this.scanAndClaimAUnclaimedMessage(streamName)
-                .then()
-                .catch((e) => console.log('PUBLISHER: Err in handling unclaimed Messages ' + e.message));
-            const processMessage = () => {
-                try {
-                    process.nextTick(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                        const result = yield this.redisGroups.xreadgroup('GROUP', this.consumerGroupName, this.instanceId, 'COUNT', 1, 'BLOCK', 0, 'STREAMS', streamName, '>');
-                        if (result) {
-                            const [, streamMessages] = result[0];
-                            for (const [id, data] of streamMessages) {
-                                const eventData = JSON.parse(data[1]);
-                                const messageId = eventData.eventId;
-                                const isDuplicate = yield this.isDuplicateMessage(streamName, messageId);
-                                if (isDuplicate) {
-                                    console.warn(`Duplicate message detected: ${messageId}`);
-                                    yield this.redisGroups.xack(streamName, this.consumerGroupName, id);
-                                    continue;
-                                }
-                                bs.next(eventData);
-                                const pmKey = `pm:${this.consumerGroupName}:${streamName}`;
-                                const currentTime = Date.now();
-                                const transaction = this.redisGroups.multi({ pipeline: true });
-                                transaction.zadd(pmKey, currentTime, messageId);
-                                transaction.xack(streamName, this.consumerGroupName, id);
-                                transaction.zadd(`ack:${streamName}`, Date.now(), id);
-                                yield transaction.exec();
-                            }
-                        }
-                        this.scanAndClaimAUnclaimedMessage(streamName)
-                            .then()
-                            .catch((e) => console.log('PUBLISHER: Err in handling unclaimed Messages ' + e.message));
-                    }));
-                }
-                catch (e) {
-                    console.error(JSON.stringify(e));
-                }
-            };
-            this.redisSubscriber.on('message', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                yield processMessage();
-            }));
-            return observable;
-        }
-        catch (e) {
-            console.error(JSON.stringify(e));
-            throw e;
-        }
-    }
-    /**
-     * This method takes all messages allocated to this instance and republishes them so
-     * that other instances of this service can receive and process them.
-     *
-     * This needs to be handled every 1-2 minutes if the queue becomes too long and messages
-     * are not being processed.
-     *
-     * Ideal implementation would be to wrap this inside a setInterval
-     * @param streamName
-     */
-    republishUnprocessedEvents(eventName) {
+    createConsumerAndRegister(eventName) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            console.log('Republishing Unprocessed Events.');
+            const pipeline = this.redisGroups.multi();
             const streamName = `${eventName}:${this.consumerGroupName}`;
-            const result = yield this.redisGroups.xreadgroup('GROUP', this.consumerGroupName, this.instanceId, 'STREAMS', streamName, '>');
-            if (!result)
-                return;
-            const [, streamMessages] = result[0];
-            if (!streamMessages)
-                return;
-            console.log(`Unprocessed events:  ${streamMessages.length}`);
-            for (const [id, data] of streamMessages) {
-                const transaction = this.redisGroups.multi({ pipeline: true });
-                const eventData = JSON.parse(data[1]);
-                // Republishing the events
-                transaction.xadd(streamName, '*', 'data', JSON.stringify(eventData));
-                transaction.publish(eventName, '');
-                transaction.xack(streamName, this.consumerGroupName, id);
-                yield transaction.exec().catch(publisherErrorHandler);
-                console.log(`Event ${eventName} with ID: ${id} published`);
-                yield transaction.exec();
-            }
+            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, , ,] = (yield pipeline.exec());
+            console.log(`PUBLISHER: Consumer Registered and created with ${this.instanceId} under ${this.consumerGroupName} with the ${createConsumerStatus[1]} consumers`);
+            return createConsumerStatus[1] === 0 || createConsumerStatus[1] === 1;
         });
     }
-    /**
-     * This method is used to claim messages in the event of a service crash. This library currently
-     * does not detect a service crash. This needs to be built as an extension of Kubernetes and
-     * a standalone service that notifies this service to process the events that are marked as
-     * pending
-     *
-     * @param streamName
-     * @param idleTimeout
-     *
-     *  * @example
-     *
-     * // Attempt to recover messages from the "order.created" stream with an idle timeout of 10 seconds
-     * await streams.recoverCrashedConsumerMessages('order.created', 10000);
-     */
-    recoverCrashedConsumerMessages(eventName, idleTimeout = 30000) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            console.log(`PUBLISHER: Running recoverCrashedConsumerMessages`);
-            const streamName = `${eventName}:${this.consumerGroupName}`;
-            const pendingMessages = (yield this.redisGroups.xpending(streamName, this.consumerGroupName, 'IDLE', 10000, 0));
-            if (!pendingMessages)
-                return;
-            const [, minId, maxId, consumers] = pendingMessages;
-            if (!consumers || consumers.length === 0)
-                return;
-            for (const [consumer, pendingCount] of consumers) {
-                if (parseInt(pendingCount) < 0)
-                    return;
-                const pending = (yield this.redisGroups.xpending(streamName, this.consumerGroupName, minId, maxId, Number(pendingCount), consumer));
-                if (!pending)
-                    return;
-                for (const [messageId] of pending) {
-                    const claimedMessage = (yield this.redisGroups.xclaim(streamName, this.consumerGroupName, this.instanceId, idleTimeout, messageId));
-                    if (claimedMessage) {
-                        console.log({ claimedMessage: JSON.stringify(claimedMessage) });
-                        const [, data] = claimedMessage[0];
+    listenInternals(eventName) {
+        /** Create the return observable */
+        const bs = new rxjs_1.BehaviorSubject(null);
+        const observable = bs.asObservable().pipe((0, rxjs_1.skip)(1));
+        /** This gets called the first time the stream is registered to pickup any messages from the previous subscription */
+        const streamName = `${eventName}:${this.consumerGroupName}`;
+        const processMessage = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            console.log(`PUBLISHER: processMessage called for ${streamName} cgn: ${this.consumerGroupName} inst: ${this.instanceId}`);
+            try {
+                const result = yield this.redisGroups.xreadgroup('GROUP', this.consumerGroupName, this.instanceId, 'COUNT', 1, 'BLOCK', 0, 'STREAMS', streamName, '>');
+                console.log(`PUBLISHER: XREADGROUP returned with ${JSON.stringify(result[0])}`);
+                if (result) {
+                    const [, streamMessages] = result[0];
+                    for (const [id, data] of streamMessages) {
                         const eventData = JSON.parse(data[1]);
-                        const transaction = this.redisGroups.multi();
-                        transaction.xadd(streamName, '*', 'data', JSON.stringify(eventData));
-                        transaction.publish(eventName, '');
-                        transaction.xack(streamName, this.consumerGroupName, messageId);
-                        yield transaction.exec().catch(publisherErrorHandler);
+                        const messageId = eventData.eventId;
+                        const isDuplicate = yield this.isDuplicateMessage(streamName, messageId);
+                        if (isDuplicate) {
+                            console.warn(`Duplicate message detected: ${messageId}`);
+                            yield this.redisGroups.xack(streamName, this.consumerGroupName, id);
+                            continue;
+                        }
+                        bs.next(eventData);
+                        const pmKey = `pm:${this.consumerGroupName}:${streamName}`;
+                        const currentTime = Date.now();
+                        const transaction = this.redisGroups.multi({ pipeline: true });
+                        transaction.zadd(pmKey, currentTime, messageId);
+                        transaction.xack(streamName, this.consumerGroupName, id);
+                        transaction.zadd(`ack:${streamName}`, Date.now(), id);
+                        yield transaction.exec();
                     }
                 }
-                // Remove the consumer if it has messages pending for more than 10 secs
-                // NOTE: Ideally, this might never happen as messages will automatically be reassigned
-                console.log(`PUBLISHER: Closing consumer in ${this.consumerGroupName} with ID: ${consumer}`);
-                yield this.redisGroups.xgroup('DELCONSUMER', streamName, this.consumerGroupName, consumer);
+                this.scanAndClaimAUnclaimedMessage(streamName)
+                    .then()
+                    .catch((e) => console.log('PUBLISHER: Err in handling unclaimed Messages ' + e.message));
+            }
+            catch (e) {
+                console.error(`PUBLISHER: ${JSON.stringify(e)}`);
             }
         });
+        this.createConsumerAndRegister(eventName)
+            .then((consumerRegistered) => {
+            if (!consumerRegistered)
+                throw new Error('PUBLISHER: Cannot setup consumer');
+            /** Create new REDIS connection and subscribe */
+            const eventStreamClient = registry_1.RedisRegistry.getConnection(`sub-${eventName}`);
+            eventStreamClient.subscribe(eventName).then(() => {
+                console.log(`PUBLISHER: Redis Subscription connection initiated for ${eventName} with ${JSON.stringify({
+                    cluster: eventStreamClient.isCluster,
+                })}`);
+            });
+            eventStreamClient.on('message', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                console.log(`PUBLISHER: Stream Notification Recieved for event ${eventName}`);
+                yield processMessage();
+            }));
+            this.scanAndClaimAUnclaimedMessage(streamName)
+                .then()
+                .catch((e) => console.log('PUBLISHER: Err in handling unclaimed Messages ' + e.message));
+        })
+            .catch((e) => {
+            console.error(`PUBLISHER: ${JSON.stringify(e)}`);
+            throw e;
+        });
+        return observable;
     }
     /**
      * This method allows the possibility of a graceful shutdown by cleaning up the
@@ -375,85 +304,32 @@ class Streams {
      */
     close() {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            yield this.clearSubscribedEvents();
+            if (this.cleanUpTimer) {
+                clearInterval(this.cleanUpTimer);
+            }
             if (this.redisPublisher) {
                 yield this.redisPublisher.quit();
             }
-            if (this.redisSubscriber) {
-                yield this.redisSubscriber.quit();
+            for (const eventName of this.eventsListened) {
+                registry_1.RedisRegistry.getConnection(`sub-${eventName}`).quit();
             }
             if (this.redisGroups) {
                 yield this.redisGroups.quit();
             }
-            if (this.cleanUpTimer) {
-                clearInterval(this.cleanUpTimer);
-            }
-        });
-    }
-    clearSubscribedEvents() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            console.log(`${this.eventsListened.length} events to be cleared`);
-            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(streamName);
-                console.log(`${eventName} removes all claims`);
-                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);
-        });
-    }
-    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);
         });
     }
     scanAndClaimAUnclaimedMessage(streamName) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const rows = yield this.redisGroups.xautoclaim(streamName, this.consumerGroupName, this.instanceId, 500, 0, 'COUNT', 1);
-            if (rows) {
+            const rows = yield this.redisGroups.xautoclaim(streamName, this.consumerGroupName, this.instanceId, 500, '0-0', 'COUNT', 1);
+            if (rows && rows[0] !== '0-0') {
+                console.log(`PUBLISHER: Handling pending unclaimed Message from ${streamName} for ${this.instanceId}`);
                 yield this.redisPublisher.publish(streamName.split(':')[0], '');
                 return this.scanAndClaimAUnclaimedMessage(streamName);
             }
-            return;
-        });
-    }
-    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(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.consumerGroupName}-temp`;
-                for (const [messageId] of pendingMessages) {
-                    transaction.xclaim(streamName, this.consumerGroupName, tempConsumerId, 10, messageId);
-                }
-                yield transaction.exec();
+            else {
+                console.log(`PUBLISHER: No previous messages found for ${streamName}`);
             }
+            return;
         });
     }
     cleanupAcknowledgedMessages(eventName, interval = 60 * 60 * 1000) {