redis-consumer 1.1.9 → 1.2.0

package/dist/index.js

@@ -1,22 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisClient = void 0;
-__exportStar(require("redis"), exports);
-var client_1 = require("./client");
-Object.defineProperty(exports, "RedisClient", { enumerable: true, get: function () { return client_1.RedisClient; } });
-__exportStar(require("./consumer"), exports);
-__exportStar(require("./producer"), exports);
+export { RedisClient } from './client.js';
+export * from './consumer.js';
+export * from './producer.js';

package/dist/producer.d.ts

@@ -1,8 +1,8 @@
-import { RedisScripts } from 'redis';
-import { StreamMessageData, StreamMessageId } from '.';
-import { RedisClient } from './client';
+import type { RedisScripts } from 'redis';
+import type { StreamMessageData, StreamMessageId } from './consumer.js';
+import type { RedisClient } from './client.js';
 export declare class RedisProducer<S extends RedisScripts = RedisScripts> {
     private client;
     constructor(client: RedisClient<S>);
-    add(stream: StreamMessageId, message: StreamMessageData): void;
+    add(stream: StreamMessageId, message: StreamMessageData): Promise<StreamMessageId>;
 }

package/dist/producer.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisProducer = void 0;
-class RedisProducer {
+export class RedisProducer {
     client;
     constructor(client) {
         this.client = client;
     }
     add(stream, message) {
-        this.client.xAdd(stream, '*', message);
+        return this.client.xAdd(stream, '*', message);
     }
 }
-exports.RedisProducer = RedisProducer;

package/dist/retry-processor.d.ts

@@ -1,16 +1,12 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { StreamProcessingFunction, RedisConsumer } from './consumer';
-import { StreamMessageReply } from '@redis/client/dist/lib/commands/generic-transformers';
-import { RedisScripts } from 'redis';
-import { EventEmitter } from 'stream';
+import type { RedisScripts } from 'redis';
+import type { RedisConsumer, StreamExecutable, StreamMessageReply } from './consumer.js';
 interface RetryState {
     lastError: Error;
     timestamps: number[];
     retries: number;
     message: StreamMessageReply;
     stream: string;
-    executable: StreamProcessingFunction<any>;
+    executable: StreamExecutable;
 }
 export type RetryFailedMessage = Omit<RetryState, 'executable' | 'lastError'>;
 export type RetryMessage = Omit<RetryFailedMessage, 'timestamps' | 'lastError'> & {
@@ -18,15 +14,22 @@ export type RetryMessage = Omit<RetryFailedMessage, 'timestamps' | 'lastError'>
 };
 interface RetryProcessorOptions {
     maxRetry: number;
-    retryTime?: string[];
+    retryTime?: string[] | undefined;
 }
-export declare class RetryProcessor<S extends RedisScripts = RedisScripts> extends EventEmitter {
+export declare class RetryProcessor<S extends RedisScripts = RedisScripts> {
     private consumer;
     private state;
+    /**
+     * Aborts the sleeps between retries. Without it a retry waiting on a long
+     * `retryTime` (15m by default) would keep the process alive after `close()`.
+     */
+    private abort;
     private retryTime;
-    private maxRetry;
+    maxRetry: number;
     constructor(consumer: RedisConsumer<S>, options: RetryProcessorOptions);
-    add(error: Error, stream: string, message: StreamMessageReply, executable: StreamProcessingFunction<any>): void;
+    /** Cancels the pending retries and forgets their state. */
+    stop(): void;
+    add(error: Error, stream: string, message: StreamMessageReply, executable: StreamExecutable): void;
     private processRetry;
     private calcTimeoutTime;
     private emitRetryFail;

package/dist/retry-processor.js

@@ -1,30 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RetryProcessor = void 0;
-const helpers_1 = require("./helpers");
-const stream_1 = require("stream");
-class RetryProcessor extends stream_1.EventEmitter {
+import { timeout } from './helpers.js';
+/**
+ * Message ids are only unique per stream, so retries must be tracked per stream
+ * as well - otherwise a message of one stream would shadow one of another.
+ */
+function retryKey(stream, id) {
+    return stream + '\u0000' + id;
+}
+export class RetryProcessor {
     consumer;
     state = new Map();
+    /**
+     * Aborts the sleeps between retries. Without it a retry waiting on a long
+     * `retryTime` (15m by default) would keep the process alive after `close()`.
+     */
+    abort = new AbortController();
     retryTime;
     maxRetry;
     constructor(consumer, options) {
-        super();
         this.consumer = consumer;
         this.retryTime = options.retryTime || ['15s', '1m', '15m'];
         this.maxRetry = options.maxRetry;
     }
+    /** Cancels the pending retries and forgets their state. */
+    stop() {
+        this.abort.abort();
+        this.state.clear();
+    }
     add(error, stream, message, executable) {
-        const id = message.id;
-        if (this.state.has(id))
+        if (this.abort.signal.aborted)
+            return;
+        const key = retryKey(stream, message.id);
+        if (this.state.has(key))
             return;
-        this.state.set(id, { lastError: error, timestamps: [], retries: 0, message, stream, executable });
-        this.processRetry(id);
+        this.state.set(key, { lastError: error, timestamps: [], retries: 0, message, stream, executable });
+        void this.processRetry(key);
     }
-    async processRetry(id) {
-        const stateObj = this.state.get(id);
+    async processRetry(key) {
+        const stateObj = this.state.get(key);
+        // Cleared by `stop()`, or already finished.
+        if (!stateObj || this.abort.signal.aborted)
+            return;
         if (stateObj.retries >= this.maxRetry) {
-            this.state.delete(id);
+            this.state.delete(key);
             this.emitRetryFail(stateObj);
             return;
         }
@@ -32,14 +49,16 @@ class RetryProcessor extends stream_1.EventEmitter {
         const timestamp = new Date().getTime();
         stateObj.timestamps.push(timestamp);
         const timeoutTime = this.calcTimeoutTime(stateObj);
-        await (0, helpers_1.timeout)(timeoutTime);
+        await timeout(timeoutTime, this.abort.signal);
+        if (this.abort.signal.aborted)
+            return;
         const fnc = stateObj.executable;
         const message = stateObj.message;
         try {
             this.emitRetry(stateObj);
             await fnc(message, stateObj.stream);
-            this.consumer.addAckMessage(stateObj.stream, id);
-            this.state.delete(id);
+            this.consumer.addAckMessage(stateObj.stream, message.id);
+            this.state.delete(key);
         }
         catch (err) {
             if (err instanceof Error) {
@@ -50,14 +69,25 @@ class RetryProcessor extends stream_1.EventEmitter {
                 stateObj.lastError = newErr;
             }
             this.emitProcessFailed(stateObj);
-            this.processRetry(id);
+            await this.processRetry(key);
+            return;
+        }
+        // The read loop is parked in `XREADGROUP`, so without an explicit flush the
+        // acknowledgement queued above would only reach Redis once the next message
+        // arrives - leaving the retried message in the pending list until then.
+        try {
+            await this.consumer.flushAcks();
+        }
+        catch (err) {
+            // The ids stay queued, so the read loop's next flush retries them.
+            this.consumer.client.emit('listen-error', err);
         }
-        return;
     }
     calcTimeoutTime(stateObj) {
         const retry = stateObj.retries;
-        const index = (retry > this.retryTime.length ? this.retryTime.length : retry) - 1;
-        const timeString = this.retryTime[index];
+        const index = Math.min(retry, this.retryTime.length) - 1;
+        // Falls back to no delay if `retryTime` is empty or shorter than expected.
+        const timeString = this.retryTime[index] ?? '0s';
         let hours = +timeString.replace(/(\d+)h/, '$1');
         let minutes = +timeString.replace(/(\d+)m/, '$1');
         let seconds = +timeString.replace(/(\d+)s/, '$1');
@@ -81,4 +111,3 @@ class RetryProcessor extends stream_1.EventEmitter {
         this.consumer.client.emit('process-error', lastError, { stream, message, retries });
     }
 }
-exports.RetryProcessor = RetryProcessor;

package/package.json

@@ -1,18 +1,23 @@
 {
   "name": "redis-consumer",
-  "version": "1.1.9",
-  "description": "Simple NodeJs consumer and producer for Redis Streams",
+  "version": "1.2.0",
+  "description": "NodeJs consumer and producer for Redis Streams",
+  "engines": {
+    "node": ">=24"
+  },
+  "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist/"
   ],
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "typecheck:example": "tsc -p tsconfig.example.json"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tomasky/redis-streams-nodejs.git"
+    "url": "git+https://github.com/tomasky/redis-consumer.git"
   },
   "author": "Sebastiaan Hekner",
   "keywords": [
@@ -29,14 +34,14 @@
   ],
   "license": "ISC",
   "bugs": {
-    "url": "https://github.com/Seboeb/redis-streams-nodejs/issues"
+    "url": "https://github.com/tomasky/redis-consumer/issues"
   },
-  "homepage": "https://github.com/tomasky/redis-streams-nodejs#readme",
+  "homepage": "https://github.com/tomasky/redis-consumer#readme",
   "dependencies": {
-    "redis": "^4.7.1"
+    "redis": "^6.2.1"
   },
   "devDependencies": {
-    "@types/node": "^22.15.0",
+    "@types/node": "latest",
     "typescript": "latest"
   }
 }