@iobroker/js-controller-adapter 7.2.3 → 8.0.0-alpha.1-20260921-e5941ca8a

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

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AdapterContextBase_exports = {};
+__export(AdapterContextBase_exports, {
+  AdapterContextBase: () => AdapterContextBase
+});
+module.exports = __toCommonJS(AdapterContextBase_exports);
+var import_js_controller_common = require("@iobroker/js-controller-common");
+class AdapterContextBase {
+  static {
+    __name(this, "AdapterContextBase");
+  }
+  #ctx;
+  /**
+   * @param ctx Shared adapter context providing live runtime state
+   */
+  constructor(ctx) {
+    this.#ctx = ctx;
+  }
+  /**
+   * The connected states DB client.
+   *
+   * @throws {Error} `ERROR_DB_CLOSED` when the states database is not connected.
+   */
+  get states() {
+    const states = this.#ctx.states;
+    if (!states) {
+      throw new Error(import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
+    }
+    return states;
+  }
+  /**
+   * The connected objects DB client.
+   *
+   * @throws {Error} `ERROR_DB_CLOSED` when the objects database is not connected.
+   */
+  get objects() {
+    const objects = this.#ctx.objects;
+    if (!objects) {
+      throw new Error(import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
+    }
+    return objects;
+  }
+  /** Current adapter common config */
+  get common() {
+    return this.#ctx.common;
+  }
+  /** Current adapter instance config (native) */
+  get config() {
+    return this.#ctx.config;
+  }
+  /** Current host name (may be undefined before init) */
+  get host() {
+    return this.#ctx.host;
+  }
+  /** Current adapter namespace, e.g. `"adapter.0"` */
+  get namespace() {
+    return this.#ctx.namespace;
+  }
+  /** Current namespace string used in log messages */
+  get namespaceLog() {
+    return this.#ctx.namespaceLog;
+  }
+  /** Logger instance */
+  get logger() {
+    return this.#ctx.logger;
+  }
+  /** Controller for UI messaging */
+  get uiMessagingController() {
+    return this.#ctx.uiMessagingController;
+  }
+  /** Increment the adapter's outbound-write counter. */
+  countOutput() {
+    this.#ctx.countOutput();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdapterContextBase
+});
+//# sourceMappingURL=AdapterContextBase.js.map

package/build/cjs/lib/adapter/managers/AdapterContextBase.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/adapter/managers/AdapterContextBase.ts"],
+  "sourcesContent": ["import type { Client as StatesInRedisClient } from '@iobroker/db-states-redis';\nimport type { Client as ObjectsInRedisClient } from '@iobroker/db-objects-redis';\nimport type { AdapterContext } from '@/lib/adapter/context.js';\nimport { tools } from '@iobroker/js-controller-common';\n\n/**\n * Base class for adapter managers that read from the shared {@link AdapterContext}.\n *\n * Holds the context in a private `#ctx` field so subclasses cannot bypass the connection-checked\n * getters and reach the raw (possibly null) DB clients directly. Access to `states`/`objects` goes\n * through the throwing getters, which raise `ERROR_DB_CLOSED` when the respective database is not\n * connected; the other getters pass ctx values through unchanged.\n *\n * Getters are `protected` because `#` privates are not visible to subclasses.\n */\nexport abstract class AdapterContextBase {\n    readonly #ctx: AdapterContext;\n\n    /**\n     * @param ctx Shared adapter context providing live runtime state\n     */\n    constructor(ctx: AdapterContext) {\n        this.#ctx = ctx;\n    }\n\n    /**\n     * The connected states DB client.\n     *\n     * @throws {Error} `ERROR_DB_CLOSED` when the states database is not connected.\n     */\n    protected get states(): StatesInRedisClient {\n        const states = this.#ctx.states;\n        if (!states) {\n            throw new Error(tools.ERRORS.ERROR_DB_CLOSED);\n        }\n        return states;\n    }\n\n    /**\n     * The connected objects DB client.\n     *\n     * @throws {Error} `ERROR_DB_CLOSED` when the objects database is not connected.\n     */\n    protected get objects(): ObjectsInRedisClient {\n        const objects = this.#ctx.objects;\n        if (!objects) {\n            throw new Error(tools.ERRORS.ERROR_DB_CLOSED);\n        }\n        return objects;\n    }\n\n    /** Current adapter common config */\n    protected get common(): ioBroker.InstanceCommon | undefined {\n        return this.#ctx.common;\n    }\n\n    /** Current adapter instance config (native) */\n    protected get config(): ioBroker.AdapterConfig {\n        return this.#ctx.config;\n    }\n\n    /** Current host name (may be undefined before init) */\n    protected get host(): string | undefined {\n        return this.#ctx.host;\n    }\n\n    /** Current adapter namespace, e.g. `\"adapter.0\"` */\n    protected get namespace(): `${string}.${number}` {\n        return this.#ctx.namespace;\n    }\n\n    /** Current namespace string used in log messages */\n    protected get namespaceLog(): string {\n        return this.#ctx.namespaceLog;\n    }\n\n    /** Logger instance */\n    protected get logger(): AdapterContext['logger'] {\n        return this.#ctx.logger;\n    }\n\n    /** Controller for UI messaging */\n    protected get uiMessagingController(): AdapterContext['uiMessagingController'] {\n        return this.#ctx.uiMessagingController;\n    }\n\n    /** Increment the adapter's outbound-write counter. */\n    protected countOutput(): void {\n        this.#ctx.countOutput();\n    }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAGA;;;;;AAAA,kCAAsB;AAYhB,MAAgB,mBAAkB;EAZxC,OAYwC;;;EAC3B;;;;EAKT,YAAY,KAAmB;AAC3B,SAAK,OAAO;EAChB;;;;;;EAOA,IAAc,SAAM;AAChB,UAAM,SAAS,KAAK,KAAK;AACzB,QAAI,CAAC,QAAQ;AACT,YAAM,IAAI,MAAM,kCAAM,OAAO,eAAe;IAChD;AACA,WAAO;EACX;;;;;;EAOA,IAAc,UAAO;AACjB,UAAM,UAAU,KAAK,KAAK;AAC1B,QAAI,CAAC,SAAS;AACV,YAAM,IAAI,MAAM,kCAAM,OAAO,eAAe;IAChD;AACA,WAAO;EACX;;EAGA,IAAc,SAAM;AAChB,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,SAAM;AAChB,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,OAAI;AACd,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,YAAS;AACnB,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,eAAY;AACtB,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,SAAM;AAChB,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,wBAAqB;AAC/B,WAAO,KAAK,KAAK;EACrB;;EAGU,cAAW;AACjB,SAAK,KAAK,YAAW;EACzB;;",
+  "names": []
+}

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

@@ -0,0 +1,103 @@
+import type { AliasTargetEntry } from '../../_Types.js';
+import type { ValidateIdOptions } from '../../../lib/adapter/validator.js';
+import type { AdapterContext } from '../../../lib/adapter/context.js';
+import { AdapterContextBase } from '../../../lib/adapter/managers/AdapterContextBase.js';
+/** Validates a (possibly foreign) id; throws on invalid. Bound to the adapter's Validator. */
+export type ValidateId = (id: string, isForeignId: boolean, options?: ValidateIdOptions | null) => void;
+/**
+ * Owns the alias subscription cache and its bookkeeping: which real (source) states feed which
+ * `alias.*` targets, the alias subscription patterns, and the single `alias.*` object subscription.
+ * The source-state change fan-out ({@link resolveSourceChange}) is synchronous by contract so the
+ * state-change handler cannot interleave a cache mutation mid-fan-out.
+ */
+export declare class AliasManager extends AdapterContextBase {
+    #private;
+    /**
+     * @param ctx Shared adapter context providing live runtime state
+     * @param validateId Bound id validator from the adapter's Validator instance
+     */
+    constructor(ctx: AdapterContext, validateId: ValidateId);
+    /**
+     * Whether the given source (real) state id currently feeds any alias.
+     *
+     * @param id the real source state id
+     */
+    hasSource(id: string): boolean;
+    /** Number of tracked source states. */
+    get size(): number;
+    /**
+     * Whether the given subscription pattern is tracked.
+     *
+     * @param pattern the subscription pattern
+     */
+    hasPattern(pattern: string): boolean;
+    /**
+     * Track a subscription pattern.
+     *
+     * @param pattern the subscription pattern
+     */
+    addPattern(pattern: string): void;
+    /**
+     * Stop tracking a subscription pattern.
+     *
+     * @param pattern the subscription pattern
+     */
+    deletePattern(pattern: string): void;
+    /**
+     * Whether `id` falls into any tracked alias pattern (wildcards via pattern2RegEx).
+     *
+     * @param id the id to test against the tracked patterns
+     */
+    matchesAnyPattern(id: string): boolean;
+    /**
+     * Reacts to a change of an `alias.*` object: re-points, updates, or removes the target across the
+     * tracked sources, and picks up a newly-appeared alias that falls into a tracked pattern.
+     * Live-iterates the cache while awaiting add/remove — the loop lives here, with the map, to
+     * preserve the original mutation-during-iteration semantics exactly.
+     *
+     * @param id the changed alias object id
+     * @param obj the new object (null/undefined if deleted)
+     */
+    handleAliasObjectChange(id: string, obj: ioBroker.Object | null | undefined): Promise<void>;
+    /**
+     * Removes every target subscribed under the given pattern, live-iterating the cache so a removal
+     * mutating the map mid-loop keeps the original semantics. Awaits each removal.
+     *
+     * @param pattern the subscription pattern being unsubscribed
+     */
+    removeTargetsForPattern(pattern: string): Promise<void>;
+    /**
+     * Synchronously computes the fan-out of a source (real) state change to its alias targets.
+     * Returns one `{ targetId, state }` per unique target. MUST NOT await — the caller relies on the
+     * cache not mutating between read and emit.
+     *
+     * @param sourceId the changed real state id
+     * @param state the new state value (or null on deletion)
+     */
+    resolveSourceChange(sourceId: string, state: ioBroker.State | null | undefined): Array<{
+        targetId: string;
+        state: ioBroker.State | null;
+    }>;
+    /** Subscribe the `alias.*` object range once (idempotent). */
+    ensureAliasObjectSubscription(): void;
+    /** Drop the `alias.*` object subscription when no aliases remain. */
+    maybeDropAliasObjectSubscription(): void;
+    /**
+     * Register an alias target for its source state, subscribing the source state (and reading its
+     * metadata once). Preserves the create-before-await ordering and the post-await existence
+     * re-check that guard a concurrent removal.
+     *
+     * @param aliasObj the `alias.*` object being subscribed
+     * @param pattern the subscription pattern that pulled it in
+     */
+    addAliasSubscribe(aliasObj: ioBroker.AnyObject, pattern: string): Promise<void>;
+    /**
+     * Remove one alias target from its source; when the source has no targets left, delete the entry
+     * and unsubscribe the source state.
+     *
+     * @param sourceId the real source state id
+     * @param aliasObjOrIdx the target entry or its index in the targets array
+     */
+    removeAliasSubscribe(sourceId: string, aliasObjOrIdx: number | AliasTargetEntry): Promise<void>;
+}
+//# sourceMappingURL=AliasManager.d.ts.map

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

@@ -0,0 +1,293 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AliasManager_exports = {};
+__export(AliasManager_exports, {
+  AliasManager: () => AliasManager
+});
+module.exports = __toCommonJS(AliasManager_exports);
+var import_js_controller_common = require("@iobroker/js-controller-common");
+var import_deep_clone = __toESM(require("deep-clone"), 1);
+var import_AdapterContextBase = require("../../../lib/adapter/managers/AdapterContextBase.js");
+var import_constants = require("../../../lib/adapter/constants.js");
+class AliasManager extends import_AdapterContextBase.AdapterContextBase {
+  static {
+    __name(this, "AliasManager");
+  }
+  #aliases = /* @__PURE__ */ new Map();
+  #aliasPatterns = /* @__PURE__ */ new Set();
+  #aliasObjectsSubscribed = false;
+  #validateId;
+  /**
+   * @param ctx Shared adapter context providing live runtime state
+   * @param validateId Bound id validator from the adapter's Validator instance
+   */
+  constructor(ctx, validateId) {
+    super(ctx);
+    this.#validateId = validateId;
+  }
+  /**
+   * Whether the given source (real) state id currently feeds any alias.
+   *
+   * @param id the real source state id
+   */
+  hasSource(id) {
+    return this.#aliases.has(id);
+  }
+  /** Number of tracked source states. */
+  get size() {
+    return this.#aliases.size;
+  }
+  /**
+   * Whether the given subscription pattern is tracked.
+   *
+   * @param pattern the subscription pattern
+   */
+  hasPattern(pattern) {
+    return this.#aliasPatterns.has(pattern);
+  }
+  /**
+   * Track a subscription pattern.
+   *
+   * @param pattern the subscription pattern
+   */
+  addPattern(pattern) {
+    this.#aliasPatterns.add(pattern);
+  }
+  /**
+   * Stop tracking a subscription pattern.
+   *
+   * @param pattern the subscription pattern
+   */
+  deletePattern(pattern) {
+    this.#aliasPatterns.delete(pattern);
+  }
+  /**
+   * Whether `id` falls into any tracked alias pattern (wildcards via pattern2RegEx).
+   *
+   * @param id the id to test against the tracked patterns
+   */
+  matchesAnyPattern(id) {
+    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)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Reacts to a change of an `alias.*` object: re-points, updates, or removes the target across the
+   * tracked sources, and picks up a newly-appeared alias that falls into a tracked pattern.
+   * Live-iterates the cache while awaiting add/remove — the loop lives here, with the map, to
+   * preserve the original mutation-during-iteration semantics exactly.
+   *
+   * @param id the changed alias object id
+   * @param obj the new object (null/undefined if deleted)
+   */
+  async handleAliasObjectChange(id, obj) {
+    let isNewAlias = true;
+    for (const [sourceId, alias] of this.#aliases) {
+      const targetAlias = alias.targets.find((entry) => entry.id === id);
+      if (targetAlias) {
+        isNewAlias = false;
+        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) {
+            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;
+            targetAlias.type = obj.common.type;
+            targetAlias.alias = (0, import_deep_clone.default)(obj.common.alias);
+          }
+        } else {
+          await this.removeAliasSubscribe(sourceId, targetAlias);
+        }
+      }
+    }
+    if (isNewAlias && obj && this.matchesAnyPattern(id)) {
+      try {
+        await this.addAliasSubscribe(obj, id);
+      } catch (e) {
+        this.logger.warn(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);
+      }
+    }
+  }
+  /**
+   * Removes every target subscribed under the given pattern, live-iterating the cache so a removal
+   * mutating the map mid-loop keeps the original semantics. Awaits each removal.
+   *
+   * @param pattern the subscription pattern being unsubscribed
+   */
+  async removeTargetsForPattern(pattern) {
+    const promises = new Array();
+    for (const [sourceId, alias] of this.#aliases) {
+      for (let i = alias.targets.length - 1; i >= 0; i--) {
+        if (alias.targets[i].pattern === pattern) {
+          promises.push(this.removeAliasSubscribe(sourceId, i));
+        }
+      }
+    }
+    await Promise.all(promises);
+  }
+  /**
+   * Synchronously computes the fan-out of a source (real) state change to its alias targets.
+   * Returns one `{ targetId, state }` per unique target. MUST NOT await — the caller relies on the
+   * cache not mutating between read and emit.
+   *
+   * @param sourceId the changed real state id
+   * @param state the new state value (or null on deletion)
+   */
+  resolveSourceChange(sourceId, state) {
+    const out = new Array();
+    const alias = this.#aliases.get(sourceId);
+    if (!alias) {
+      return out;
+    }
+    const uniqueTargets = /* @__PURE__ */ new Set();
+    for (const target of alias.targets) {
+      const targetId = target.id;
+      if (uniqueTargets.has(targetId)) {
+        continue;
+      }
+      uniqueTargets.add(targetId);
+      const aState = state ? import_js_controller_common.tools.formatAliasValue({
+        sourceCommon: alias.source,
+        targetCommon: target,
+        state: (0, import_deep_clone.default)(state),
+        logger: this.logger,
+        logNamespace: this.namespaceLog,
+        sourceId,
+        targetId
+      }) : null;
+      if (aState || !state) {
+        out.push({ targetId, state: aState });
+      }
+    }
+    return out;
+  }
+  /** Subscribe the `alias.*` object range once (idempotent). */
+  ensureAliasObjectSubscription() {
+    if (!this.#aliasObjectsSubscribed) {
+      this.#aliasObjectsSubscribed = true;
+      this.objects.subscribe(`${import_constants.ALIAS_STARTS_WITH}*`);
+    }
+  }
+  /** Drop the `alias.*` object subscription when no aliases remain. */
+  maybeDropAliasObjectSubscription() {
+    if (!this.#aliases.size && this.#aliasObjectsSubscribed) {
+      this.#aliasObjectsSubscribed = false;
+      this.objects.unsubscribe(`${import_constants.ALIAS_STARTS_WITH}*`);
+    }
+  }
+  /**
+   * Register an alias target for its source state, subscribing the source state (and reading its
+   * metadata once). Preserves the create-before-await ordering and the post-await existence
+   * re-check that guard a concurrent removal.
+   *
+   * @param aliasObj the `alias.*` object being subscribed
+   * @param pattern the subscription pattern that pulled it in
+   */
+  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`);
+      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.#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 {
+      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);
+  }
+  /**
+   * Remove one alias target from its source; when the source has no targets left, delete the entry
+   * and unsubscribe the source state.
+   *
+   * @param sourceId the real source state id
+   * @param aliasObjOrIdx the target entry or its index in the targets array
+   */
+  async removeAliasSubscribe(sourceId, aliasObjOrIdx) {
+    if (!this.#aliases.has(sourceId)) {
+      return;
+    }
+    const alias = this.#aliases.get(sourceId);
+    const pos = typeof aliasObjOrIdx === "number" ? aliasObjOrIdx : alias.targets.indexOf(aliasObjOrIdx);
+    if (pos !== -1) {
+      alias.targets.splice(pos, 1);
+      if (!alias.targets.length) {
+        this.#aliases.delete(sourceId);
+        await this.states.unsubscribe(sourceId);
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AliasManager
+});
+//# sourceMappingURL=AliasManager.js.map

package/build/cjs/lib/adapter/managers/AliasManager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/adapter/managers/AliasManager.ts"],
+  "sourcesContent": ["import { tools } from '@iobroker/js-controller-common';\nimport deepClone from 'deep-clone';\nimport type { AliasDetails, AliasTargetEntry } from '../../_Types.js';\nimport type { ValidateIdOptions } from '@/lib/adapter/validator.js';\nimport type { AdapterContext } from '@/lib/adapter/context.js';\nimport { AdapterContextBase } from '@/lib/adapter/managers/AdapterContextBase.js';\nimport { ALIAS_STARTS_WITH, SYSTEM_ADMIN_USER } from '@/lib/adapter/constants.js';\n\n/** Validates a (possibly foreign) id; throws on invalid. Bound to the adapter's Validator. */\nexport type ValidateId = (id: string, isForeignId: boolean, options?: ValidateIdOptions | null) => void;\n\n/**\n * Owns the alias subscription cache and its bookkeeping: which real (source) states feed which\n * `alias.*` targets, the alias subscription patterns, and the single `alias.*` object subscription.\n * The source-state change fan-out ({@link resolveSourceChange}) is synchronous by contract so the\n * state-change handler cannot interleave a cache mutation mid-fan-out.\n */\nexport class AliasManager extends AdapterContextBase {\n    readonly #aliases = new Map<string, AliasDetails>();\n    readonly #aliasPatterns = new Set<string>();\n    #aliasObjectsSubscribed = false;\n    readonly #validateId: ValidateId;\n\n    /**\n     * @param ctx Shared adapter context providing live runtime state\n     * @param validateId Bound id validator from the adapter's Validator instance\n     */\n    constructor(ctx: AdapterContext, validateId: ValidateId) {\n        super(ctx);\n        this.#validateId = validateId;\n    }\n\n    /**\n     * Whether the given source (real) state id currently feeds any alias.\n     *\n     * @param id the real source state id\n     */\n    hasSource(id: string): boolean {\n        return this.#aliases.has(id);\n    }\n\n    /** Number of tracked source states. */\n    get size(): number {\n        return this.#aliases.size;\n    }\n\n    /**\n     * Whether the given subscription pattern is tracked.\n     *\n     * @param pattern the subscription pattern\n     */\n    hasPattern(pattern: string): boolean {\n        return this.#aliasPatterns.has(pattern);\n    }\n\n    /**\n     * Track a subscription pattern.\n     *\n     * @param pattern the subscription pattern\n     */\n    addPattern(pattern: string): void {\n        this.#aliasPatterns.add(pattern);\n    }\n\n    /**\n     * Stop tracking a subscription pattern.\n     *\n     * @param pattern the subscription pattern\n     */\n    deletePattern(pattern: string): void {\n        this.#aliasPatterns.delete(pattern);\n    }\n\n    /**\n     * Whether `id` falls into any tracked alias pattern (wildcards via pattern2RegEx).\n     *\n     * @param id the id to test against the tracked patterns\n     */\n    matchesAnyPattern(id: string): boolean {\n        for (const aliasPattern of this.#aliasPatterns) {\n            const testPattern =\n                aliasPattern.slice(-1) === '*' ? new RegExp(tools.pattern2RegEx(aliasPattern)) : aliasPattern;\n            if (\n                (typeof testPattern === 'string' && aliasPattern === id) ||\n                (testPattern instanceof RegExp && testPattern.test(id))\n            ) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * Reacts to a change of an `alias.*` object: re-points, updates, or removes the target across the\n     * tracked sources, and picks up a newly-appeared alias that falls into a tracked pattern.\n     * Live-iterates the cache while awaiting add/remove \u2014 the loop lives here, with the map, to\n     * preserve the original mutation-during-iteration semantics exactly.\n     *\n     * @param id the changed alias object id\n     * @param obj the new object (null/undefined if deleted)\n     */\n    async handleAliasObjectChange(id: string, obj: ioBroker.Object | null | undefined): Promise<void> {\n        let isNewAlias = true;\n        for (const [sourceId, alias] of this.#aliases) {\n            const targetAlias = alias.targets.find(entry => entry.id === id);\n            if (targetAlias) {\n                isNewAlias = false;\n                if (obj?.common?.alias?.id) {\n                    const newSourceId =\n                        typeof obj.common.alias.id.read === 'string' ? obj.common.alias.id.read : obj.common.alias.id;\n                    if (newSourceId !== sourceId) {\n                        await this.removeAliasSubscribe(sourceId, targetAlias);\n                        try {\n                            await this.addAliasSubscribe(obj, targetAlias.pattern);\n                        } catch (e: any) {\n                            this.logger.error(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);\n                        }\n                    } else {\n                        targetAlias.min = obj.common.min;\n                        targetAlias.max = obj.common.max;\n                        targetAlias.type = obj.common.type;\n                        targetAlias.alias = deepClone(obj.common.alias);\n                    }\n                } else {\n                    await this.removeAliasSubscribe(sourceId, targetAlias);\n                }\n            }\n        }\n        if (isNewAlias && obj && this.matchesAnyPattern(id)) {\n            try {\n                await this.addAliasSubscribe(obj, id);\n            } catch (e: any) {\n                this.logger.warn(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);\n            }\n        }\n    }\n\n    /**\n     * Removes every target subscribed under the given pattern, live-iterating the cache so a removal\n     * mutating the map mid-loop keeps the original semantics. Awaits each removal.\n     *\n     * @param pattern the subscription pattern being unsubscribed\n     */\n    async removeTargetsForPattern(pattern: string): Promise<void> {\n        const promises = new Array<Promise<void>>();\n        for (const [sourceId, alias] of this.#aliases) {\n            for (let i = alias.targets.length - 1; i >= 0; i--) {\n                if (alias.targets[i].pattern === pattern) {\n                    promises.push(this.removeAliasSubscribe(sourceId, i));\n                }\n            }\n        }\n        await Promise.all(promises);\n    }\n\n    /**\n     * Synchronously computes the fan-out of a source (real) state change to its alias targets.\n     * Returns one `{ targetId, state }` per unique target. MUST NOT await \u2014 the caller relies on the\n     * cache not mutating between read and emit.\n     *\n     * @param sourceId the changed real state id\n     * @param state the new state value (or null on deletion)\n     */\n    resolveSourceChange(\n        sourceId: string,\n        state: ioBroker.State | null | undefined,\n    ): Array<{ targetId: string; state: ioBroker.State | null }> {\n        const out = new Array<{ targetId: string; state: ioBroker.State | null }>();\n        const alias = this.#aliases.get(sourceId);\n        if (!alias) {\n            return out;\n        }\n        const uniqueTargets = new Set<string>();\n        for (const target of alias.targets) {\n            const targetId = target.id;\n            if (uniqueTargets.has(targetId)) {\n                continue;\n            }\n            uniqueTargets.add(targetId);\n            const aState = state\n                ? tools.formatAliasValue({\n                      sourceCommon: alias.source,\n                      targetCommon: target,\n                      state: deepClone(state),\n                      logger: this.logger,\n                      logNamespace: this.namespaceLog,\n                      sourceId,\n                      targetId,\n                  })\n                : null;\n            if (aState || !state) {\n                out.push({ targetId, state: aState });\n            }\n        }\n        return out;\n    }\n\n    /** Subscribe the `alias.*` object range once (idempotent). */\n    ensureAliasObjectSubscription(): void {\n        if (!this.#aliasObjectsSubscribed) {\n            this.#aliasObjectsSubscribed = true;\n            this.objects.subscribe(`${ALIAS_STARTS_WITH}*`);\n        }\n    }\n\n    /** Drop the `alias.*` object subscription when no aliases remain. */\n    maybeDropAliasObjectSubscription(): void {\n        if (!this.#aliases.size && this.#aliasObjectsSubscribed) {\n            this.#aliasObjectsSubscribed = false;\n            this.objects.unsubscribe(`${ALIAS_STARTS_WITH}*`);\n        }\n    }\n\n    /**\n     * Register an alias target for its source state, subscribing the source state (and reading its\n     * metadata once). Preserves the create-before-await ordering and the post-await existence\n     * re-check that guard a concurrent removal.\n     *\n     * @param aliasObj the `alias.*` object being subscribed\n     * @param pattern the subscription pattern that pulled it in\n     */\n    async addAliasSubscribe(aliasObj: ioBroker.AnyObject, pattern: string): Promise<void> {\n        if (aliasObj.type !== 'state') {\n            return;\n        }\n        if (!aliasObj.common?.alias?.id) {\n            this.logger.warn(`${this.namespaceLog} Alias ${aliasObj._id} has no target 5`);\n            throw new Error(`Alias ${aliasObj._id} has no target`);\n        }\n        const sourceId = tools.isObject(aliasObj.common.alias.id)\n            ? aliasObj.common.alias.id.read\n            : aliasObj.common.alias.id;\n        try {\n            this.#validateId(sourceId, true, null);\n        } catch (e: any) {\n            throw new Error(`Error validating alias id of ${aliasObj._id}: ${e.message}`);\n        }\n        const targetEntry: AliasTargetEntry = {\n            alias: deepClone(aliasObj.common.alias),\n            id: aliasObj._id,\n            pattern,\n            type: aliasObj.common.type,\n            max: aliasObj.common.max,\n            min: aliasObj.common.min,\n            unit: aliasObj.common.unit,\n        };\n        let aliasDetails: AliasDetails;\n        if (!this.#aliases.has(sourceId)) {\n            aliasDetails = { targets: [] };\n            this.#aliases.set(sourceId, aliasDetails);\n        } else {\n            aliasDetails = this.#aliases.get(sourceId)!;\n        }\n        if (!aliasDetails.source) {\n            await this.states.subscribe(sourceId);\n            const sourceObj = await this.objects.getObject(sourceId, { user: SYSTEM_ADMIN_USER });\n            if (sourceObj?.common && this.#aliases.has(sourceObj._id)) {\n                aliasDetails.source = {\n                    min: sourceObj.common.min,\n                    max: sourceObj.common.max,\n                    type: sourceObj.common.type,\n                    unit: sourceObj.common.unit,\n                };\n            }\n        }\n        aliasDetails.targets.push(targetEntry);\n    }\n\n    /**\n     * Remove one alias target from its source; when the source has no targets left, delete the entry\n     * and unsubscribe the source state.\n     *\n     * @param sourceId the real source state id\n     * @param aliasObjOrIdx the target entry or its index in the targets array\n     */\n    async removeAliasSubscribe(sourceId: string, aliasObjOrIdx: number | AliasTargetEntry): Promise<void> {\n        if (!this.#aliases.has(sourceId)) {\n            return;\n        }\n        const alias = this.#aliases.get(sourceId)!;\n        const pos = typeof aliasObjOrIdx === 'number' ? aliasObjOrIdx : alias.targets.indexOf(aliasObjOrIdx);\n        if (pos !== -1) {\n            alias.targets.splice(pos, 1);\n            if (!alias.targets.length) {\n                this.#aliases.delete(sourceId);\n                await this.states.unsubscribe(sourceId);\n            }\n        }\n    }\n}\n"],
+  "mappings": "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",
+  "names": ["deepClone"]
+}

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

@@ -0,0 +1,50 @@
+import type { InternalGetCertificatesResult } from '../../_Types.js';
+import type { AdapterContext } from '../../../lib/adapter/context.js';
+import { AdapterContextBase } from '../../../lib/adapter/managers/AdapterContextBase.js';
+/** ID of the object holding all configured certificates */
+export declare const CERTIFICATES_OBJECT_ID = "system.certificates";
+/** Fetches SSL certificates from `system.certificates`, resolving file-backed values to their contents. */
+export declare class CertificateManager extends AdapterContextBase {
+    #private;
+    /**
+     * @param ctx Shared adapter context providing live runtime state
+     */
+    constructor(ctx: AdapterContext);
+    /**
+     * Tells whether a new version of the `system.certificates` object actually changes one of the
+     * certificates handed out by the last {@link getCertificates} call. Unrelated certificates being
+     * added, changed or removed are ignored, so that editing some other adapter's certificate does
+     * not restart this one.
+     *
+     * Compares the raw (unresolved) values: for a file-backed certificate that is the path, so
+     * repointing it to a different file counts as a change, while a change of the file content is
+     * left to the file watcher.
+     *
+     * @param obj the new `system.certificates` object, or null/undefined if it was deleted
+     */
+    hasRelevantChange(obj: ioBroker.OtherObject | null | undefined): boolean;
+    /**
+     * Forgets the certificates handed out by the last {@link getCertificates} call, so a subsequent
+     * change of `system.certificates` is no longer treated as relevant by {@link hasRelevantChange}.
+     * Used when the adapter stops watching its certificates.
+     */
+    stopWatching(): void;
+    /**
+     * Loads the named certificates from `system.certificates`. File-backed values (short strings that
+     * are existing paths) are read from disk and their paths collected in `certFilePaths` so the caller
+     * can watch them.
+     *
+     * @param names public/private/chained certificate names
+     * @param names.publicName Name of the public certificate
+     * @param names.privateName Name of the private key
+     * @param names.chainedName Name of the chained certificate
+     * @throws {Error} `ERROR_DB_CLOSED` when the objects database is not connected
+     * @throws {Error} `ERROR_NOT_FOUND` when the requested certificates are not configured
+     */
+    getCertificates(names: {
+        publicName?: string;
+        privateName?: string;
+        chainedName?: string;
+    }): Promise<InternalGetCertificatesResult>;
+}
+//# sourceMappingURL=CertificateManager.d.ts.map