@inteli.city/node-red-contrib-rabbit-mq 1.0.0

package/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

package/README.md

@@ -0,0 +1,239 @@
+# @inteli.city/node-red-contrib-rabbit-mq
+
+Node-RED nodes for consuming, producing, and acknowledging RabbitMQ messages via AMQP.
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Nodes](#nodes)
+  - [mq.consumer](#mqconsumer)
+  - [mq.ackw](#mqackw)
+  - [mq.producer](#mqproducer)
+- [Basic Flow](#basic-flow)
+- [System Behavior](#system-behavior)
+- [Important Decisions](#important-decisions)
+- [Common Issues](#common-issues)
+- [Debug](#debug)
+- [Simple Example](#simple-example)
+
+---
+
+## Overview
+
+These three nodes implement the **consume → process → ack** pattern for RabbitMQ.
+
+- `mq.consumer` connects to a queue and emits messages into the Node-RED flow
+- `mq.ackw` acknowledges the message after processing — **required**
+- `mq.producer` publishes messages to an exchange with a routing key
+
+The consumer operates in manual ack mode. RabbitMQ only removes a message from the queue when `mq.ackw` is called. Without an ack, the message stays in-flight until the timeout fires and is then requeued.
+
+---
+
+## Nodes
+
+### mq.consumer
+
+Connects to a RabbitMQ queue and emits one message per delivery.
+
+#### Parameters
+
+| Field | Description |
+|---|---|
+| Host | Broker address |
+| User / Password | AMQP credentials |
+| Queue | Queue name (asserted as durable on connect) |
+| Prefetch | Maximum number of unacknowledged messages at once |
+| Timeout (min) | Maximum time before automatic nack. `0` uses the 5-minute floor |
+| SSL/TLS | Use `amqps://` — required for cloud brokers |
+| Debug mode | Enables verbose logs |
+
+#### Behavior
+
+- Connects automatically on deploy
+- On failure: reconnects with exponential backoff (1s → 2s → ... → 60s)
+- **Prefetch** limits parallelism: with `prefetch=1`, the consumer only receives the next message after acking the current one
+- **Timeout**: if the flow does not call `mq.ackw` within the configured window, the message is automatically nacked and requeued
+
+#### Output
+
+Each emitted message contains:
+
+```
+msg.payload     → message content (JSON or string)
+msg.rabbitmq    → internal context (do not modify)
+msg._msgid      → delivery identifier
+```
+
+> **Warning:** `msg.rabbitmq` must be passed intact to `mq.ackw`. Any node that recreates the `msg` object (e.g. `return { payload: ... }`) will destroy this context.
+
+---
+
+### mq.ackw
+
+Acknowledges a message to RabbitMQ.
+
+#### When to use
+
+Always, after processing a message consumed by `mq.consumer`.
+
+#### What it does
+
+- Calls `channel.ack(message)` on the broker
+- Cancels the message timeout timer
+- Passes `msg` downstream (nodes can be chained after the ack)
+
+#### Consequences of not using it
+
+- The message remains "unacked" in RabbitMQ
+- The prefetch window fills up after N messages (where N = configured prefetch)
+- The consumer **silently stops receiving new messages**
+- After the timeout, the message is nacked and requeued — the cycle repeats
+
+---
+
+### mq.producer
+
+Publishes messages to a RabbitMQ exchange.
+
+#### Parameters
+
+| Field | Description |
+|---|---|
+| Host | Broker address |
+| User / Password | AMQP credentials |
+| Exchange | Exchange name (asserted as `direct` and durable on connect) |
+| Routing Key | Default routing key |
+| SSL/TLS | Use `amqps://` — required for cloud brokers |
+| Debug mode | Enables publish logs |
+
+#### Connection behavior
+
+- Connects on deploy. On failure: exponential backoff (1s → 30s)
+- Uses a **confirm channel**: only advances in the flow after the broker confirms receipt
+- `msg.exchange` and `msg.routingKey` override the configured values per message
+
+#### When disconnected
+
+> **Messages are dropped.** If the producer is not connected when a message arrives, the message is lost and a `warn` is written to the logs.
+
+There is no internal buffer. Messages arriving during reconnection are discarded.
+
+---
+
+## Basic Flow
+
+```
+mq.consumer → [processing] → mq.ackw
+```
+
+1. `mq.consumer` receives the message and emits it
+2. The flow processes it (function node, HTTP request, database, etc.)
+3. `mq.ackw` confirms to RabbitMQ that the message was handled
+
+**Ack is mandatory.** Without it:
+
+```
+message delivered → not acked → timeout (≥5 min) → nack → requeued → delivered again
+```
+
+---
+
+## System Behavior
+
+**Automatic reconnect**
+All nodes reconnect automatically with exponential backoff. Restarting Node-RED is not required.
+
+**Prefetch**
+Controls how many messages can be in-flight simultaneously per consumer. With `prefetch=1`, the flow is strictly sequential. With `prefetch=N`, up to N messages can be processed in parallel — but all must be acked.
+
+**Blocking due to missing ack**
+If all prefetch slots are occupied by unacked messages, RabbitMQ stops delivering new messages to that consumer. No error is raised — the consumer simply goes silent.
+
+**Redelivery**
+Nacked or timed-out messages are requeued and redelivered. The field `msg.rabbitmq.message.fields.redelivered` indicates whether a message is a redelivery.
+
+---
+
+## Important Decisions
+
+- **The producer drops messages when disconnected.** There is no internal buffer. If guaranteed delivery is required, implement persistence in the flow before the producer.
+
+- **The system is at-least-once.** The same message may be delivered more than once (after nack, reconnection, or timeout). Flows should be idempotent or detect duplicates.
+
+- **Ack is the flow's responsibility.** `mq.consumer` does not ack automatically. Every path through the flow must reach `mq.ackw` — including error paths.
+
+---
+
+## Common Issues
+
+- **Consumer stopped receiving messages**
+  → Prefetch is saturated. Most common cause: `mq.ackw` is not being reached in the flow (disconnected node, silent error, or `msg.rabbitmq` destroyed by a function node).
+
+- **Duplicate messages**
+  → Expected behavior. Indicates a nack or reconnection occurred before the ack.
+
+- **Messages disappearing in the producer**
+  → The producer was disconnected. Messages arriving during reconnection are discarded.
+
+- **`msg.rabbitmq` is undefined in mq.ackw**
+  → An upstream node recreated the `msg` object without preserving `msg.rabbitmq`. Fix by using `msg.payload = ...; return msg;` instead of `return { payload: ... }`.
+
+- **Consumer connects but receives no messages after restart**
+  → Check if the queue has messages with "unacked" status from a previous session. They will be requeued once the old connection expires on the broker.
+
+---
+
+## Debug
+
+Debug mode is enabled via checkbox in `mq.consumer` and `mq.producer`.
+
+When enabled, the following logs appear:
+
+**mq.consumer:**
+- Connection details (URL, channel, queue, consumerTag)
+- Each message received (msgid, deliveryTag)
+- Inflight size and prefetch state
+- 10s timer to detect flows missing an ack
+
+**mq.producer:**
+- Connection established
+- Each publish (exchange, routing key)
+
+**When to enable:**
+- To investigate why the consumer stopped receiving messages
+- To confirm that messages are being published
+- To trace the lifecycle of a specific message
+
+**Disable in production.** Generates one log entry per message, creating excessive noise and unnecessary I/O.
+
+---
+
+## Simple Example
+
+### Publishing messages
+
+```
+[inject (repeat: 1s)] → [mq.producer]
+```
+
+Configure `mq.producer`:
+- Exchange: `X.Teste`
+- Routing Key: `R.Teste`
+- SSL: enabled
+
+### Consuming and acknowledging messages
+
+```
+[mq.consumer] → [debug] → [mq.ackw]
+```
+
+Configure `mq.consumer`:
+- Queue: `X.Teste`
+- Prefetch: `1`
+- Timeout: `0` (uses the 5-minute floor)
+- SSL: enabled
+
+The `debug` node displays `msg.payload`. The `mq.ackw` confirms to the broker. Without `mq.ackw` at the end, the consumer will stall after the first message (prefetch=1).

package/mq.ackw.html

@@ -0,0 +1,49 @@
+<!-- Edit panel template -->
+<script type="text/html" data-template-name="mq.ackw">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="name">
+    </div>
+</script>
+
+<!-- Help panel -->
+<script type="text/html" data-help-name="mq.ackw">
+    <p>Acknowledges a RabbitMQ message previously emitted by a <code>mq.consumer</code> node.</p>
+
+    <h3>Input</h3>
+    <dl class="message-properties">
+        <dt>rabbitmq <span class="property-type">object</span></dt>
+        <dd>Must contain <code>_msgid</code> – provided automatically by the consumer node.</dd>
+    </dl>
+
+    <h3>Output</h3>
+    <p>Passes the message downstream unchanged after a successful ack, so you can chain further processing after acknowledgement.</p>
+
+    <h3>Details</h3>
+    <ul>
+        <li>Calls <code>channel.ack(message)</code> on the underlying AMQP channel.</li>
+        <li>Cancels the per-message timeout configured on the consumer.</li>
+        <li>Logs a critical error if the message context is missing or already released.</li>
+    </ul>
+</script>
+
+<!-- Node registration -->
+<script type="text/javascript">
+    RED.nodes.registerType('mq.ackw', {
+        category: 'network',
+        color: '#F7D4B5',
+        defaults: {
+            name: { value: '' }
+        },
+        inputs:  1,
+        outputs: 1,
+        icon: 'rabbit.svg',
+        paletteLabel: 'mq.ackw',
+        label: function () {
+            return this.name || 'mq.ackw';
+        },
+        labelStyle: function () {
+            return this.name ? 'node_label_italic' : '';
+        }
+    });
+</script>

package/mq.ackw.js

@@ -0,0 +1,50 @@
+'use strict';
+
+module.exports = function (RED) {
+    const inflight = require('./mq.store');
+
+    function MQAckNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.on('input', function (msg, send, done) {
+            send = send || function () { node.send.apply(node, arguments); };
+            done = done || function (err) { if (err) node.error(err, msg); };
+
+            if (!msg.rabbitmq || !msg.rabbitmq._msgid) {
+                node.error('[ack-guard] CRITICAL: msg.rabbitmq._msgid missing – rabbitmq context was lost in the flow (check function/change nodes upstream)', msg);
+                done();
+                return;
+            }
+
+            const msgid = msg.rabbitmq._msgid;
+            const entry = inflight.get(msgid);
+
+            if (!entry) {
+                node.error(`[ack-guard] CRITICAL: missing inflight entry for msgid=${msgid} – message was lost or already released (timed out / double-acked?)`, msg);
+                done();
+                return;
+            }
+
+            if (entry.timeout) {
+                clearTimeout(entry.timeout);
+            }
+
+            try {
+                entry.channel.ack(entry.message);
+            } catch (e) {
+                node.error(`[ack] ack failed for msgid=${msgid}: ${e.message}`, msg);
+                inflight.delete(msgid);
+                done(e);
+                return;
+            }
+
+            inflight.delete(msgid);
+
+            send(msg);
+            done();
+        });
+    }
+
+    RED.nodes.registerType('mq.ackw', MQAckNode);
+};

package/mq.consumer.html

@@ -0,0 +1,105 @@
+<!-- Edit panel template -->
+<script type="text/html" data-template-name="mq.consumer">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-host"><i class="fa fa-server"></i> Host</label>
+        <input type="text" id="node-input-host" placeholder="localhost">
+    </div>
+    <div class="form-row">
+        <label for="node-input-user"><i class="fa fa-user"></i> User</label>
+        <input type="text" id="node-input-user" placeholder="guest">
+    </div>
+    <div class="form-row">
+        <label for="node-input-password"><i class="fa fa-lock"></i> Password</label>
+        <input type="password" id="node-input-password" placeholder="guest">
+    </div>
+    <div class="form-row">
+        <label for="node-input-queue"><i class="fa fa-inbox"></i> Queue</label>
+        <input type="text" id="node-input-queue" placeholder="my-queue">
+    </div>
+    <div class="form-row">
+        <label for="node-input-prefetch"><i class="fa fa-tachometer"></i> Prefetch</label>
+        <input type="number" id="node-input-prefetch" min="1" placeholder="1" style="width:80px">
+    </div>
+    <div class="form-row">
+        <label for="node-input-timeout"><i class="fa fa-clock-o"></i> Timeout (min)</label>
+        <input type="number" id="node-input-timeout" min="0" step="0.1" placeholder="0 = 5 min floor" style="width:140px">
+    </div>
+    <div class="form-row">
+        <label for="node-input-ssl"><i class="fa fa-shield"></i> SSL/TLS</label>
+        <input type="checkbox" id="node-input-ssl" style="width:auto; margin-top:4px">
+    </div>
+    <div class="form-row">
+        <label for="node-input-debug"><i class="fa fa-bug"></i> Debug mode</label>
+        <input type="checkbox" id="node-input-debug" style="width:auto; margin-top:4px">
+        <label for="node-input-debug" style="width:auto"> (verbose – disable in production)</label>
+    </div>
+</script>
+
+<!-- Help panel -->
+<script type="text/html" data-help-name="mq.consumer">
+    <p>Connects to a RabbitMQ queue and emits one message per delivery.</p>
+
+    <h3>Configuration</h3>
+    <dl class="message-properties">
+        <dt>Host</dt>
+        <dd>RabbitMQ hostname or IP address.</dd>
+        <dt>User / Password</dt>
+        <dd>AMQP credentials (stored securely via Node-RED credential store).</dd>
+        <dt>Queue</dt>
+        <dd>Name of the queue to consume. The queue is asserted as durable on connect.</dd>
+        <dt>Prefetch</dt>
+        <dd>Maximum number of unacknowledged messages delivered to this consumer at once.</dd>
+        <dt>Timeout (min)</dt>
+        <dd>If a message is not acknowledged within this many minutes it will be negatively acknowledged (nack) and requeued. Set to 0 to use the built-in 5-minute floor — timeout cannot be fully disabled.</dd>
+        <dt>SSL/TLS</dt>
+        <dd>Enable to use <code>amqps://</code> (TLS-secured connection). Disable only for local or non-secure RabbitMQ instances.</dd>
+    </dl>
+
+    <h3>Output</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">object | string</span></dt>
+        <dd>Parsed JSON body of the message, or a raw string if parsing fails.</dd>
+        <dt>rabbitmq <span class="property-type">object</span></dt>
+        <dd>Internal context needed by the <code>mq.ackw</code> node. Do not modify.</dd>
+        <dt>_msgid <span class="property-type">string</span></dt>
+        <dd>Unique message identifier used to correlate acknowledgements.</dd>
+    </dl>
+
+    <h3>Connection behaviour</h3>
+    <p>On connection failure the node automatically reconnects using exponential backoff (1 s → 2 s → … → 60 s max).</p>
+</script>
+
+<!-- Node registration -->
+<script type="text/javascript">
+    RED.nodes.registerType('mq.consumer', {
+        category: 'network',
+        color: '#F7D4B5',
+        defaults: {
+            name:     { value: '' },
+            host:     { value: 'localhost', required: true },
+            queue:    { value: '',          required: true },
+            prefetch: { value: 1 },
+            timeout:  { value: 0 },
+            ssl:      { value: true },
+            debug:    { value: false }
+        },
+        credentials: {
+            user:     { type: 'text' },
+            password: { type: 'password' }
+        },
+        inputs:  0,
+        outputs: 1,
+        icon: 'rabbit.svg',
+        paletteLabel: 'mq.consumer',
+        label: function () {
+            return this.name || 'mq.consumer';
+        },
+        labelStyle: function () {
+            return this.name ? 'node_label_italic' : '';
+        }
+    });
+</script>

package/mq.consumer.js

@@ -0,0 +1,259 @@
+'use strict';
+
+module.exports = function (RED) {
+    const amqp = require('amqplib');
+    const inflight = require('./mq.store');
+
+    // Safety floor: never allow the timeout to be fully disabled.
+    // A flow misconfiguration (missing ack node) would otherwise permanently
+    // exhaust the prefetch window and silently deadlock the consumer.
+    const MIN_TIMEOUT_MS   = 5 * 60 * 1000;   // 5 minutes
+    const FLOW_CHECK_DELAY = 10 * 1000;        // warn after 10 s if still unacked
+
+    function MQConsumerNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        const host     = config.host;
+        const queue    = config.queue;
+        const prefetch = parseInt(config.prefetch, 10) || 1;
+
+        // If timeout is 0 (disabled), enforce the minimum.
+        // This ensures no message can permanently block the channel.
+        const configuredMs = (parseFloat(config.timeout) || 0) * 60 * 1000;
+        const timeoutMs    = configuredMs > 0 ? configuredMs : MIN_TIMEOUT_MS;
+
+        const debug = config.debug === true || config.debug === 'true';
+
+        const ssl = config.ssl !== false && config.ssl !== 'false';
+
+        const user     = node.credentials.user     || '';
+        const password = node.credentials.password || '';
+
+        let connection     = null;
+        let channel        = null;
+        let reconnectTimer = null;
+        let reconnectDelay = 1000;
+        let closing        = false;
+
+        if (debug) node.debug(`[consumer-debug] timeout active: ${timeoutMs}ms`);
+
+        // ------------------------------------------------------------------ //
+        // Connection logic
+        // ------------------------------------------------------------------ //
+
+        async function connect() {
+            if (closing) return;
+
+            node.status({ fill: 'yellow', shape: 'ring', text: 'connecting…' });
+
+            try {
+                const protocol = ssl ? 'amqps' : 'amqp';
+                if (debug) node.debug(`[consumer-debug] connecting – ${protocol}://${encodeURIComponent(user)}@${host} queue="${queue}"`);
+
+                const url = `${protocol}://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}`;
+                connection = await amqp.connect(url);
+                if (debug) node.debug(`[consumer-debug] connection established`);
+
+                connection.on('error', (err) => {
+                    node.warn(`[consumer] connection error: ${err.message}`);
+                    connection = null;
+                    channel    = null;
+                    scheduleReconnect();
+                });
+
+                connection.on('close', () => {
+                    if (!closing) {
+                        node.warn(`[consumer] connection closed unexpectedly, scheduling reconnect`);
+                        connection = null;
+                        channel    = null;
+                        scheduleReconnect();
+                    }
+                });
+
+                channel = await connection.createChannel();
+                if (debug) node.debug(`[consumer-debug] channel created`);
+
+                channel.on('error', (err) => {
+                    node.warn(`[consumer] channel error: ${err.message}`);
+                    channel = null;
+                });
+
+                channel.on('close', () => {
+                    node.warn(`[consumer] channel closed`);
+                });
+
+                const queueInfo = await channel.assertQueue(queue, { durable: true });
+                if (debug) node.debug(`[consumer-debug] queue asserted: "${queue}" – messages=${queueInfo.messageCount} consumers=${queueInfo.consumerCount}`);
+
+                channel.prefetch(prefetch);
+                if (debug) node.debug(`[consumer-debug] prefetch set: ${prefetch}`);
+
+                reconnectDelay = 1000;
+                node.status({ fill: 'green', shape: 'dot', text: `connected: ${queue}` });
+
+                const consumeResult = await channel.consume(queue, (msg) => {
+                    if (msg === null) {
+                        node.warn(`[consumer] consumer cancelled by broker on queue="${queue}"`);
+                        return;
+                    }
+                    handleMessage(msg);
+                }, { noAck: false });
+
+                if (debug) node.debug(`[consumer-debug] consuming – consumerTag="${consumeResult.consumerTag}"`);
+
+            } catch (err) {
+                node.error(`[consumer] failed to connect: ${err.message}`);
+                node.status({ fill: 'red', shape: 'ring', text: `error: ${err.message}` });
+                scheduleReconnect();
+            }
+        }
+
+        // Discard all inflight entries that belong to a given channel.
+        // Must be called before nulling the channel reference so the match works.
+        // Cancels every pending timeout so no deferred action fires against a
+        // dead channel after RabbitMQ has already requeued those messages.
+        function clearInflightForChannel(ch) {
+            if (!ch) return;
+            let count = 0;
+            for (const [msgid, entry] of inflight.entries()) {
+                if (entry.channel === ch) {
+                    if (entry.timeout) clearTimeout(entry.timeout);
+                    inflight.delete(msgid);
+                    count++;
+                }
+            }
+            if (count > 0) {
+                node.warn(`[consumer] discarded ${count} inflight message(s) – connection lost, RabbitMQ will requeue them`);
+            }
+        }
+
+        function scheduleReconnect() {
+            if (closing) return;
+            clearInflightForChannel(channel);   // reset before nulling refs
+            connection = null;
+            channel    = null;
+
+            node.status({ fill: 'yellow', shape: 'ring', text: `reconnecting in ${reconnectDelay / 1000}s…` });
+            reconnectTimer = setTimeout(() => {
+                reconnectDelay = Math.min(reconnectDelay * 2, 60000);
+                connect();
+            }, reconnectDelay);
+        }
+
+        // ------------------------------------------------------------------ //
+        // Message handling
+        // ------------------------------------------------------------------ //
+
+        function handleMessage(msg) {
+            const msgid = RED.util.generateId();
+
+            let payload;
+            try {
+                payload = JSON.parse(msg.content.toString());
+            } catch (e) {
+                node.warn(`[consumer] JSON parse failed, using raw string: ${e.message}`);
+                payload = msg.content.toString();
+            }
+
+            // Safety-net timeout: nack and requeue if the flow never reaches
+            // the ack node within the configured window.
+            const timeoutHandle = setTimeout(() => {
+                const entry = inflight.get(msgid);
+                if (!entry) return;
+
+                // Only nack if the channel is still the same live channel.
+                // If the connection was lost, clearInflightForChannel() will
+                // have already removed this entry — but under a race condition
+                // the timeout may fire just before or just after that cleanup.
+                // In either case, acting on a closed/replaced channel is wrong.
+                if (!channel || entry.channel !== channel) {
+                    node.warn(`[consumer-guard] timeout for msgid=${msgid} skipped – channel no longer valid, RabbitMQ already requeued`);
+                    inflight.delete(msgid);
+                    return;
+                }
+
+                node.warn(`[consumer-guard] auto-nack triggered for msgid=${msgid} – flow did not ack in time (requeue=true)`);
+                try {
+                    entry.channel.nack(entry.message, false, true);
+                } catch (e) {
+                    node.error(`[consumer-guard] auto-nack error for msgid=${msgid}: ${e.message}`);
+                }
+
+                inflight.delete(msgid);
+            }, timeoutMs);
+
+            inflight.set(msgid, {
+                channel,
+                message: msg,
+                timeout: timeoutHandle
+            });
+
+            // ---- Observability guards ----------------------------------------
+
+            if (debug) {
+                node.debug(`[consumer-debug] inflight size=${inflight.size}`);
+            }
+
+            if (debug && inflight.size >= prefetch) {
+                node.debug(`[consumer-debug] prefetch limit reached (inflight=${inflight.size} prefetch=${prefetch}) – normal backpressure behavior`);
+            }
+
+            // Early-warning: only active in debug mode to avoid per-message timer overhead.
+            if (debug) {
+                setTimeout(() => {
+                    if (inflight.has(msgid)) {
+                        node.error(`[consumer-guard] message ${msgid} still unacked after ${FLOW_CHECK_DELAY / 1000}s – flow likely not reaching ack node`);
+                    }
+                }, FLOW_CHECK_DELAY);
+            }
+
+            if (debug) node.debug(`[consumer-debug] message received – msgid=${msgid} deliveryTag=${msg.fields.deliveryTag}`);
+
+            const outMsg = {
+                payload,
+                _msgid: msgid,
+                rabbitmq: {
+                    message: msg,
+                    _msgid: msgid
+                }
+            };
+
+            node.send(outMsg);
+        }
+
+        // ------------------------------------------------------------------ //
+        // Cleanup on node close / redeploy
+        // ------------------------------------------------------------------ //
+
+        node.on('close', async (done) => {
+            closing = true;
+
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+
+            clearInflightForChannel(channel);
+
+            try {
+                if (channel)    await channel.close().catch(() => {});
+                if (connection) await connection.close().catch(() => {});
+            } catch (e) {
+                node.warn(`[consumer] error during close: ${e.message}`);
+            }
+
+            node.status({});
+            done();
+        });
+
+        connect();
+    }
+
+    RED.nodes.registerType('mq.consumer', MQConsumerNode, {
+        credentials: {
+            user:     { type: 'text' },
+            password: { type: 'password' }
+        }
+    });
+};

package/mq.producer.html

@@ -0,0 +1,104 @@
+<!-- Edit panel template -->
+<script type="text/html" data-template-name="mq.producer">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-host"><i class="fa fa-server"></i> Host</label>
+        <input type="text" id="node-input-host" placeholder="localhost">
+    </div>
+    <div class="form-row">
+        <label for="node-input-user"><i class="fa fa-user"></i> User</label>
+        <input type="text" id="node-input-user" placeholder="guest">
+    </div>
+    <div class="form-row">
+        <label for="node-input-password"><i class="fa fa-lock"></i> Password</label>
+        <input type="password" id="node-input-password" placeholder="guest">
+    </div>
+    <div class="form-row">
+        <label for="node-input-exchange"><i class="fa fa-random"></i> Exchange</label>
+        <input type="text" id="node-input-exchange" placeholder="my-exchange">
+    </div>
+    <div class="form-row">
+        <label for="node-input-routingKey"><i class="fa fa-key"></i> Routing Key</label>
+        <input type="text" id="node-input-routingKey" placeholder="my-routing-key">
+    </div>
+    <div class="form-row">
+        <label for="node-input-ssl"><i class="fa fa-shield"></i> SSL/TLS</label>
+        <input type="checkbox" id="node-input-ssl" style="width:auto; margin-top:4px">
+    </div>
+    <div class="form-row">
+        <label for="node-input-debug"><i class="fa fa-bug"></i> Debug mode</label>
+        <input type="checkbox" id="node-input-debug" style="width:auto; margin-top:4px">
+        <label for="node-input-debug" style="width:auto"> (verbose – disable in production)</label>
+    </div>
+</script>
+
+<!-- Help panel -->
+<script type="text/html" data-help-name="mq.producer">
+    <p>Publishes messages to a RabbitMQ exchange.</p>
+
+    <h3>Configuration</h3>
+    <dl class="message-properties">
+        <dt>Host</dt>
+        <dd>RabbitMQ hostname or IP address.</dd>
+        <dt>User / Password</dt>
+        <dd>AMQP credentials (stored securely via Node-RED credential store).</dd>
+        <dt>Exchange</dt>
+        <dd>Target exchange name. Asserted as <code>direct</code> and durable on connect.</dd>
+        <dt>Routing Key</dt>
+        <dd>Default routing key used when <code>msg.routingKey</code> is not set.</dd>
+        <dt>SSL/TLS</dt>
+        <dd>Enable to use <code>amqps://</code> (TLS-secured connection). Disable only for local or non-secure RabbitMQ instances.</dd>
+    </dl>
+
+    <h3>Input</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">any</span></dt>
+        <dd>Published as <code>{ data: msg.payload }</code> (JSON-encoded).</dd>
+        <dt>exchange <span class="property-type">string</span> <span class="property-optional">(optional)</span></dt>
+        <dd>Overrides the configured exchange for this message only.</dd>
+        <dt>routingKey <span class="property-type">string</span> <span class="property-optional">(optional)</span></dt>
+        <dd>Overrides the configured routing key for this message only.</dd>
+    </dl>
+
+    <h3>Output</h3>
+    <p>Forwards <code>msg</code> unchanged downstream after the broker confirms receipt.</p>
+
+    <h3>Connection behaviour</h3>
+    <p>Connects eagerly on deploy. On failure the node reconnects using exponential backoff (1 s → 2 s → … → 30 s max). Messages arriving while disconnected are dropped and logged as warnings.</p>
+
+    <h3>Publish confirmation</h3>
+    <p>Uses a <em>confirm channel</em>, so the node waits for a broker-level ack before forwarding the message downstream.</p>
+</script>
+
+<!-- Node registration -->
+<script type="text/javascript">
+    RED.nodes.registerType('mq.producer', {
+        category: 'network',
+        color: '#F7D4B5',
+        defaults: {
+            name:       { value: '' },
+            host:       { value: 'localhost', required: true },
+            exchange:   { value: '',          required: true },
+            routingKey: { value: '' },
+            ssl:        { value: true },
+            debug:      { value: false }
+        },
+        credentials: {
+            user:     { type: 'text' },
+            password: { type: 'password' }
+        },
+        inputs:  1,
+        outputs: 1,
+        icon: 'rabbit.svg',
+        paletteLabel: 'mq.producer',
+        label: function () {
+            return this.name || 'mq.producer';
+        },
+        labelStyle: function () {
+            return this.name ? 'node_label_italic' : '';
+        }
+    });
+</script>

package/mq.producer.js

@@ -0,0 +1,181 @@
+'use strict';
+
+module.exports = function (RED) {
+    const amqp = require('amqplib');
+
+    function MQProducerNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        const cfgExchange   = config.exchange;
+        const cfgRoutingKey = config.routingKey;
+        const host          = config.host;
+
+        const ssl   = config.ssl   !== false && config.ssl   !== 'false';
+        const debug = config.debug === true  || config.debug === 'true';
+
+        const user     = node.credentials.user     || '';
+        const password = node.credentials.password || '';
+
+        let connection     = null;
+        let channel        = null;
+        let reconnectTimer = null;
+        let reconnectDelay = 1000;
+        let closing        = false;
+        let connecting     = false;
+
+        // ------------------------------------------------------------------ //
+        // Connection logic
+        // ------------------------------------------------------------------ //
+
+        async function connect() {
+            if (closing || connecting) return;
+            connecting = true;
+
+            node.status({ fill: 'yellow', shape: 'dot', text: 'connecting…' });
+
+            try {
+                const protocol = ssl ? 'amqps' : 'amqp';
+                if (debug) node.debug(`[producer-debug] connecting – ${protocol}://${encodeURIComponent(user)}@${host} exchange="${cfgExchange}"`);
+                const url = `${protocol}://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}`;
+                connection = await amqp.connect(url);
+
+                connection.on('error', (err) => {
+                    node.warn(`[producer] connection error: ${err.message}`);
+                    connection = null;
+                    channel    = null;
+                    scheduleReconnect();
+                });
+
+                connection.on('close', () => {
+                    if (!closing) {
+                        node.warn('[producer] connection closed unexpectedly, scheduling reconnect');
+                        connection = null;
+                        channel    = null;
+                        scheduleReconnect();
+                    }
+                });
+
+                channel = await connection.createConfirmChannel();
+
+                channel.on('error', (err) => {
+                    node.warn(`[producer] channel error: ${err.message}`);
+                    channel = null;
+                });
+
+                await channel.assertExchange(cfgExchange, 'direct', { durable: true });
+
+                connecting     = false;
+                reconnectDelay = 1000;
+                node.status({ fill: 'green', shape: 'ring', text: `connected: ${cfgExchange} → ${cfgRoutingKey || '-'}` });
+                if (debug) node.debug(`[producer-debug] connected – exchange="${cfgExchange}"`);
+
+            } catch (err) {
+                connecting = false;
+                connection = null;
+                channel    = null;
+                node.error(`[producer] failed to connect: ${err.message}`);
+                node.status({ fill: 'red', shape: 'ring', text: `error: ${err.message}` });
+                scheduleReconnect();
+            }
+        }
+
+        function scheduleReconnect() {
+            if (closing || reconnectTimer) return;
+            node.status({ fill: 'yellow', shape: 'dot', text: `reconnecting in ${reconnectDelay / 1000}s…` });
+            reconnectTimer = setTimeout(() => {
+                reconnectTimer = null;
+                reconnectDelay = Math.min(reconnectDelay * 2, 30000);
+                connect();
+            }, reconnectDelay);
+        }
+
+        // ------------------------------------------------------------------ //
+        // Message input
+        // ------------------------------------------------------------------ //
+
+        node.on('input', async function (msg, send, done) {
+            send = send || function () { node.send.apply(node, arguments); };
+            done = done || function (err) { if (err) node.error(err, msg); };
+
+            if (!channel) {
+                if (!connecting && !reconnectTimer) connect();
+                node.warn('[producer] message dropped – producer is not connected to RabbitMQ');
+                node.status({ fill: 'red', shape: 'ring', text: 'not connected' });
+                done();
+                return;
+            }
+
+            const targetExchange   = msg.exchange   || cfgExchange;
+            const targetRoutingKey = msg.routingKey || cfgRoutingKey;
+
+            const message = { data: msg.payload };
+            const buffer  = Buffer.from(JSON.stringify(message));
+
+            try {
+                await new Promise((resolve, reject) => {
+                    const drained = channel.publish(
+                        targetExchange,
+                        targetRoutingKey,
+                        buffer,
+                        { persistent: true },
+                        (err) => { if (err) reject(err); else resolve(); }
+                    );
+                    if (!drained) {
+                        node.warn('[producer] channel write buffer full – back-pressure applied');
+                    }
+                });
+
+                if (debug) {
+                    node.debug(`[producer-debug] published to exchange="${targetExchange}" routingKey="${targetRoutingKey}"`);
+                }
+                node.status({ fill: 'green', shape: 'ring', text: `published: ${targetExchange} → ${targetRoutingKey}` });
+                send(msg);
+                done();
+
+                setTimeout(() => {
+                    if (channel) node.status({ fill: 'green', shape: 'ring', text: `connected: ${cfgExchange} → ${cfgRoutingKey || '-'}` });
+                }, 2000);
+
+            } catch (err) {
+                node.error(`[producer] publish failed: ${err.message}`, msg);
+                node.status({ fill: 'red', shape: 'ring', text: `publish error: ${err.message}` });
+                channel = null;
+                scheduleReconnect();
+                done(err);
+            }
+        });
+
+        // ------------------------------------------------------------------ //
+        // Cleanup on node close / redeploy
+        // ------------------------------------------------------------------ //
+
+        node.on('close', async (done) => {
+            closing = true;
+
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+
+            try {
+                if (channel)    await channel.close().catch(() => {});
+                if (connection) await connection.close().catch(() => {});
+            } catch (e) {
+                node.warn(`[producer] error during close: ${e.message}`);
+            }
+
+            node.status({});
+            done();
+        });
+
+        connect();
+    }
+
+    RED.nodes.registerType('mq.producer', MQProducerNode, {
+        credentials: {
+            user:     { type: 'text' },
+            password: { type: 'password' }
+        }
+    });
+};

package/mq.store.js

@@ -0,0 +1,8 @@
+'use strict';
+
+// Shared in-memory store for inflight RabbitMQ messages.
+// Node.js module caching ensures both mq.consumer and mq.ackw
+// share the exact same Map instance within a process.
+const inflight = new Map();
+
+module.exports = inflight;

package/package.json

@@ -0,0 +1,18 @@
+{
+    "name": "@inteli.city/node-red-contrib-rabbit-mq",
+    "version": "1.0.0",
+    "description": "Node-RED nodes for producing, consuming and acknowledging RabbitMQ messages",
+    "keywords": ["node-red", "rabbitmq", "amqp"],
+    "license": "Apache-2.0",
+    "dependencies": {
+        "amqplib": "^0.10.9"
+    },
+    "node-red": {
+        "version": ">=2.0.0",
+        "nodes": {
+            "mq.consumer": "mq.consumer.js",
+            "mq.ackw":     "mq.ackw.js",
+            "mq.producer": "mq.producer.js"
+        }
+    }
+}