@machhub-dev/node-red-nodes 1.0.5

package/dist/lib/services/http.service.js

@@ -0,0 +1,188 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPService = exports.HTTPException = void 0;
+class HTTPException extends Error {
+    constructor(status, statusText, body) {
+        super();
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+    }
+    get message() {
+        return `(EXCEPTION) ${this.statusText} - ${this.body}`;
+    }
+}
+exports.HTTPException = HTTPException;
+class HTTPService {
+    constructor(url, prefix) {
+        if (prefix == null)
+            prefix = "";
+        this.url = new URL(prefix, url);
+        this._request = new RequestParameters(this.url);
+    }
+    get request() {
+        return this._request;
+    }
+}
+exports.HTTPService = HTTPService;
+class RequestParameters {
+    constructor(base, query) {
+        this.base = base;
+        this.query = query;
+        this.headers = {};
+    }
+    withQuery(path, query) {
+        const newPath = [this.base.pathname, path].map(pathPart => pathPart.replace(/(^\/|\/$)/g, "")).join("/");
+        const newURL = new URL(newPath, this.base);
+        for (const key in query) {
+            newURL.searchParams.append(key, query[key]);
+        }
+        return newURL;
+    }
+    parseInit(method) {
+        if (method == null && this.headers == null)
+            return;
+        let tempInit = Object.assign({}, this.init);
+        if (tempInit == null) {
+            tempInit = {};
+        }
+        if (method != null && tempInit != null)
+            tempInit.method = method;
+        if (this.headers != null && tempInit != null) {
+            tempInit.headers = Object.assign({}, this.headers);
+        }
+        return tempInit;
+    }
+    withBody(body) {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.body = body;
+        return this;
+    }
+    includeCredentials() {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.credentials = "include";
+        return this;
+    }
+    includeSameOriginCredentials() {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.credentials = "same-origin";
+        return this;
+    }
+    keepAlive() {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.keepalive = true;
+        return this;
+    }
+    followRedirect() {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.redirect = "follow";
+        return this;
+    }
+    errorOnRedirect() {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.redirect = "error";
+        return this;
+    }
+    setHeader(key, value) {
+        if (this.headers == null) {
+            this.headers = {
+                key: value
+            };
+        }
+        this.headers[key] = value;
+        return this;
+    }
+    setBearerToken(token) {
+        this.setHeader("Authorization", `Bearer ${token}`);
+        return this;
+    }
+    // public withAccessToken(): RequestParameters {
+    //     const tkn = localStorage.getItem("x-machhub-auth-tkn");
+    //     this.setHeader("Authorization", `Bearer ${tkn}`);
+    //     return this;
+    // }
+    withContentType(mime) {
+        this.setHeader("Content-Type", mime);
+        return this;
+    }
+    withJSON(body) {
+        const bd = JSON.stringify(body);
+        return this.withBody(bd).withContentType("application/json");
+    }
+    get(path, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(this.withQuery(path, query), this.parseInit());
+            if (!response.ok) {
+                throw new HTTPException(response.status, response.statusText, yield response.text());
+            }
+            return response.json();
+        });
+    }
+    post(path, query, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const init = this.parseInit("POST") || {};
+            if (body) {
+                if (body instanceof FormData) {
+                    init.body = body;
+                }
+                else {
+                    init.body = JSON.stringify(body);
+                    init.headers = Object.assign(Object.assign({}, init.headers), { 'Content-Type': 'application/json' });
+                }
+            }
+            const response = yield fetch(this.withQuery(path, query), init);
+            if (!response.ok) {
+                throw new HTTPException(response.status, response.statusText, yield response.text());
+            }
+            return response.json();
+        });
+    }
+    put(path, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(this.withQuery(path, query), this.parseInit("PUT"));
+            if (!response.ok) {
+                throw new HTTPException(response.status, response.statusText, yield response.text());
+            }
+            return response.json();
+        });
+    }
+    delete(path, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(this.withQuery(path, query), this.parseInit("DELETE"));
+            if (!response.ok) {
+                throw new HTTPException(response.status, response.statusText, yield response.text());
+            }
+            return response.json();
+        });
+    }
+    patch(path, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(this.withQuery(path, query), this.parseInit("PATCH"));
+            if (!response.ok) {
+                throw new HTTPException(response.status, response.statusText, yield response.text());
+            }
+            return response.json();
+        });
+    }
+}

package/dist/lib/services/mqtt.service.js

@@ -0,0 +1,234 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MQTTService = void 0;
+const mqtt_1 = __importDefault(require("mqtt"));
+class MQTTService {
+    constructor() {
+        this.subscribedTopics = [];
+    }
+    static getInstance(settings, statusCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If we already have an instance, return it
+            if (this.instance && this.instance.client && this.instance.client.connected) {
+                console.log("Returning existing MQTT instance");
+                if (statusCallback) {
+                    statusCallback({ fill: "green", shape: "dot", text: "MQTT Connected" });
+                }
+                return this.instance;
+            }
+            // If we're already in the process of creating an instance, wait for it
+            // TODO: Optimize to show that error messages as well for the non-first callers instead of just showing Connecting...
+            if (this.instancePromise) {
+                // console.log("Waiting for existing MQTT instance creation");
+                if (statusCallback) {
+                    statusCallback({ fill: "yellow", shape: "dot", text: "Connecting..." });
+                }
+                return this.instancePromise;
+            }
+            // Create new instance
+            // console.log("Creating new MQTT instance");
+            this.instancePromise = this.createInstance(settings, statusCallback);
+            try {
+                this.instance = yield this.instancePromise;
+                return this.instance;
+            }
+            catch (error) {
+                // Creation failed, clear the promise and instance
+                this.instancePromise = null;
+                this.instance = null;
+                console.error("Failed to create MQTT instance:", error.toString());
+                throw error;
+            }
+        });
+    }
+    static createInstance(settings, statusCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = new MQTTService();
+            // let info;
+            // let retryCount = 0;
+            // while (true) {
+            //     console.log("MQTTService: Checking stopConnecting flag:", this.stopConnecting);
+            //     if (this.stopConnecting) {
+            //         this.stopConnecting = false;
+            //         break;
+            //     }
+            //     try {
+            //         retryCount++;
+            //         if (statusCallback) {
+            //             statusCallback({ fill: "yellow", shape: "dot", text: `Fetching MACHHUB info... (attempt ${retryCount})` });
+            //         }
+            //         info = await HTTPAPIService.getMACHHUBInfo(settings);
+            //         break;
+            //     } catch (error) {
+            //         console.error(`Failed to fetch MACHHUB Info. Attempt ${retryCount}:`, error.toString());
+            //         if (statusCallback) {
+            //             statusCallback({ fill: "red", shape: "dot", text: `Failed to fetch info (attempt ${retryCount}): Retrying in 5s...` });
+            //         }
+            //         await new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds before retrying
+            //     }
+            // }
+            // if (!info) {
+            //     console.error("Failed to fetch MACHHUB Info. Retrying...");
+            //     await new Promise(resolve => setTimeout(resolve, 5000));
+            // }
+            // instance.protocol = "mqtt";
+            // instance.host = info.uns.bind.mqtt.host;
+            // instance.port = info.uns.bind.mqtt.port;
+            // instance.url = `${instance.protocol}://${instance.host}:${instance.port}`;
+            if (statusCallback) {
+                statusCallback({ fill: "yellow", shape: "dot", text: "Connecting to MQTT..." });
+            }
+            const url = `mqtt://${settings.host}:${settings.mqttPort}`;
+            let mqttRetryCount = 0;
+            while (true) {
+                if (this.stopConnecting && mqttRetryCount > 0) {
+                    console.log("MQTT connection stopped by resetInstance()");
+                    this.stopConnecting = false; // reset for future connections
+                    break;
+                }
+                try {
+                    mqttRetryCount++;
+                    if (statusCallback) {
+                        statusCallback({ fill: "yellow", shape: "dot", text: `Connecting to MQTT... (attempt ${mqttRetryCount})` });
+                    }
+                    // console.log("Attempting MQTT connection with clientId:", settings.clientId, ", clientSecret:", settings.clientSecret, " at", settings.host + ":" + settings.mqttPort);
+                    instance.client = yield mqtt_1.default.connectAsync(url, {
+                        protocolVersion: 5,
+                        clientId: settings.clientId,
+                        username: settings.clientId,
+                        password: settings.clientSecret,
+                    });
+                    instance.attachMessageListener();
+                    // console.log("MQTT connection established successfully");
+                    if (statusCallback) {
+                        statusCallback({ fill: "green", shape: "dot", text: "MQTT Connected" });
+                    }
+                    break;
+                }
+                catch (error) {
+                    console.error(`Failed to connect to MQTT ${url}. Attempt ${mqttRetryCount}:`, error.toString());
+                    if (statusCallback) {
+                        statusCallback({ fill: "red", shape: "ring", text: `(${mqttRetryCount}): ${error.toString()}. Retrying in 5s...` });
+                    }
+                    yield new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds before retrying
+                }
+            }
+            return instance;
+        });
+    }
+    // Method to reset the instance
+    static resetInstance() {
+        if (this.instance && this.instance.client) {
+            this.instance.client.end();
+        }
+        this.instance = null;
+        this.instancePromise = null;
+        this.stopConnecting = true;
+    }
+    // Adds a topic and handler to the subscribed list
+    addTopicHandler(topic, handler) {
+        try {
+            this.subscribedTopics.push({ topic, handler });
+            // console.log("New Subscription Handler : ", topic)
+            this.client.subscribe(topic, { qos: 2 }, (err) => {
+                if (err) {
+                    console.error(`Failed to subscribe to topic ${topic}:`, err);
+                }
+            });
+        }
+        catch (e) {
+            console.error(`Failed to subscribe to topic ${topic}:`, e);
+        }
+    }
+    // Publishes a message to a specific topic
+    publish(topic, message) {
+        try {
+            const payload = JSON.stringify(message);
+            // console.log("Publishing to ", topic, ", with payload : ", payload)
+            this.client.publish(topic, payload, {
+                qos: 2, retain: true,
+                properties: {
+                    contentType: "json",
+                }
+            }, (err) => {
+                if (err) {
+                    console.error(`Failed to publish message to ${topic}:`, err);
+                }
+            });
+        }
+        catch (e) {
+            console.error(`Failed to Publish to topic ${topic}:`, e);
+            throw e;
+        }
+        return false;
+    }
+    attachMessageListener() {
+        this.client.on('message', (topic, message, packet) => {
+            for (const subscribedTopic of this.subscribedTopics) {
+                if (this.matchesTopic(subscribedTopic.topic, topic)) {
+                    const parsedMessage = this.parseMessage(message, topic);
+                    subscribedTopic.handler(parsedMessage, packet.retain);
+                    break;
+                }
+            }
+        });
+    }
+    // Matches MQTT topic patterns with wildcards (+ for single level, # for multi-level)
+    matchesTopic(pattern, topic) {
+        // Handle exact match first for performance
+        if (pattern === topic) {
+            return true;
+        }
+        const patternParts = pattern.split('/');
+        const topicParts = topic.split('/');
+        let i = 0;
+        let j = 0;
+        while (i < patternParts.length && j < topicParts.length) {
+            const patternPart = patternParts[i];
+            if (patternPart === '#') {
+                // Multi-level wildcard matches everything from this point
+                return true;
+            }
+            else if (patternPart === '+') {
+                // Single-level wildcard matches any single level
+                i++;
+                j++;
+            }
+            else if (patternPart === topicParts[j]) {
+                // Exact match
+                i++;
+                j++;
+            }
+            else {
+                // No match
+                return false;
+            }
+        }
+        // Check if we've consumed both pattern and topic completely
+        return i === patternParts.length && j === topicParts.length;
+    }
+    parseMessage(message, topic) {
+        try {
+            return JSON.parse(message.toString());
+        }
+        catch (error) {
+            console.warn("Failed to parse message as JSON '" + topic + "' : ", message.toString());
+            return message.toString();
+        }
+    }
+}
+exports.MQTTService = MQTTService;
+MQTTService.instancePromise = null;
+MQTTService.stopConnecting = false;

package/dist/nodes/bulk-tag-write.html

@@ -0,0 +1,91 @@
+<script type="text/javascript">
+  RED.nodes.registerType('machhub.bulk.tag.write', {
+    category: 'MACHHUB',
+    color: '#c777f1',
+    defaults: {
+      name: { value: "" },
+      useConfigNode: { value: false }, // Toggle between JSON file and config node
+      machhub: { value: "", type: "machhub-config" }
+    },
+    paletteLabel: "Bulk Tag Write",
+    inputs: 1,
+    icon: "font-awesome/fa-tags",
+    label: function () {
+      return this.name ? "[BW] " + this.name : "Bulk Tag Write";
+    },
+
+    oneditprepare: async function () {
+      let node = this;
+      const $machhub = $("#node-input-machhub");
+      const $useConfigNode = $("#node-input-useConfigNode");
+      const $configRow = $("#config-node-row");
+
+      // Toggle config node visibility based on checkbox
+      function toggleConfigNode() {
+        if ($useConfigNode.is(":checked")) {
+          $configRow.show();
+        } else {
+          $configRow.hide();
+        }
+      }
+
+      // Initialize visibility
+      toggleConfigNode();
+
+      // Handle checkbox change
+      $useConfigNode.on("change", toggleConfigNode);
+
+      const machhubNodes = [];
+      RED.nodes.eachConfig(function (n) {
+        if (n.type === "machhub-config") {
+          machhubNodes.push(n);
+        }
+      });
+
+      // Auto-select the first MACHHUB config node if none is selected
+      if (!node.machhub && machhubNodes.length > 0) {
+        node.machhub = machhubNodes[0].id;
+        $machhub.val(node.machhub);
+      } else {
+        $machhub.val(node.machhub);
+      }
+    },
+
+    oneditsave: function () {
+      this.useConfigNode = $("#node-input-useConfigNode").is(":checked");
+      this.machhub = $("#node-input-machhub").val();
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="machhub.bulk.tag.write">
+  <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-useConfigNode" style="width: auto; padding-right: 10px;">
+      <i class="fa fa-cog"></i> Use Config Node
+    </label>
+    <input type="checkbox" id="node-input-useConfigNode" style="width: auto; margin: 0;">
+    <span style="margin-left: 10px; color: #999; font-size: 11px; font-style: italic;">
+      (leave unchecked to use machhub.env.json)
+    </span>
+  </div>
+  <div class="form-row" id="config-node-row">
+    <label for="node-input-machhub"><i class="fa fa-server"></i> Config</label>
+    <input type="text" id="node-input-machhub">
+  </div>
+</script>
+
+<script type="text/html" data-help-name="machhub.bulk.tag.write">
+  <p>This node performs a bulk write operation to multiple selected tags in MACHHUB.</p>
+  <p>Provide an input where <code>msg.payload</code> is a JSON object containing key-value pairs. Each key should be the full tag path (e.g., <code>Namespace/Folder/Tag</code>), and each value is the data to be written to that tag.</p>
+  <p><strong>Example:</strong></p>
+  <pre>
+msg.payload = {
+  "Namespace1/FolderA/Tag1": 123,
+  "Namespace1/FolderA/Tag2": 12
+}
+  </pre>
+</script>

package/dist/nodes/bulk-tag-write.js

@@ -0,0 +1,118 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const mqtt_service_1 = require("../lib/services/mqtt.service");
+const machhub_env_loader_1 = require("../lib/config/machhub-env-loader");
+function default_1(RED) {
+    function BulkTagWriteNode(config) {
+        RED.nodes.createNode(this, config);
+        var node = this;
+        let mqttService = null;
+        let isInitializing = false;
+        let initializationPromise = null;
+        node.useConfigNode = config.useConfigNode || false;
+        // Determine configuration source
+        let machhubConfig;
+        if (node.useConfigNode) {
+            // Use config node
+            machhubConfig = RED.nodes.getNode(config.machhub);
+            if (!machhubConfig) {
+                // Fallback: try to find any available config node
+                const allConfigs = [];
+                RED.nodes.eachNode((configNode) => {
+                    if (configNode.type === "machhub-config") {
+                        allConfigs.push(configNode);
+                    }
+                });
+                if (allConfigs.length > 0) {
+                    machhubConfig = allConfigs[0];
+                    node.machhub = machhubConfig.id;
+                }
+                else {
+                    node.status({ fill: "red", shape: "ring", text: "No MACHHUB config node available" });
+                    node.error("No MACHHUB config node available");
+                    return;
+                }
+            }
+        }
+        else {
+            // Use machhub.env.json
+            try {
+                machhubConfig = machhub_env_loader_1.MachhubEnvLoader.loadConfig(RED.settings.userDir);
+            }
+            catch (error) {
+                node.status({ fill: "red", shape: "ring", text: "Failed to load machhub.env.json: " + error.message });
+                node.error("Failed to load machhub.env.json: " + error.message);
+                return;
+            }
+        }
+        node.on('close', () => {
+            mqtt_service_1.MQTTService.resetInstance();
+            mqttService = null;
+            initializationPromise = null;
+        });
+        node.on('input', function (msg) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    node.status({ fill: "orange", shape: "dot", text: "Sending Payload" });
+                    // Wait for initialization if still in progress
+                    if (isInitializing && initializationPromise) {
+                        yield initializationPromise;
+                    }
+                    // Check if mqttService is initialized
+                    if (!mqttService) {
+                        node.status({ fill: "red", shape: "dot", text: "MQTT service not initialized" });
+                        return;
+                    }
+                    Object.keys(msg.payload).forEach(function (key) {
+                        try {
+                            mqttService.publish(key, msg.payload[key]);
+                        }
+                        catch (error) {
+                            node.status({ fill: "red", shape: "dot", text: "Failed to publish to '" + key + "':  " + error.toString() });
+                        }
+                    });
+                    node.status({ fill: "green", shape: "dot", text: "Payload successfully sent to all tags." });
+                }
+                catch (error) {
+                    node.status({ fill: "red", shape: "dot", text: "Error setting up MQTT: " + error.toString() });
+                }
+            });
+        });
+        // Initialize MQTT service
+        initializationPromise = (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                isInitializing = true;
+                node.status({ fill: "yellow", shape: "dot", text: "Connecting..." });
+                // Use MACHHUB config to get MQTT service with status callback
+                while (true) {
+                    // console.log("Getting MQTT instance");
+                    mqttService = yield mqtt_service_1.MQTTService.getInstance(machhubConfig, (status) => {
+                        node.status(status);
+                    });
+                    // console.log("MQTT Service obtained client:", mqttService.client);
+                    if (mqttService.client) {
+                        break;
+                    }
+                }
+                node.status({ fill: "green", shape: "dot", text: "Ready to publish" });
+            }
+            catch (error) {
+                node.status({ fill: "red", shape: "dot", text: "Error setting up MQTT: " + error.toString() });
+            }
+            finally {
+                isInitializing = false;
+            }
+        }))();
+    }
+    RED.nodes.registerType("machhub.bulk.tag.write", BulkTagWriteNode);
+}