@iobroker/js-controller-adapter 7.2.4 → 7.2.5

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

@@ -388,6 +388,8 @@ export interface InternalAddChannelToEnumOptions {
 export interface SendToOptions {
     /** Method throws or calls error cb, if callback not called in time, works for single targets only */
     timeout?: number;
+    /** The user on whose behalf the message is sent */
+    user?: ioBroker.ObjectIDs.User;
 }
 export interface InternalSendToOptions {
     instanceName: string;
@@ -411,6 +413,7 @@ export interface InternalSendToHostOptions {
     command: string;
     message: any;
     callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo;
+    options?: SendToOptions;
 }
 export interface InternalGetStateOptions {
     id: string;

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

@@ -162,7 +162,7 @@ export interface AdapterClass {
      * Sends a message to a specific host or all hosts.
      */
     sendToHostAsync(hostName: string, message: ioBroker.MessagePayload): Promise<ioBroker.Message | undefined>;
-    sendToHostAsync(hostName: string, command: string, message: ioBroker.MessagePayload): Promise<ioBroker.Message | undefined>;
+    sendToHostAsync(hostName: string, command: string, message: ioBroker.MessagePayload, options?: SendToOptions): Promise<ioBroker.Message | undefined>;
     /**
      * Sends a message to a specific instance or all instances of some specific adapter.
      */
@@ -722,7 +722,7 @@ export declare class AdapterClass extends EventEmitter {
     sendTo(instanceName: string, command: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo, options?: SendToOptions): void;
     private _sendTo;
     sendToHost(hostName: string | null, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
-    sendToHost(hostName: string | null, command: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
+    sendToHost(hostName: string | null, command: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo, options?: SendToOptions): void;
     private _sendToHost;
     sendToUI(options: SendToUserInterfaceClientOptions): Promise<void>;
     registerNotification<Scope extends keyof ioBroker.NotificationScopes>(scope: Scope, category: ioBroker.NotificationScopes[Scope] | null, message: string, options?: NotificationOptions): Promise<void>;

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

@@ -363,7 +363,6 @@ class AdapterClass extends import_node_events.EventEmitter {
     this.readFileAsync = import_js_controller_common.tools.promisify(this.readFile, this, ["file", "mimeType"]);
     this.writeFileAsync = import_js_controller_common.tools.promisify(this.writeFile, this);
     this.fileExistsAsync = import_js_controller_common.tools.promisify(this.fileExists, this);
-    this.sendToHostAsync = import_js_controller_common.tools.promisifyNoError(this.sendToHost, this);
     this.setStateAsync = import_js_controller_common.tools.promisify(this.setState, this);
     this.setStateChangedAsync = import_js_controller_common.tools.promisify(this.setStateChanged, this, ["id", "notChanged"]);
     this.setForeignStateAsync = import_js_controller_common.tools.promisify(this.setForeignState, this);
@@ -4711,13 +4710,27 @@ class AdapterClass extends import_node_events.EventEmitter {
       this.sendTo(instanceName, command, message, callback, options);
     });
   }
+  /**
+   * The `user` field of an outbound message, from the `user` of the send options.
+   *
+   * Spread into the envelope, so a send without a user leaves the field out entirely instead of
+   * putting an empty one in: a receiver that checks `obj.user` must be able to tell "nobody named a
+   * user" from "the user is known", and an empty string is neither.
+   *
+   * @param options the send options the caller passed, if any
+   */
+  #userOf(options) {
+    const user = options?.user;
+    return typeof user === "string" && user ? { user } : {};
+  }
   async _sendTo(_options) {
     const { command, message, callback, options } = _options;
     let { instanceName } = _options;
     const obj = {
       command,
       message,
-      from: `system.adapter.${this.namespace}`
+      from: `system.adapter.${this.namespace}`,
+      ...this.#userOf(options)
     };
     if (!instanceName) {
       return import_js_controller_common.tools.maybeCallbackWithError(callback, "No instanceName provided or not a string");
@@ -4817,8 +4830,10 @@ class AdapterClass extends import_node_events.EventEmitter {
    *              if (!result) adapter.log.error('No response received');
    *            }
    *        ```
+   * @param options optional send options: a `timeout` for the answer, or the `user` this message is
+   * sent on behalf of - the host sees it as `obj.user`
    */
-  sendToHost(hostName, command, message, callback) {
+  sendToHost(hostName, command, message, callback, options) {
     if (typeof message === "undefined") {
       message = command;
       command = "send";
@@ -4830,17 +4845,57 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (!import_js_controller_common.tools.isObject(callback)) {
       import_validator.Validator.assertOptionalCallback(callback, "callback");
     }
+    if (options !== void 0) {
+      import_validator.Validator.assertObject(options, "options");
+    }
     return this._sendToHost({
       hostName,
       command,
       message,
+      options,
       callback
     });
   }
+  /**
+   * Async version of sendToHost
+   *
+   * Resolves with whatever the host answered - like the promisified version it replaces, an error
+   * of the host reaches the caller as the resolved value, and that is left alone: an adapter that
+   * awaits this today must not start seeing rejections.
+   *
+   * It rejects in one case: a `timeout` was asked for in the send options and elapsed, which is
+   * how `sendToAsync` reports the same thing. Whoever passes that option is writing against an
+   * option that did not exist before and can expect it; whoever passes none keeps the old
+   * behaviour, including a host that never answers and a caller that waits for ever.
+   *
+   * @param hostName name of the host where the message must be sent to. E.g. "myPC" or "system.host.myPC". If argument is null, the message will be sent to all hosts.
+   * @param command command name. One of: "cmdExec", "getRepository", "getInstalled", ...
+   * @param message object that will be given as argument for request
+   * @param options optional send options: a `timeout` for the answer, or the `user` the message is sent for
+   */
+  sendToHostAsync(hostName, command, message, options) {
+    const timeout = options?.timeout;
+    return new Promise((resolve, reject) => {
+      this.sendToHost(
+        hostName,
+        command,
+        message,
+        // The answer of a host travels through the states database and is therefore never an
+        // `Error` instance; one can only come from here, and only where a budget was named.
+        (result) => timeout && result instanceof Error ? reject(result) : resolve(result),
+        options
+      );
+    });
+  }
   async _sendToHost(_options) {
-    const { command, message, callback } = _options;
+    const { command, message, callback, options } = _options;
     let { hostName } = _options;
-    const obj = { command, message, from: `system.adapter.${this.namespace}` };
+    const obj = {
+      command,
+      message,
+      from: `system.adapter.${this.namespace}`,
+      ...this.#userOf(options)
+    };
     if (!this.#states) {
       this._logger.info(`${this.namespaceLog} sendToHost not processed because States database not connected`);
       return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
@@ -4889,7 +4944,18 @@ class AdapterClass extends import_node_events.EventEmitter {
           if (this._callbackId >= 4294967295) {
             this._callbackId = 1;
           }
-          this.messageCallbacks.set(obj.callback.id, { cb: callback, time: Date.now() });
+          const callbackId = obj.callback.id;
+          let timer;
+          if (options?.timeout) {
+            timer = setTimeout(() => {
+              const callbackObj = this.messageCallbacks.get(callbackId);
+              if (callbackObj) {
+                callbackObj.cb(new Error("Timeout exceeded"));
+                this.messageCallbacks.delete(callbackId);
+              }
+            }, options.timeout);
+          }
+          this.messageCallbacks.set(callbackId, { cb: callback, time: Date.now(), timer });
         } else {
           obj.callback = callback;
           obj.callback.ack = true;