@yroshcha/node-red-contrib-redis-full 1.0.6 → 1.0.8

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project are documented in this file.
 
+## 1.0.8 — 2026-08-12
+
+### Fixed
+
+- `redis xreadgroup` and `redis xautoclaim` now restore nested object and array fields that were serialised by `redis xadd`, while preserving scalar Redis fields as strings.
+
+## 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

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.6` is the current stable release.** See [CHANGELOG.md](CHANGELOG.md) for release notes and compatibility information.
+**`1.0.8` is the current stable release.** See [CHANGELOG.md](CHANGELOG.md) for release notes and compatibility information.
 
 ## Production profile
 
@@ -58,6 +58,7 @@ Safe consumer defaults and important settings:
 - **Rate limit (msg/s) = 0** is unlimited. For example, `500` limits average downstream delivery to 500 events per second.
 - **Read interval (ms) = 0** reads as fast as Redis responds. `1000` calls `XREADGROUP` no more often than once per second, independent of queue depth.
 - **Batch wait (ms) = 0** emits one event at a time. With a positive value, the node emits an array once it has collected `COUNT` events or the wait expires. `msg.payload` and `msg.streamId` become arrays.
+- Nested object and array fields written by `redis xadd` are automatically decoded from JSON by `redis xreadgroup` and `redis xautoclaim`; scalar Redis fields remain strings.
 - **Batch interval (ms)** sets the minimum delay between emitted batches regardless of queue depth. For one batch of up to 50 entries per second, use `COUNT = 50` and `Batch interval = 1000`.
 - **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.
@@ -116,7 +117,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.6",
+  "version": "1.0.8",
   "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,22 @@ module.exports = function (RED) {
     return obj;
   }
 
+  function parseStreamFields(flat) {
+    const obj = parseFlatFields(flat);
+    for (const [field, value] of Object.entries(obj)) {
+      // redis xadd serialises nested objects and arrays to JSON. Restore only
+      // these compound JSON values; scalar strings such as "true", "42", or
+      // "null" remain strings and preserve Redis field semantics.
+      if (typeof value !== 'string' || !/^[\[{]/.test(value.trim())) continue;
+      try {
+        obj[field] = JSON.parse(value);
+      } catch (_) {
+        // A value that merely looks like JSON is still a valid Redis string.
+      }
+    }
+    return obj;
+  }
+
   function isNoGroupError(err) {
     return String(err && err.message ? err.message : err).includes('NOGROUP');
   }
@@ -237,7 +253,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);
@@ -245,25 +261,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;
@@ -314,10 +347,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();
@@ -820,7 +884,7 @@ module.exports = function (RED) {
       if (!Array.isArray(flat)) {
         throw new Error(`Stream entry ${id} no longer has a payload; do not trim streams below the PEL horizon`);
       }
-      const payload = parseFlatFields(flat);
+      const payload = parseStreamFields(flat);
       if (checkDeliveryCount && await shouldDeadLetter(id, payload)) return;
       if (!await waitForDeliverySlot() || paused) return false;
 
@@ -1125,7 +1189,7 @@ module.exports = function (RED) {
           const [nextCursor, entries] = res;
           cursor = nextCursor;
           for (const [id, flat] of entries || []) {
-            claimed.push({ streamId: id, payload: parseFlatFields(flat) });
+            claimed.push({ streamId: id, payload: parseStreamFields(flat) });
           }
         } while (cursor !== '0' && claimed.length < node.maxMessages);