homey-api 3.17.4 → 3.17.6

package/lib/HomeyAPI/HomeyAPIV3.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const SocketIOClient = require('socket.io-client');
 const Util = require('../Util');
 const HomeyAPI = require('./HomeyAPI');
 const HomeyAPIError = require('./HomeyAPIError');
@@ -14,6 +13,8 @@ const ManagerUsers = require('./HomeyAPIV3/ManagerUsers');
 const ManagerZones = require('./HomeyAPIV3/ManagerZones');
 const DiscoveryManager = require('./HomeyAPIV3/DiscoveryManager');
 const Manager = require('./HomeyAPIV3/Manager');
+const SocketSession = require('./HomeyAPIV3/SocketSession');
+const SubscriptionRegistry = require('./HomeyAPIV3/SubscriptionRegistry');
 
 /**
  * An authenticated Homey API. Do not construct this class manually.
@@ -118,6 +119,13 @@ class HomeyAPIV3 extends HomeyAPI {
     });
 
     this.__discoveryManager = new DiscoveryManager(this);
+    this.__socketSession = new SocketSession(this);
+    this.__subscriptionRegistry = new SubscriptionRegistry({
+      homey: this,
+      session: this.__socketSession,
+    });
+
+    this.__bindSocketSessionEvents();
 
     this.generateManagersFromSpecification();
   }
@@ -143,6 +151,31 @@ class HomeyAPIV3 extends HomeyAPI {
     return this.__strategyId;
   }
 
+  get __socket() {
+    return this.__socketSession.socket;
+  }
+
+  get __homeySocket() {
+    return this.__socketSession.homeySocket;
+  }
+
+  __bindSocketSessionEvents() {
+    for (const event of [
+      'connect',
+      'disconnect',
+      'reconnect',
+      'reconnect_attempt',
+      'reconnecting',
+      'reconnect_error',
+      'connect_error',
+      'error',
+    ]) {
+      this.__socketSession.on(event, (...args) => {
+        this.emit(event, ...args);
+      });
+    }
+  }
+
   /*
    * Generate Managers from JSON specification
    * A manager instance is created when it's first accessed
@@ -465,234 +498,46 @@ class HomeyAPIV3 extends HomeyAPI {
    * @returns {Boolean}
    */
   isConnected() {
-    return Boolean(this.__homeySocket && this.__homeySocket.connected);
+    return this.__socketSession.isConnected();
   }
 
   async subscribe(
     uri,
-    {
-      onConnect = () => {},
-      onReconnect = () => {},
-      onReconnectError = () => {},
-      onDisconnect = () => {},
-      onEvent = () => {},
-    }
+    handlers
   ) {
-    this.__debug('subscribe', uri);
-
-    await this.connect();
-    await Util.timeout(
-      new Promise((resolve, reject) => {
-        if (this.isConnected() !== true) {
-          reject(new Error('Not connected after connect.'));
-          return;
-        }
-
-        this.__homeySocket.once('disconnect', (reason) => {
-          reject(new Error(reason));
-        });
-        this.__debug('subscribing', uri);
-        this.__homeySocket.emit('subscribe', uri, (err) => {
-          if (err) {
-            this.__debug('Failed to subscribe', uri, err);
-            return reject(err);
-          }
-
-          this.__debug('subscribed', uri);
-          return resolve();
-        });
-      }),
-      this.constructor.SUBSCRIBE_TIMEOUT,
-      `Failed to subscribe to ${uri} (Timeout after ${this.constructor.SUBSCRIBE_TIMEOUT}ms).`
-    );
-
-    // On Connect
-    const __onEvent = (event, data) => {
-      onEvent(event, data);
-    };
-    this.__homeySocket.on(uri, __onEvent);
-
-    onConnect();
-
-    // On Disconnect
-    const __onDisconnect = (reason) => {
-      onDisconnect(reason);
-    };
-    this.__socket.on('disconnect', __onDisconnect);
-
-    // On Reconnect
-    const __onReconnect = () => {
-      Promise.resolve()
-        .then(async () => {
-          await this.connect();
-          await Util.timeout(
-            new Promise((resolve, reject) => {
-              if (this.isConnected() !== true) {
-                reject(new Error('Not connected after connect. (Reconnect)'));
-                return;
-              }
-
-              this.__homeySocket.once('disconnect', (reason) => {
-                reject(new Error(reason));
-              });
-              this.__debug('subscribing', uri);
-              this.__homeySocket.emit('subscribe', uri, (err) => {
-                if (err) {
-                  this.__debug('Failed to subscribe', uri, err);
-                  return reject(err);
-                }
-
-                this.__debug('subscribed', uri);
-                return resolve();
-              });
-            }),
-            this.constructor.SUBSCRIBE_TIMEOUT,
-            `Failed to subscribe to ${uri} (Timeout after ${this.constructor.SUBSCRIBE_TIMEOUT}ms).`
-          );
-
-          this.__homeySocket.on(uri, __onEvent);
-
-          onReconnect();
-        })
-        .catch((err) => onReconnectError(err));
-    };
-    this.__socket.on('reconnect', __onReconnect);
-
-    return {
-      unsubscribe: () => {
-        if (this.__homeySocket) {
-          this.__homeySocket.emit('unsubscribe', uri);
-          this.__homeySocket.removeListener(uri, __onEvent);
-        }
+    return this.__subscriptionRegistry.subscribe(uri, handlers);
+  }
 
-        if (this.__socket) {
-          this.__socket.removeListener('disconnect', __onDisconnect);
-          this.__socket.removeListener('reconnect', __onReconnect);
-        }
-      },
-    };
+  async __apiRequest({
+    uri,
+    operation,
+    args,
+    timeout = this.constructor.DEFAULT_TIMEOUT,
+  }) {
+    return this.__socketSession.requestApi({
+      uri,
+      operation,
+      args,
+      timeout,
+    });
   }
 
   async connect() {
-    if (!this.__connectPromise) {
-      this.__connectPromise = Promise.resolve().then(async () => {
-        // Ensure Base URL
-        const baseUrl = await this.baseUrl;
-
-        // Ensure Token
-        if (!this.__token) await this.login();
-
-        return new Promise((resolve, reject) => {
-          this.__debug(`SocketIOClient ${baseUrl}`);
-
-          this.__socket = SocketIOClient(baseUrl, {
-            autoConnect: false,
-            transports: ['websocket'],
-            reconnection: this.__reconnect,
-          });
-
-          this.__socket.on('disconnect', (reason) => {
-            this.__debug('SocketIOClient.onDisconnect', reason);
-            this.emit('disconnect', reason);
-          });
-
-          this.__socket.on('error', (err) => {
-            this.__debug('SocketIOClient.onError', err.message);
-            this.emit('error', err);
-          });
-
-          this.__socket.on('reconnect', () => {
-            this.__debug('SocketIOClient.onReconnect');
-            this.emit('reconnect');
-          });
-
-          this.__socket.on('reconnect_attempt', () => {
-            this.__debug(`SocketIOClient.onReconnectAttempt`);
-            this.emit('reconnect_attempt');
-          });
-
-          this.__socket.on('reconnecting', (attempt) => {
-            this.__debug(`SocketIOClient.onReconnecting (Attempt #${attempt})`);
-            this.emit('reconnecting');
-          });
-
-          this.__socket.on('reconnect_error', (err) => {
-            this.__debug('SocketIOClient.onReconnectError', err.message, err);
-            this.emit('reconnect_error');
-          });
-
-          this.__socket.on('connect_error', (err) => {
-            this.__debug('SocketIOClient.onConnectError', err.message);
-            this.emit('connect_error');
-            reject(err);
-          });
-
-          this.__socket.on('connect', () => {
-            this.__debug('SocketIOClient.onConnect');
-            this.emit('connect');
-            this.__handshakeClient()
-              .then(() => {
-                this.__debug('SocketIOClient.onConnect.onHandshakeClientSuccess');
-                resolve();
-              })
-              .catch((err) => {
-                this.__debug('SocketIOClient.onConnect.onHandshakeClientError', err.message);
-                reject(err);
-              });
-          });
-
-          this.__socket.open();
-        });
-      });
-
-      this.__connectPromise.catch((err) => {
-        this.__debug('SocketIOClient Error', err.message);
-        delete this.__connectPromise;
-      });
-    }
-
-    return this.__connectPromise;
+    await this.__socketSession.ensureConnected();
   }
 
   isConnecting() {
-    return this.__connectPromise != null;
+    return this.__socketSession.isConnecting();
   }
 
   async disconnect() {
-    // Should we wait for connect here?
-
-    // Also disconnect __homeySocket?
-
-    if (this.__socket) {
-      await new Promise((resolve) => {
-        if (this.__socket.connected) {
-          this.__socket.once('disconnect', () => resolve());
-          this.__socket.disconnect();
-        } else {
-          resolve();
-        }
-        this.__socket.removeAllListeners();
-        this.__socket = null;
-      });
-    }
-
-    // TODO todo what?
+    await this.__socketSession.disconnect();
   }
 
   destroy() {
     this.__destroyed = true;
-
-    if (this.__homeySocket) {
-      this.__homeySocket.removeAllListeners();
-      this.__homeySocket.close();
-      this.__homeySocket = null;
-    }
-
-    if (this.__socket) {
-      this.__socket.removeAllListeners();
-      this.__socket.close();
-      this.__socket = null;
-    }
+    this.__subscriptionRegistry.destroy();
+    this.__socketSession.destroy();
 
     this.removeAllListeners();
   }
@@ -700,128 +545,6 @@ class HomeyAPIV3 extends HomeyAPI {
   isDestroyed() {
     return this.__destroyed;
   }
-
-  async __handshakeClient() {
-    this.__debug('__handshakeClient');
-
-    const onResult = ({ namespace }) => {
-      this.__debug('SocketIOClient.onHandshakeClientSuccess', `Namespace: ${namespace}`);
-
-      return new Promise((resolve, reject) => {
-        this.__homeySocket = this.__socket.io.socket(namespace);
-
-        this.__homeySocket.once('connect', () => {
-          this.__debug(`SocketIOClient.Namespace[${namespace}].onConnect`);
-          resolve();
-        });
-
-        this.__homeySocket.once('connect_error', (err) => {
-          this.__debug(`SocketIOClient.Namespace[${namespace}].onConnectError`, err.message);
-          if (err) {
-            if (err instanceof Error) {
-              return reject(err);
-            }
-
-            // .statusCode for homey-core .code for homey-client.
-            if (typeof err === 'object') {
-              return reject(
-                new HomeyAPIError({ error_description: err.message }, err.statusCode || err.code)
-              );
-            }
-
-            return reject(new Error(String(err)));
-          }
-
-          reject(new Error(`Unknown error connecting to namespace ${namespace}.`));
-        });
-
-        this.__homeySocket.on('disconnect', (reason) => {
-          this.__debug(`SocketIOClient.Namespace[${namespace}].onDisconnect`, reason);
-        });
-
-        this.__homeySocket.on('reconnecting', (attempt) => {
-          this.__debug(
-            `SocketIOClient.Namespace[${namespace}].onReconnecting (Attempt #${attempt})`
-          );
-        });
-
-        this.__homeySocket.on('reconnect', () => {
-          this.__debug(`SocketIOClient.Namespace[${namespace}].onReconnect`);
-        });
-
-        this.__homeySocket.on('reconnect_error', (err) => {
-          this.__debug(`SocketIOClient.Namespace[${namespace}].onReconnectError`, err.message);
-        });
-
-        this.__homeySocket.open();
-      });
-    };
-
-    const handshakeClient = async (token) => {
-      return new Promise((resolve, reject) => {
-        this.__socket.emit(
-          'handshakeClient',
-          {
-            token,
-            homeyId: this.id,
-          },
-          (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);
-            }
-
-            return resolve(result);
-          }
-        );
-      });
-    };
-
-    const token = this.__token;
-
-    try {
-      const result = await Util.timeout(
-        handshakeClient(token),
-        this.constructor.HANDSHAKE_TIMEOUT,
-        `Failed to handshake client (Timeout after ${this.constructor.HANDSHAKE_TIMEOUT}ms).`
-      );
-
-      return onResult(result);
-    } catch (err) {
-      // Only try if AthomCloudAPI is available so we never try to refresh on local api's.
-      if ((err.statusCode === 401 || err.code === 401) && this.__api != null) {
-        this.__debug('Token expired, refreshing...');
-        await this.refreshForToken(token, false);
-        const result = await Util.timeout(
-          handshakeClient(this.__token),
-          this.constructor.HANDSHAKE_TIMEOUT,
-          `Failed to handshake client (Timeout after ${this.constructor.HANDSHAKE_TIMEOUT}ms).`
-        );
-
-        return onResult(result);
-      }
-
-      throw err;
-    }
-  }
-
   hasScope(scope) {
     if (this.__session == null) {
       this.__debug('Tried to call hasScope without a session present.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homey-api",
-  "version": "3.17.4",
+  "version": "3.17.6",
   "description": "Homey API",
   "main": "index.js",
   "license": "SEE LICENSE",