@machhub-dev/node-red-nodes 1.0.9-test → 1.0.10-test

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

@@ -15,11 +15,13 @@ 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" });
                 }
@@ -39,6 +41,7 @@ class MQTTService {
             this.instancePromise = this.createInstance(settings, statusCallback);
             try {
                 this.instance = yield this.instancePromise;
+                this.instancePromise = null; // Clear so future calls re-evaluate fresh state
                 return this.instance;
             }
             catch (error) {
@@ -106,17 +109,8 @@ class MQTTService {
                         clientId: settings.clientId,
                         username: settings.clientId,
                         password: settings.clientSecret,
-                        reconnectPeriod: 0, // disable MQTT.js auto-reconnect; we manage reconnection via getInstance()
                     });
                     instance.attachMessageListener();
-                    // Re-subscribe any topics registered before this connection was established
-                    for (const sub of MQTTService.subscribedTopics) {
-                        instance.client.subscribe(sub.topic, { qos: 2 }, (err) => {
-                            if (err) {
-                                console.error(`Failed to re-subscribe to topic ${sub.topic}:`, err);
-                            }
-                        });
-                    }
                     // console.log("MQTT connection established successfully");
                     if (statusCallback) {
                         statusCallback({ fill: "green", shape: "dot", text: "MQTT Connected" });
@@ -134,22 +128,19 @@ class MQTTService {
             return instance;
         });
     }
-    // Method to reset the instance and all state (full shutdown / redeploy)
+    // Method to reset the instance
     static resetInstance() {
-        const inst = this.instance;
-        // Clear references first so the 'close' event handler guard doesn't re-null unnecessarily
+        if (this.instance && this.instance.client) {
+            this.instance.client.end();
+        }
         this.instance = null;
         this.instancePromise = null;
         this.stopConnecting = true;
-        this.subscribedTopics = [];
-        if (inst && inst.client) {
-            inst.client.end();
-        }
     }
     // Adds a topic and handler to the subscribed list
     addTopicHandler(topic, handler) {
         try {
-            MQTTService.subscribedTopics.push({ topic, handler });
+            this.subscribedTopics.push({ topic, handler });
             // console.log("New Subscription Handler : ", topic)
             this.client.subscribe(topic, { qos: 2 }, (err) => {
                 if (err) {
@@ -161,23 +152,6 @@ class MQTTService {
             console.error(`Failed to subscribe to topic ${topic}:`, e);
         }
     }
-    // Removes a topic handler and unsubscribes from the broker if no other handler covers the same topic
-    removeTopicHandler(topic, handler) {
-        MQTTService.subscribedTopics = MQTTService.subscribedTopics.filter(st => !(st.topic === topic && st.handler === handler));
-        const stillSubscribed = MQTTService.subscribedTopics.some(st => st.topic === topic);
-        if (!stillSubscribed) {
-            try {
-                this.client.unsubscribe(topic, (err) => {
-                    if (err) {
-                        console.error(`Failed to unsubscribe from topic ${topic}:`, err);
-                    }
-                });
-            }
-            catch (e) {
-                console.error(`Failed to unsubscribe from topic ${topic}:`, e);
-            }
-        }
-    }
     // Publishes a message to a specific topic
     publish(topic, message) {
         try {
@@ -202,7 +176,7 @@ class MQTTService {
     }
     attachMessageListener() {
         this.client.on('message', (topic, message, packet) => {
-            for (const subscribedTopic of MQTTService.subscribedTopics) {
+            for (const subscribedTopic of this.subscribedTopics) {
                 if (this.matchesTopic(subscribedTopic.topic, topic)) {
                     const parsedMessage = this.parseMessage(message, topic);
                     subscribedTopic.handler(parsedMessage, packet.retain);
@@ -210,14 +184,6 @@ class MQTTService {
                 }
             }
         });
-        // When the broker closes the connection (e.g. session expired), self-reset so the
-        // next getInstance() call creates a fresh client with an empty in-flight store.
-        this.client.on('close', () => {
-            if (MQTTService.instance === this) {
-                MQTTService.instance = null;
-                MQTTService.instancePromise = null;
-            }
-        });
     }
     // Matches MQTT topic patterns with wildcards (+ for single level, # for multi-level)
     matchesTopic(pattern, topic) {
@@ -266,4 +232,3 @@ class MQTTService {
 exports.MQTTService = MQTTService;
 MQTTService.instancePromise = null;
 MQTTService.stopConnecting = false;
-MQTTService.subscribedTopics = [];

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

@@ -56,6 +56,7 @@ function default_1(RED) {
             }
         }
         node.on('close', () => {
+            mqtt_service_1.MQTTService.resetInstance();
             mqttService = null;
             initializationPromise = null;
         });
@@ -63,13 +64,18 @@ function default_1(RED) {
             return __awaiter(this, void 0, void 0, function* () {
                 try {
                     node.status({ fill: "orange", shape: "dot", text: "Sending Payload" });
-                    // Always fetch the current instance so we recover transparently after reconnects
-                    const service = yield mqtt_service_1.MQTTService.getInstance(machhubConfig, (status) => {
-                        node.status(status);
-                    });
+                    // 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 {
-                            service.publish(key, msg.payload[key]);
+                            mqttService.publish(key, msg.payload[key]);
                         }
                         catch (error) {
                             node.status({ fill: "red", shape: "dot", text: "Failed to publish to '" + key + "':  " + error.toString() });
@@ -88,16 +94,9 @@ function default_1(RED) {
                 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;
-                    }
-                }
+                mqttService = yield mqtt_service_1.MQTTService.getInstance(machhubConfig, (status) => {
+                    node.status(status);
+                });
                 node.status({ fill: "green", shape: "dot", text: "Ready to publish" });
             }
             catch (error) {

package/dist/nodes/tag-read.js

@@ -61,36 +61,22 @@ function default_1(RED) {
             isRetained: false,
             payload: undefined
         };
-        let mqttService = null;
-        let topicHandler = null;
         node.on('close', function () {
-            if (topicHandler && mqttService) {
-                mqttService.removeTopicHandler(node.selectedTag, topicHandler);
-            }
-            mqttService = null;
-            topicHandler = null;
+            mqtt_service_1.MQTTService.resetInstance();
         });
         (() => __awaiter(this, void 0, void 0, function* () {
             try {
                 node.status({ fill: "yellow", shape: "dot", text: "Connecting..." });
                 // Use MACHHUB config from machhub.env.json 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;
-                    }
-                }
-                topicHandler = (message, isRetained) => {
+                const mqttService = yield mqtt_service_1.MQTTService.getInstance(machhubConfig, (status) => {
+                    node.status(status);
+                });
+                mqttService.addTopicHandler(node.selectedTag, (message, isRetained) => {
                     msg.payload = message;
                     msg.isRetained = isRetained;
                     node.send(msg);
                     node.status({ fill: "green", shape: "dot", text: "Payload Received" });
-                };
-                mqttService.addTopicHandler(node.selectedTag, topicHandler);
+                });
                 node.status({ fill: "green", shape: "dot", text: "MQTT Listening" });
             }
             catch (error) {

package/dist/nodes/tag-write.js

@@ -58,17 +58,23 @@ function default_1(RED) {
             }
         }
         node.on('close', () => {
+            mqtt_service_1.MQTTService.resetInstance();
             mqttService = null;
             initializationPromise = null;
         });
         node.on('input', (msg) => __awaiter(this, void 0, void 0, function* () {
             try {
                 node.status({ fill: "orange", shape: "dot", text: "Sending Payload" });
-                // Always fetch the current instance so we recover transparently after reconnects
-                const service = yield mqtt_service_1.MQTTService.getInstance(machhubConfig, (status) => {
-                    node.status(status);
-                });
-                yield service.publish(node.selectedTag, msg.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;
+                }
+                yield mqttService.publish(node.selectedTag, msg.payload);
                 node.status({ fill: "green", shape: "dot", text: "Payload Sent" });
             }
             catch (err) {
@@ -80,16 +86,9 @@ function default_1(RED) {
             try {
                 isInitializing = true;
                 node.status({ fill: "yellow", shape: "dot", text: "Connecting..." });
-                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;
-                    }
-                }
+                mqttService = yield mqtt_service_1.MQTTService.getInstance(machhubConfig, (status) => {
+                    node.status(status);
+                });
                 node.status({ fill: "green", shape: "dot", text: "Ready to publish" });
             }
             catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@machhub-dev/node-red-nodes",
-  "version": "1.0.9-test",
+  "version": "1.0.10-test",
   "description": "Node-RED API for MACHHUB EDGE",
   "scripts": {
     "build": "yarn clean && npx tsc && yarn copy-files",