fix: Wait until integration is loaded before attempting to register e…

…ntities

With version HA 0.111.0 websocket connects before all integrations are
loaded. This puts checks in place to wait until the NR integration is
loaded before attempting to register entities.

Closes #247

lib/base-node.js

@@ -265,6 +265,13 @@ class BaseNode {
         );
     }
 
+    get isIntegrationLoaded() {
+        return (
+            this.websocketClient.isConnected &&
+            this.websocketClient.isIntegrationLoaded
+        );
+    }
+
     getPrettyDate() {
         return new Date().toLocaleDateString('en-US', {
             month: 'short',

lib/events-ha-node.js

@@ -40,7 +40,7 @@ class EventsHaNode extends EventsNode {
     async init() {
         await this.loadPersistedData();
 
-        if (this.isConnected) {
+        if (this.isIntegrationLoaded) {
             this.registerEntity();
             this.removeFromHomeAssistant();
         }
@@ -50,7 +50,10 @@ class EventsHaNode extends EventsNode {
         super.onClose(removed);
 
         if (removed) {
-            if (this.isConnected && this.nodeConfig.exposeToHomeAssistant) {
+            if (
+                this.isIntegrationLoaded &&
+                this.nodeConfig.exposeToHomeAssistant
+            ) {
                 this.removeFromHomeAssistant(true);
             }
             await this.removeNodeData();
@@ -59,17 +62,16 @@ class EventsHaNode extends EventsNode {
         this.removeSubscription();
     }
 
-    async onHaConfigUpdate() {
-        this.registerEntity();
-        this.removeFromHomeAssistant();
-    }
-
-    onHaIntegration(type) {
+    async onHaIntegration(type) {
         if (type === 'loaded') {
-            this.registerEntity();
+            if (this.registered) {
+                // Update the state of exposed nodes because when the HA client
+                // resubscribes it registers the entity with the original state
+                setTimeout(() => this.updateHomeAssistant(), 300);
+            }
+            await this.registerEntity();
         } else if (type === 'unloaded') {
             this.isEnabled = true;
-            this.registered = false;
             if (this.subscription) {
                 this.subscription();
                 this.subscription = null;

lib/events-node.js

@@ -82,15 +82,15 @@ class EventsNode extends BaseNode {
         if (err.message) this.error(err.message);
     }
 
-    onHaConfigUpdate() {
-        this.registerEntity();
-    }
-
     onHaIntegration(type) {
-        if (type === 'loaded') {
-            this.registerEntity();
-        } else if (type === 'unloaded') {
-            this.registered = false;
+        switch (type) {
+            case 'loaded':
+            case 'notloaded':
+                this.registerEntity();
+                break;
+            case 'unloaded':
+                this.registered = false;
+                break;
         }
     }
 

lib/ha-websocket.js

@@ -9,6 +9,10 @@ const MSG_TYPE_AUTH_REQUIRED = 'auth_required';
 const MSG_TYPE_AUTH_INVALID = 'auth_invalid';
 const MSG_TYPE_AUTH_OK = 'auth_ok';
 const connectionStates = ['CONNECTING', 'CONNECTED', 'DISCONNECTED', 'ERROR'];
+const INTEGRATION_EVENT = 'nodered';
+const INTEGRATION_NOT_LOADED = 'notloaded';
+const INTEGRATION_LOADED = 'loaded';
+const INTEGRATION_UNLOADED = 'unloaded';
 
 class HaWebsocket extends EventEmitter {
     constructor(config) {
@@ -47,6 +51,10 @@ class HaWebsocket extends EventEmitter {
         return HaWebsocket.ERROR;
     }
 
+    get isIntegrationLoaded() {
+        return this.integrationVersion !== 0;
+    }
+
     async connect() {
         this.client = await homeassistant
             .createConnection({
@@ -104,6 +112,11 @@ class HaWebsocket extends EventEmitter {
         this.onStatesLoadedAndRunning();
 
         // Home Assistant Events
+        await this.client.subscribeEvents(
+            (evt) => this.integrationEvent(evt),
+            INTEGRATION_EVENT
+        );
+
         homeassistant.subscribeConfig(this.client, (config) =>
             this.onClientConfigUpdate(config)
         );
@@ -125,6 +138,27 @@ class HaWebsocket extends EventEmitter {
         if (!this.isHomeAssistantRunning) {
             this.isHomeAssistantRunning = true;
             this.emit('ha_client:running');
+            if (!this.isIntegrationLoaded) {
+                this.createIntegrationEvent(INTEGRATION_NOT_LOADED);
+            }
+        }
+    }
+
+    integrationEvent(evt) {
+        const oldVersion = this.integrationVersion;
+        switch (evt.data.type) {
+            case INTEGRATION_LOADED:
+                this.integrationVersion = evt.data.version;
+                break;
+            case INTEGRATION_UNLOADED:
+                this.integrationVersion = 0;
+                break;
+            case INTEGRATION_NOT_LOADED:
+                this.emit(`integration`, evt.data.type);
+                return;
+        }
+        if (oldVersion !== this.integrationVersion) {
+            this.emit(`integration`, evt.data.type);
         }
     }
 
@@ -169,7 +203,6 @@ class HaWebsocket extends EventEmitter {
 
         // Always need the state_changed event
         currentEvents.add('state_changed');
-        currentEvents.add('nodered');
 
         const add = new Set(
             [...currentEvents].filter((x) => !this.subscribedEvents.has(x))
@@ -240,16 +273,6 @@ class HaWebsocket extends EventEmitter {
             const eventType = msg.event_type;
             const entityId = msg.data && msg.data.entity_id;
 
-            if (eventType === 'nodered') {
-                if (msg.data.type === 'loaded') {
-                    this.integrationVersion = msg.data.version;
-                } else if (msg.data.type === 'unloaded') {
-                    this.integrationVersion = 0;
-                }
-                this.emit(`integration`, msg.data.type);
-                return;
-            }
-
             const emitEvent = {
                 event_type: eventType,
                 entity_id: entityId,
@@ -293,12 +316,22 @@ class HaWebsocket extends EventEmitter {
             this.integrationVersion === 0
         ) {
             try {
-                this.integrationVersion = await this.send({
-                    type: 'nodered/version',
-                });
+                const version = await this.getIntegrationVersion();
+                this.createIntegrationEvent(INTEGRATION_LOADED, version);
             } catch (e) {}
         }
-        this.emit('ha_events:config_update');
+    }
+
+    async getIntegrationVersion() {
+        return this.send({
+            type: 'nodered/version',
+        });
+    }
+
+    createIntegrationEvent(type, version) {
+        this.integrationEvent({
+            data: { type, version },
+        });
     }
 
     onClientOpen() {

nodes/entity/entity.js

@@ -42,13 +42,6 @@ module.exports = function (RED) {
     class EntityNode extends EventsHaNode {
         constructor(nodeDefinition) {
             super(nodeDefinition, RED, nodeOptions);
-            this.registered = false;
-
-            this.init();
-        }
-
-        async init() {
-            await this.loadPersistedData();
         }
 
         setConnectionStatus(additionalText) {
@@ -124,11 +117,9 @@ module.exports = function (RED) {
         onHaEventsClose() {
             super.onHaEventsClose();
 
-            this.registered = false;
-        }
-
-        async onConfigUpdate() {
-            this.registerEntity();
+            if (this.nodeConfig.entityType !== 'switch') {
+                this.registered = false;
+            }
         }
 
         onHaIntegration(type) {
@@ -148,7 +139,7 @@ module.exports = function (RED) {
             if (
                 this.nodeConfig.entityType !== 'switch' &&
                 this.registered &&
-                this.isConnected &&
+                this.isIntegrationLoaded &&
                 removed
             ) {
                 const payload = {

nodes/webhook/webhook.js

@@ -22,7 +22,7 @@ module.exports = function (RED) {
         constructor(nodeDefinition) {
             super(nodeDefinition, RED, nodeOptions);
 
-            if (this.isConnected) {
+            if (this.isIntegrationLoaded) {
                 this.registerEntity();
             }
         }