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

package/build/cjs/index.js

@@ -3,6 +3,7 @@ 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 });
@@ -16,20 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var esm_exports = {};
-__export(esm_exports, {
+var index_exports = {};
+__export(index_exports, {
   Client: () => import_db_objects_redis.Client,
   ObjectsInMemoryFileDB: () => import_objectsInMemFileDB.ObjectsInMemoryFileDB,
   Server: () => import_objectsInMemServerClass.ObjectsInMemoryServerClass,
   getDefaultPort: () => getDefaultPort
 });
-module.exports = __toCommonJS(esm_exports);
+module.exports = __toCommonJS(index_exports);
 var import_objectsInMemFileDB = require("./lib/objects/objectsInMemFileDB.js");
 var import_db_objects_redis = require("@iobroker/db-objects-redis");
 var import_objectsInMemServerClass = require("./lib/objects/objectsInMemServerClass.js");
 function getDefaultPort() {
   return 9001;
 }
+__name(getDefaultPort, "getDefaultPort");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Client,

package/build/cjs/index.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/index.ts"],
   "sourcesContent": ["export { ObjectsInMemoryFileDB } from './lib/objects/objectsInMemFileDB.js';\nexport { Client } from '@iobroker/db-objects-redis';\nexport { ObjectsInMemoryServerClass as Server } from './lib/objects/objectsInMemServerClass.js';\n\n/**\n * Get the default port of the objects db\n */\nexport function getDefaultPort(): number {\n    return 9001;\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;;;;;;;;AAAA,gCAAsC;AACtC,8BAAuB;AACvB,qCAAqD;AAK/C,SAAU,iBAAc;AAC1B,SAAO;AACX;",
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;AAAA,gCAAsC;AACtC,8BAAuB;AACvB,qCAAqD;AAK/C,SAAU,iBAAc;AAC1B,SAAO;AACX;AAFgB;",
   "names": []
 }

package/build/cjs/lib/objects/objectsInMemFileDB.d.ts

@@ -1,32 +1,137 @@
+/**
+ *      Object DB in memory - Server
+ *
+ *      Copyright 2013-2026 bluefox <dogafox@gmail.com>
+ *
+ *      MIT License
+ *
+ */
+import fs from 'fs-extra';
+import { InMemoryFileDB, type FileDbSettings, type MetaObject } from '@iobroker/db-base';
+/** Options accepted by the file access methods (or, for writes, a mime type string) */
+interface FileAccessOptions {
+    /** Access control list / permission context (cleared internally before use) */
+    acl?: {
+        owner: ioBroker.ObjectIDs.User;
+        ownerGroup: ioBroker.ObjectIDs.Group;
+        file: {
+            read?: boolean;
+            write?: boolean;
+            permissions?: number;
+        };
+    } | null;
+    /** User that owns a newly created file, or the user whose access is being checked */
+    user?: ioBroker.ObjectIDs.User;
+    /** Group that owns a newly created file */
+    group?: ioBroker.ObjectIDs.Group;
+    /** Groups the requesting user belongs to (used for permission checks) */
+    groups?: ioBroker.ObjectIDs.Group[];
+    /** File permission bitmask for a newly created file */
+    mode?: number;
+    /** Explicit mime type to store with the file */
+    mimeType?: string;
+    /** Bypass the in-memory file cache and read from disk */
+    noFileCache?: boolean;
+    /** Whether directory listings should be filtered by the user's permissions */
+    filter?: boolean;
+}
+interface Subscription {
+    pattern: string;
+    regex: RegExp;
+}
+interface SubscriptionClient {
+    _subscribe?: Record<string, Subscription[]>;
+}
+/** Metadata stored alongside a file */
+export interface FileOptions {
+    /** Timestamp (ms) when the file was created */
+    createdAt?: number;
+    /** Access control list of the file */
+    acl: ioBroker.FileACL;
+    /** The mime type of the file */
+    mimeType: string;
+    /** Whether the file content is binary */
+    binary?: boolean;
+    /** Timestamp (ms) when the file was last modified */
+    modifiedAt?: number;
+    /** File system stats of the file */
+    stats?: fs.Stats;
+}
 /**
  * This class inherits InMemoryFileDB class and adds all relevant logic for objects
  * including the available methods for use by js-controller directly
  */
-export class ObjectsInMemoryFileDB extends InMemoryFileDB {
-    constructor(settings: any);
-    change: any;
-    META_ID: string;
-    fileOptions: {};
-    files: {};
-    writeTimer: NodeJS.Timeout | null;
-    writeIds: any[];
-    preserveSettings: string[];
-    defaultNewAcl: any;
-    namespace: any;
-    writeFileInterval: number;
-    objectsDir: string;
-    existingMetaObjects: {};
-    _normalizeFilename(name: any): any;
-    _saveFileSettings(id: any, force: any): void;
-    _loadFileSettings(id: any): void;
-    syncFileDirectory(limitId: any): {
+export declare class ObjectsInMemoryFileDB<THandler extends SubscriptionClient> extends InMemoryFileDB<ioBroker.AnyObject | ioBroker.DesignObject, THandler> {
+    private readonly META_ID;
+    protected readonly fileOptions: {
+        [id: string]: {
+            [fileName: string]: FileOptions;
+        };
+    };
+    private readonly files;
+    private writeTimer;
+    private writeIds;
+    protected readonly defaultNewAcl: {
+        object: number;
+        state: number;
+        file: number;
+        owner: ioBroker.ObjectIDs.User;
+        ownerGroup: ioBroker.ObjectIDs.Group;
+    } | null;
+    private readonly writeFileInterval;
+    protected readonly objectsDir: string;
+    private existingMetaObjects;
+    /**
+     * @param settings Settings for the objects database
+     */
+    constructor(settings: FileDbSettings<ioBroker.AnyObject | ioBroker.DesignObject>);
+    /**
+     * Normalize a file name by collapsing slashes and backslashes into a single forward slash
+     *
+     * @param name The file name to normalize
+     */
+    _normalizeFilename(name: string): string;
+    /**
+     * 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?: string | boolean, force?: boolean): void;
+    /**
+     * 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: string): void;
+    /**
+     * 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?: string): {
         numberSuccess: number;
-        notifications: any[];
+        notifications: string[];
     };
-    _writeFile(id: any, name: any, data: any, options: any): void;
-    _readFile(id: any, name: any, options: any): {
-        fileContent: any;
-        fileMime: any;
+    /**
+     * 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: string, name: string, data: Buffer | string, options?: FileAccessOptions | string): void;
+    /**
+     * 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: string, name: string, options?: FileAccessOptions): {
+        fileContent: Buffer | string;
+        fileMime: string;
     };
     /**
      * Check if given object exists
@@ -34,71 +139,195 @@ export class ObjectsInMemoryFileDB extends InMemoryFileDB {
      * @param id id of the object
      * @returns if the object exists
      */
-    _objectExists(id: any): boolean;
+    _objectExists(id: string): boolean;
     /**
      * Check if given file exists
      *
      * @param id id of the namespace
      * @param [name] name of the file
-     * @returns
+     * @returns true if the file exists
      */
-    _fileExists(id: any, name?: any): boolean;
+    _fileExists(id: string, name?: string): boolean;
     /**
      * Check if given directory exists
      *
      * @param id id of the namespace
      * @param [name] name of the directory
-     * @returns
+     * @returns true if the directory exists
      */
-    dirExists(id: any, name?: any): boolean;
-    _unlink(id: any, name: any): void;
-    _readDir(id: any, name: any, options: any): {
+    dirExists(id: string, name?: string): boolean;
+    /**
+     * 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: string, name: string): void;
+    /**
+     * 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: string, name: string, options?: FileAccessOptions): {
         file: string;
-        stats: fs.Stats;
+        stats: {
+            size?: number;
+        };
         isDir: boolean;
-        acl: any;
-        modifiedAt: any;
-        createdAt: any;
+        acl: ioBroker.EvaluatedFileACL;
+        notExists?: boolean;
+        virtualFile?: boolean;
+        modifiedAt: number | undefined;
+        createdAt: undefined | number;
     }[];
-    _rename(id: any, oldName: any, newName: any): void;
-    _clone(obj: any): any;
-    _subscribeMeta(client: any, pattern: any): void;
-    _subscribeConfigForClient(client: any, pattern: any): void;
-    _unsubscribeConfigForClient(client: any, pattern: any): void;
-    _subscribeFileForClient(client: any, id: any, pattern: any): void;
-    _unsubscribeFileForClient(client: any, id: any, pattern: any): void;
-    _getObject(id: any): any;
-    _getKeys(pattern: any): string[];
-    _getObjects(keys: any): any;
-    _ensureMetaDict(): any;
+    /**
+     * 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: string, oldName: string, newName: string): void;
+    /**
+     * Create a deep clone of the given object
+     *
+     * @param obj The object to clone
+     */
+    _clone<T>(obj: T): T;
+    /**
+     * Subscribe a client to meta changes
+     *
+     * @param client The client to subscribe
+     * @param pattern The pattern of meta IDs to subscribe to
+     */
+    _subscribeMeta(client: THandler, pattern: string): void;
+    /**
+     * 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: THandler, pattern: string): void;
+    /**
+     * 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: THandler, pattern: string): void;
+    /**
+     * 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: THandler, id: string, pattern: string | string[]): void;
+    /**
+     * 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: THandler, id: string, pattern: string | string[]): void;
+    /**
+     * Get a single object by its ID (used by the server)
+     *
+     * @param id The object ID to read
+     */
+    _getObject(id: string): ioBroker.AnyObject | ioBroker.DesignObject | MetaObject | undefined;
+    /**
+     * Get all object IDs matching the given pattern, sorted (used by the server)
+     *
+     * @param pattern The pattern to match object IDs against
+     */
+    _getKeys(pattern: string): string[];
+    /**
+     * Get the values of the given object IDs (used by the server)
+     *
+     * @param keys The object IDs to read
+     */
+    _getObjects(keys: (string | null)[]): (ioBroker.AnyObject | ioBroker.DesignObject | MetaObject | undefined)[];
+    /**
+     * Get the meta dictionary, creating it if it does not exist yet
+     */
+    _ensureMetaDict(): MetaObject;
     /**
      * Get value of given meta id
      *
-     * @param id
-     * @returns
+     * @param id The meta ID to read
+     * @returns the stored meta value
      */
-    getMeta(id: any): any;
+    getMeta(id: string): string;
     /**
      * 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: string, value: string): void;
+    /**
+     * 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
      */
-    setMeta(id: any, value: any): void;
-    _setObjectDirect(id: any, obj: any): void;
+    _setObjectDirect(id: string, obj: ioBroker.AnyObject | ioBroker.DesignObject | MetaObject): void;
     /**
      * Delete the given object from the dataset
      *
      * @param id unique id of the object
      */
-    _delObject(id: any): void;
-    _applyView(func: any, params: any): {
-        rows: never[];
+    _delObject(id: string): void;
+    /**
+     * 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: {
+        map: string;
+        reduce?: '_stats';
+    }, params?: {
+        startkey?: string;
+        endkey?: string;
+        include_docs?: boolean;
+    } | null): {
+        rows: {
+            id: string;
+            value: ioBroker.AnyObject | ioBroker.DesignObject | MetaObject | {
+                max: ioBroker.AnyObject | ioBroker.DesignObject | MetaObject | null;
+            };
+        }[];
     };
-    _getObjectView(design: any, search: any, params: any): {
-        rows: never[];
+    /**
+     * 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: string, search: string, params?: {
+        startkey?: string;
+        endkey?: string;
+        include_docs?: boolean;
+    } | null): {
+        rows: {
+            id: string;
+            value: ioBroker.AnyObject | ioBroker.DesignObject | MetaObject | {
+                max: ioBroker.AnyObject | ioBroker.DesignObject | MetaObject | null;
+            };
+        }[];
     };
+    /**
+     * Destructor of the class. Called by shutting down.
+     */
+    destroy(): Promise<void>;
 }
-import { InMemoryFileDB } from '@iobroker/db-base';
-import fs from 'fs-extra';
+export {};
 //# sourceMappingURL=objectsInMemFileDB.d.ts.map