@iobroker/js-controller-adapter 6.0.10-alpha.0-20240804-d9be20474 → 6.0.11

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014-2023 bluefox<dogafox@gmail.com>,
+Copyright (c) 2014-2024 bluefox<dogafox@gmail.com>,
 Copyright (c) 2014      hobbyquaker
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

package/README.md

@@ -3,4 +3,4 @@ The Library contains the Adapter class of ioBroker.
 
 ## License
 MIT
-Copyright 2018-2023 bluefox <dogafox@gmail.com>  
+Copyright 2018-2024 bluefox <dogafox@gmail.com>  

package/build/cjs/lib/_Types.d.ts

@@ -173,7 +173,7 @@ export interface InternalFormatDateOptions {
     _format?: string;
 }
 export interface AliasDetails {
-    source: AliasDetailsSource | null;
+    source?: AliasDetailsSource;
     targets: AliasTargetEntry[];
 }
 export interface AliasDetailsSource {

package/build/cjs/lib/adapter/adapter.d.ts

@@ -727,7 +727,19 @@ export declare class AdapterClass extends EventEmitter {
     getForeignStates(pattern: Pattern, callback: ioBroker.GetStatesCallback): void;
     getForeignStates(pattern: Pattern, options: unknown, callback: ioBroker.GetStatesCallback): void;
     private _getForeignStates;
+    /**
+     * Add subscription for given alias, if it is not a state it will be ignored
+     *
+     * @param aliasObj the alias object
+     * @param pattern pattern to subscribe for
+     */
     private _addAliasSubscribe;
+    /**
+     * Remove an alias subscribe
+     *
+     * @param sourceId id of the source object
+     * @param aliasObjOrIdx the alias target or the index of the targets array
+     */
     private _removeAliasSubscribe;
     subscribeForeignStates(pattern: Pattern, callback?: ioBroker.ErrorCallback): void;
     subscribeForeignStates(pattern: Pattern, options: unknown, callback?: ioBroker.ErrorCallback): void;

package/build/cjs/lib/adapter/adapter.js

@@ -4923,85 +4923,63 @@ class AdapterClass extends import_node_events.EventEmitter {
       }
     }
   }
-  async _addAliasSubscribe(aliasObj, pattern, callback) {
-    if (aliasObj?.common?.alias?.id) {
-      if (aliasObj.type !== "state") {
-        this._logger.warn(
-          `${this.namespaceLog} Expected alias ${aliasObj._id} to be of type "state", got "${aliasObj.type}"`
-        );
-        return import_js_controller_common.tools.maybeCallbackWithError(
-          callback,
-          new Error(`Expected alias ${aliasObj._id} to be of type "state", got "${aliasObj.type}"`)
-        );
-      }
-      const sourceId = import_js_controller_common.tools.isObject(aliasObj.common.alias.id) ? aliasObj.common.alias.id.read : aliasObj.common.alias.id;
-      try {
-        this._utils.validateId(sourceId, true, null);
-      } catch (e) {
-        this._logger.warn(`${this.namespaceLog} Error validating alias id of ${aliasObj._id}: ${e.message}`);
-        return import_js_controller_common.tools.maybeCallbackWithError(callback, new Error(`Error validating alias id of ${aliasObj._id}: ${e.message}`));
-      }
-      let aliasDetails;
-      if (!this.aliases.has(sourceId)) {
-        aliasDetails = { source: null, targets: [] };
-        this.aliases.set(sourceId, aliasDetails);
-      } else {
-        aliasDetails = this.aliases.get(sourceId) || { source: null, targets: [] };
-      }
-      const targetEntry = {
-        alias: (0, import_deep_clone.default)(aliasObj.common.alias),
-        id: aliasObj._id,
-        pattern,
-        type: aliasObj.common.type,
-        max: aliasObj.common.max,
-        min: aliasObj.common.min,
-        unit: aliasObj.common.unit
-      };
-      aliasDetails.targets.push(targetEntry);
-      if (!aliasDetails.source) {
-        let sourceObj;
-        try {
-          await this.#states.subscribe(sourceId);
-          sourceObj = await this.#objects.getObject(sourceId, { user: import_constants.SYSTEM_ADMIN_USER });
-        } catch (e) {
-          return import_js_controller_common.tools.maybeCallbackWithError(callback, e);
-        }
-        if (sourceObj?.common) {
-          if (!this.aliases.has(sourceObj._id)) {
-            this._logger.error(`${this.namespaceLog} Alias subscription error. Please check your alias definitions: sourceId=${sourceId}, sourceObj=${JSON.stringify(sourceObj)}`);
-          } else {
-            aliasDetails.source = {
-              min: sourceObj.common.min,
-              max: sourceObj.common.max,
-              type: sourceObj.common.type,
-              unit: sourceObj.common.unit
-            };
-          }
-        }
-        return import_js_controller_common.tools.maybeCallback(callback);
-      } else {
-        return import_js_controller_common.tools.maybeCallback(callback);
-      }
-    } else if (aliasObj && aliasObj.type === "state") {
+  async _addAliasSubscribe(aliasObj, pattern) {
+    if (aliasObj.type !== "state") {
+      return;
+    }
+    if (!aliasObj.common?.alias?.id) {
       this._logger.warn(`${this.namespaceLog} Alias ${aliasObj._id} has no target 5`);
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, new Error(`Alias ${aliasObj._id} has no target`));
+      throw new Error(`Alias ${aliasObj._id} has no target`);
+    }
+    const sourceId = import_js_controller_common.tools.isObject(aliasObj.common.alias.id) ? aliasObj.common.alias.id.read : aliasObj.common.alias.id;
+    try {
+      this._utils.validateId(sourceId, true, null);
+    } catch (e) {
+      throw new Error(`Error validating alias id of ${aliasObj._id}: ${e.message}`);
+    }
+    const targetEntry = {
+      alias: (0, import_deep_clone.default)(aliasObj.common.alias),
+      id: aliasObj._id,
+      pattern,
+      type: aliasObj.common.type,
+      max: aliasObj.common.max,
+      min: aliasObj.common.min,
+      unit: aliasObj.common.unit
+    };
+    let aliasDetails;
+    if (!this.aliases.has(sourceId)) {
+      aliasDetails = { targets: [] };
+      this.aliases.set(sourceId, aliasDetails);
     } else {
-      return import_js_controller_common.tools.maybeCallback(callback);
+      aliasDetails = this.aliases.get(sourceId);
+    }
+    if (!aliasDetails.source) {
+      await this.#states.subscribe(sourceId);
+      const sourceObj = await this.#objects.getObject(sourceId, { user: import_constants.SYSTEM_ADMIN_USER });
+      if (sourceObj?.common && this.aliases.has(sourceObj._id)) {
+        aliasDetails.source = {
+          min: sourceObj.common.min,
+          max: sourceObj.common.max,
+          type: sourceObj.common.type,
+          unit: sourceObj.common.unit
+        };
+      }
     }
+    aliasDetails.targets.push(targetEntry);
   }
-  async _removeAliasSubscribe(sourceId, aliasObj, callback) {
+  async _removeAliasSubscribe(sourceId, aliasObjOrIdx) {
     if (!this.aliases.has(sourceId)) {
-      return import_js_controller_common.tools.maybeCallback(callback);
+      return;
     }
-    const pos = typeof aliasObj === "number" ? aliasObj : this.aliases.get(sourceId).targets.indexOf(aliasObj);
+    const alias = this.aliases.get(sourceId);
+    const pos = typeof aliasObjOrIdx === "number" ? aliasObjOrIdx : alias.targets.indexOf(aliasObjOrIdx);
     if (pos !== -1) {
-      this.aliases.get(sourceId).targets.splice(pos, 1);
-      if (!this.aliases.get(sourceId).targets.length) {
+      alias.targets.splice(pos, 1);
+      if (!alias.targets.length) {
         this.aliases.delete(sourceId);
         await this.#states.unsubscribe(sourceId);
       }
     }
-    return import_js_controller_common.tools.maybeCallback(callback);
   }
   subscribeForeignStates(pattern, options, callback) {
     pattern = pattern || "*";
@@ -5076,7 +5054,7 @@ class AdapterClass extends import_node_events.EventEmitter {
         const aliasObjs = await this._getObjectsByArray(aliasesIds, options);
         for (const aliasObj of aliasObjs) {
           if (aliasObj) {
-            promises.push(new Promise((resolve) => this._addAliasSubscribe(aliasObj, aliasObj._id, resolve)));
+            promises.push(this._addAliasSubscribe(aliasObj, aliasObj._id));
           }
         }
       }
@@ -5106,7 +5084,7 @@ class AdapterClass extends import_node_events.EventEmitter {
           for (const id of Object.keys(objs)) {
             if (id.startsWith(import_constants.ALIAS_STARTS_WITH)) {
               const aliasObj = objs[id];
-              promises.push(new Promise((resolve) => this._addAliasSubscribe(aliasObj, pattern, resolve)));
+              promises.push(this._addAliasSubscribe(aliasObj, pattern));
             }
           }
           try {
@@ -5136,9 +5114,10 @@ class AdapterClass extends import_node_events.EventEmitter {
         this.#objects.subscribe(`${import_constants.ALIAS_STARTS_WITH}*`);
       }
       try {
-        const aliasObj = await this.#objects.getObjectAsync(pattern, options);
+        const aliasObj = await this.#objects.getObject(pattern, options);
         if (aliasObj) {
-          await this._addAliasSubscribe(aliasObj, pattern, callback);
+          await this._addAliasSubscribe(aliasObj, pattern);
+          return import_js_controller_common.tools.maybeCallback(callback);
         } else {
           return import_js_controller_common.tools.maybeCallback(callback);
         }
@@ -5993,13 +5972,12 @@ class AdapterClass extends import_node_events.EventEmitter {
               if (obj?.common?.alias?.id) {
                 const newSourceId = typeof obj.common.alias.id.read === "string" ? obj.common.alias.id.read : obj.common.alias.id;
                 if (newSourceId !== sourceId) {
-                  this._removeAliasSubscribe(sourceId, targetAlias, async () => {
-                    try {
-                      await this._addAliasSubscribe(obj, targetAlias.pattern);
-                    } catch (e) {
-                      this._logger.error(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);
-                    }
-                  });
+                  await this._removeAliasSubscribe(sourceId, targetAlias);
+                  try {
+                    await this._addAliasSubscribe(obj, targetAlias.pattern);
+                  } catch (e) {
+                    this._logger.error(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);
+                  }
                 } else {
                   targetAlias.min = obj.common.min;
                   targetAlias.max = obj.common.max;
@@ -6007,11 +5985,11 @@ class AdapterClass extends import_node_events.EventEmitter {
                   targetAlias.alias = (0, import_deep_clone.default)(obj.common.alias);
                 }
               } else {
-                this._removeAliasSubscribe(sourceId, targetAlias);
+                await this._removeAliasSubscribe(sourceId, targetAlias);
               }
             }
           }
-          if (isNewAlias) {
+          if (isNewAlias && obj) {
             for (const aliasPattern of this.aliasPatterns) {
               const testPattern = aliasPattern.slice(-1) === "*" ? new RegExp(import_js_controller_common.tools.pattern2RegEx(aliasPattern)) : aliasPattern;
               if (typeof testPattern === "string" && aliasPattern === id || testPattern instanceof RegExp && testPattern.test(id)) {