homey-api 3.0.10 → 3.0.11

package/lib/AthomCloudAPI/User.js

@@ -40,6 +40,7 @@ class User extends APIDefinition {
    */
   getHomeyById(id) {
     const homey = this.homeys.find(homey => homey.id === id);
+
     if (!homey) {
       throw new Error(`Homey Not Found: ${id}`);
     }
@@ -52,6 +53,7 @@ class User extends APIDefinition {
    */
   getFirstHomey() {
     const homey = this.homeys[0];
+    
     if (!homey) {
       throw new Error('No Homey Available');
     }

package/lib/AthomCloudAPI.js

@@ -126,17 +126,10 @@ for(const {@link HomeyAPIV2.ManagerDevices.Device device} of Object.values(devic
    */
   async isLoggedIn() {
     const store = await this.__getStore();
-    if (!store.token
-      || !store.token.access_token) return false;
 
-    try {
-      this.__user = await this.getAuthenticatedUser({
-        $cache: false,
-      });
-      return true;
-    } catch (err) {
-      return false;
-    }
+    if (!store.token || !store.token.access_token) return false;
+
+    return true;
   }
 
   /**
@@ -145,20 +138,56 @@ for(const {@link HomeyAPIV2.ManagerDevices.Device device} of Object.values(devic
    * @param {object} [opts.$cache=true] - Use the cache
    * @returns {Promise<AthomCloudAPI.User>}
    */
-  async getAuthenticatedUser({
-    $cache = true,
-  } = {}) {
+  async getAuthenticatedUser({ $cache = true } = {}) {
     if ($cache === true && this.__user instanceof User) {
       return this.__user;
     }
 
+    const properties = await this.call({
+      method: 'get',
+      path: '/user/me',
+    });
+
     this.__user = new User({
       api: this,
-      properties: await this.call({
-        method: 'get',
-        path: '/user/me',
-      }),
+      properties: properties,
     });
+  
+    return this.__user;
+  }
+
+  async getAuthenticatedUserFromStore({ $cache = true } = {}) {
+    if ($cache === true && this.__user instanceof User) {
+      return this.__user;
+    }
+
+    if ($cache === true && this.__user == null) {
+      const store = await this.__getStore();
+
+      if (store.user) {
+        this.__user = new User({
+          api: this,
+          properties: store.user,
+        });
+
+        return this.__user;
+      }
+    }
+
+    const properties = await this.call({
+      method: 'get',
+      path: '/user/me',
+    });
+
+    this.__user = new User({
+      api: this,
+      properties: properties,
+    });
+
+    await this.__setStore({
+      user: properties,
+    })
+
     return this.__user;
   }
 
@@ -201,6 +230,31 @@ for(const {@link HomeyAPIV2.ManagerDevices.Device device} of Object.values(devic
     return `${this.baseUrl}/oauth2/authorise?${search.toString()}`;
   }
 
+  async getDelegatedLoginUrl(args = {}) {
+    if (args.baseUrl == null) {
+      throw new TypeError('baseUrl is required');
+    }
+
+    const token = await this.createDelegationToken({
+      audience: args.audience,
+      meta: args.meta,
+    });
+
+    const search = new URLSearchParams();
+    search.append('user_token', token);
+
+    if (typeof args.state === 'string') {
+      search.append('state', args.state);
+    }
+
+    if (typeof args.resource === 'string') {
+      search.append('resource', args.resource);
+    }
+
+    const seperator = args.baseUrl.indexOf('?') >= 0 ? '&' : '?';
+    return args.baseUrl + seperator + search.toString();
+  }
+
   /**
    * Logout and delete the local token.
    * @returns {Promise<void>}

package/lib/EventEmitter.js

@@ -70,6 +70,7 @@ class EventEmitter {
    * @param {function} callback
    */
   off(event, callback) {
+    this.__listeners[event] = this.__listeners[event] || [];
     this.__listeners[event] = this.__listeners[event].filter(cb => cb !== callback);
 
     return this;

package/lib/HomeyAPI/HomeyAPIV2/ManagerDevices/Device.js

@@ -13,7 +13,6 @@ class Device extends DeviceV3 {
     delete item.zoneName;
     return item;
   }
-
 }
 
 module.exports = Device;

package/lib/HomeyAPI/HomeyAPIV2/ManagerDrivers/Driver.js

@@ -19,7 +19,7 @@ class Driver extends DriverV3 {
 
     return item;
   }
-
+  
 }
 
 module.exports = Driver;

package/lib/HomeyAPI/HomeyAPIV3/Manager.js

@@ -35,14 +35,26 @@ class Manager extends EventEmitter {
     });
 
     // Set Items
-    Object.defineProperty(this, 'items', {
+    Object.defineProperty(this, 'itemClasses', {
       value: Object.entries(items).reduce((obj, [itemName, item]) => {
         const ItemClass = this.constructor.CRUD[itemName]
           ? this.constructor.CRUD[itemName]
-          // eslint-disable-next-line no-eval
-          : eval(`(class ${itemName} extends Item {})`);
+          : (() => {
+            return class extends Item {};
+          })();
+  
         ItemClass.ID = item.id;
-        obj[item.id] = ItemClass;
+        obj[itemName] = ItemClass;
+
+        return obj;
+      }, {}),
+      enumerable: false,
+      writable: false,
+    });
+
+    Object.defineProperty(this, 'itemNames', {
+      value: Object.entries(items).reduce((obj, [itemName, item]) => {
+        obj[item.id] = itemName;
 
         return obj;
       }, {}),
@@ -76,6 +88,12 @@ class Manager extends EventEmitter {
       writable: false,
     });
 
+    Object.defineProperty(this, '__pendingCalls', {
+      value: {},
+      enumerable: false,
+      writable: false,
+    });
+
     // Create methods
     for (const [operationId, operation] of Object.entries(operations)) {
       Object.defineProperty(this,
@@ -181,181 +199,219 @@ class Manager extends EventEmitter {
               path = `${path}?${queryString}`;
             }
 
-            let result;
-            const benchmark = Util.benchmark();
-
-            // If connected to Socket.io,
-            // try to get the CRUD Item from Cache.
-            if (this.isConnected() && operation.crud && $cache === true) {
-              const itemId = items[operation.crud.item].id;
-
-              switch (operation.crud.type) {
-                case 'getOne': {
-                  if (this.__cache[itemId][args.id]) {
-                    return this.__cache[itemId][args.id];
-                  }
+            if (
+              operation.method.toLowerCase() === 'get' &&
+              $cache === true &&
+              this.__pendingCalls[path] != null &&
+              Object.keys(body).length === 0
+            ) {
+              this.__debug(`Reusing pending call ${operationId}`);
+              const result = await this.__pendingCalls[path];
 
-                  break;
-                }
-                case 'getAll': {
-                  if (this.__cache[itemId]
-                    && this.__cacheAllComplete[itemId]) {
-                    return this.__cache[itemId];
-                  }
-                  break;
-                }
-                default:
-                  break;
-              }
+              return result;
             }
 
-            // 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.__ioNamespace.emit('api', {
-                  args,
-                  operation: operationId,
-                  uri: this.uri,
-                }, (err, result) => {
-                  // String Error
-                  if (typeof err === 'string') {
-                    err = new HomeyAPIError({
-                      error: err,
-                    }, 500);
-                    return reject(err);
-                  }
-
-                  // Object Error
-                  if (typeof err === 'object' && err !== null) {
-                    err = new HomeyAPIError({
-                      stack: err.stack,
-                      error: err.error,
-                      error_description: err.error_description,
-                    }, err.statusCode || err.code || 500);
-                    return reject(err);
-                  }
-
-                  return resolve(result);
-                });
-              }), $timeout);
-            } else {
-              // Get from HTTP
-              result = await this.homey.call({
+            this.__pendingCalls[path] = (async () => {
+              const result = await this.__request({
+                $validate,
+                $cache,
                 $timeout,
-                headers,
+                $socket,
+                operationId,
+                operation,
+                path,
                 body,
-                path: `/api/manager/${this.constructor.ID}${path}`,
-                method: operation.method,
+                query,
+                headers,
+                ...args
               });
-            }
 
-            // Transform and cache output if this is a CRUD call
-            if (operation.crud) {
-              const itemId = items[operation.crud.item].id;
-              const Item = this.items[itemId];
-
-              switch (operation.crud.type) {
-                case 'getOne': {
-                  let item = { ...result };
-                  item = Item.transformGet(item);
-                  item = new Item({
-                    id: item.id,
-                    homey: this.homey,
-                    manager: this,
-                    properties: { ...item },
-                  });
+              return result;
+            })().finally(() => {
+              delete this.__pendingCalls[path];
+            });
 
-                  if (this.isConnected()) {
-                    this.__cache[itemId][item.id] = item;
-                  }
+            const result = await this.__pendingCalls[path];
 
-                  return item;
-                }
-                case 'getAll': {
-                  const items = {};
-
-                  // Add all to cache
-                  for (let item of Object.values(result)) {
-                    item = Item.transformGet(item);
-
-                    if (this.isConnected() && this.__cache[itemId][item.id]) {
-                      items[item.id] = this.__cache[itemId][item.id];
-                      items[item.id].__update(item);
-                    } else {
-                      items[item.id] = new Item({
-                        id: item.id,
-                        homey: this.homey,
-                        manager: this,
-                        properties: { ...item },
-                      });
-
-                      if (this.isConnected()) {
-                        this.__cache[itemId][item.id] = items[item.id];
-                      }
-                    }
-                  }
-
-                  // Find and delete deleted items from cache
-                  if (this.__cache[itemId]) {
-                    for (const cachedItem of Object.values(this.__cache[itemId])) {
-                      if (!items[cachedItem.id]) {
-                        delete this.__cache[itemId][cachedItem.id];
-                      }
-                    }
-                  }
-
-                  // Mark cache as complete
-                  if (this.isConnected()) {
-                    this.__cacheAllComplete[itemId] = true;
-                  }
+            return result;
+          },
+        });
+    }
+  }
 
-                  return items;
-                }
-                case 'createOne':
-                case 'updateOne': {
-                  let item = { ...result };
-                  item = Item.transformGet(item);
-
-                  if (this.isConnected() && this.__cache[itemId][item.id]) {
-                    item = this.__cache[itemId][item.id];
-                    item.__update(item);
-                  } else {
-                    item = Item.transformGet(item);
-                    item = new Item({
-                      id: item.id,
-                      homey: this.homey,
-                      manager: this,
-                      properties: { ...item },
-                    });
+  async __request({ $cache, $timeout, $socket, operationId, operation, path, body, headers, ...args }) {
+    let result;
+    const benchmark = Util.benchmark();
+
+    // If connected to Socket.io,
+    // try to get the CRUD Item from Cache.
+    if (this.isConnected() && operation.crud && $cache === true) {
+      const itemId = this.itemClasses[operation.crud.item].ID;
+
+      switch (operation.crud.type) {
+        case 'getOne': {
+          if (this.__cache[itemId][args.id]) {
+            return this.__cache[itemId][args.id];
+          }
+
+          break;
+        }
+        case 'getAll': {
+          if (this.__cache[itemId] && this.__cacheAllComplete[itemId]) {
+            return this.__cache[itemId];
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
 
-                    if (this.isConnected()) {
-                      this.__cache[itemId][item.id] = item;
-                    }
-                  }
+    // 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.__ioNamespace.emit('api', {
+          args,
+          operation: operationId,
+          uri: this.uri,
+        }, (err, result) => {
+          // String Error
+          if (typeof err === 'string') {
+            err = new HomeyAPIError({
+              error: err,
+            }, 500);
+            return reject(err);
+          }
+
+          // Object Error
+          if (typeof err === 'object' && err !== null) {
+            err = new HomeyAPIError({
+              stack: err.stack,
+              error: err.error,
+              error_description: err.error_description,
+            }, err.statusCode || err.code || 500);
+            return reject(err);
+          }
+
+          return resolve(result);
+        });
+      }), $timeout);
+    } else {
+      // Get from HTTP
+      result = await this.homey.call({
+        $timeout,
+        headers,
+        body,
+        path: `/api/manager/${this.constructor.ID}${path}`,
+        method: operation.method,
+      });
+    }
 
-                  return item;
-                }
-                case 'deleteOne': {
-                  if (this.isConnected() && this.__cache[itemId][args.id]) {
-                    this.__cache[itemId][args.id].destroy();
-                    delete this.__cache[itemId][args.id];
-                  }
+    // Transform and cache output if this is a CRUD call
+    if (operation.crud) {
+      const ItemClass = this.itemClasses[operation.crud.item];
+
+      switch (operation.crud.type) {
+        case 'getOne': {
+          let props = { ...result };
+          props = ItemClass.transformGet(props);
+
+          const item = new ItemClass({
+            id: props.id,
+            homey: this.homey,
+            manager: this,
+            properties: props,
+          });
+
+          if (this.isConnected()) {
+            this.__cache[ItemClass.ID][item.id] = item;
+          }
+
+          return item;
+        }
+        case 'getAll': {
+          const items = {};
+
+          // Add all to cache
+          for (let props of Object.values(result)) {
+            props = ItemClass.transformGet(props);
+
+            if (this.isConnected() && this.__cache[ItemClass.ID][props.id]) {
+              items[props.id] = this.__cache[ItemClass.ID][props.id];
+              items[props.id].__update(props);
+            } else {
+              items[props.id] = new ItemClass({
+                id: props.id,
+                homey: this.homey,
+                manager: this,
+                properties: props,
+              });
 
-                  return undefined;
-                }
-                default:
-                  break;
+              if (this.isConnected()) {
+                this.__cache[ItemClass.ID][props.id] = items[props.id];
               }
             }
+          }
 
-            this.__debug(`${operationId} took ${benchmark()}ms`);
-            return result;
-          },
-        });
+          // Find and delete deleted items from cache
+          if (this.__cache[ItemClass.ID]) {
+            for (const cachedItem of Object.values(this.__cache[ItemClass.ID])) {
+              if (!items[cachedItem.id]) {
+                delete this.__cache[ItemClass.ID][cachedItem.id];
+              }
+            }
+          }
+
+          // Mark cache as complete
+          if (this.isConnected()) {
+            this.__cacheAllComplete[ItemClass.ID] = true;
+          }
+
+          return items;
+        }
+        case 'createOne':
+        case 'updateOne': {
+          let item = null;
+          let props = { ...result };
+
+          props = ItemClass.transformGet(props);
+
+          if (this.isConnected() && this.__cache[ItemClass.ID][props.id]) {
+            item = this.__cache[ItemClass.ID][props.id];
+            item.__update(props);
+          } else {
+            item = new ItemClass({
+              id: props.id,
+              homey: this.homey,
+              manager: this,
+              properties: { ...props },
+            });
+
+            if (this.isConnected()) {
+              this.__cache[ItemClass.ID][props.id] = item;
+            }
+          }
+
+          return item;
+        }
+        case 'deleteOne': {
+          if (this.isConnected() && this.__cache[ItemClass.ID][args.id]) {
+            this.__cache[ItemClass.ID][args.id].destroy();
+            delete this.__cache[ItemClass.ID][args.id];
+          }
+
+          return undefined;
+        }
+        default:
+          break;
+      }
     }
+
+    this.__debug(`${operationId} took ${benchmark()}ms`);
+    return result;
   }
 
   /**
@@ -426,40 +482,41 @@ class Manager extends EventEmitter {
               || event.endsWith('.update')
               || event.endsWith('.delete')) {
               const [itemId, operation] = event.split('.');
-              const Item = this.items[itemId];
+              const itemName = this.itemNames[itemId];
+              const ItemClass = this.itemClasses[itemName];
 
               switch (operation) {
                 case 'create': {
-                  data = Item.transformGet(data);
+                  const props = ItemClass.transformGet(data);
 
-                  const item = new Item({
-                    id: data.id,
+                  const item = new ItemClass({
+                    id: props.id,
                     homey: this.homey,
                     manager: this,
-                    properties: { ...data },
+                    properties: props,
                   });
-                  this.__cache[itemId][data.id] = item;
+                  this.__cache[ItemClass.ID][props.id] = item;
 
                   return this.emit(event, item);
                 }
                 case 'update': {
-                  data = Item.transformGet(data);
+                  const props = ItemClass.transformGet(data);
 
-                  if (this.__cache[itemId][data.id]) {
-                    const item = this.__cache[itemId][data.id];
-                    item.__update(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': {
-                  data = Item.transformGet(data);
+                  const props = ItemClass.transformGet(data);
 
-                  if (this.__cache[itemId][data.id]) {
-                    const item = this.__cache[itemId][data.id];
+                  if (this.__cache[ItemClass.ID][props.id]) {
+                    const item = this.__cache[ItemClass.ID][props.id];
                     item.__delete();
-                    delete this.__cache[itemId][item.id];
+                    delete this.__cache[ItemClass.ID][item.id];
                     return this.emit(event, {
                       id: item.id,
                     });

package/lib/HomeyAPI/HomeyAPIV3/ManagerDevices/Capability.js

@@ -10,6 +10,11 @@ const Item = require('../Item');
  */
 class Capability extends Item {
 
+  get uri() {
+    console.warn('Capability.uri is deprecated. Please use Capability.ownerUri instead.');
+    return undefined;
+  }
+
 }
 
 module.exports = Capability;

package/lib/HomeyAPI/HomeyAPIV3/ManagerDevices/Device.js

@@ -40,6 +40,8 @@ class Device extends Item {
    * onOffInstance.setValue(true).catch(console.error);
    */
   makeCapabilityInstance(capabilityId, listener) {
+    this.__debug('Creating capability instance for: ', capabilityId);
+
     this.connect().catch(err => {
       this.__debug(err);
     });
@@ -121,18 +123,20 @@ class Device extends Item {
       this.manager.getDevice({
         id: this.id,
       }).then(async device => {
-        Object.entries(this.__capabilityInstances).forEach(([capabilityId, capabilityInstance]) => {
+        Object.entries(this.__capabilityInstances).forEach(([capabilityId, capabilityInstances]) => {
           const value = device.capabilitiesObj
             ? typeof device.capabilitiesObj[capabilityId] !== 'undefined'
               ? device.capabilitiesObj[capabilityId].value
               : null
             : null;
 
-          capabilityInstance.__onCapabilityValue({
-            capabilityId,
-            value,
-            transactionId: Util.uuid(),
-          });
+          for (const capabilityInstance of capabilityInstances) {
+            capabilityInstance.__onCapabilityValue({
+              capabilityId,
+              value,
+              transactionId: Util.uuid(),
+            });
+          }
         });
       })
         // eslint-disable-next-line no-console
@@ -169,10 +173,10 @@ class Device extends Item {
 
     return Object.values(logs)
       .filter(log => log.ownerUri === this.uri)
-      .reduce((result, log) => ({
-        ...result,
-        [log.id]: log,
-      }), {});
+      .reduce((accumulator, log) => {
+        accumulator[log.id] = log;
+        return accumulator;
+      }, {});
   }
 
   /**
@@ -237,6 +241,16 @@ class Device extends Item {
     return item;
   }
 
+  get driverUri() {
+    console.warn('Device.driverUri is deprecated. Please use Device.driverId instead.');
+    return undefined;
+  }
+
+  get zoneName() {
+    console.warn('Device.zoneName is deprecated.');
+    return undefined;
+  }
+
 }
 
 module.exports = Device;

package/lib/HomeyAPI/HomeyAPIV3/ManagerDevices/DeviceCapability.js

@@ -112,7 +112,7 @@ class DeviceCapability extends EventEmitter {
       capabilityReference.lastUpdated = this.__lastChanged;
     }
 
-    this.__listener(value);
+    this.__listener(value, this);
   }
 
   __onDeviceDelete() {
@@ -160,7 +160,7 @@ class DeviceCapability extends EventEmitter {
     });
 
     this.__value = value;
-    this.__lastChanged = new Date();
+    this.__lastChanged = transactionTime;
 
     // Mutate the current device capabilitiesObj so it always reflects the last value.
     const capabilityReference = this.device.capabilitiesObj && this.device.capabilitiesObj[this.id];

package/lib/HomeyAPI/HomeyAPIV3/ManagerDrivers/Driver.js

@@ -9,6 +9,16 @@ const Item = require('../Item');
  */
 class Driver extends Item {
 
+  get uri() {
+    console.warn('Driver.uri is deprecated. Please use Driver.ownerUri instead.');
+    return undefined;
+  }
+
+  get uriObj() {
+    console.warn('Driver.uriObj is deprecated.');
+    return undefined;
+  }
+
 }
 
 module.exports = Driver;

package/lib/HomeyAPI/HomeyAPIV3/ManagerDrivers/PairSession.js

@@ -9,6 +9,14 @@ const Item = require('../Item');
  */
 class PairSession extends Item {
 
+  static transformGet(item) {
+    item = super.transformGet(item);
+
+    delete item.uri;
+
+    return item;
+  }
+
 }
 
 module.exports = PairSession;

package/lib/HomeyAPI/HomeyAPIV3/ManagerFlow/FlowCardAction.js

@@ -10,6 +10,16 @@ const FlowCard = require('./FlowCard');
  */
 class FlowCardAction extends FlowCard {
 
+  get uri() {
+    console.warn('FlowCardAction.uri is deprecated. Use FlowCardAction.ownerUri instead.');
+    return undefined;
+  }
+
+  get uriObj() {
+    console.warn('FlowCardAction.uriObj is deprecated.');
+    return undefined;
+  }
+
 }
 
 module.exports = FlowCardAction;

package/lib/HomeyAPI/HomeyAPIV3/ManagerFlow/FlowCardCondition.js

@@ -10,6 +10,16 @@ const FlowCard = require('./FlowCard');
  */
 class FlowCardCondition extends FlowCard {
 
+  get uri() {
+    console.warn('FlowCardCondition.uri is deprecated. Use FlowCardCondition.ownerUri instead.');
+    return undefined;
+  }
+
+  get uriObj() {
+    console.warn('FlowCardCondition.uriObj is deprecated.');
+    return undefined;
+  }
+
 }
 
 module.exports = FlowCardCondition;

package/lib/HomeyAPI/HomeyAPIV3/ManagerFlow/FlowCardTrigger.js

@@ -10,6 +10,16 @@ const FlowCard = require('./FlowCard');
  */
 class FlowCardTrigger extends FlowCard {
 
+  get uri() {
+    console.warn('FlowCardTrigger.uri is deprecated. Use FlowCardTrigger.ownerUri instead.');
+    return undefined;
+  }
+
+  get uriObj() {
+    console.warn('FlowCardTrigger.uriObj is deprecated.');
+    return undefined;
+  }
+
 }
 
 module.exports = FlowCardTrigger;

package/lib/HomeyAPI/HomeyAPIV3/ManagerFlowToken/FlowToken.js

@@ -25,6 +25,21 @@ class FlowToken extends Item {
     return item;
   }
 
+  get uri() {
+    console.warn('FlowToken.uri is deprecated. Use FlowToken.ownerUri instead.');
+    return undefined;
+  }
+
+  get uriObj() {
+    console.warn('FlowToken.uriObj is deprecated.');
+    return undefined;
+  }
+
+  get ownerName() {
+    console.warn('FlowToken.ownerName is deprecated.');
+    return undefined;
+  }
+
 }
 
 module.exports = FlowToken;

package/lib/HomeyAPI/HomeyAPIV3/ManagerInsights/Log.js

@@ -24,6 +24,21 @@ class Log extends Item {
     return item;
   }
 
+  get uri() {
+    console.warn('Log.uri is deprecated. Use Log.ownerUri instead.');
+    return undefined;
+  }
+
+  get uriObj() {
+    console.warn('Log.uriObj is deprecated.');
+    return undefined;
+  }
+
+  get ownerName() {
+    console.warn('Log.ownerName is deprecated.');
+    return undefined;
+  }
+
 }
 
 module.exports = Log;

package/lib/HomeyAPI/HomeyAPIV3/ManagerUsers.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const Manager = require('./Manager');
+
+class ManagerUsers extends Manager {
+
+  __userMe = null;
+
+  async getUserMe(...args) {
+    if (this.__userMe != null) {
+      return await this.__userMe;
+    }
+
+    // TODO
+    // 
+    // - dont cache if args contains cache false
+    // - dont cache if not connected to manager users
+    // - remove on disonnect manager users
+    // - set the user in the users cache
+
+    this.__userMe = this.__super__getUserMe(...args).catch(err => {
+      this.__userMe = null;
+      throw err;
+    });
+
+    return await this.__userMe;
+  }
+
+}
+
+module.exports = ManagerUsers;

package/lib/HomeyAPI/HomeyAPIV3.js

@@ -11,6 +11,7 @@ const ManagerDevices = require('./HomeyAPIV3/ManagerDevices');
 const ManagerFlow = require('./HomeyAPIV3/ManagerFlow');
 const ManagerFlowToken = require('./HomeyAPIV3/ManagerFlowToken');
 const ManagerInsights = require('./HomeyAPIV3/ManagerInsights');
+const ManagerUsers = require('./HomeyAPIV3/ManagerUsers');
 
 // eslint-disable-next-line no-unused-vars
 const Manager = require('./HomeyAPIV3/Manager');
@@ -30,6 +31,7 @@ class HomeyAPIV3 extends HomeyAPI {
     ManagerFlow,
     ManagerFlowToken,
     ManagerInsights,
+    ManagerUsers,
   };
 
   constructor({
@@ -143,8 +145,9 @@ class HomeyAPIV3 extends HomeyAPI {
         if (!this.__managers[managerName]) {
           const ManagerClass = this.constructor.MANAGERS[managerName]
             ? this.constructor.MANAGERS[managerName]
-            // eslint-disable-next-line no-eval
-            : eval(`(class ${managerName} extends Manager {})`);
+            : (() => {
+              return class extends Manager {};
+            })();
 
           ManagerClass.ID = manager.id;
 
@@ -416,6 +419,11 @@ class HomeyAPIV3 extends HomeyAPI {
 
     const resStatusText = res.status;
     const resHeadersContentType = res.headers.get('Content-Type');
+    const version = res.headers.get('x-homey-version');
+    if (version) this.version = version;
+    const tier = res.headers.get('x-homey-tier');
+    if (tier) this.tier = tier;
+
     const resBodyText = await res.text();
     let resBodyJson;
     if (resHeadersContentType && resHeadersContentType.startsWith('application/json')) {
@@ -545,7 +553,11 @@ class HomeyAPIV3 extends HomeyAPI {
     await new Promise((resolve, reject) => {
       this.__ioNamespace.once('disconnect', reject);
       this.__ioNamespace.emit('subscribe', uri, err => {
-        if (err) return reject(err);
+        if (err) {
+          this.__debug('Failed to subscribe', uri, err);
+          return reject(err)
+        }
+      
         return resolve();
       });
     });
@@ -570,7 +582,11 @@ class HomeyAPIV3 extends HomeyAPI {
         await this.connect();
         await new Promise((resolve, reject) => {
           this.__ioNamespace.emit('subscribe', uri, err => {
-            if (err) return reject(err);
+            if (err) {
+              this.__debug('Failed to subscribe', uri, err);
+              return reject(err)
+            }
+            
             return resolve();
           });
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homey-api",
-  "version": "3.0.10",
+  "version": "3.0.11",
   "description": "Homey API",
   "main": "index.js",
   "files": [