@inteli.city/node-red-contrib-http-plus 1.0.0

package/httprequest+.js

@@ -0,0 +1,311 @@
+/**
+ * Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * 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.
+ **/
+
+"use strict";
+const STATUS_INTERVAL_MS = 1000;
+
+module.exports = async function(RED) {
+    const { got } = await import('got');
+    const mustache = require("mustache");
+
+    // --- HTTP admin endpoints (registered once per runtime) ---
+    RED.httpAdmin.get("/http-request-plus/:id/status", function(req, res) {
+        const n = RED.nodes.getNode(req.params.id);
+        if (!n || typeof n.getStatus !== "function") { return res.sendStatus(404); }
+        res.json(n.getStatus());
+    });
+
+    RED.httpAdmin.post("/http-request-plus/:id/kill", function(req, res) {
+        const n = RED.nodes.getNode(req.params.id);
+        if (!n || typeof n.killAll !== "function") { return res.sendStatus(404); }
+        n.killAll();
+        res.sendStatus(200);
+    });
+    // ---
+
+    function HTTPRequest(n) {
+        RED.nodes.createNode(this, n);
+        const node = this;
+        const nodeUrl          = n.url;
+        const isTemplatedUrl   = (nodeUrl || "").indexOf("{{") !== -1;
+        const nodeMethod       = (n.method || "GET").toUpperCase();
+        node.ret               = n.ret || "txt";
+        node.queueLimit        = Math.max(1, Number(n.queue) || 1);
+
+        let pendingQueue = [];
+        let activeCount  = 0;
+        let activeJobs   = new Set();
+        let closing      = false;
+
+        // --- state tracking ---
+        let currentState     = { waiting: 0, executing: 0 };
+        let lastEmittedState = null;
+        let statusTimer      = null;
+        let lastEmitTime     = 0;
+
+        function closeError() {
+            const err = new Error("Node closed");
+            err.nodeClosing = true;
+            return err;
+        }
+
+        function computeState() {
+            return { waiting: pendingQueue.length, executing: activeCount };
+        }
+
+        function computeStatus(state) {
+            const method   = nodeMethod === "use" ? "HTTP" : nodeMethod;
+            const urlLabel = (n.url || "").replace(/^https?:\/\//, "").slice(0, 25);
+            return {
+                fill:  state.executing > 0 ? "blue" : "grey",
+                shape: state.executing > 0 ? "ring" : "dot",
+                text:  state.waiting + " (" + state.executing + "/" + node.queueLimit + ") " + method + " " + urlLabel
+            };
+        }
+
+        function emitStatus() {
+            lastEmitTime = Date.now();
+            if (
+                lastEmittedState &&
+                currentState.waiting   === lastEmittedState.waiting &&
+                currentState.executing === lastEmittedState.executing
+            ) { return; }
+            lastEmittedState = { waiting: currentState.waiting, executing: currentState.executing };
+            node.status(computeStatus(currentState));
+        }
+
+        function scheduleStatusEmit() {
+            const now  = Date.now();
+            const idle = currentState.waiting === 0 && currentState.executing === 0;
+            if (idle) {
+                if (statusTimer) { clearTimeout(statusTimer); statusTimer = null; }
+                emitStatus();
+                return;
+            }
+            if (now - lastEmitTime >= STATUS_INTERVAL_MS) {
+                emitStatus();
+                return;
+            }
+            if (!statusTimer) {
+                const delay = STATUS_INTERVAL_MS - (now - lastEmitTime);
+                statusTimer = setTimeout(function() {
+                    statusTimer = null;
+                    emitStatus();
+                }, delay);
+            }
+        }
+
+        function computeAndStoreState() {
+            currentState = computeState();
+            scheduleStatusEmit();
+        }
+
+        // --- request execution ---
+        async function performRequest(msg, signal) {
+            let url = nodeUrl || msg.url;
+            if (!url) { throw new Error("URL is required"); }
+            if (isTemplatedUrl) { url = mustache.render(nodeUrl, msg); }
+            if (!/^https?:\/\//i.test(url)) { url = "http://" + url; }
+
+            const method = (n.method === "use" && msg.method ? msg.method : nodeMethod).toUpperCase();
+
+            // Headers — silently ignore arrays or invalid JSON
+            let nodeHeaders = {};
+            try {
+                const parsed = JSON.parse(n.headers || "{}");
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    nodeHeaders = parsed;
+                }
+            } catch(e) { /* fallback to {} */ }
+            const msgHeaders = (msg.headers && typeof msg.headers === 'object' && !Array.isArray(msg.headers))
+                ? msg.headers : {};
+            const headers = Object.assign({}, msgHeaders, nodeHeaders);
+
+            const opts = {
+                method,
+                headers,
+                timeout:         { request: parseInt(RED.settings.httpRequestTimeout) || 120000 },
+                throwHttpErrors: false,
+                retry:           { limit: 0 },
+                responseType:    'buffer',
+                decompress:      true
+            };
+
+            if (signal) { opts.signal = signal; }
+
+            // Payload routing
+            if (method === 'GET' || method === 'DELETE') {
+                if (msg.payload !== null && msg.payload !== undefined &&
+                    typeof msg.payload === 'object' && !Array.isArray(msg.payload)) {
+                    opts.searchParams = msg.payload;
+                }
+                // non-object payloads silently ignored for GET/DELETE
+            } else if (method !== 'HEAD') {
+                let body;
+                if (n.payloadAsBody) {
+                    body = msg.payload;
+                } else {
+                    try { body = JSON.parse(n.body || "{}"); } catch(e) { body = {}; }
+                    if (msg.payload !== undefined) body = msg.payload;
+                }
+                if (typeof body === 'object' && !Buffer.isBuffer(body)) {
+                    opts.json = body;
+                } else if (typeof body === 'string' || Buffer.isBuffer(body)) {
+                    opts.body = body;
+                } else if (typeof body === 'number') {
+                    opts.body = String(body);
+                }
+            }
+
+            const res = await got(url, opts);
+
+            msg.statusCode  = res.statusCode;
+            msg.headers     = res.headers;
+            msg.responseUrl = res.url;
+            msg.payload     = res.body;
+
+            if (node.ret !== 'bin') {
+                msg.payload = msg.payload.toString('utf8');
+                if (node.ret === 'obj') {
+                    if (res.statusCode === 204) {
+                        msg.payload = {};
+                    } else {
+                        try { msg.payload = JSON.parse(msg.payload); }
+                        catch(e) { node.warn("http.request+: response is not valid JSON"); }
+                    }
+                }
+            }
+
+            return msg;
+        }
+
+        // --- queue engine ---
+        function executeTask(task) {
+            let cancelled = false;
+            const controller = typeof AbortController !== "undefined" ? new AbortController() : null;
+            const signal     = controller ? controller.signal : null;
+
+            task.cancel = function() {
+                if (!cancelled) {
+                    cancelled = true;
+                    if (controller) { controller.abort(); }
+                    activeCount--;
+                    task.reject(closeError());
+                }
+            };
+
+            activeJobs.add(task);
+
+            performRequest(task.msg, signal)
+                .then(function(resultMsg) {
+                    activeJobs.delete(task);
+                    if (!cancelled) {
+                        activeCount--;
+                        processQueue();
+                        computeAndStoreState();
+                        task.resolve(resultMsg);
+                    }
+                })
+                .catch(function(err) {
+                    activeJobs.delete(task);
+                    if (!cancelled) {
+                        activeCount--;
+                        processQueue();
+                        computeAndStoreState();
+                        if (err.response) {
+                            err.statusCode   = err.response.statusCode;
+                            err.responseBody = err.response.body;
+                        }
+                        task.reject(err);
+                    }
+                });
+        }
+
+        function processQueue() {
+            while (activeCount < node.queueLimit && pendingQueue.length > 0) {
+                const task = pendingQueue.shift();
+                activeCount++;
+                executeTask(task);
+            }
+        }
+
+        function enqueue(msg, send, done) {
+            new Promise(function(resolve, reject) {
+                if (closing) { return reject(closeError()); }
+                pendingQueue.push({ msg, resolve, reject });
+                processQueue();
+                computeAndStoreState();
+            }).then(function(resultMsg) {
+                send(resultMsg);
+                done();
+            }).catch(function(err) {
+                if (!err.nodeClosing) {
+                    const statusCode = err.statusCode;
+                    const label = statusCode
+                        ? statusCode + " " + err.message
+                        : err.message;
+                    node.error("http.request+: " + label, msg);
+                    node.status({ fill: "red", shape: "ring", text: label });
+                    msg.payload    = err.responseBody ? err.responseBody.toString('utf8') : err.message;
+                    msg.statusCode = statusCode || err.code;
+                    send(msg);
+                }
+                done();
+            });
+        }
+
+        // --- public API ---
+        node.getStatus = function() {
+            return { executing: activeCount, waiting: pendingQueue.length };
+        };
+
+        node.killAll = function() {
+            for (const job of activeJobs) {
+                try { job.cancel(); } catch (_) {}
+            }
+            activeJobs.clear();
+
+            for (const task of pendingQueue) {
+                try { task.reject(closeError()); } catch (_) {}
+            }
+            pendingQueue = [];
+
+            computeAndStoreState();
+        };
+
+        node.on("close", function(done) {
+            closing = true;
+            if (statusTimer) { clearTimeout(statusTimer); statusTimer = null; }
+            node.killAll();
+            node.status({});
+            done();
+        });
+
+        computeAndStoreState();
+
+        node.on("input", function(msg, send, done) {
+            if (closing) { done(); return; }
+            if (msg.stop === true) {
+                node.killAll();
+                done();
+                return;
+            }
+            enqueue(msg, send, done);
+        });
+    }
+
+    RED.nodes.registerType("http.request+", HTTPRequest);
+};

package/libs/swagger.js

@@ -0,0 +1,213 @@
+"use strict";
+
+const endpoints = new Map();
+let cachedSpec = null;
+
+function normalizePath(path) {
+    return path.replace(/:([^/]+)/g, "{$1}");
+}
+
+function zodToJsonSchema(zodType) {
+    if (!zodType || !zodType._def) return {};
+
+    const def = zodType._def;
+    const typeName = def.typeName;
+
+    if (typeName === "ZodString")  return { type: "string" };
+    if (typeName === "ZodNumber")  return { type: "number" };
+    if (typeName === "ZodBoolean") return { type: "boolean" };
+
+    if (typeName === "ZodEnum") {
+        return { type: "string", enum: def.values };
+    }
+
+    if (typeName === "ZodArray") {
+        return { type: "array", items: zodToJsonSchema(def.type) };
+    }
+
+    if (typeName === "ZodObject") {
+        const properties = {};
+        const required = [];
+        const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+        for (const key in shape) {
+            const field = shape[key];
+            const fieldDef = field._def;
+            const isOptional = fieldDef.typeName === "ZodOptional";
+            const innerType = isOptional ? fieldDef.innerType : field;
+            properties[key] = zodToJsonSchema(innerType);
+            if (!isOptional) required.push(key);
+        }
+        const schema = { type: "object", properties };
+        if (required.length > 0) schema.required = required;
+        return schema;
+    }
+
+    if (typeName === "ZodOptional") {
+        return zodToJsonSchema(def.innerType);
+    }
+
+    if (typeName === "ZodUnion") {
+        return { oneOf: def.options.map(zodToJsonSchema) };
+    }
+
+    return {};
+}
+
+function buildOperationObject(meta) {
+    const { schema, method } = meta;
+    const def = schema._def;
+    const typeName = def && def.typeName;
+
+    // Expect top-level z.object with keys: body, query, params
+    if (typeName !== "ZodObject") {
+        return { summary: "Auto-generated" };
+    }
+
+    const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+
+    const parameters = [];
+    const pathParamNames = [];
+
+    // Extract {param} names from normalized path
+    const normalizedPath = normalizePath(meta.path);
+    const pathParamRegex = /\{([^}]+)\}/g;
+    let m;
+    while ((m = pathParamRegex.exec(normalizedPath)) !== null) {
+        pathParamNames.push(m[1]);
+    }
+
+    // params → path parameters
+    if (shape.params) {
+        const paramsDef = shape.params._def;
+        const paramsTypeName = paramsDef && paramsDef.typeName;
+        if (paramsTypeName === "ZodObject") {
+            const paramsShape = typeof paramsDef.shape === "function" ? paramsDef.shape() : paramsDef.shape;
+            for (const key in paramsShape) {
+                parameters.push({
+                    name: key,
+                    in: "path",
+                    required: true,
+                    schema: zodToJsonSchema(paramsShape[key])
+                });
+            }
+        }
+    } else {
+        // auto-inject path params from URL if no explicit params schema
+        for (const name of pathParamNames) {
+            parameters.push({ name, in: "path", required: true, schema: { type: "string" } });
+        }
+    }
+
+    // query → query parameters
+    if (shape.query) {
+        const queryDef = shape.query._def;
+        const queryTypeName = queryDef && queryDef.typeName;
+        if (queryTypeName === "ZodObject") {
+            const queryShape = typeof queryDef.shape === "function" ? queryDef.shape() : queryDef.shape;
+            for (const key in queryShape) {
+                const fieldDef = queryShape[key]._def;
+                const isOptional = fieldDef.typeName === "ZodOptional";
+                parameters.push({
+                    name: key,
+                    in: "query",
+                    required: !isOptional,
+                    schema: zodToJsonSchema(isOptional ? fieldDef.innerType : queryShape[key])
+                });
+            }
+        }
+    }
+
+    if (method === "get" && shape.body) {
+        console.warn(
+            "[swagger] GET " + meta.path + " defines a body schema. " +
+            "GET requests should use 'query' instead of 'body'."
+        );
+    }
+
+    const operation = { summary: shape.body ? "Auto-generated (validated request)" : "Auto-generated" };
+    if (parameters.length > 0) operation.parameters = parameters;
+
+    // body → requestBody (only relevant for non-GET methods)
+    if (shape.body && method !== "get") {
+        operation.requestBody = {
+            required: true,
+            content: {
+                "application/json": {
+                    schema: zodToJsonSchema(shape.body)
+                }
+            }
+        };
+    }
+
+    operation.responses = { "200": { description: "OK" } };
+
+    return operation;
+}
+
+function registerEndpoint(meta) {
+    if (!meta || !meta.schema || !meta.nodeId) return;
+    cachedSpec = null;
+    endpoints.set(meta.nodeId, meta);
+}
+
+function unregisterEndpoint(nodeId) {
+    if (!nodeId) return;
+    endpoints.delete(nodeId);
+    cachedSpec = null;
+}
+
+function generateSpec() {
+    const paths = {};
+
+    for (const meta of endpoints.values()) {
+        const normalizedPath = normalizePath(meta.path);
+        if (!paths[normalizedPath]) paths[normalizedPath] = {};
+        paths[normalizedPath][meta.method] = buildOperationObject(meta);
+    }
+
+    cachedSpec = {
+        openapi: "3.0.0",
+        info: { title: "Node-RED API", version: "1.0.0" },
+        paths
+    };
+
+    return cachedSpec;
+}
+
+function getCachedSpec() {
+    if (cachedSpec) return cachedSpec;
+    return generateSpec();
+}
+
+function registerRoutes(RED) {
+    RED.httpNode.get("/openapi.json", function(_req, res) {
+        res.json(getCachedSpec());
+    });
+
+    RED.httpNode.get("/docs", function(_req, res) {
+        res.setHeader("Content-Type", "text/html");
+        res.send(`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Node-RED API Docs</title>
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist/swagger-ui.css" />
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist/swagger-ui-bundle.js"></script>
+  <script>
+    SwaggerUIBundle({
+      url: "/openapi.json",
+      dom_id: "#swagger-ui",
+      presets: [SwaggerUIBundle.presets.apis, SwaggerUIBundle.SwaggerUIStandalonePreset],
+      layout: "BaseLayout"
+    });
+  </script>
+</body>
+</html>`);
+    });
+}
+
+module.exports = { registerEndpoint, unregisterEndpoint, generateSpec, getCachedSpec, registerRoutes };

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "@inteli.city/node-red-contrib-http-plus",
+    "version": "1.0.0",
+    "dependencies": {
+        "body-parser": "1.20.3",
+        "content-type": "1.0.5",
+        "cookie-parser": "1.4.7",
+        "cookie": "0.7.2",
+        "cors": "2.8.5",
+        "form-data": "4.0.4",
+        "got": "12.6.1",
+        "hash-sum": "2.0.0",
+        "hpagent": "1.2.0",
+        "is-utf8": "0.2.1",
+        "media-typer": "1.1.0",
+        "multer": "2.0.2",
+        "mustache": "4.2.0",
+        "on-headers": "1.1.0",
+        "raw-body": "3.0.0",
+        "tough-cookie": "5.1.2",
+        "uuid": "9.0.1",
+        "jsonwebtoken": "^9.0.2",
+        "jwks-rsa": "^3.1.0",
+        "zod": "^3.23.8"
+    },
+    "keywords": ["node-red"],
+    "license": "Apache-2.0",
+    "node-red": {
+        "version": ">=2.0.0",
+        "nodes": {
+            "httpproxy+": "httpproxy+.js",
+            "http-auth-config+": "http-auth-config+.js",
+            "httpin+": "httpin+.js",
+            "httprequest+": "httprequest+.js"
+        }
+    }
+}