homey-api 3.17.4 → 3.17.5

package/lib/HomeyAPI/HomeyAPIV3/Item.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const EventEmitter = require('../../EventEmitter');
+const RealtimeConsumer = require('./RealtimeConsumer');
 
 /**
  * A superclass for all CRUD Items.
@@ -61,6 +62,37 @@ class Item extends EventEmitter {
       writable: true,
     });
 
+    this.__realtimeConsumer = new RealtimeConsumer({
+      subscribe: (uri, handlers) => this.homey.subscribe(uri, handlers),
+      getUri: () => this.uri,
+      debug: (...props) => this.__debug(...props),
+      setConnected: (connected) => {
+        this.__connected = connected;
+      },
+      onConnect: () => {
+        this.onConnect();
+      },
+      onDisconnect: () => {
+        this.onDisconnect();
+      },
+      onReconnect: () => {
+        this.onReconnect();
+      },
+      onEvent: (event, data) => {
+        if (event === 'update') {
+          this.__update(this.constructor.transformGet({ ...data }));
+          return;
+        }
+
+        if (event === 'delete') {
+          this.__delete();
+          return;
+        }
+
+        this.emit(event, data);
+      },
+    });
+
     // Set Properties
     for (const [key, value] of Object.entries(properties)) {
       if (key === 'id') continue;
@@ -93,7 +125,7 @@ class Item extends EventEmitter {
     this.manager.__debug(`[${this.constructor.name}:${this.id}]`, ...props);
   }
 
-  __update(properties) {
+  __update(properties, { emitEvent = true } = {}) {
     for (const [key, value] of Object.entries(properties)) {
       if (key === 'id') continue;
       this[key] = value;
@@ -101,7 +133,9 @@ class Item extends EventEmitter {
 
     this.__lastUpdated = new Date();
 
-    this.emit('update', properties);
+    if (emitEvent) {
+      this.emit('update', properties);
+    }
   }
 
   __delete() {
@@ -113,91 +147,14 @@ class Item extends EventEmitter {
    * Connect to this item's Socket.io namespace.
    */
   async connect() {
-    this.__debug('connect');
-
-    // If disconnecting, await that first
-    try {
-      // Ensure all microtasks are done first. E.g. if disconnect is called in the same tick as
-      // connect. This way the disconnect is always started first so we can await the disconnect
-      // promise before we try to connect again.
-      await Promise.resolve();
-      await this.__disconnectPromise;
-      // eslint-disable-next-line no-empty
-    } catch (err) { }
-
-    this.__connectPromise = Promise.resolve().then(async () => {
-      if (!this.io) {
-        this.io = this.homey.subscribe(this.uri, {
-          onConnect: () => {
-            this.__debug('onConnect');
-            this.__connected = true;
-
-            this.onConnect();
-          },
-          onDisconnect: () => {
-            this.__debug('onDisconnect');
-            this.__connected = false;
-
-            this.onDisconnect();
-          },
-          onReconnect: () => {
-            this.__debug('onDisconnect');
-
-            this.onReconnect();
-          },
-          onEvent: (event, data) => {
-            this.__debug('onEvent', event, data);
-
-            this.emit(event, data);
-          },
-        });
-      }
-
-      await this.io;
-    });
-
-    // Delete the connecting Promise
-    this.__connectPromise
-      .catch(() => { })
-      .finally(() => {
-        delete this.__connectPromise;
-      });
-
-    await this.__connectPromise;
+    await this.__realtimeConsumer.connect();
   }
 
   /**
    * Discconnect from this item's Socket.io namespace.
    */
   async disconnect() {
-    this.__debug('disconnect');
-
-    // If connecting, await that first
-    try {
-      await this.__connectPromise;
-      // eslint-disable-next-line no-empty
-    } catch (err) { }
-
-    this.__disconnectPromise = Promise.resolve().then(async () => {
-      this.__connected = false;
-
-      if (this.io) {
-        this.io
-          .then((io) => io.unsubscribe())
-          .catch((err) => this.__debug('Error Disconnecting:', err));
-      }
-    });
-
-    // Delete the disconnecting Promise
-    this.__disconnectPromise
-      .catch(() => { })
-      .finally(() => {
-        delete this.__disconnectPromise;
-        // Delete this.io so connect can start new connections.
-        delete this.io;
-      });
-
-    await this.__disconnectPromise;
+    await this.__realtimeConsumer.disconnect();
   }
 
   onConnect() {

package/lib/HomeyAPI/HomeyAPIV3/Manager.js

@@ -2,8 +2,8 @@
 
 const EventEmitter = require('../../EventEmitter');
 const Util = require('../../Util');
-const HomeyAPIError = require('../HomeyAPIError');
 const Item = require('./Item');
+const RealtimeConsumer = require('./RealtimeConsumer');
 
 /**
  * @class
@@ -87,6 +87,71 @@ class Manager extends EventEmitter {
       writable: false,
     });
 
+    this.__realtimeConsumer = new RealtimeConsumer({
+      subscribe: (uri, handlers) => this.homey.subscribe(uri, handlers),
+      getUri: () => this.uri,
+      debug: (...props) => this.__debug(...props),
+      setConnected: (connected) => {
+        this.__connected = connected;
+      },
+      onEvent: (event, data) => {
+        // Transform & add to cache if this is a CRUD event
+        if (event.endsWith('.create') || event.endsWith('.update') || event.endsWith('.delete')) {
+          const [itemId, operation] = event.split('.');
+          const itemName = this.itemNames[itemId];
+          const ItemClass = this.itemClasses[itemName];
+
+          switch (operation) {
+            case 'create': {
+              const props = ItemClass.transformGet(data);
+
+              const item = new ItemClass({
+                id: props.id,
+                homey: this.homey,
+                manager: this,
+                properties: props,
+              });
+              this.__cache[ItemClass.ID][props.id] = item;
+
+              this.emit(event, item);
+              return;
+            }
+            case 'update': {
+              const props = ItemClass.transformGet(data);
+
+              if (this.__cache[ItemClass.ID][props.id]) {
+                const item = this.__cache[ItemClass.ID][props.id];
+                item.__update(props);
+                this.emit(event, item);
+                return;
+              }
+
+              break;
+            }
+            case 'delete': {
+              const props = ItemClass.transformGet(data);
+
+              if (this.__cache[ItemClass.ID][props.id]) {
+                const item = this.__cache[ItemClass.ID][props.id];
+                item.__delete();
+                delete this.__cache[ItemClass.ID][item.id];
+                this.emit(event, {
+                  id: item.id,
+                });
+                return;
+              }
+
+              break;
+            }
+            default:
+              break;
+          }
+        }
+
+        this.emit(event, data);
+      },
+    });
+
     // Create methods
     for (const [operationId, operation] of Object.entries(operations)) {
       Object.defineProperty(
@@ -244,6 +309,7 @@ class Manager extends EventEmitter {
 
   async __request({ $cache, $updateCache, $timeout, $socket, operationId, operation, path, body, headers, shouldRetry, ...args }) {
     let result;
+    let hasSocketResult = false;
     const benchmark = Util.benchmark();
 
     // If connected to Socket.io,
@@ -273,47 +339,24 @@ class Manager extends EventEmitter {
     // If Homey is connected to Socket.io,
     // send the API request to socket.io.
     // This is about ~2x faster than HTTP
-    if (this.homey.isConnected() && $socket === true) {
-      result = await Util.timeout(
-        new Promise((resolve, reject) => {
-          this.__debug(`IO ${operationId}`);
-          this.homey.__homeySocket.emit(
-            'api',
-            {
-              args,
-              operation: operationId,
-              uri: this.uri,
-            },
-            (err, result) => {
-              if (err != null) {
-                if (typeof err === 'object') {
-                  err = new HomeyAPIError(
-                    {
-                      stack: err.stack,
-                      error: err.error,
-                      error_description: err.error_description,
-                    },
-                    err.statusCode || err.code || 500
-                  );
-                } else if (typeof err === 'string') {
-                  err = new HomeyAPIError(
-                    {
-                      error: err,
-                    },
-                    500
-                  );
-                }
-
-                return reject(err);
-              }
+    if ($socket === true && this.homey.isConnected()) {
+      try {
+        this.__debug(`IO ${operationId}`);
+        result = await this.homey.__apiRequest({
+          uri: this.uri,
+          operation: operationId,
+          args,
+          timeout: $timeout,
+        });
+        hasSocketResult = true;
+      } catch (err) {
+        if (err.code !== 'ERR_SOCKET_SESSION_NOT_READY') {
+          throw err;
+        }
+      }
+    }
 
-              return resolve(result);
-            }
-          );
-        }),
-        $timeout
-      );
-    } else {
+    if (!hasSocketResult) {
       // Get from HTTP
       result = await this.homey.call({
         $timeout,
@@ -396,7 +439,11 @@ class Manager extends EventEmitter {
 
           if (this.isConnected() && $updateCache === true && this.__cache[ItemClass.ID][props.id]) {
             item = this.__cache[ItemClass.ID][props.id];
-            item.__update(props);
+            item.__update(props, {
+              // Local mutation results update the cached item immediately, but the
+              // realtime manager event is responsible for the public update event.
+              emitEvent: false,
+            });
           } else {
             item = new ItemClass({
               id: props.id,
@@ -462,119 +509,7 @@ class Manager extends EventEmitter {
    * @returns {Promise<void>}
    */
   async connect() {
-    this.__debug('connect');
-
-    // If disconnecting, await that first
-    try {
-      await this.__disconnectPromise;
-      // eslint-disable-next-line no-empty
-    } catch (err) { }
-
-    if (this.__connectPromise) {
-      await this.__connectPromise;
-      return;
-    }
-
-    if (this.io) {
-      await this.io;
-      return;
-    }
-
-    this.__connectPromise = Promise.resolve().then(async () => {
-      if (!this.io) {
-        this.io = this.homey.subscribe(this.uri, {
-          onConnect: () => {
-            this.__debug('onConnect');
-            this.__connected = true;
-          },
-          onDisconnect: reason => {
-            this.__debug(`onDisconnect Reason:${reason}`);
-            this.__connected = false;
-
-            // Disable for now. We should probably only set the cache to invalid.
-
-            // Clear CRUD Item cache
-            // for (const itemId of Object.keys(this.__cache)) {
-            //   this.__cache[itemId] = {};
-            //   this.__cacheAllComplete[itemId] = false;
-            // }
-          },
-          onReconnect: () => {
-            this.__debug(`onReconnect`);
-            this.__connected = true;
-          },
-          onEvent: (event, data) => {
-            this.__debug('onEvent', event);
-
-            // Transform & add to cache if this is a CRUD event
-            if (event.endsWith('.create') || event.endsWith('.update') || event.endsWith('.delete')) {
-              const [itemId, operation] = event.split('.');
-              const itemName = this.itemNames[itemId];
-              const ItemClass = this.itemClasses[itemName];
-
-              switch (operation) {
-                case 'create': {
-                  const props = ItemClass.transformGet(data);
-
-                  const item = new ItemClass({
-                    id: props.id,
-                    homey: this.homey,
-                    manager: this,
-                    properties: props,
-                  });
-                  this.__cache[ItemClass.ID][props.id] = item;
-
-                  return this.emit(event, item);
-                }
-                case 'update': {
-                  const props = ItemClass.transformGet(data);
-
-                  if (this.__cache[ItemClass.ID][props.id]) {
-                    const item = this.__cache[ItemClass.ID][props.id];
-                    item.__update(props);
-                    return this.emit(event, item);
-                  }
-
-                  break;
-                }
-                case 'delete': {
-                  const props = ItemClass.transformGet(data);
-
-                  if (this.__cache[ItemClass.ID][props.id]) {
-                    const item = this.__cache[ItemClass.ID][props.id];
-                    item.__delete();
-                    delete this.__cache[ItemClass.ID][item.id];
-                    return this.emit(event, {
-                      id: item.id,
-                    });
-                  }
-
-                  break;
-                }
-                default:
-                  break;
-              }
-            }
-
-            // Fire event listeners
-            this.emit(event, data);
-          },
-        });
-      }
-
-      await this.io;
-    });
-
-    // Delete the connecting Promise
-    this.__connectPromise
-      .catch(() => {
-        delete this.io;
-      })
-      .finally(() => {
-        delete this.__connectPromise;
-      });
-
-    await this.__connectPromise;
+    await this.__realtimeConsumer.connect();
   }
 
   /**
@@ -582,32 +517,7 @@ class Manager extends EventEmitter {
    * @returns {Promise<void>}
    */
   async disconnect() {
-    this.__debug('disconnect');
-
-    // If connecting, await that first
-    try {
-      await this.__connectPromise;
-      // eslint-disable-next-line no-empty
-    } catch (err) { }
-
-    this.__disconnectPromise = Promise.resolve().then(async () => {
-      this.__connected = false;
-
-      if (this.io) {
-        await this.io.then(io => io.unsubscribe()).catch(err => this.__debug('Error Disconnecting:', err));
-
-        delete this.io;
-      }
-    });
-
-    // Delete the disconnecting Promise
-    this.__disconnectPromise
-      .catch(() => { })
-      .finally(() => {
-        delete this.__disconnectPromise;
-      });
-
-    await this.__disconnectPromise;
+    await this.__realtimeConsumer.disconnect();
   }
 
   /**

package/lib/HomeyAPI/HomeyAPIV3/RealtimeConsumer.js

@@ -0,0 +1,140 @@
+'use strict';
+
+class RealtimeConsumer {
+  constructor({
+    subscribe,
+    getUri,
+    debug,
+    onConnect = () => {},
+    onDisconnect = () => {},
+    onReconnect = () => {},
+    onReconnectError = () => {},
+    onEvent = () => {},
+    setConnected = () => {},
+  }) {
+    this.__subscribe = subscribe;
+    this.__getUri = getUri;
+    this.__debug = debug;
+    this.__onConnect = onConnect;
+    this.__onDisconnect = onDisconnect;
+    this.__onReconnect = onReconnect;
+    this.__onReconnectError = onReconnectError;
+    this.__onEvent = onEvent;
+    this.__setConnected = setConnected;
+
+    this.__subscriptionPromise = null;
+    this.__connectPromise = null;
+    this.__disconnectPromise = null;
+  }
+
+  async connect() {
+    this.__debug('connect');
+
+    try {
+      await Promise.resolve();
+      await this.__disconnectPromise;
+      // eslint-disable-next-line no-empty
+    } catch (err) {}
+
+    if (this.__connectPromise) {
+      await this.__connectPromise;
+      return;
+    }
+
+    if (this.__subscriptionPromise) {
+      await this.__subscriptionPromise;
+      return;
+    }
+
+    const connectPromise = Promise.resolve().then(async () => {
+      if (!this.__subscriptionPromise) {
+        this.__subscriptionPromise = Promise.resolve(
+          this.__subscribe(this.__getUri(), {
+            onConnect: () => {
+              this.__debug('onConnect');
+              this.__setConnected(true);
+              this.__onConnect();
+            },
+            onDisconnect: (reason) => {
+              this.__debug(`onDisconnect Reason:${reason}`);
+              this.__setConnected(false);
+              this.__onDisconnect(reason);
+            },
+            onReconnect: () => {
+              this.__debug('onReconnect');
+              this.__setConnected(true);
+              this.__onReconnect();
+            },
+            onReconnectError: (err) => {
+              this.__debug('onReconnectError', err.message);
+              this.__onReconnectError(err);
+            },
+            onEvent: (event, data) => {
+              this.__debug('onEvent', event, data);
+              this.__onEvent(event, data);
+            },
+          })
+        );
+      }
+
+      await this.__subscriptionPromise;
+    });
+
+    this.__connectPromise = connectPromise;
+
+    connectPromise
+      .catch(() => {
+        this.__subscriptionPromise = null;
+      })
+      .finally(() => {
+        if (this.__connectPromise === connectPromise) {
+          this.__connectPromise = null;
+        }
+      });
+
+    await connectPromise;
+  }
+
+  async disconnect() {
+    this.__debug('disconnect');
+
+    try {
+      await this.__connectPromise;
+      // eslint-disable-next-line no-empty
+    } catch (err) {}
+
+    if (this.__disconnectPromise) {
+      await this.__disconnectPromise;
+      return;
+    }
+
+    const disconnectPromise = Promise.resolve().then(async () => {
+      this.__setConnected(false);
+
+      // A failed connect clears __subscriptionPromise in connect(). In that case
+      // disconnect() becomes a safe no-op because there is no subscription handle
+      // left to unsubscribe.
+      if (this.__subscriptionPromise) {
+        await this.__subscriptionPromise
+          .then((subscription) => subscription.unsubscribe())
+          .catch((err) => this.__debug('Error Disconnecting:', err));
+      }
+    });
+
+    this.__disconnectPromise = disconnectPromise;
+
+    disconnectPromise
+      .catch(() => {})
+      .finally(() => {
+        if (this.__disconnectPromise === disconnectPromise) {
+          this.__disconnectPromise = null;
+        }
+
+        this.__subscriptionPromise = null;
+      });
+
+    await disconnectPromise;
+  }
+}
+
+module.exports = RealtimeConsumer;