node-red-contrib-aws-sqs-variable 1.0.0

package/aws-sqs.js

@@ -0,0 +1,260 @@
+/**
+ * AWS SQS Node for Node-RED
+ *
+ * Supports sending and receiving messages from SQS with flexible inputs.
+ */
+
+const {
+    SQSClient,
+    SendMessageCommand,
+    ReceiveMessageCommand,
+    DeleteMessageCommand
+} = require("@aws-sdk/client-sqs");
+
+module.exports = function(RED) {
+    /**
+     * Get value from different input types
+     * @param {string} value - Value to get
+     * @param {string} type - Type of value (str, msg, flow, global, env)
+     * @param {Object} msg - Message object
+     * @param {Object} node - Node instance
+     * @returns {string|null} Retrieved value
+     */
+    function getValue(value, type, msg, node) {
+        if (value === null || value === undefined) return null;
+
+        try {
+            let result;
+            switch (type) {
+                case 'msg':
+                    result = RED.util.getMessageProperty(msg, value);
+                    break;
+                case 'flow':
+                    result = getNestedValue(node.context().flow, value);
+                    break;
+                case 'global':
+                    result = getNestedValue(node.context().global, value);
+                    break;
+                case 'env':
+                    result = process.env[value];
+                    break;
+                default:
+                    result = value;
+            }
+            return result;
+        } catch (err) {
+            throw new Error(`Failed to get value for type: ${type}, value: ${value}. Error: ${err.message}`);
+        }
+    }
+
+    /**
+     * Helper function to get nested values like "all_vars.host"
+     * @param {Object} context - Context object
+     * @param {string} path - Dot-separated path
+     * @returns {*} Retrieved value
+     */
+    function getNestedValue(context, path) {
+        if (!context) return undefined;
+        if (path.includes('.')) {
+            const parts = path.split('.');
+            let result = context.get(parts[0]);
+            for (let i = 1; i < parts.length; i++) {
+                if (result && typeof result === 'object') {
+                    result = result[parts[i]];
+                } else {
+                    return undefined;
+                }
+            }
+            return result;
+        }
+        return context.get(path);
+    }
+
+    function AWSSQSNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        const sqsConfig = RED.nodes.getNode(config.awsConfig);
+
+        if (!sqsConfig) {
+            node.error("AWS SQS configuration not found.");
+            return;
+        }
+
+        // Store configuration
+        node.operation = config.operation;
+        node.queueUrl = config.queueUrl;
+        node.queueUrlType = config.queueUrlType;
+        node.messageBody = config.messageBody;
+        node.messageBodyType = config.messageBodyType;
+        node.messageGroupId = config.messageGroupId;
+        node.messageGroupIdType = config.messageGroupIdType;
+        node.messageDeduplicationId = config.messageDeduplicationId;
+        node.messageDeduplicationIdType = config.messageDeduplicationIdType;
+        node.maxNumberOfMessages = parseInt(config.maxNumberOfMessages, 10) || 1;
+        node.waitTimeSeconds = parseInt(config.waitTimeSeconds, 10) || 0;
+        node.visibilityTimeout = parseInt(config.visibilityTimeout, 10) || 30;
+        node.deleteAfterReceive = config.deleteAfterReceive === true || config.deleteAfterReceive === "true";
+        node.parseJsonBody = config.parseJsonBody === true || config.parseJsonBody === "true";
+        node.pollEnabled = config.pollEnabled === true || config.pollEnabled === "true";
+        node.pollIntervalSeconds = parseInt(config.pollIntervalSeconds, 10) || 30;
+
+        let pollTimer = null;
+        let isPolling = false;
+
+        function setPollingStatus() {
+            if (node.operation === "receive" && node.pollEnabled) {
+                const interval = Math.max(node.pollIntervalSeconds, 1);
+                node.status({ fill: "yellow", shape: "dot", text: `Waiting (${interval}s)` });
+            }
+        }
+
+        async function handleMessage(msg, send, done, fromPolling) {
+            try {
+                const client = sqsConfig.getClient(msg, node);
+                
+                if (!client || !(client instanceof SQSClient)) {
+                    if (sqsConfig.deferMissingConfig) {
+                        node.status({ fill: "yellow", shape: "ring", text: "Waiting for configuration" });
+                        return;
+                    }
+                    throw new Error("Failed to initialize SQS client");
+                }
+
+                const queueUrl = getValue(node.queueUrl, node.queueUrlType, msg, node) || msg.queueUrl;
+                if (!queueUrl) {
+                    throw new Error("Queue URL is required. Provide it in node configuration or msg.queueUrl");
+                }
+
+                if (node.operation === "send") {
+                    let bodyValue = getValue(node.messageBody, node.messageBodyType, msg, node);
+                    if (bodyValue === null || bodyValue === undefined) {
+                        bodyValue = msg.payload;
+                    }
+
+                    if (bodyValue === null || bodyValue === undefined) {
+                        throw new Error("Message body is required");
+                    }
+
+                    const bodyString = typeof bodyValue === "string" ? bodyValue : JSON.stringify(bodyValue);
+
+                    node.status({ fill: "blue", shape: "dot", text: "Sending message..." });
+
+                    const messageGroupId = getValue(node.messageGroupId, node.messageGroupIdType, msg, node) || msg.messageGroupId;
+                    const messageDeduplicationId = getValue(node.messageDeduplicationId, node.messageDeduplicationIdType, msg, node) || msg.messageDeduplicationId;
+
+                    const sendParams = {
+                        QueueUrl: queueUrl,
+                        MessageBody: bodyString
+                    };
+
+                    if (messageGroupId) {
+                        sendParams.MessageGroupId = messageGroupId;
+                    }
+                    if (messageDeduplicationId) {
+                        sendParams.MessageDeduplicationId = messageDeduplicationId;
+                    }
+
+                    const response = await client.send(new SendMessageCommand(sendParams));
+
+                    msg.payload = {
+                        messageId: response.MessageId,
+                        md5OfMessageBody: response.MD5OfMessageBody
+                    };
+
+                    node.status({ fill: "green", shape: "dot", text: "Message sent" });
+                    send(msg);
+                    done();
+                    return;
+                }
+
+                // Receive messages
+                if (fromPolling) {
+                    node.status({ fill: "blue", shape: "dot", text: "Polling..." });
+                } else {
+                    node.status({ fill: "blue", shape: "dot", text: "Receiving messages..." });
+                }
+
+                const receiveParams = {
+                    QueueUrl: queueUrl,
+                    MaxNumberOfMessages: Math.min(Math.max(node.maxNumberOfMessages, 1), 10),
+                    WaitTimeSeconds: Math.min(Math.max(node.waitTimeSeconds, 0), 20),
+                    VisibilityTimeout: Math.min(Math.max(node.visibilityTimeout, 0), 43200)
+                };
+
+                const response = await client.send(new ReceiveMessageCommand(receiveParams));
+                const messages = response.Messages || [];
+
+                if (node.parseJsonBody && messages.length > 0) {
+                    for (const message of messages) {
+                        if (typeof message.Body === "string") {
+                            try {
+                                message.Body = JSON.parse(message.Body);
+                            } catch (parseError) {
+                                // Keep string body if parsing fails
+                            }
+                        }
+                    }
+                }
+
+                if (node.deleteAfterReceive && messages.length > 0) {
+                    for (const message of messages) {
+                        if (message.ReceiptHandle) {
+                            await client.send(new DeleteMessageCommand({
+                                QueueUrl: queueUrl,
+                                ReceiptHandle: message.ReceiptHandle
+                            }));
+                        }
+                    }
+                }
+
+                msg.payload = messages;
+                node.status({ fill: "green", shape: "dot", text: "Messages received" });
+                if (fromPolling) {
+                    setPollingStatus();
+                }
+                send(msg);
+                done();
+
+            } catch (err) {
+                node.error(err.message, msg);
+                node.status({ fill: "red", shape: "ring", text: err.message });
+                
+                msg.payload = { error: err.message };
+                send(msg);
+                done();
+                if (fromPolling) {
+                    setPollingStatus();
+                }
+            }
+        }
+
+        node.on('input', async (msg, send, done) => {
+            await handleMessage(msg, send, done, false);
+        });
+
+        node.status({});
+
+        if (node.operation === "receive" && node.pollEnabled) {
+            const intervalMs = Math.max(node.pollIntervalSeconds, 1) * 1000;
+            setPollingStatus();
+            pollTimer = setInterval(async () => {
+                if (isPolling) return;
+                isPolling = true;
+                try {
+                    await handleMessage({}, node.send.bind(node), () => {}, true);
+                } finally {
+                    isPolling = false;
+                }
+            }, intervalMs);
+        }
+
+        node.on('close', () => {
+            if (pollTimer) {
+                clearInterval(pollTimer);
+                pollTimer = null;
+            }
+        });
+    }
+
+    RED.nodes.registerType("aws-sqs", AWSSQSNode);
+};

package/examples/advanced-usage.json

@@ -0,0 +1,267 @@
+[
+    {
+        "id": "sqs-advanced-flow",
+        "type": "tab",
+        "label": "AWS SQS Advanced Examples",
+        "disabled": false,
+        "info": "Advanced examples showing different configuration types, FIFO usage, and polling."
+    },
+    {
+        "id": "inject-fifo-send",
+        "type": "inject",
+        "z": "sqs-advanced-flow",
+        "name": "FIFO Send",
+        "props": [
+            {
+                "p": "payload"
+            },
+            {
+                "p": "messageGroupId",
+                "v": "orders",
+                "vt": "str"
+            },
+            {
+                "p": "messageDeduplicationId",
+                "v": "msg-{{{_msgid}}}",
+                "vt": "str"
+            }
+        ],
+        "repeat": "",
+        "crontab": "",
+        "once": false,
+        "onceDelay": 0.1,
+        "topic": "",
+        "payload": "{\"orderId\":123,\"status\":\"created\"}",
+        "payloadType": "json",
+        "x": 140,
+        "y": 80,
+        "wires": [
+            [
+                "sqs-fifo-send-node"
+            ]
+        ]
+    },
+    {
+        "id": "sqs-fifo-send-node",
+        "type": "aws-sqs",
+        "z": "sqs-advanced-flow",
+        "name": "FIFO Send",
+        "awsConfig": "sqs-config-env",
+        "operation": "send",
+        "queueUrl": "https://sqs.eu-central-1.amazonaws.com/123456789012/my-queue.fifo",
+        "queueUrlType": "str",
+        "messageBody": "payload",
+        "messageBodyType": "msg",
+        "messageGroupId": "messageGroupId",
+        "messageGroupIdType": "msg",
+        "messageDeduplicationId": "messageDeduplicationId",
+        "messageDeduplicationIdType": "msg",
+        "maxNumberOfMessages": 1,
+        "waitTimeSeconds": 0,
+        "visibilityTimeout": 30,
+        "deleteAfterReceive": true,
+        "parseJsonBody": false,
+        "pollEnabled": false,
+        "pollIntervalSeconds": 30,
+        "x": 380,
+        "y": 80,
+        "wires": [
+            [
+                "debug-fifo-send"
+            ]
+        ]
+    },
+    {
+        "id": "debug-fifo-send",
+        "type": "debug",
+        "z": "sqs-advanced-flow",
+        "name": "FIFO Send Result",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": false,
+        "complete": "payload",
+        "targetType": "msg",
+        "x": 610,
+        "y": 80,
+        "wires": []
+    },
+    {
+        "id": "inject-poll-start",
+        "type": "inject",
+        "z": "sqs-advanced-flow",
+        "name": "Start Polling",
+        "props": [
+            {
+                "p": "payload"
+            }
+        ],
+        "repeat": "",
+        "crontab": "",
+        "once": false,
+        "onceDelay": 0.1,
+        "topic": "",
+        "payload": "{}",
+        "payloadType": "json",
+        "x": 140,
+        "y": 160,
+        "wires": [
+            [
+                "sqs-poll-receive-node"
+            ]
+        ]
+    },
+    {
+        "id": "sqs-poll-receive-node",
+        "type": "aws-sqs",
+        "z": "sqs-advanced-flow",
+        "name": "Polling Receive",
+        "awsConfig": "sqs-config-context",
+        "operation": "receive",
+        "queueUrl": "sqs.queueUrl",
+        "queueUrlType": "global",
+        "messageBody": "payload",
+        "messageBodyType": "msg",
+        "messageGroupId": "",
+        "messageGroupIdType": "str",
+        "messageDeduplicationId": "",
+        "messageDeduplicationIdType": "str",
+        "maxNumberOfMessages": 10,
+        "waitTimeSeconds": 20,
+        "visibilityTimeout": 60,
+        "deleteAfterReceive": true,
+        "parseJsonBody": true,
+        "pollEnabled": true,
+        "pollIntervalSeconds": 30,
+        "x": 390,
+        "y": 160,
+        "wires": [
+            [
+                "debug-polling"
+            ]
+        ]
+    },
+    {
+        "id": "debug-polling",
+        "type": "debug",
+        "z": "sqs-advanced-flow",
+        "name": "Polling Receive Result",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": false,
+        "complete": "payload",
+        "targetType": "msg",
+        "x": 640,
+        "y": 160,
+        "wires": []
+    },
+    {
+        "id": "inject-dynamic-queue",
+        "type": "inject",
+        "z": "sqs-advanced-flow",
+        "name": "Dynamic Queue URL",
+        "props": [
+            {
+                "p": "payload"
+            },
+            {
+                "p": "queueUrl",
+                "v": "https://sqs.eu-central-1.amazonaws.com/123456789012/another-queue",
+                "vt": "str"
+            }
+        ],
+        "repeat": "",
+        "crontab": "",
+        "once": false,
+        "onceDelay": 0.1,
+        "topic": "",
+        "payload": "{\"message\":\"dynamic queue\"}",
+        "payloadType": "json",
+        "x": 150,
+        "y": 240,
+        "wires": [
+            [
+                "sqs-dynamic-send-node"
+            ]
+        ]
+    },
+    {
+        "id": "sqs-dynamic-send-node",
+        "type": "aws-sqs",
+        "z": "sqs-advanced-flow",
+        "name": "Dynamic Queue Send",
+        "awsConfig": "sqs-config-iam",
+        "operation": "send",
+        "queueUrl": "queueUrl",
+        "queueUrlType": "msg",
+        "messageBody": "payload",
+        "messageBodyType": "msg",
+        "messageGroupId": "",
+        "messageGroupIdType": "str",
+        "messageDeduplicationId": "",
+        "messageDeduplicationIdType": "str",
+        "maxNumberOfMessages": 1,
+        "waitTimeSeconds": 0,
+        "visibilityTimeout": 30,
+        "deleteAfterReceive": true,
+        "parseJsonBody": false,
+        "pollEnabled": false,
+        "pollIntervalSeconds": 30,
+        "x": 390,
+        "y": 240,
+        "wires": [
+            [
+                "debug-dynamic-send"
+            ]
+        ]
+    },
+    {
+        "id": "debug-dynamic-send",
+        "type": "debug",
+        "z": "sqs-advanced-flow",
+        "name": "Dynamic Send Result",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": false,
+        "complete": "payload",
+        "targetType": "msg",
+        "x": 610,
+        "y": 240,
+        "wires": []
+    },
+    {
+        "id": "sqs-config-env",
+        "type": "aws-sqs-config",
+        "name": "Environment Config",
+        "region": "eu-central-1",
+        "useIAMRole": false,
+        "accessKeyIdType": "env",
+        "accessKeyIdContext": "AWS_ACCESS_KEY_ID",
+        "secretAccessKeyType": "env",
+        "secretAccessKeyContext": "AWS_SECRET_ACCESS_KEY"
+    },
+    {
+        "id": "sqs-config-context",
+        "type": "aws-sqs-config",
+        "name": "Context Config",
+        "region": "eu-central-1",
+        "useIAMRole": false,
+        "accessKeyIdType": "global",
+        "accessKeyIdContext": "aws.accessKeyId",
+        "secretAccessKeyType": "global",
+        "secretAccessKeyContext": "aws.secretAccessKey"
+    },
+    {
+        "id": "sqs-config-iam",
+        "type": "aws-sqs-config",
+        "name": "IAM Role Config",
+        "region": "eu-central-1",
+        "useIAMRole": true,
+        "accessKeyIdType": "str",
+        "accessKeyIdContext": "",
+        "secretAccessKeyType": "str",
+        "secretAccessKeyContext": ""
+    }
+]

package/examples/basic-usage.json

@@ -0,0 +1,160 @@
+[
+    {
+        "id": "sqs-basic-flow",
+        "type": "tab",
+        "label": "AWS SQS Basic Example",
+        "disabled": false,
+        "info": "Basic example showing how to send and receive messages with AWS SQS."
+    },
+    {
+        "id": "inject-send-basic",
+        "type": "inject",
+        "z": "sqs-basic-flow",
+        "name": "Send Message",
+        "props": [
+            {
+                "p": "payload"
+            }
+        ],
+        "repeat": "",
+        "crontab": "",
+        "once": false,
+        "onceDelay": 0.1,
+        "topic": "",
+        "payload": "{\"message\":\"Hello from Node-RED\"}",
+        "payloadType": "json",
+        "x": 140,
+        "y": 120,
+        "wires": [
+            [
+                "sqs-send-node"
+            ]
+        ]
+    },
+    {
+        "id": "sqs-send-node",
+        "type": "aws-sqs",
+        "z": "sqs-basic-flow",
+        "name": "Send to Queue",
+        "awsConfig": "sqs-config-basic",
+        "operation": "send",
+        "queueUrl": "https://sqs.eu-central-1.amazonaws.com/123456789012/my-queue",
+        "queueUrlType": "str",
+        "messageBody": "payload",
+        "messageBodyType": "msg",
+        "messageGroupId": "",
+        "messageGroupIdType": "str",
+        "messageDeduplicationId": "",
+        "messageDeduplicationIdType": "str",
+        "maxNumberOfMessages": 1,
+        "waitTimeSeconds": 0,
+        "visibilityTimeout": 30,
+        "deleteAfterReceive": true,
+        "parseJsonBody": false,
+        "pollEnabled": false,
+        "pollIntervalSeconds": 30,
+        "x": 380,
+        "y": 120,
+        "wires": [
+            [
+                "debug-send-basic"
+            ]
+        ]
+    },
+    {
+        "id": "debug-send-basic",
+        "type": "debug",
+        "z": "sqs-basic-flow",
+        "name": "Send Result",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": false,
+        "complete": "payload",
+        "targetType": "msg",
+        "x": 610,
+        "y": 120,
+        "wires": []
+    },
+    {
+        "id": "inject-receive-basic",
+        "type": "inject",
+        "z": "sqs-basic-flow",
+        "name": "Receive Once",
+        "props": [
+            {
+                "p": "payload"
+            }
+        ],
+        "repeat": "",
+        "crontab": "",
+        "once": false,
+        "onceDelay": 0.1,
+        "topic": "",
+        "payload": "{}",
+        "payloadType": "json",
+        "x": 140,
+        "y": 200,
+        "wires": [
+            [
+                "sqs-receive-node"
+            ]
+        ]
+    },
+    {
+        "id": "sqs-receive-node",
+        "type": "aws-sqs",
+        "z": "sqs-basic-flow",
+        "name": "Receive from Queue",
+        "awsConfig": "sqs-config-basic",
+        "operation": "receive",
+        "queueUrl": "https://sqs.eu-central-1.amazonaws.com/123456789012/my-queue",
+        "queueUrlType": "str",
+        "messageBody": "payload",
+        "messageBodyType": "msg",
+        "messageGroupId": "",
+        "messageGroupIdType": "str",
+        "messageDeduplicationId": "",
+        "messageDeduplicationIdType": "str",
+        "maxNumberOfMessages": 5,
+        "waitTimeSeconds": 10,
+        "visibilityTimeout": 30,
+        "deleteAfterReceive": true,
+        "parseJsonBody": true,
+        "pollEnabled": false,
+        "pollIntervalSeconds": 30,
+        "x": 390,
+        "y": 200,
+        "wires": [
+            [
+                "debug-receive-basic"
+            ]
+        ]
+    },
+    {
+        "id": "debug-receive-basic",
+        "type": "debug",
+        "z": "sqs-basic-flow",
+        "name": "Receive Result",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": false,
+        "complete": "payload",
+        "targetType": "msg",
+        "x": 620,
+        "y": 200,
+        "wires": []
+    },
+    {
+        "id": "sqs-config-basic",
+        "type": "aws-sqs-config",
+        "name": "AWS SQS Config",
+        "region": "eu-central-1",
+        "useIAMRole": false,
+        "accessKeyIdType": "env",
+        "accessKeyIdContext": "AWS_ACCESS_KEY_ID",
+        "secretAccessKeyType": "env",
+        "secretAccessKeyContext": "AWS_SECRET_ACCESS_KEY"
+    }
+]