@theotherwillembotha/node-red-cluster 0.0.55

package/build/cluster/service/ClusterService.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterService = void 0;
+const node_red_plugincore_1 = require("@theotherwillembotha/node-red-plugincore");
+const transport_node_1 = require("@nats-io/transport-node");
+const ClusterClient_1 = require("./ClusterClient");
+class ClusterService extends node_red_plugincore_1.BaseService {
+    static { this._clients = {}; }
+    constructor() {
+        super("ClusterService");
+    }
+    // ── BaseService lifecycle ────────────────────────────────────────────────
+    async init(red) {
+        console.log("STARTING: ClusterService");
+        const writePermission = red.auth.needsPermission("inject.write");
+        red.httpAdmin.get("/cluster/status/:configId", writePermission, (req, res) => this._handleStatus(req, res));
+        red.httpAdmin.get("/cluster/members/:configId", writePermission, (req, res) => this._handleMembers(req, res));
+        red.httpAdmin.get("/cluster/discovery/:configId", writePermission, (req, res) => this._handleDiscovery(req, res));
+        red.httpAdmin.post("/cluster/testconnection", writePermission, (req, res) => this._handleTestConnection(req, res));
+    }
+    deinit(_red) {
+        console.log("STOPPING: ClusterService");
+        Object.values(ClusterService._clients).forEach(client => {
+            client.stop().catch(err => console.error("ClusterService: error stopping client:", err));
+        });
+        ClusterService._clients = {};
+    }
+    // ── Static client management ─────────────────────────────────────────────
+    static ensureClient(configId, params) {
+        let client = ClusterService._clients[configId];
+        if (!client) {
+            client = new ClusterClient_1.ClusterClient(params);
+            ClusterService._clients[configId] = client;
+            client.start().catch(err => {
+                console.error(`ClusterService: failed to start client for ${configId}:`, err);
+            });
+        }
+        else {
+            client.updateParams(params);
+        }
+        return client;
+    }
+    static getClient(configId) {
+        return ClusterService._clients[configId] ?? null;
+    }
+    static removeClient(configId) {
+        const client = ClusterService._clients[configId];
+        if (client) {
+            client.stop().catch(err => console.error(`ClusterService: error stopping client ${configId}:`, err));
+            delete ClusterService._clients[configId];
+        }
+    }
+    // ── HTTP admin handlers ──────────────────────────────────────────────────
+    _handleStatus(req, res) {
+        const client = ClusterService._clients[req.params.configId];
+        if (!client) {
+            res.status(404).json({ error: "No client for that config node" });
+            return;
+        }
+        res.json({ status: client.status(), params: client.params() });
+    }
+    async _handleMembers(req, res) {
+        const client = ClusterService._clients[req.params.configId];
+        if (!client) {
+            res.status(404).json({ error: "No client for that config node" });
+            return;
+        }
+        const kv = client.kvBucket();
+        if (!kv || client.status() !== "connected") {
+            res.status(503).json({ error: "Not connected", status: client.status() });
+            return;
+        }
+        try {
+            const members = [];
+            const iter = await kv.keys("instances.>");
+            for await (const key of iter) {
+                members.push(key.replace(/^instances\./, ""));
+            }
+            res.json({ members });
+        }
+        catch (err) {
+            // No keys found is not an error  return empty list
+            res.json({ members: [] });
+        }
+    }
+    async _handleDiscovery(req, res) {
+        const client = ClusterService._clients[req.params.configId];
+        if (!client) {
+            res.status(404).json({ error: "No client for that config node" });
+            return;
+        }
+        const kv = client.kvBucket();
+        if (!kv || client.status() !== "connected") {
+            res.status(503).json({ error: "Not connected", status: client.status() });
+            return;
+        }
+        const instances = {};
+        const endpoints = {};
+        try {
+            const instanceIter = await kv.keys("instances.>");
+            for await (const key of instanceIter) {
+                const entry = await kv.get(key);
+                if (entry && entry.operation === "PUT") {
+                    const instanceId = key.replace(/^instances\./, "");
+                    try {
+                        instances[instanceId] = JSON.parse(entry.string());
+                    }
+                    catch (_) { }
+                }
+            }
+        }
+        catch (_) { /* no instance keys */ }
+        try {
+            const endpointIter = await kv.keys("endpoints.>");
+            for await (const key of endpointIter) {
+                const entry = await kv.get(key);
+                if (entry && entry.operation === "PUT") {
+                    // key: "endpoints.<instanceId>.<subject...>"
+                    const withoutPrefix = key.replace(/^endpoints\./, "");
+                    const dotIdx = withoutPrefix.indexOf(".");
+                    if (dotIdx === -1)
+                        continue;
+                    const instanceId = withoutPrefix.substring(0, dotIdx);
+                    const subject = withoutPrefix.substring(dotIdx + 1);
+                    if (!endpoints[instanceId])
+                        endpoints[instanceId] = [];
+                    endpoints[instanceId].push(subject);
+                }
+            }
+        }
+        catch (_) { /* no endpoint keys */ }
+        res.json({ instances, endpoints });
+    }
+    // ── Test connection ──────────────────────────────────────────────────────
+    async _handleTestConnection(req, res) {
+        const { natsAddress, natsUser, natsPass } = req.body;
+        const nats = await this._testNats(natsAddress, natsUser, natsPass);
+        res.json({ nats });
+    }
+    async _testNats(address, user, pass) {
+        try {
+            const opts = { servers: address, maxReconnectAttempts: 0, timeout: 5000 };
+            if (user)
+                opts.user = user;
+            if (pass)
+                opts.pass = pass;
+            const nc = await (0, transport_node_1.connect)(opts);
+            await nc.drain();
+            return { ok: true, message: "Connected successfully" };
+        }
+        catch (err) {
+            return { ok: false, error: err.message || "Connection failed" };
+        }
+    }
+    // ── ServiceDescriptor ────────────────────────────────────────────────────
+    static getServiceDescriptor() {
+        return new node_red_plugincore_1.ServiceDescriptor("@theotherwillembotha/clusterservice", "ClusterService", "integration-plugin", "./cluster/service/ClusterService", ClusterService);
+    }
+}
+exports.ClusterService = ClusterService;

package/build/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cluster/node/ClusterConfigNode"), exports);
+__exportStar(require("./cluster/node/ClusterPublishNode"), exports);
+__exportStar(require("./cluster/node/ClusterSubscribeNode"), exports);

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@theotherwillembotha/node-red-cluster",
+  "version": "0.0.55",
+  "description": "Node-RED clustering plugin - connect multiple Node-RED instances into a coordinated cluster using NATS JetStream for message transport and NATS KV for shared state.",
+  "main": "./build/index.js",
+  "exports": "./build/index.js",
+  "author": "Willem Botha (@theotherwillembotha)",
+  "license": "ISC",
+  "keywords": [
+    "node-red",
+    "cluster",
+    "distributed",
+    "nats",
+    "jetstream",
+    "messaging"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "npm run clean && tsc && npm run generate-nodes && npm run copy-files",
+    "clean": "rm -rf ./build",
+    "generate-nodes": "node build/GenerateNodes.js",
+    "copy-files": "cp -r ./icons ./build/"
+  },
+  "files": [
+    "build/",
+    "documentation/",
+    "LICENSE",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theotherwillembotha/nodered_cluster.git"
+  },
+  "bugs": {
+    "url": "https://github.com/theotherwillembotha/nodered_cluster/issues"
+  },
+  "homepage": "https://github.com/theotherwillembotha/nodered_cluster#readme",
+  "engines": {
+    "node": ">=18",
+    "nodered": ">=4.0.0"
+  },
+  "dependencies": {
+    "@nats-io/jetstream": "^3.4.0",
+    "@nats-io/kv": "^3.4.0",
+    "@nats-io/nats-core": "^3.4.0",
+    "@nats-io/transport-node": "^3.4.0",
+    "@theotherwillembotha/node-red-plugincore": "^0.0.55"
+  },
+  "devDependencies": {
+    "@theotherwillembotha/node-red-plugincore": "../nodered_plugincore",
+    "@types/node": "^25.9.1",
+    "@types/node-red": "~1.3.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "node-red": {
+    "version": ">=4.0.0",
+    "nodes": {
+      "cluster": "./build/Nodes.js"
+    },
+    "plugins": {
+      "cluster": "./build/Plugins.js"
+    }
+  }
+}