homey-api 3.0.10 → 3.0.12

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;