@iobroker/db-objects-file 7.2.3 → 8.0.0-alpha.2-20260923-99da17fcc

package/build/esm/lib/objects/objectsInMemFileDB.js

@@ -1,11 +1,12 @@
 /**
  *      Object DB in memory - Server
  *
- *      Copyright 2013-2024 bluefox <dogafox@gmail.com>
+ *      Copyright 2013-2026 bluefox <dogafox@gmail.com>
  *
  *      MIT License
  *
  */
+/// <reference types="@iobroker/types-dev" />
 import fs from 'fs-extra';
 import path from 'node:path';
 import { InMemoryFileDB } from '@iobroker/db-base';
@@ -17,62 +18,70 @@ import deepClone from 'deep-clone';
  * including the available methods for use by js-controller directly
  */
 export class ObjectsInMemoryFileDB extends InMemoryFileDB {
+    META_ID = '**META**';
+    fileOptions = {};
+    files = {};
+    writeTimer = null;
+    writeIds = [];
+    defaultNewAcl;
+    writeFileInterval;
+    objectsDir;
+    // cached meta information for file operations
+    existingMetaObjects = {};
+    /**
+     * @param settings Settings for the objects database
+     */
     constructor(settings) {
-        settings = settings || {};
-        settings.fileDB = settings.fileDB || {
+        settings.fileDB ??= {
             fileName: 'objects.json',
             backupDirName: 'backup-objects',
         };
         super(settings);
-        if (!this.change) {
-            this.change = id => {
-                this.log.silly(`${this.namespace} objects change: ${id} ${JSON.stringify(this.change)}`);
-            };
-        }
-        this.META_ID = '**META**';
-        this.fileOptions = {};
-        this.files = {};
-        this.writeTimer = null;
-        this.writeIds = [];
-        this.preserveSettings = ['custom'];
+        this.change ||= id => {
+            this.log.silly(`${this.namespace} objects change: ${id} ${JSON.stringify(this.change)}`);
+        };
         this.defaultNewAcl = this.settings.defaultNewAcl || null;
         this.namespace = this.settings.namespace || this.settings.hostname || '';
         this.writeFileInterval =
             this.settings.connection && typeof this.settings.connection.writeFileInterval === 'number'
-                ? parseInt(this.settings.connection.writeFileInterval)
+                ? this.settings.connection.writeFileInterval
                 : 5_000;
         if (!settings.jsonlDB) {
             this.log.silly(`${this.namespace} Objects DB uses file write interval of ${this.writeFileInterval} ms`);
         }
         this.objectsDir = path.join(this.dataDir, 'files');
-        // cached meta information for file operations
-        this.existingMetaObjects = {};
-        // Handle some < js-controller 2.0 broken objects and correct them
-        for (const obj of Object.values(this.dataset)) {
-            if (tools.isObject(obj) && obj.acl && obj.acl.permissions && !obj.acl.object) {
-                obj.acl.object = obj.acl.permissions;
-                delete obj.acl.permissions;
-            }
-        }
         // init default new acl
         const configObj = this.dataset['system.config'];
-        if (configObj && configObj.common && configObj.common.defaultNewAcl) {
+        if (configObj?.common?.defaultNewAcl) {
             this.defaultNewAcl = deepClone(configObj.common.defaultNewAcl);
         }
     }
-    // internal functionality
+    /**
+     * Normalize a file name by collapsing slashes and backslashes into a single forward slash
+     *
+     * @param name The file name to normalize
+     */
     _normalizeFilename(name) {
         return name ? name.replace(/[/\\]+/g, '/') : name;
     }
     // -------------- FILE FUNCTIONS -------------------------------------------
-    // internal functionality
+    /**
+     * Schedule writing the file settings (_data.json) to disk
+     *
+     * @param id The object ID whose file settings should be saved, or a boolean used as the force flag
+     * @param force If true, write the settings immediately instead of debounced
+     */
     _saveFileSettings(id, force) {
         if (typeof id === 'boolean') {
             force = id;
             id = undefined;
         }
-        id !== undefined && !this.writeIds.includes(id) && this.writeIds.push(id);
-        this.writeTimer && clearTimeout(this.writeTimer);
+        if (id !== undefined && !this.writeIds.includes(id)) {
+            this.writeIds.push(id);
+        }
+        if (this.writeTimer) {
+            clearTimeout(this.writeTimer);
+        }
         // if store immediately
         if (force) {
             this.writeTimer = null;
@@ -106,7 +115,11 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             }, 1_000);
         }
     }
-    // internal functionality
+    /**
+     * Load the file settings (_data.json) for the given object ID into memory
+     *
+     * @param id The object ID whose file settings should be loaded
+     */
     _loadFileSettings(id) {
         if (!this.fileOptions[id]) {
             const location = path.join(this.objectsDir, id, '_data.json');
@@ -142,7 +155,11 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             }
         }
     }
-    // server only functionality
+    /**
+     * Synchronize the in-memory file metadata with the files actually present on disk (server only)
+     *
+     * @param limitId Optional object ID to limit the synchronization to
+     */
     syncFileDirectory(limitId) {
         const resNotifies = [];
         let resSynced = 0;
@@ -152,7 +169,7 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             list.forEach(file => {
                 file = `${dir}/${file}`;
                 const stat = fs.statSync(file);
-                if (stat && stat.isDirectory()) {
+                if (stat?.isDirectory()) {
                     /* Recurse into a subdirectory */
                     results = results.concat(getAllFiles(file));
                 }
@@ -164,7 +181,7 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             return results;
         }
         const res = this._getObjectView('system', 'meta', null);
-        // collect meta ids to generate warning if non existing
+        // collect meta ids to generate warning if non-existing
         const metaIds = res.rows.map(obj => obj.id).filter(id => !limitId || limitId === id);
         if (!fs.existsSync(this.objectsDir)) {
             return {
@@ -206,10 +223,9 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
                     this.fileOptions[dir][localFile] = {
                         createdAt: fileStat.ctimeMs,
                         acl: {
-                            owner: (this.defaultNewAcl && this.defaultNewAcl.owner) || utils.CONSTS.SYSTEM_ADMIN_USER,
-                            ownerGroup: (this.defaultNewAcl && this.defaultNewAcl.ownerGroup) ||
-                                utils.CONSTS.SYSTEM_ADMIN_GROUP,
-                            permissions: (this.defaultNewAcl && this.defaultNewAcl.file) ||
+                            owner: this.defaultNewAcl?.owner || utils.CONSTS.SYSTEM_ADMIN_USER,
+                            ownerGroup: this.defaultNewAcl?.ownerGroup || utils.CONSTS.SYSTEM_ADMIN_GROUP,
+                            permissions: this.defaultNewAcl?.file ||
                                 utils.CONSTS.ACCESS_USER_RW |
                                     utils.CONSTS.ACCESS_GROUP_READ |
                                     utils.CONSTS.ACCESS_EVERY_READ, // 0x644
@@ -223,27 +239,36 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             });
             this._saveFileSettings(dir);
             resSynced += dirSynced;
-            dirSynced && resNotifies.push(`Added ${dirSynced} Files in Directory "${dir}"`);
+            if (dirSynced) {
+                resNotifies.push(`Added ${dirSynced} Files in Directory "${dir}"`);
+            }
         });
         return {
             numberSuccess: resSynced,
             notifications: resNotifies,
         };
     }
-    // needed by server
+    /**
+     * Write a file into an object's file storage (used by the server)
+     *
+     * @param id The object ID owning the file
+     * @param name The file name
+     * @param data The file content
+     * @param options Optional write options, or the mime type as a string
+     */
     _writeFile(id, name, data, options) {
         if (typeof options === 'string') {
             options = { mimeType: options };
         }
-        if (options && options.acl) {
+        if (options?.acl) {
             options.acl = null;
         }
         const _path = utils.sanitizePath(id, name);
         id = _path.id;
         name = _path.name;
-        options = options || {};
+        options ||= {};
         this._loadFileSettings(id);
-        this.files[id] = this.files[id] || {};
+        this.files[id] ||= {};
         try {
             if (!fs.existsSync(this.objectsDir)) {
                 fs.mkdirSync(this.objectsDir);
@@ -261,22 +286,17 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
         const mime = utils.getMimeType(ext);
         const _mimeType = mime.mimeType;
         const isBinary = mime.isBinary;
-        this.fileOptions[id][name] = this.fileOptions[id][name] || { createdAt: Date.now() };
-        this.fileOptions[id][name].acl = this.fileOptions[id][name].acl || {
-            owner: options.user || (this.defaultNewAcl && this.defaultNewAcl.owner) || utils.CONSTS.SYSTEM_ADMIN_USER,
-            ownerGroup: options.group ||
-                (this.defaultNewAcl && this.defaultNewAcl.ownerGroup) ||
-                utils.CONSTS.SYSTEM_ADMIN_GROUP,
+        this.fileOptions[id][name] ||= { createdAt: Date.now() };
+        this.fileOptions[id][name].acl ||= {
+            owner: options.user || this.defaultNewAcl?.owner || utils.CONSTS.SYSTEM_ADMIN_USER,
+            ownerGroup: options.group || this.defaultNewAcl?.ownerGroup || utils.CONSTS.SYSTEM_ADMIN_GROUP,
             permissions: options.mode ||
-                (this.defaultNewAcl && this.defaultNewAcl.file) ||
+                this.defaultNewAcl?.file ||
                 utils.CONSTS.ACCESS_USER_RW | utils.CONSTS.ACCESS_GROUP_READ | utils.CONSTS.ACCESS_EVERY_READ, // 0x644
         };
         this.fileOptions[id][name].mimeType = options.mimeType || _mimeType;
         this.fileOptions[id][name].binary = isBinary;
-        this.fileOptions[id][name].acl.ownerGroup =
-            this.fileOptions[id][name].acl.ownerGroup ||
-                (this.defaultNewAcl && this.defaultNewAcl.ownerGroup) ||
-                utils.CONSTS.SYSTEM_ADMIN_GROUP;
+        this.fileOptions[id][name].acl.ownerGroup ||= this.defaultNewAcl?.ownerGroup || utils.CONSTS.SYSTEM_ADMIN_GROUP;
         this.fileOptions[id][name].modifiedAt = Date.now();
         try {
             // Create directories if complex structure
@@ -304,43 +324,48 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             // publish event in states
             this.log.silly(`${this.namespace} memory publish ${id} ${JSON.stringify({ name, file: true, size })}`);
             this.publishAll('files', `${id}$%$${name}`, size);
-        }, name, data.byteLength);
+        }, name, Buffer.byteLength(data));
     }
-    // needed by server
+    /**
+     * Read a file from an object's file storage (used by the server)
+     *
+     * @param id The object ID owning the file
+     * @param name The file name
+     * @param options Optional read options
+     */
     _readFile(id, name, options) {
-        if (options && options.acl) {
+        if (options?.acl) {
             options.acl = null;
         }
         const _path = utils.sanitizePath(id, name);
         id = _path.id;
         name = _path.name;
-        options = options || {};
+        options ||= {};
         try {
             this._loadFileSettings(id);
-            this.files[id] = this.files[id] || {};
+            this.files[id] ||= {};
             if (!this.files[id][name] || this.settings.connection.noFileCache || options.noFileCache) {
                 const location = path.join(this.objectsDir, id, name);
                 if (fs.existsSync(location)) {
                     // Create description object if not exists
-                    this.fileOptions[id][name] = this.fileOptions[id][name] || {
+                    this.fileOptions[id][name] ||= {
                         acl: {
-                            owner: (this.defaultNewAcl && this.defaultNewAcl.owner) || utils.CONSTS.SYSTEM_ADMIN_USER,
-                            ownerGroup: (this.defaultNewAcl && this.defaultNewAcl.ownerGroup) ||
-                                utils.CONSTS.SYSTEM_ADMIN_GROUP,
-                            permissions: (this.defaultNewAcl && this.defaultNewAcl.file.permissions) ||
+                            owner: this.defaultNewAcl?.owner || utils.CONSTS.SYSTEM_ADMIN_USER,
+                            ownerGroup: this.defaultNewAcl?.ownerGroup || utils.CONSTS.SYSTEM_ADMIN_GROUP,
+                            permissions: this.defaultNewAcl?.file ||
                                 utils.CONSTS.ACCESS_USER_ALL |
                                     utils.CONSTS.ACCESS_GROUP_ALL |
                                     utils.CONSTS.ACCESS_EVERY_ALL, // 777
                         },
                     };
+                    // convert from old format
                     if (typeof this.fileOptions[id][name] !== 'object') {
                         this.fileOptions[id][name] = {
                             mimeType: this.fileOptions[id][name],
                             acl: {
-                                owner: (this.defaultNewAcl && this.defaultNewAcl.owner) || utils.CONSTS.SYSTEM_ADMIN_USER,
-                                ownerGroup: (this.defaultNewAcl && this.defaultNewAcl.ownerGroup) ||
-                                    utils.CONSTS.SYSTEM_ADMIN_GROUP,
-                                permissions: (this.defaultNewAcl && this.defaultNewAcl.file.permissions) ||
+                                owner: this.defaultNewAcl?.owner || utils.CONSTS.SYSTEM_ADMIN_USER,
+                                ownerGroup: this.defaultNewAcl?.ownerGroup || utils.CONSTS.SYSTEM_ADMIN_GROUP,
+                                permissions: this.defaultNewAcl?.file ||
                                     utils.CONSTS.ACCESS_USER_ALL |
                                         utils.CONSTS.ACCESS_GROUP_ALL |
                                         utils.CONSTS.ACCESS_EVERY_ALL, // 777
@@ -354,10 +379,8 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
                         this.fileOptions[id][name].binary = mimeType.isBinary;
                         this.fileOptions[id][name].mimeType = mimeType.mimeType;
                     }
-                    if (!this.fileOptions[id][name].binary) {
-                        if (this.files[id][name]) {
-                            this.files[id][name] = this.files[id][name].toString();
-                        }
+                    if (!this.fileOptions[id][name].binary && this.files[id][name]) {
+                        this.files[id][name] = this.files[id][name].toString();
                     }
                 }
                 else {
@@ -372,9 +395,9 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             if (this.fileOptions[id][name] && !this.fileOptions[id][name].acl) {
                 // all files belong to admin by default, but everyone can edit it
                 this.fileOptions[id][name].acl = {
-                    owner: (this.defaultNewAcl && this.defaultNewAcl.owner) || utils.CONSTS.SYSTEM_ADMIN_USER,
-                    ownerGroup: (this.defaultNewAcl && this.defaultNewAcl.ownerGroup) || utils.CONSTS.SYSTEM_ADMIN_GROUP,
-                    permissions: (this.defaultNewAcl && this.defaultNewAcl.file.permissions) ||
+                    owner: this.defaultNewAcl?.owner || utils.CONSTS.SYSTEM_ADMIN_USER,
+                    ownerGroup: this.defaultNewAcl?.ownerGroup || utils.CONSTS.SYSTEM_ADMIN_GROUP,
+                    permissions: this.defaultNewAcl?.file ||
                         utils.CONSTS.ACCESS_USER_ALL | utils.CONSTS.ACCESS_GROUP_ALL | utils.CONSTS.ACCESS_EVERY_RW, // 776
                 };
             }
@@ -421,7 +444,7 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
      *
      * @param id id of the namespace
      * @param [name] name of the file
-     * @returns
+     * @returns true if the file exists
      */
     // needed by server
     _fileExists(id, name) {
@@ -446,7 +469,7 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
      *
      * @param id id of the namespace
      * @param [name] name of the directory
-     * @returns
+     * @returns true if the directory exists
      */
     // special functionality only for Server (used together with SyncFileDirectory)
     dirExists(id, name) {
@@ -466,7 +489,12 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             return false;
         }
     }
-    // needed by server
+    /**
+     * Delete a file or directory from an object's file storage (used by the server)
+     *
+     * @param id The object ID owning the file
+     * @param name The file or directory name to delete
+     */
     _unlink(id, name) {
         const _path = utils.sanitizePath(id, name);
         id = _path.id;
@@ -489,7 +517,7 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
                 if (this.fileOptions[id]) {
                     delete this.fileOptions[id];
                 }
-                if (this.files[id] && this.files[id]) {
+                if (this.files[id]) {
                     delete this.files[id];
                 }
             }
@@ -502,10 +530,10 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
                     this.log.error(`${this.namespace} Cannot delete file "${path.join(id, name)}": ${e.message}`);
                     throw e;
                 }
-                if (this.fileOptions[id][name]) {
+                if (this.fileOptions[id]?.[name]) {
                     delete this.fileOptions[id][name];
                 }
-                if (this.files[id] && this.files[id][name]) {
+                if (this.files[id]?.[name]) {
                     delete this.files[id][name];
                 }
                 // Store dir description
@@ -518,9 +546,15 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             }, id, name);
         }
     }
-    // needed by server
+    /**
+     * List the contents of a directory in an object's file storage (used by the server)
+     *
+     * @param id The object ID owning the files
+     * @param name The directory name to list
+     * @param options Optional read options
+     */
     _readDir(id, name, options) {
-        if (options && options.acl) {
+        if (options?.acl) {
             options.acl = null;
         }
         if ((id === '' || id === '/' || id === '*') && (name === '' || name === '*')) {
@@ -531,7 +565,7 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             id = _path.id;
             name = _path.name;
         }
-        options = options || {};
+        options ||= {};
         // Find all files and directories starts with name
         const _files = [];
         if (id && id === '*') {
@@ -544,9 +578,8 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
         const len = name ? name.length : 0;
         for (const f of Object.keys(this.fileOptions[id])) {
             if (!name || f.substring(0, len) === name) {
-                let rest = f.substring(len);
-                rest = rest.split('/', 2);
-                if (rest[0] && _files.indexOf(rest[0]) === -1) {
+                const rest = f.substring(len).split('/', 2);
+                if (rest[0] && !_files.includes(rest[0])) {
                     _files.push(rest[0]);
                 }
             }
@@ -558,7 +591,7 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
                 if (dirFiles[i] === '..' || dirFiles[i] === '.') {
                     continue;
                 }
-                if (dirFiles[i] !== '_data.json' && _files.indexOf(dirFiles[i]) === -1) {
+                if (dirFiles[i] !== '_data.json' && !_files.includes(dirFiles[i])) {
                     _files.push(dirFiles[i]);
                 }
             }
@@ -575,16 +608,14 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             if (fs.existsSync(path.join(location, file))) {
                 try {
                     const stats = fs.statSync(path.join(location, file));
-                    const acl = this.fileOptions[id][name + file] && this.fileOptions[id][name + file].acl
+                    const acl = this.fileOptions[id][name + file]?.acl
                         ? deepClone(this.fileOptions[id][name + file].acl) // copy settings
                         : {
                             read: true,
                             write: true,
-                            owner: (this.defaultNewAcl && this.defaultNewAcl.owner) ||
-                                utils.CONSTS.SYSTEM_ADMIN_USER,
-                            ownerGroup: (this.defaultNewAcl && this.defaultNewAcl.ownerGroup) ||
-                                utils.CONSTS.SYSTEM_ADMIN_GROUP,
-                            permissions: (this.defaultNewAcl && this.defaultNewAcl.file.permissions) ||
+                            owner: this.defaultNewAcl?.owner || utils.CONSTS.SYSTEM_ADMIN_USER,
+                            ownerGroup: this.defaultNewAcl?.ownerGroup || utils.CONSTS.SYSTEM_ADMIN_GROUP,
+                            permissions: this.defaultNewAcl?.file ||
                                 utils.CONSTS.ACCESS_USER_RW |
                                     utils.CONSTS.ACCESS_GROUP_READ |
                                     utils.CONSTS.ACCESS_EVERY_READ,
@@ -592,24 +623,24 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
                     // if filter for user
                     if (options.filter && acl) {
                         // If user may not write
-                        if (!options.acl.file.write) {
+                        if (!options.acl?.file.write) {
                             // write
                             acl.permissions &= ~(utils.CONSTS.ACCESS_USER_WRITE |
                                 utils.CONSTS.ACCESS_GROUP_WRITE |
                                 utils.CONSTS.ACCESS_EVERY_WRITE);
                         }
                         // If user may not read
-                        if (!options.acl.file.read) {
+                        if (!options.acl?.file.read) {
                             // read
                             acl.permissions &= ~(utils.CONSTS.ACCESS_USER_READ |
                                 utils.CONSTS.ACCESS_GROUP_READ |
                                 utils.CONSTS.ACCESS_EVERY_READ);
                         }
                         if (options.user !== utils.CONSTS.SYSTEM_ADMIN_USER &&
-                            options.groups.includes(utils.CONSTS.SYSTEM_ADMIN_GROUP)) {
+                            options.groups?.includes(utils.CONSTS.SYSTEM_ADMIN_GROUP)) {
                             if (acl.owner !== options.user) {
                                 // Check if the user is in the group
-                                if (options.groups.includes(acl.ownerGroup)) {
+                                if (options.groups?.includes(acl.ownerGroup)) {
                                     // Check group rights
                                     if (!(acl.permissions & utils.CONSTS.ACCESS_GROUP_RW)) {
                                         continue;
@@ -642,9 +673,9 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
                     }
                     res.push({
                         file,
-                        stats: stats,
+                        stats,
                         isDir: stats.isDirectory(),
-                        acl: acl,
+                        acl,
                         modifiedAt: this.fileOptions[id][name + file]
                             ? this.fileOptions[id][name + file].modifiedAt
                             : undefined,
@@ -660,7 +691,13 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
         }
         return res;
     }
-    // needed by server
+    /**
+     * Rename a file or directory in an object's file storage (used by the server)
+     *
+     * @param id The object ID owning the file
+     * @param oldName The current file or directory name
+     * @param newName The new file or directory name
+     */
     _rename(id, oldName, newName) {
         const _path = utils.sanitizePath(id, oldName);
         id = _path.id;
@@ -691,29 +728,57 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
         });
         this._saveFileSettings(id, true);
     }
-    // internal functionality
+    /**
+     * Create a deep clone of the given object
+     *
+     * @param obj The object to clone
+     */
     _clone(obj) {
         if (obj === null || obj === undefined || !tools.isObject(obj)) {
             return obj;
         }
         const temp = obj.constructor(); // changed
         for (const key of Object.keys(obj)) {
+            // @ts-expect-error known problem
             temp[key] = this._clone(obj[key]);
         }
         return temp;
     }
+    /**
+     * Subscribe a client to meta changes
+     *
+     * @param client The client to subscribe
+     * @param pattern The pattern of meta IDs to subscribe to
+     */
     _subscribeMeta(client, pattern) {
         this.handleSubscribe(client, 'meta', pattern);
     }
-    // needed by server
+    /**
+     * Subscribe a client to object changes (used by the server)
+     *
+     * @param client The client to subscribe
+     * @param pattern The pattern of object IDs to subscribe to
+     */
     _subscribeConfigForClient(client, pattern) {
         this.handleSubscribe(client, 'objects', pattern);
     }
-    // needed by server
+    /**
+     * Unsubscribe a client from object changes (used by the server)
+     *
+     * @param client The client to unsubscribe
+     * @param pattern The pattern of object IDs to unsubscribe from
+     */
     _unsubscribeConfigForClient(client, pattern) {
-        this.handleUnsubscribe(client, 'objects', pattern); // ignore options => unsubscribe may everyone
+        // ignore options => unsubscribe may everyone
+        this.handleUnsubscribe(client, 'objects', pattern).catch(e => this.log.error(`${this.namespace} Cannot unsubscribe client from objects: ${e.message}`));
     }
-    // needed by server
+    /**
+     * Subscribe a client to file changes of an object (used by the server)
+     *
+     * @param client The client to subscribe
+     * @param id The object ID owning the files
+     * @param pattern One or more file name patterns to subscribe to
+     */
     _subscribeFileForClient(client, id, pattern) {
         if (Array.isArray(pattern)) {
             pattern.forEach(pattern => this.handleSubscribe(client, 'files', `${id}$%$${pattern}`));
@@ -722,33 +787,54 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             this.handleSubscribe(client, 'files', `${id}$%$${pattern}`);
         }
     }
-    // needed by server
+    /**
+     * Unsubscribe a client from file changes of an object (used by the server)
+     *
+     * @param client The client to unsubscribe
+     * @param id The object ID owning the files
+     * @param pattern One or more file name patterns to unsubscribe from
+     */
     _unsubscribeFileForClient(client, id, pattern) {
         if (Array.isArray(pattern)) {
             pattern.forEach(pattern => this.handleUnsubscribe(client, 'files', `${id}$%$${pattern}`));
         }
         else {
-            this.handleUnsubscribe(client, 'files', `${id}$%$${pattern}`);
+            this.handleUnsubscribe(client, 'files', `${id}$%$${pattern}`).catch(e => this.log.error(`${this.namespace} Cannot unsubscribe client from files: ${e.message}`));
         }
     }
-    // needed by server
+    /**
+     * Get a single object by its ID (used by the server)
+     *
+     * @param id The object ID to read
+     */
     _getObject(id) {
         return this.dataset[id];
     }
-    // needed by server
+    /**
+     * Get all object IDs matching the given pattern, sorted (used by the server)
+     *
+     * @param pattern The pattern to match object IDs against
+     */
     _getKeys(pattern) {
         const r = new RegExp(tools.pattern2RegEx(pattern));
         const result = Object.keys(this.dataset).filter(id => r.test(id) && id !== this.META_ID);
         result.sort();
         return result;
     }
-    // needed by server
+    /**
+     * Get the values of the given object IDs (used by the server)
+     *
+     * @param keys The object IDs to read
+     */
     _getObjects(keys) {
         if (!keys) {
             throw new Error('no keys');
         }
-        return keys.map(id => this.dataset[id]);
+        return keys.map(id => (id ? this.dataset[id] : undefined));
     }
+    /**
+     * Get the meta dictionary, creating it if it does not exist yet
+     */
     _ensureMetaDict() {
         let meta = this.dataset[this.META_ID];
         if (!meta) {
@@ -760,8 +846,8 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
     /**
      * Get value of given meta id
      *
-     * @param id
-     * @returns
+     * @param id The meta ID to read
+     * @returns the stored meta value
      */
     getMeta(id) {
         const meta = this._ensureMetaDict();
@@ -770,8 +856,8 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
     /**
      * Sets given value to id in metaNamespace
      *
-     * @param id
-     * @param value
+     * @param id The meta ID to write
+     * @param value The value to store
      */
     setMeta(id, value) {
         const meta = this._ensureMetaDict();
@@ -783,11 +869,14 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             this.log.silly(`${this.namespace} memory publish meta ${id} ${value}`);
             this.publishAll('meta', id, value);
         });
-        if (!this.stateTimer) {
-            this.stateTimer = setTimeout(() => this.saveState(), this.writeFileInterval);
-        }
+        this.stateTimer ||= setTimeout(() => this.saveState(), this.writeFileInterval);
     }
-    // needed by server
+    /**
+     * Directly set an object value and publish the change (used by the server)
+     *
+     * @param id The object ID to set
+     * @param obj The object to store
+     */
     _setObjectDirect(id, obj) {
         this.dataset[id] = obj;
         // object updated -> if type changed to meta -> cache
@@ -795,7 +884,7 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             this.existingMetaObjects[id] = true;
         }
         setImmediate(() => this.publishAll('objects', id, obj));
-        this.stateTimer = this.stateTimer || setTimeout(() => this.saveState(), this.writeFileInterval);
+        this.stateTimer ||= setTimeout(() => this.saveState(), this.writeFileInterval);
     }
     /**
      * Delete the given object from the dataset
@@ -821,14 +910,21 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
             this.stateTimer = setTimeout(() => this.saveState(), this.writeFileInterval);
         }
     }
-    // internal functionality
+    /**
+     * Apply a view's map function over all objects and collect the matching rows
+     *
+     * @param func The view definition containing the map function
+     * @param func.map The map function source code to apply
+     * @param func.reduce Optional reduce function (only the built-in '_stats' is supported)
+     * @param params Query parameters such as startkey and endkey
+     */
     _applyView(func, params) {
         const result = {
             rows: [],
         };
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        function _emit_(id, obj) {
-            result.rows.push({ id: id, value: obj });
+        function _emit_(id, value) {
+            result.rows.push({ id, value });
         }
         const f = eval(`(${func.map.replace(/emit/g, '_emit_')})`);
         for (const [id, obj] of Object.entries(this.dataset)) {
@@ -858,7 +954,7 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
                 }
             }
             if (max !== null) {
-                result.rows = [{ id: '_stats', value: { max: max } }];
+                result.rows = [{ id: '_stats', value: { max } }];
             }
             else {
                 result.rows = [];
@@ -866,14 +962,20 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
         }
         return result;
     }
-    // needed by server
+    /**
+     * Run a predefined object view (design document) and return the matching rows (used by the server)
+     *
+     * @param design The design document name
+     * @param search The view name within the design document
+     * @param params Query parameters such as startkey and endkey
+     */
     _getObjectView(design, search, params) {
         const designObj = this.dataset[`_design/${design}`];
         if (!designObj) {
             this.log.error(`${this.namespace} Cannot find view "${design}"`);
             throw new Error(`Cannot find view "${design}"`);
         }
-        if (!(designObj.views && designObj.views[search])) {
+        if (!designObj.views?.[search]) {
             this.log.warn(`${this.namespace} Cannot find search "${search}" in "${design}"`);
             throw new Error(`Cannot find search "${search}" in "${design}"`);
         }