@iobroker/db-states-redis 7.2.3 → 8.0.0-alpha.1-20260921-e5941ca8a

package/build/cjs/index.d.ts

@@ -1,4 +1,4 @@
-export { StateRedisClient as Client } from './lib/states/statesInRedisClient.js';
+export { StateRedisClient as Client, type StatesSettings } from './lib/states/statesInRedisClient.js';
 export { interview } from './lib/states/interview.js';
 /**
  * Get the default port for the database

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,19 +17,20 @@ 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_statesInRedisClient.StateRedisClient,
   Server: () => Server,
   getDefaultPort: () => getDefaultPort,
   interview: () => import_interview.interview
 });
-module.exports = __toCommonJS(esm_exports);
+module.exports = __toCommonJS(index_exports);
 var import_statesInRedisClient = require("./lib/states/statesInRedisClient.js");
 var import_interview = require("./lib/states/interview.js");
 function getDefaultPort(host) {
   return host.includes(",") ? 26379 : 6379;
 }
+__name(getDefaultPort, "getDefaultPort");
 const Server = null;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/build/cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.ts"],
-  "sourcesContent": ["/// <reference types=\"@iobroker/types-dev\" />\nexport { StateRedisClient as Client } from '@/lib/states/statesInRedisClient.js';\nexport { interview } from '@/lib/states/interview.js';\n/**\n * Get the default port for the database\n *\n * @param host string of host(s)\n */\nexport function getDefaultPort(host: string): number {\n    return host.includes(',') ? 26379 : 6379;\n}\nexport const Server = null;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;;;;;;;;AACA,iCAA2C;AAC3C,uBAA0B;AAMpB,SAAU,eAAe,MAAY;AACvC,SAAO,KAAK,SAAS,GAAG,IAAI,QAAQ;AACxC;AACO,MAAM,SAAS;",
+  "sourcesContent": ["/// <reference types=\"@iobroker/types-dev\" />\nexport { StateRedisClient as Client, type StatesSettings } from '@/lib/states/statesInRedisClient.js';\nexport { interview } from '@/lib/states/interview.js';\n/**\n * Get the default port for the database\n *\n * @param host string of host(s)\n */\nexport function getDefaultPort(host: string): number {\n    return host.includes(',') ? 26379 : 6379;\n}\nexport const Server = null;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;AACA,iCAAgE;AAChE,uBAA0B;AAMpB,SAAU,eAAe,MAAY;AACvC,SAAO,KAAK,SAAS,GAAG,IAAI,QAAQ;AACxC;AAFgB;AAGT,MAAM,SAAS;",
   "names": []
 }

package/build/cjs/lib/states/interview.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 });
@@ -25,6 +26,7 @@ var import_js_controller_common_db = require("@iobroker/js-controller-common-db"
 function interview(config) {
   return (0, import_js_controller_common_db.defaultRedisInterview)({ config, type: "states" });
 }
+__name(interview, "interview");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   interview

package/build/cjs/lib/states/interview.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../../../src/lib/states/interview.ts"],
   "sourcesContent": ["import { defaultRedisInterview } from '@iobroker/js-controller-common-db';\n\n/**\n * Custom interview during setup\n *\n * @param config the prefilled database config\n */\nexport function interview(config: ioBroker.StatesDatabaseOptions): Promise<ioBroker.StatesDatabaseOptions> {\n    return defaultRedisInterview<ioBroker.StatesDatabaseOptions>({ config, type: 'states' });\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;;;;;AAAA,qCAAsC;AAOhC,SAAU,UAAU,QAAsC;AAC5D,aAAO,sDAAsD,EAAE,QAAQ,MAAM,SAAQ,CAAE;AAC3F;",
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;;;;;AAAA,qCAAsC;AAOhC,SAAU,UAAU,QAAsC;AAC5D,aAAO,sDAAsD,EAAE,QAAQ,MAAM,SAAQ,CAAE;AAC3F;AAFgB;",
   "names": []
 }

package/build/cjs/lib/states/statesInRedisClient.d.ts

@@ -1,7 +1,7 @@
 /**
  *      States DB in redis - Client
  *
- *      Copyright 2013-2024 bluefox <dogafox@gmail.com>
+ *      Copyright 2013-2026 bluefox <dogafox@gmail.com>
  *      Copyright 2013-2014 hobbyquaker
  *
  *      MIT License
@@ -11,29 +11,47 @@ import type { InternalLogger } from '@iobroker/js-controller-common-db/tools';
 import type { DbStatus, ConnectionOptions } from '@iobroker/db-base/inMemFileDB';
 type UserChangeFunction = (id: string, state: ioBroker.State | null) => void;
 type ChangeFunction = (id: string, state: ioBroker.State | ioBroker.Message | null) => void;
+/** Settings for the states database client */
 export interface StatesSettings {
+    /** Called once the client is connected */
     connected?: () => void;
+    /** Called when the client gets disconnected */
     disconnected?: () => void;
+    /** Handler for user-level state changes */
     changeUser?: UserChangeFunction;
+    /** Handler for system-level state and message changes */
     change?: ChangeFunction;
+    /** Connection options for the redis server */
     connection: ConnectionOptions;
+    /** Whether to connect to the database immediately (default true) */
     autoConnect?: boolean;
+    /** Logger instance to use */
     logger?: InternalLogger;
+    /** Name of this host */
     hostname?: string;
+    /** Namespace of this client */
     namespace?: string;
+    /** Namespace used for meta information */
     metaNamespace?: string;
+    /** Namespace used for sessions */
     namespaceSession?: string;
+    /** Namespace used for log messages */
     namespaceLog?: string;
+    /** Namespace used for the message box */
     namespaceMsg?: string;
+    /** Redis key prefix (defaults to "io") */
     redisNamespace?: string;
 }
 /** The internal log message does not have an _id parameter */
 type LogMessageInternal = Omit<ioBroker.LogMessage, '_id'>;
+/**
+ * Client for the states database backed by Redis (or the in-memory redis-protocol server)
+ */
 export declare class StateRedisClient {
     private settings;
     private readonly namespaceRedis;
     private readonly namespaceRedisL;
-    namespaceMsg: string;
+    private readonly namespaceMsg;
     private readonly namespaceLog;
     private readonly namespaceSession;
     private readonly metaNamespace;
@@ -52,73 +70,328 @@ export declare class StateRedisClient {
     private readonly userSubscriptions;
     /** System level subscriptions value true means messagebox is subscribed */
     private readonly systemSubscriptions;
+    /**
+     * @param settings Settings for the states client including connection and namespaces
+     */
     constructor(settings: StatesSettings);
     /**
      * Checks if we are allowed to start and sets the protocol version accordingly
      *
      */
     _determineProtocolVersion(): Promise<void>;
+    /**
+     * Connect to the states database and set up the change and message subscriptions
+     */
     connectDb(): void;
+    /**
+     * Get the current status of the database
+     */
     getStatus(): DbStatus;
+    /**
+     * Set the value of a state
+     *
+     * @param id The id of the state to set
+     * @param state The value (or full state object) to set
+     */
     setState(id: string, state: ioBroker.SettableState | ioBroker.StateValue): Promise<string>;
     /** @deprecated migrate to promisified version (without callback) */
-    setState(id: string, state: ioBroker.SettableState | ioBroker.StateValue, callback: (err: Error | null | undefined, id: string) => void): Promise<void>;
+    setState(id: string, state: ioBroker.SettableState | ioBroker.StateValue, callback: (err: Error | null | undefined, id: string) => void): void;
     /**
      * Promise-version of setState
      *
-     * @param id
-     * @param state
+     * @param id The id of the state to set
+     * @param state The value (or full state object) to set
      * @deprecated use version without `Async` postfix
      */
     setStateAsync(id: string, state: ioBroker.SettableState | ioBroker.StateValue): Promise<string>;
+    /**
+     * Directly set the raw stored value of a state without publishing a change (used for restore, do not call it)
+     *
+     * @param id The id of the state to set
+     * @param state The raw state object to store
+     */
     setRawState(id: string, state: ioBroker.SettableState): Promise<string>;
+    /**
+     * Get state from database
+     *
+     * @param id id of the state
+     */
     getState(id: string): ioBroker.GetStatePromise;
-    getState(id: string, callback?: (err: Error | null | undefined, state?: ioBroker.State | null) => void): Promise<ioBroker.CallbackReturnTypeOf<ioBroker.GetStateCallback> | void>;
+    /**
+     * Get state from database
+     *
+     * @param id id of the state
+     * @param callback optional callback, leave out and use promise return type
+     */
+    getState(id: string, callback: (err: Error | null | undefined, state?: ioBroker.State | null) => void): void;
     /**
      * Promise-version of getState
      *
-     * @param id
+     * @param id id of the state to get
      */
     getStateAsync(id: string): Promise<ioBroker.CallbackReturnTypeOf<ioBroker.GetStateCallback> | void>;
+    /**
+     * Get the values of multiple states
+     *
+     * @param keys The ids of the states to read
+     * @param callback Optional callback, leave out and use the promise return type
+     * @param dontModify If true, the returned states are not cloned/modified
+     */
     getStates(keys: string[], callback?: undefined, dontModify?: boolean): Promise<(ioBroker.State | null)[]>;
-    getStates(keys: string[], callback: (err: Error | undefined | null, states?: (ioBroker.State | null)[]) => void, dontModify?: boolean): Promise<void>;
-    getStates(keys: string[], callback: (err: Error | undefined | null, states?: (ioBroker.State | null)[]) => void, dontModify?: boolean): Promise<void>;
+    /**
+     * Get the values of multiple states
+     *
+     * @param keys The ids of the states to read
+     * @param callback Callback called with the read states
+     * @param dontModify If true, the returned states are not cloned/modified
+     */
+    getStates(keys: string[], callback: (err: Error | undefined | null, states?: (ioBroker.State | null)[]) => void, dontModify?: boolean): void;
     /**
      * @param keys - array of keys which will be deleted from db
      * @param callback function to be executed after keys have been deleted
      */
     _destroyDBHelper(keys: string[], callback?: ioBroker.ErrorCallback): Promise<void>;
+    /**
+     * Destroy (delete) all states in the database
+     */
+    destroyDB(): Promise<void>;
     /**
      * @param callback cb function to be executed after DB has been destroyed
      */
-    destroyDB(callback?: ioBroker.ErrorCallback): Promise<void>;
+    destroyDB(callback: ioBroker.ErrorCallback): void;
+    /**
+     * Destructor of the class. Called when shutting down to close the redis connections.
+     */
     destroy(): Promise<void>;
-    delState(id: string, callback?: ioBroker.DeleteStateCallback): Promise<ioBroker.CallbackReturnTypeOf<ioBroker.DeleteStateCallback> | void>;
+    /**
+     * Delete a state and publish the deletion
+     *
+     * @param id The id of the state to delete
+     */
+    delState(id: string): Promise<ioBroker.CallbackReturnTypeOf<ioBroker.DeleteStateCallback>>;
+    /**
+     * Delete a state and publish the deletion
+     *
+     * @param id The id of the state to delete
+     * @param callback Callback called with the deleted id
+     */
+    delState(id: string, callback: ioBroker.DeleteStateCallback): void;
+    /**
+     * Get all state ids matching the given pattern
+     *
+     * @param pattern The pattern to match state ids against
+     * @param callback Optional callback, leave out and use the promise return type
+     * @param dontModify If true, the returned keys are not stripped of the namespace
+     */
     getKeys(pattern: string, callback?: undefined, dontModify?: boolean): Promise<ioBroker.CallbackReturnTypeOf<ioBroker.GetKeysCallback>>;
-    getKeys(pattern: string, callback: ioBroker.GetKeysCallback, dontModify?: boolean): Promise<void>;
-    subscribe(pattern: string, callback?: ioBroker.ErrorCallback): Promise<void>;
-    subscribe(pattern: string, asUser: boolean, callback?: ioBroker.ErrorCallback): Promise<void>;
     /**
-     * @param pattern
-     * @param callback callback function (optional)
+     * Get all state ids matching the given pattern
+     *
+     * @param pattern The pattern to match state ids against
+     * @param callback Callback called with the matching keys
+     * @param dontModify If true, the returned keys are not stripped of the namespace
+     */
+    getKeys(pattern: string, callback: ioBroker.GetKeysCallback, dontModify?: boolean): void;
+    /**
+     * Subscribe to state changes matching the given pattern
+     *
+     * @param pattern The pattern to subscribe to
+     */
+    subscribe(pattern: string): Promise<void>;
+    /**
+     * Subscribe to state changes matching the given pattern
+     *
+     * @param pattern The pattern to subscribe to
+     * @param callback callback function
      */
-    subscribeUser(pattern: string, callback?: ioBroker.ErrorCallback): Promise<void>;
-    unsubscribe(pattern: string, asUser: boolean, callback?: ioBroker.ErrorCallback): Promise<void>;
-    unsubscribe(pattern: string, callback?: ioBroker.ErrorCallback): Promise<void>;
+    subscribe(pattern: string, callback: ioBroker.ErrorCallback): void;
     /**
-     * @param pattern
-     * @param callback callback function (optional)
+     * Subscribe to state changes matching the given pattern
+     *
+     * @param pattern The pattern to subscribe to
+     * @param asUser - if true it will be subscribed as user
+     */
+    subscribe(pattern: string, asUser: boolean): Promise<void>;
+    /**
+     * Subscribe to state changes matching the given pattern
+     *
+     * @param pattern The pattern to subscribe to
+     * @param asUser - if true it will be subscribed as user
+     * @param callback callback function
+     */
+    subscribe(pattern: string, asUser: boolean, callback: ioBroker.ErrorCallback): void;
+    /**
+     * Subscribe to state changes matching the given pattern as a user
+     *
+     * @param pattern The pattern to subscribe to
+     */
+    subscribeUser(pattern: string): Promise<void>;
+    /**
+     * Subscribe to state changes matching the given pattern as a user
+     *
+     * @param pattern The pattern to subscribe to
+     * @param callback callback function
+     */
+    subscribeUser(pattern: string, callback: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe from state changes matching the given pattern
+     *
+     * @param pattern The pattern to unsubscribe from
+     */
+    unsubscribe(pattern: string): Promise<void>;
+    /**
+     * Unsubscribe from state changes matching the given pattern
+     *
+     * @param pattern The pattern to unsubscribe from
+     * @param callback callback function
+     */
+    unsubscribe(pattern: string, callback: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe from state changes matching the given pattern
+     *
+     * @param pattern The pattern to unsubscribe from
+     * @param asUser - if true it will be unsubscribed as user
+     */
+    unsubscribe(pattern: string, asUser: boolean): Promise<void>;
+    /**
+     * Unsubscribe from state changes matching the given pattern
+     *
+     * @param pattern The pattern to unsubscribe from
+     * @param asUser - if true it will be unsubscribed as user
+     * @param callback callback function
+     */
+    unsubscribe(pattern: string, asUser: boolean, callback: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe from state changes matching the given pattern as a user
+     *
+     * @param pattern The pattern to unsubscribe from
+     */
+    unsubscribeUser(pattern: string): Promise<void>;
+    /**
+     * Unsubscribe from state changes matching the given pattern as a user
+     *
+     * @param pattern The pattern to unsubscribe from
+     * @param callback callback function
+     */
+    unsubscribeUser(pattern: string, callback: ioBroker.ErrorCallback): void;
+    /**
+     * Push a message into the message box of the given id
+     *
+     * @param id The id of the message box owner
+     * @param message The message to push
      */
-    unsubscribeUser(pattern: string, callback?: ioBroker.ErrorCallback): Promise<void>;
     pushMessage(id: string, message: ioBroker.SendableMessage): Promise<void>;
-    subscribeMessage(id: string, callback?: ioBroker.ErrorCallback): Promise<void>;
-    unsubscribeMessage(id: string, callback?: ioBroker.ErrorCallback): Promise<void>;
-    pushLog(id: string, log: LogMessageInternal, callback?: (err: Error | undefined | null, id?: string) => void): Promise<string | void>;
-    subscribeLog(id: string, callback?: ioBroker.ErrorCallback): Promise<void>;
-    unsubscribeLog(id: string, callback?: ioBroker.ErrorCallback): Promise<void>;
-    getSession(id: string, callback: (err: Error | undefined | null, session?: Record<string, any> | null) => void): Promise<Record<string, any> | null | void>;
-    setSession(id: string, expireS: number, obj: Record<string, any>, callback?: ioBroker.ErrorCallback): Promise<void>;
-    destroySession(id: string, callback?: ioBroker.ErrorCallback): Promise<void>;
+    /**
+     * Subscribe to messages sent to the given id
+     *
+     * @param id The id of the message box to subscribe to
+     */
+    subscribeMessage(id: string): Promise<void>;
+    /**
+     * Subscribe to messages sent to the given id
+     *
+     * @param id The id of the message box to subscribe to
+     * @param callback callback function
+     */
+    subscribeMessage(id: string, callback: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe from messages sent to the given id
+     *
+     * @param id The id of the message box to unsubscribe from
+     */
+    unsubscribeMessage(id: string): Promise<void>;
+    /**
+     * Unsubscribe from messages sent to the given id
+     *
+     * @param id The id of the message box to unsubscribe from
+     * @param callback callback function
+     */
+    unsubscribeMessage(id: string, callback: ioBroker.ErrorCallback): void;
+    /**
+     * Push a log message to the given log target
+     *
+     * @param id The id of the log target
+     * @param log The log message to push
+     * @param callback Optional callback called with the generated log id
+     */
+    pushLog(id: string, log: LogMessageInternal): Promise<string>;
+    /**
+     * Push a log message to the given log target
+     *
+     * @param id The id of the log target
+     * @param log The log message to push
+     * @param callback Callback called with the generated log id
+     */
+    pushLog(id: string, log: LogMessageInternal, callback: (err: Error | undefined | null, id?: string) => void): void;
+    /**
+     * Subscribe to log messages of the given id
+     *
+     * @param id The id of the log target to subscribe to
+     */
+    subscribeLog(id: string): Promise<void>;
+    /**
+     * Subscribe to log messages of the given id
+     *
+     * @param id The id of the log target to subscribe to
+     * @param callback callback function
+     */
+    subscribeLog(id: string, callback: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe from log messages of the given id
+     *
+     * @param id The id of the log target to unsubscribe from
+     */
+    unsubscribeLog(id: string): Promise<void>;
+    /**
+     * Unsubscribe from log messages of the given id
+     *
+     * @param id The id of the log target to unsubscribe from
+     * @param callback callback function
+     */
+    unsubscribeLog(id: string, callback: ioBroker.ErrorCallback): void;
+    /**
+     * Get a stored session by its id
+     *
+     * @param id The id of the session to read
+     */
+    getSession(id: string): Promise<ioBroker.Session | null>;
+    /**
+     * Get a stored session by its id
+     *
+     * @param id The id of the session to read
+     * @param callback Called with the session object, or null if not found
+     */
+    getSession(id: string, callback: (err: Error | undefined | null, session?: ioBroker.Session | null) => void): void;
+    /**
+     * Create or update a session and set its expiration
+     *
+     * @param id The id of the session
+     * @param expireS Expiration time in seconds from now
+     * @param obj The session data to store
+     */
+    setSession(id: string, expireS: number, obj: ioBroker.Session): Promise<void>;
+    /**
+     * Create or update a session and set its expiration
+     *
+     * @param id The id of the session
+     * @param expireS Expiration time in seconds from now
+     * @param obj The session data to store
+     * @param callback callback function
+     */
+    setSession(id: string, expireS: number, obj: ioBroker.Session, callback: ioBroker.ErrorCallback): void;
+    /**
+     * Destroy (delete) a session by its id
+     *
+     * @param id The id of the session to destroy
+     */
+    destroySession(id: string): Promise<void>;
+    /**
+     * Destroy (delete) a session by its id
+     *
+     * @param id The id of the session to destroy
+     * @param callback callback function
+     */
+    destroySession(id: string, callback: ioBroker.ErrorCallback): void;
     /**
      * Returns the protocol version from DB
      *