[BUGFIX] Improvement of adapter.findForeignObject (#3020)

GermanBluefox · web-flow · commit d7f4b912895e · 2025-03-23T12:57:48.000+01:00
* Improvement of adapter.findForeignObject

* Formatting

* Fixing tests

* Fixing typing

* Added positive tests

* Added positive tests
diff --git a/packages/adapter/src/lib/adapter/adapter.ts b/packages/adapter/src/lib/adapter/adapter.ts
@@ -507,12 +507,7 @@ export interface AdapterClass {
     ): ioBroker.SetObjectPromise;
 
     /**
-     * Finds an object by its ID or name
-     */
-    findForeignObjectAsync(idOrName: string, type: string): Promise<{ id: string; name: string }>;
-
-    /**
-     * Creates an object with type channel. It must be located under a device
+     * Creates an object with a type channel. It must be located under a device
      *
      * @deprecated use `extendObject` instead
      */
@@ -1022,11 +1017,6 @@ export class AdapterClass extends EventEmitter {
          */
         this.getForeignObjectsAsync = tools.promisify(this.getForeignObjects, this);
 
-        /**
-         * Promise-version of `Adapter.findForeignObject`
-         */
-        this.findForeignObjectAsync = tools.promisify(this.findForeignObject, this, ['id', 'name']);
-
         /**
          * Promise-version of `Adapter.getForeignObject`
          */
@@ -4380,7 +4370,7 @@ export class AdapterClass extends EventEmitter {
             }
         }
 
-        // don't forget, that enums returns names in row[x].id and not IDs, you can find id in rows[x].value._id
+        // don't forget that enums returns names in row[x].id and not IDs, you can find id in rows[x].value._id
         let _enums;
         try {
             _enums = await this.getEnumsAsync(enums);
@@ -4449,21 +4439,21 @@ export class AdapterClass extends EventEmitter {
     }
 
     // external signature
-    findForeignObject(idOrName: string, type: string | null, callback: ioBroker.FindObjectCallback): void;
+    findForeignObject(idOrName: string, type: ioBroker.CommonType | null, callback: ioBroker.FindObjectCallback): void;
     findForeignObject(
         idOrName: string,
-        type: string | null,
-        options: unknown,
+        type: ioBroker.CommonType | null,
+        options: { user?: `system.user.${string}`; language?: ioBroker.Languages },
         callback: ioBroker.FindObjectCallback,
     ): void;
 
     /**
      * Find any object by name or ID.
      *
-     * Find object by the exact name or ID.
+     * Find an object by the exact name or ID.
      *
      * @param id exactly object ID (without namespace)
-     * @param type optional common.type of state: 'number', 'string', 'boolean', 'file', ...
+     * @param type optional `common.type` of state: 'number', 'string', 'boolean', 'file', ...
      * @param options optional user context
      * @param callback return result
      *        ```js
@@ -4504,7 +4494,39 @@ export class AdapterClass extends EventEmitter {
             return tools.maybeCallbackWithError(callback, e);
         }
 
-        this.#objects.findObject(id, type, options || {}, callback);
+        this.#objects.findObject(id, type as ioBroker.CommonType | null, options || {}, callback);
+    }
+
+    /**
+     * Find an object by the exact name or ID.
+     *
+     * @param id exactly object ID (without a namespace)
+     * @param type optional `common.type` of the state: 'number', 'string', 'boolean', 'file', ...
+     * @param options optional user context with language
+     * @param options.user current user
+     * @param options.language language in which the search must be done for multi-language names
+     * @result if the object was found by ID it will return id and may be the multi-language name it exists. If the object was found by name it will return id and the multi-language name. If the object was not found, it will return only name that was searched for.
+     */
+    findForeignObjectAsync(
+        id: string,
+        type: ioBroker.CommonType | null,
+        options?: { user?: `system.user.${string}`; language?: ioBroker.Languages },
+    ): Promise<{ id?: string; name: ioBroker.StringOrTranslated }> {
+        return new Promise<{ id?: string; name: ioBroker.StringOrTranslated }>((resolve, reject) =>
+            this.findForeignObject(
+                id,
+                type,
+                options || {},
+                (err, id?: string, name?: ioBroker.StringOrTranslated): void => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        // if not error, name cannot be undefined
+                        resolve(id ? { id, name: name! } : { name: name! });
+                    }
+                },
+            ),
+        );
     }
 
     // external signatures
diff --git a/packages/controller/test/lib/testObjects.ts b/packages/controller/test/lib/testObjects.ts
@@ -99,11 +99,17 @@ export function register(it: Mocha.TestFunction, expect: Chai.ExpectStatic, cont
                     expect(idOrName).to.be.equal('test3');
                     expect(id).to.be.equal(undefined);
 
-                    objects.findObject('test2', 'channel', (err, id, idOrName) => {
+                    objects.findObject('test2', 'boolean', (err, id, idOrName) => {
                         expect(err).to.be.not.ok;
                         expect(idOrName).to.be.equal('test2');
                         expect(id).to.be.equal(undefined);
-                        done();
+
+                        objects.findObject('test2', 'string', (err, id, idOrName) => {
+                            expect(err).to.be.not.ok;
+                            expect(idOrName).to.be.equal('test2');
+                            expect(id).to.be.equal(testId);
+                            done();
+                        });
                     });
                 });
             });
@@ -125,10 +131,14 @@ export function register(it: Mocha.TestFunction, expect: Chai.ExpectStatic, cont
             })
             .then(id => {
                 expect(id).to.be.equal(undefined);
-                return objects.findObject('test3', 'channel');
+                return objects.findObject('test3', 'boolean');
             })
             .then(id => {
                 expect(id).to.be.equal(undefined);
+                return objects.findObject('test2', 'string');
+            })
+            .then(id => {
+                expect(id).to.be.equal(testId);
                 done();
             })
             .catch(err => {
diff --git a/packages/controller/test/lib/testObjectsFunctions.ts b/packages/controller/test/lib/testObjectsFunctions.ts
@@ -312,7 +312,7 @@ export function register(it: Mocha.TestFunction, expect: Chai.ExpectStatic, cont
                 expect(err).to.be.null;
                 expect(id).to.be.equal(`${context.adapterShortName}.0.${gid}`);
 
-                context.adapter.findForeignObject('test1', 'channel', function (err, id) {
+                context.adapter.findForeignObject('test1', 'boolean', function (err, id) {
                     expect(err).to.be.null;
 
                     expect(id).to.be.undefined;
diff --git a/packages/db-objects-redis/src/lib/objects/objectsInRedisClient.ts b/packages/db-objects-redis/src/lib/objects/objectsInRedisClient.ts
@@ -4726,19 +4726,18 @@ export class ObjectsInRedisClient {
      */
     private _findObject(
         idOrName: string,
-        type: string | null,
-        options: CallOptions,
+        type: ioBroker.CommonType | null,
+        options: CallOptions & { language?: ioBroker.Languages },
         callback?: ioBroker.FindObjectCallback,
     ): void {
+        // Try to read by ID
         this._getObject(idOrName, options, (err, obj) => {
             // Assume it is ID
-            if (
-                obj &&
-                utils.checkObject(obj, options, CONSTS.ACCESS_READ) &&
-                (!type || (obj.common && obj.common.type === type))
-            ) {
+            if (obj && utils.checkObject(obj, options, CONSTS.ACCESS_READ) && (!type || obj.common?.type === type)) {
                 return tools.maybeCallbackWithError(callback, null, idOrName, obj.common.name);
             }
+
+            // Get all objects that this user may read
             this._getKeys(
                 '*',
                 options,
@@ -4751,14 +4750,14 @@ export class ObjectsInRedisClient {
                         return tools.maybeCallbackWithError(callback, err);
                     }
 
-                    let objs;
+                    let objs: (string | null)[];
                     try {
                         objs = await this.client.mget(keys);
                     } catch (e) {
                         return tools.maybeCallbackWithRedisError(callback, e);
                     }
                     objs = objs || [];
-                    // Assume it is name
+                    // Assume it is a name
                     for (let i = 0; i < keys.length; i++) {
                         const strObj = objs[i];
                         let obj: ioBroker.AnyObject | null;
@@ -4768,12 +4767,15 @@ export class ObjectsInRedisClient {
                             this.log.error(`${this.namespace} Cannot parse JSON ${keys[i]}: ${objs[i]}`);
                             continue;
                         }
-                        if (
-                            obj?.common &&
-                            obj.common.name === idOrName &&
-                            (!type || ('type' in obj.common && obj.common.type === type))
-                        ) {
-                            return tools.maybeCallbackWithError(callback, null, obj._id, idOrName);
+
+                        if (obj?.common && (!type || ('type' in obj.common && obj.common.type === type))) {
+                            let name = obj?.common?.name;
+                            if (name && typeof name === 'object') {
+                                name = name[options.language || 'en'] || name.en;
+                            }
+                            if (name === idOrName) {
+                                return tools.maybeCallbackWithError(callback, null, obj._id, obj.common.name);
+                            }
                         }
                     }
                     return tools.maybeCallbackWithError(callback, null, undefined, idOrName);
@@ -4786,25 +4788,25 @@ export class ObjectsInRedisClient {
     // The user has provided a callback, thus we call it
     findObject(
         idOrName: string,
-        type: string | null,
-        options: CallOptions | null,
+        type: ioBroker.CommonType | null,
+        options: (CallOptions & { language?: ioBroker.Languages }) | null,
         callback: ioBroker.FindObjectCallback,
     ): void;
 
     // The user has provided a callback without options
-    findObject(idOrName: string, type: string | null, callback: ioBroker.FindObjectCallback): void;
+    findObject(idOrName: string, type: ioBroker.CommonType | null, callback: ioBroker.FindObjectCallback): void;
 
     // No callback provided by user, we return a promise
     findObject(
         idOrName: string,
-        type?: string | null,
-        options?: CallOptions | null,
+        type?: ioBroker.CommonType | null,
+        options?: (CallOptions & { language?: ioBroker.Languages }) | null,
     ): Promise<ioBroker.CallbackReturnTypeOf<ioBroker.FindObjectCallback>>;
 
     findObject(
         idOrName: string,
-        type: string | null,
-        options: CallOptions | null,
+        type: ioBroker.CommonType | null,
+        options: (CallOptions & { language?: ioBroker.Languages }) | null,
         callback?: ioBroker.FindObjectCallback,
     ): void | Promise<ioBroker.CallbackReturnTypeOf<ioBroker.FindObjectCallback>> {
         if (typeof type === 'function') {
