@yroshcha/node-red-contrib-redis-full 1.0.5 → 1.0.7

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project are documented in this file.
 
+## 1.0.7 — 2026-08-12
+
+### Added
+
+- Restored continuous `BLPOP` and `BRPOP` modes in `redis sub`, compatible with the original Redis input node workflow. Configure a list key as Topic and an optional timeout in seconds; the node keeps reading on its dedicated connection.
+
+## 1.0.6 — 2026-08-11
+
+### Fixed
+
+- `redis xreadgroup` now restores its consumer group with `MKSTREAM` when a running consumer receives `NOGROUP`, including a deleted or restarted DLQ stream.
+
 ## 1.0.5 — 2026-08-11
 
 ### Fixed

package/README.md

@@ -17,7 +17,7 @@ Every node type is prefixed with `yroshcha-redis-*`; the palette category is uni
 | Palette label | Type | Redis command(s) | Purpose |
 |---|---|---|---|
 | `redis cmd` | `yroshcha-redis-command` | any | Runs a generic command through `.call()`. `Block` forces a dedicated connection for commands such as `BLPOP`, `BRPOP`, or `WAIT`. |
-| `redis sub` | `yroshcha-redis-subscribe` | `SUBSCRIBE` / `PSUBSCRIBE` | Pub/Sub on a dedicated connection. Supports dynamic subscribe/unsubscribe through `msg.subscribe` and `msg.unsubscribe`. |
+| `redis sub` | `yroshcha-redis-subscribe` | `SUBSCRIBE` / `PSUBSCRIBE` / `BLPOP` / `BRPOP` | Pub/Sub or continuous Redis List intake on a dedicated connection. Pub/Sub supports dynamic subscribe/unsubscribe through `msg.subscribe` and `msg.unsubscribe`. |
 | `redis multi` | `yroshcha-redis-multi` | `MULTI` / `EXEC` | Atomic transaction from a command list. |
 | `redis scan` | `yroshcha-redis-scan` | `SCAN` / `HSCAN` / `SSCAN` / `ZSCAN` | Cursor-based non-blocking scan. |
 | `redis xadd` | `yroshcha-redis-stream-out` | `XADD` | Publishes to a stream. `MAXLEN` requires explicit unsafe confirmation. |
@@ -41,11 +41,11 @@ For a local archive, use `npm install /path/to/yroshcha-node-red-contrib-redis-f
 ## Connection model
 
 - `yroshcha-redis-config` keeps one shared ioredis client (`getClient()`) for non-blocking nodes: `redis cmd` (without `Block`), `redis multi`, `redis scan`, `redis xadd`, `redis xack`, `redis xautoclaim`, `redis consumer gc`, and `redis stream metrics`.
-- Blocking operations use a dedicated connection (`getDedicatedClient()`): `redis sub`, `redis xreadgroup`, and `redis cmd` when `Block` is enabled.
+- Blocking operations use a dedicated connection (`getDedicatedClient()`): `redis sub` (including BLPOP/BRPOP), `redis xreadgroup`, and `redis cmd` when `Block` is enabled.
 
 ## Release status
 
-**`1.0.5` is the current stable release.** See [CHANGELOG.md](CHANGELOG.md) for release notes and compatibility information.
+**`1.0.7` is the current stable release.** See [CHANGELOG.md](CHANGELOG.md) for release notes and compatibility information.
 
 ## Production profile
 
@@ -62,6 +62,7 @@ Safe consumer defaults and important settings:
 - **Max deliveries = 5.** After the limit is exceeded, an entry is atomically moved to `<stream>:dlq` and acknowledged. In Redis Cluster, source and DLQ keys must share a hash tag, for example `orders:{eu}` and `orders:{eu}:dlq`.
 - **Start paused (wait for resume)** makes a consumer create/verify its group without calling `XREADGROUP`. It takes no work until a control-plane `resume` request arrives; use it for controlled pod startup after readiness checks.
 - Startup initialisation retries a failed dedicated connection, `XGROUP CREATE`, and the initial `SUBSCRIBE` up to **five times** with exponential backoff and jitter. A transient Redis/TLS/DNS delay does not permanently stop a new consumer or subscriber.
+- If a consumer group disappears after startup (for example after a Redis restart, `XGROUP DESTROY`, or deleting an empty DLQ stream), `redis xreadgroup` recreates it with `MKSTREAM` and resumes.
 - `redis xautoclaim` limits each manual recovery run through `Run limit` (default 1000), avoiding oversized Node-RED payloads.
 - `redis scan` limits one emitted Node-RED message to **10,000** items by default. It sets `msg.scanTruncated = true` when that safety limit is reached; raise `Result limit` / `msg.maxResults` only after sizing the Node-RED heap for the result.
 - `MAXLEN` in `redis xadd` remains blocked until **Allow unsafe MAXLEN trim** is explicitly confirmed. Trimming can remove a payload still represented in a PEL.
@@ -115,7 +116,7 @@ Run `redis consumer gc` from an input message, typically a scheduled Inject node
 ## Choosing a node
 
 - Read or write a single Redis value/command: `redis cmd`.
-- Broadcast delivery without persistence: `redis sub`.
+- Broadcast delivery without persistence: `redis sub` in SUBSCRIBE/PSUBSCRIBE mode. For a simple Redis List queue, select BLPOP/BRPOP in the same node; it continuously reads the configured Topic without a feedback loop.
 - Atomic command list without WATCH: `redis multi`.
 - Scan keys or fields without blocking Redis: `redis scan`.
 - Reliable delivery with consumer groups, ACK, and recovery: `redis xadd` → `redis xreadgroup` → `redis xack`. Keep `redis xautoclaim` for manual recovery and `redis consumer gc` for periodic cleanup.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yroshcha/node-red-contrib-redis-full",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Production-oriented Redis palette for Node-RED: generic commands, Pub/Sub, scans, transactions, and Redis Streams consumer groups.",
   "keywords": ["node-red", "redis", "redis-streams", "pubsub", "xadd", "xreadgroup", "ioredis"],
   "license": "MIT",

package/redis.html

@@ -181,7 +181,9 @@
       name: { value: '' },
       server: { type: 'yroshcha-redis-config', required: true },
       mode: { value: 'subscribe' },
-      channels: { value: '' }
+      channels: { value: '' },
+      topic: { value: '' },
+      timeout: { value: 0, validate: RED.validators.number() }
     },
     inputs: 1,
     outputs: 1,
@@ -189,6 +191,15 @@
     label: function () {
       return this.name || 'redis ' + this.mode;
     },
+    oneditprepare: function () {
+      const updateMode = () => {
+        const isList = ['blpop', 'brpop'].includes($('#node-input-mode').val());
+        $('.redis-sub-channels-row').toggle(!isList);
+        $('.redis-sub-list-row').toggle(isList);
+      };
+      $('#node-input-mode').on('change', updateMode);
+      updateMode();
+    },
     onadd: function () { this.l = true; }
   });
 </script>
@@ -203,12 +214,22 @@
     <select id="node-input-mode">
       <option value="subscribe">SUBSCRIBE (exact channels)</option>
       <option value="psubscribe">PSUBSCRIBE (patterns)</option>
+      <option value="blpop">BLPOP (left side of list)</option>
+      <option value="brpop">BRPOP (right side of list)</option>
     </select>
   </div>
-  <div class="form-row">
+  <div class="form-row redis-sub-channels-row">
     <label for="node-input-channels">Channels</label>
     <input type="text" id="node-input-channels" placeholder="comma-separated, e.g. app:notify, app:alerts">
   </div>
+  <div class="form-row redis-sub-list-row">
+    <label for="node-input-topic">Topic</label>
+    <input type="text" id="node-input-topic" placeholder="Redis list key, e.g. events">
+  </div>
+  <div class="form-row redis-sub-list-row">
+    <label for="node-input-timeout">Timeout (sec)</label>
+    <input type="text" id="node-input-timeout" placeholder="0 = wait indefinitely">
+  </div>
   <div class="form-row">
     <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
     <input type="text" id="node-input-name">
@@ -216,9 +237,9 @@
 </script>
 
 <script type="text/html" data-help-name="yroshcha-redis-subscribe">
-  <p>Subscribes with <code>SUBSCRIBE</code>/<code>PSUBSCRIBE</code> on a dedicated connection.</p>
-  <p>Output: <code>msg.topic</code>, <code>msg.payload</code>, and <code>msg.pattern</code> for pattern subscriptions.</p>
-  <p>Dynamic control: <code>msg.subscribe</code>/<code>msg.unsubscribe</code> are arrays of channels.</p>
+  <p>Uses a dedicated connection for <code>SUBSCRIBE</code>/<code>PSUBSCRIBE</code> or continuous <code>BLPOP</code>/<code>BRPOP</code> list intake.</p>
+  <p>For Pub/Sub, enter comma-separated Channels. Output: <code>msg.topic</code>, <code>msg.payload</code>, and <code>msg.pattern</code> for pattern subscriptions. Dynamic control: <code>msg.subscribe</code>/<code>msg.unsubscribe</code> are arrays of channels.</p>
+  <p>For BLPOP/BRPOP, enter one Redis list key as Topic. The node continuously emits each popped value as <code>msg.payload</code> and the list key as <code>msg.topic</code>. Timeout is in seconds; <code>0</code> waits indefinitely.</p>
 </script>
 
 <script type="text/javascript">

package/redis.js

@@ -173,6 +173,10 @@ module.exports = function (RED) {
     return obj;
   }
 
+  function isNoGroupError(err) {
+    return String(err && err.message ? err.message : err).includes('NOGROUP');
+  }
+
   // ---------------------------------------------------------------------
   // yroshcha-redis-command — БУДЬ-ЯКА команда Redis через ioredis .call().
   // "block" форсує окреме з'єднання (для BLPOP/BRPOP/WAIT тощо).
@@ -233,7 +237,7 @@ module.exports = function (RED) {
   RED.nodes.registerType('yroshcha-redis-command', RedisCommandNode);
 
   // ---------------------------------------------------------------------
-  // yroshcha-redis-subscribe — SUBSCRIBE/PSUBSCRIBE, завжди на окремому з'єднанні.
+  // yroshcha-redis-subscribe — Pub/Sub and blocking List intake on a dedicated connection.
   // ---------------------------------------------------------------------
   function RedisSubscribeNode(config) {
     RED.nodes.createNode(this, config);
@@ -241,25 +245,42 @@ module.exports = function (RED) {
     node.server = getServer(node, config);
     if (!node.server) return;
 
-    node.mode = config.mode === 'psubscribe' ? 'psubscribe' : 'subscribe';
+    node.mode = ['subscribe', 'psubscribe', 'blpop', 'brpop'].includes(config.mode)
+      ? config.mode
+      : 'subscribe';
     node.channels = (config.channels || '').split(',').map((s) => s.trim()).filter(Boolean);
+    node.topic = (config.topic || '').trim();
+    // Redis list blocking timeout is expressed in seconds. Zero means block
+    // indefinitely, therefore commandTimeout must be disabled for that client.
+    node.timeout = Math.max(0, parseInt(config.timeout, 10) || 0);
+    const isListPop = node.mode === 'blpop' || node.mode === 'brpop';
 
-    if (!node.channels.length) {
+    if (!isListPop && !node.channels.length) {
       node.error('At least one Redis channel or pattern is required');
       return;
     }
+    if (isListPop && !node.topic) {
+      node.error('A Redis list key (Topic) is required for BLPOP/BRPOP');
+      return;
+    }
 
-    const client = node.server.getDedicatedClient();
+    const client = node.server.getDedicatedClient(isListPop ? {
+      commandTimeout: node.timeout ? Math.max(node.server.commandTimeout, node.timeout * 1000 + 1000) : undefined,
+      maxRetriesPerRequest: 1,
+      autoResendUnfulfilledCommands: false
+    } : undefined);
     let subscribed = [];
     let stopped = false;
 
-    const eventName = node.mode === 'psubscribe' ? 'pmessage' : 'message';
-    client.on(eventName, (a, b, c) => {
-      const outMsg = node.mode === 'psubscribe'
-        ? { pattern: a, topic: b, payload: c }
-        : { topic: a, payload: b };
-      node.send(outMsg);
-    });
+    if (!isListPop) {
+      const eventName = node.mode === 'psubscribe' ? 'pmessage' : 'message';
+      client.on(eventName, (a, b, c) => {
+        const outMsg = node.mode === 'psubscribe'
+          ? { pattern: a, topic: b, payload: c }
+          : { topic: a, payload: b };
+        node.send(outMsg);
+      });
+    }
 
     async function doSubscribe(channels) {
       if (!channels.length) return;
@@ -310,10 +331,41 @@ module.exports = function (RED) {
       }
     }
 
-    startSubscription();
+    async function startListPop() {
+      // A list pop is intentionally a continuous source node: Redis returns
+      // one item and the next call begins immediately. Unlike a generic cmd
+      // node, users do not need to wire an output back into its input.
+      const method = node.mode;
+      let delayMs = 500;
+      node.status({ fill: 'green', shape: 'dot', text: `waiting (${method.toUpperCase()})` });
+      while (!stopped) {
+        try {
+          const result = await client[method](node.topic, node.timeout);
+          delayMs = 500;
+          if (!result || stopped) continue;
+          const [key, value] = result;
+          node.status({ fill: 'green', shape: 'dot', text: `received (${method.toUpperCase()})` });
+          node.send({ topic: key, payload: value });
+        } catch (err) {
+          if (stopped) break;
+          const delay = Math.min(delayMs, node.server.retryMaxDelay) + Math.random() * delayMs * 0.3;
+          node.status({ fill: 'red', shape: 'ring', text: `retry in ${Math.round(delay)}ms` });
+          node.error(`Redis ${method.toUpperCase()} error: ${err.message}`);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          delayMs = Math.min(delayMs * 2, node.server.retryMaxDelay);
+        }
+      }
+    }
+
+    if (isListPop) startListPop();
+    else startSubscription();
 
     node.on('input', async function (msg, send, done) {
       try {
+        if (isListPop) {
+          done();
+          return;
+        }
         if (Array.isArray(msg.subscribe) && msg.subscribe.length) await doSubscribe(msg.subscribe);
         if (Array.isArray(msg.unsubscribe) && msg.unsubscribe.length) await doUnsubscribe(msg.unsubscribe);
         done();
@@ -962,6 +1014,22 @@ module.exports = function (RED) {
         } catch (err) {
           if (stopped) break;
 
+          // A Redis restart, a manual XGROUP DESTROY, or deletion of an empty
+          // DLQ stream can remove the group after this node has started.
+          // Recreate it before backing off; ensureGroup handles a concurrent
+          // creator through BUSYGROUP and is safe to call repeatedly.
+          if (isNoGroupError(err)) {
+            try {
+              await ensureGroup(blockingClient);
+              currentBackoffMs = node.initialBackoffMs;
+              node.status({ fill: 'yellow', shape: 'ring', text: 'consumer group restored' });
+              node.warn(`Redis stream consumer group restored: ${node.group}@${node.streamKey}`);
+              continue;
+            } catch (restoreErr) {
+              err = restoreErr;
+            }
+          }
+
           const jitter = Math.random() * currentBackoffMs * 0.3; // до +30%
           const delay = Math.min(currentBackoffMs, node.maxBackoffMs) + jitter;