@iobroker/js-controller-common-db 7.2.3 → 8.0.0-alpha.1-20260921-e5941ca8a

package/build/cjs/lib/common/maybeCallback.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../../../src/lib/common/maybeCallback.ts"],
   "sourcesContent": ["// Beware, below be TypeScript dragons!\n\nimport { ERRORS } from '@/lib/common/tools.js';\n\ntype MaybeCbCallback<T extends any[]> = (...args: T) => void;\ntype MaybeCbErrCallback<T extends any[]> = (error: Error | null | undefined, ...args: T) => void;\n\n// Helper type to infer the return type of the maybeCallbackWithError function\n// If the callback is given, the return type is void\n// otherwise, the return type is a Promise whose resolved value type depends on the given arguments, or the error variable\ntype MaybeCbErrReturnType<\n    TCb extends MaybeCbErrCallback<any> | null | undefined,\n    TErr extends Error | string | null | undefined,\n    TArgs extends any[],\n> =\n    TCb extends MaybeCbErrCallback<any>\n        ? void\n        : // If there is an error given, the promise will never resolve\n          TErr extends Error | string\n          ? Promise<never>\n          : // Infer the return type from the arguments\n            Promise<\n                [] extends TArgs\n                    ? void // if ([] === T) void\n                    : [any] extends TArgs\n                      ? TArgs[0] // else if (T has one element) => take first element\n                      : TArgs // else return T entirely\n            >;\n\n// Helper type to infer the callback arguments for the maybeCallbackWithError function\n// If a callback is given, they must match its arguments. Otherwise, they are inferred and default to any[]\ntype MaybeCbErrCallbackParameters<\n    CB extends MaybeCbErrCallback<any> | null | undefined,\n    TErr extends Error | string | null | undefined,\n> =\n    Exclude<CB, undefined | null> extends MaybeCbErrCallback<infer U>\n        ? // If the error argument is given,\n          TErr extends Error | string\n            ? //  don't require arguments but allow passing them\n              U | []\n            : // Otherwise, require the correct args\n              U\n        : any[];\n\n// Helper type to infer the callback arguments for the maybeCallback function\n// If a callback is given, they must match its arguments. Otherwise, they are inferred and default to any[]\ntype MaybeCbCallbackParameters<CB extends MaybeCbCallback<any> | null | undefined> =\n    Exclude<CB, undefined | null> extends MaybeCbCallback<infer U> ? U : any[];\n\n// Helper type to infer the return type of the maybeCallback function\n// If the callback is given, the return type is void\n// otherwise, the return type is a Promise whose resolved value type depends on the given arguments\ntype MaybeCbReturnType<TCb extends MaybeCbErrCallback<any> | null | undefined, TArgs extends any[]> =\n    TCb extends MaybeCbCallback<any>\n        ? void\n        : // Infer the return type from the arguments\n          Promise<\n              [] extends TArgs\n                  ? void // if ([] === T) void\n                  : [any] extends TArgs\n                    ? TArgs[0] // else if (T has one element) => take first element\n                    : TArgs // else return T entirely\n          >;\n\n// Helper type to lower the inference priority of an argument\ntype NoInfer<T> = T & { [K in keyof T]: T[K] };\n\n// This is the publicly visible signature of maybeCallback. The one below is just internal\n// and makes implementing the function much, much easier (although a bit unsound).\nexport function maybeCallback<\n    // Limit the callback type to a valid callback type\n    TCb extends MaybeCbCallback<any> | null | undefined,\n    // The callback arguments must match the callback args\n    TArgs extends MaybeCbCallbackParameters<TCb> = MaybeCbCallbackParameters<TCb>,\n>(\n    callback: TCb,\n    // Infer the arguments with lower priority than the callback - they need to match it.\n    ...args: NoInfer<TArgs>\n): MaybeCbReturnType<TCb, TArgs>;\n\n/**\n * Checks if the given callback is a function and if so calls it with the given parameter immediately, else a resolved Promise is returned\n *\n * @param callback - callback function to be executed\n * @param args - as many arguments as needed, which will be returned by the callback function or by the Promise\n * @returns if Promise is resolved with multiple arguments, an array is returned\n */\nexport function maybeCallback<T extends any[]>(callback?: MaybeCbCallback<T> | null, ...args: T): Promise<any> | void {\n    if (typeof callback === 'function') {\n        // if function we call it with given param\n        setImmediate(callback, ...args);\n    } else {\n        return Promise.resolve(args.length > 1 ? args : args[0]);\n    }\n}\n\n// This is the publicly visible signature of maybeCallbackWithError. The one below is just internal\n// and makes implementing the function much, much easier (although a bit unsound).\nexport function maybeCallbackWithError<\n    // Limit the callback type to a valid callback type\n    TCb extends MaybeCbErrCallback<any> | null | undefined,\n    // And the error to either an error or sting, or null/undefined\n    TErr extends Error | string | null | undefined,\n    // The callback arguments must match the callback args\n    TArgs extends MaybeCbErrCallbackParameters<TCb, TErr> = MaybeCbErrCallbackParameters<TCb, TErr>,\n>(\n    callback: TCb,\n    error: TErr,\n    // Infer the arguments with lower priority than the callback - they need to match it.\n    ...args: NoInfer<TArgs>\n): MaybeCbErrReturnType<TCb, TErr, TArgs>;\n\n/**\n * Checks if the given callback is a function and if so calls it with the given error and parameter immediately, else a resolved or rejected Promise is returned. Error ERROR_DB_CLOSED are not rejecting the promise\n *\n * @param callback - callback function to be executed\n * @param error - error which will be used by the callback function. If callback is not a function and\n * error is given, a rejected Promise is returned. If error is given, but it is not an instance of Error, it is converted into one.\n * @param args - as many arguments as needed, which will be returned by the callback function or by the Promise\n * @returns if Promise is resolved with multiple arguments, an array is returned\n */\nexport function maybeCallbackWithError<T extends any[]>(\n    callback: MaybeCbErrCallback<T> | null | undefined,\n    error: Error | string | null | undefined,\n    ...args: T\n): Promise<any> | void {\n    if (error !== undefined && error !== null && !(error instanceof Error)) {\n        // if it's not a real Error, we convert it into one\n        error = new Error(error);\n    }\n    const isDbError = error ? error.message === ERRORS.ERROR_DB_CLOSED : false;\n\n    if (typeof callback === 'function') {\n        setImmediate(callback, error, ...args);\n    } else if (error && !isDbError) {\n        return Promise.reject(error);\n    } else {\n        return Promise.resolve(args.length > 1 ? args : args[0]);\n    }\n}\n\n// This is the publicly visible signature of maybeCallbackWithRedisError, which is an exact copy of maybeCallbackWithError's signature.\n// The one below is just internal and makes implementing the function much, much easier (although a bit unsound).\nexport function maybeCallbackWithRedisError<\n    // Limit the callback type to a valid callback type\n    TCb extends MaybeCbErrCallback<any> | null | undefined,\n    // And the error to either an error or sting, or null/undefined\n    TErr extends Error | string | null | undefined,\n    // The callback arguments must match the callback args\n    TArgs extends MaybeCbErrCallbackParameters<TCb, TErr> = MaybeCbErrCallbackParameters<TCb, TErr>,\n>(\n    callback: TCb,\n    error: TErr,\n    // Infer the arguments with lower priority than the callback - they need to match it.\n    ...args: NoInfer<TArgs>\n): MaybeCbErrReturnType<TCb, TErr, TArgs>;\n\n/**\n * Checks if the given callback is a function and if so calls it with the given error and parameter immediately, else a resolved or rejected Promise is returned. Redis-Error \"Connection is closed.\" is converted into ERROR_DB_CLOSED\n *\n * @param callback - callback function to be executed\n * @param error - error which will be used by the callback function. If callback is not a function and\n * error is given, a rejected Promise is returned. If error is given, but it is not an instance of Error, it is converted into one.\n * @param args - as many arguments as needed, which will be returned by the callback function or by the Promise\n * @returns Promise if Promise is resolved with multiple arguments, an array is returned\n */\nexport function maybeCallbackWithRedisError<T extends any[]>(\n    callback: MaybeCbErrCallback<T> | null | undefined,\n    error: Error | string | null | undefined,\n    ...args: T\n): Promise<any> | void {\n    if (error instanceof Error && error.message.includes('Connection is closed')) {\n        error.message = ERRORS.ERROR_DB_CLOSED;\n    }\n    return maybeCallbackWithError(callback, error, ...args);\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;;;;;;;AAEA,mBAAuB;AAqFjB,SAAU,cAA+B,aAAyC,MAAO;AAC3F,MAAI,OAAO,aAAa,YAAY;AAEhC,iBAAa,UAAU,GAAG,IAAI;EAClC,OAAO;AACH,WAAO,QAAQ,QAAQ,KAAK,SAAS,IAAI,OAAO,KAAK,CAAC,CAAC;EAC3D;AACJ;AA2BM,SAAU,uBACZ,UACA,UACG,MAAO;AAEV,MAAI,UAAU,UAAa,UAAU,QAAQ,EAAE,iBAAiB,QAAQ;AAEpE,YAAQ,IAAI,MAAM,KAAK;EAC3B;AACA,QAAM,YAAY,QAAQ,MAAM,YAAY,oBAAO,kBAAkB;AAErE,MAAI,OAAO,aAAa,YAAY;AAChC,iBAAa,UAAU,OAAO,GAAG,IAAI;EACzC,WAAW,SAAS,CAAC,WAAW;AAC5B,WAAO,QAAQ,OAAO,KAAK;EAC/B,OAAO;AACH,WAAO,QAAQ,QAAQ,KAAK,SAAS,IAAI,OAAO,KAAK,CAAC,CAAC;EAC3D;AACJ;AA2BM,SAAU,4BACZ,UACA,UACG,MAAO;AAEV,MAAI,iBAAiB,SAAS,MAAM,QAAQ,SAAS,sBAAsB,GAAG;AAC1E,UAAM,UAAU,oBAAO;EAC3B;AACA,SAAO,uBAAuB,UAAU,OAAO,GAAG,IAAI;AAC1D;",
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;;;;;;;AAEA,mBAAuB;AAqFjB,SAAU,cAA+B,aAAyC,MAAO;AAC3F,MAAI,OAAO,aAAa,YAAY;AAEhC,iBAAa,UAAU,GAAG,IAAI;EAClC,OAAO;AACH,WAAO,QAAQ,QAAQ,KAAK,SAAS,IAAI,OAAO,KAAK,CAAC,CAAC;EAC3D;AACJ;AAPgB;AAkCV,SAAU,uBACZ,UACA,UACG,MAAO;AAEV,MAAI,UAAU,UAAa,UAAU,QAAQ,EAAE,iBAAiB,QAAQ;AAEpE,YAAQ,IAAI,MAAM,KAAK;EAC3B;AACA,QAAM,YAAY,QAAQ,MAAM,YAAY,oBAAO,kBAAkB;AAErE,MAAI,OAAO,aAAa,YAAY;AAChC,iBAAa,UAAU,OAAO,GAAG,IAAI;EACzC,WAAW,SAAS,CAAC,WAAW;AAC5B,WAAO,QAAQ,OAAO,KAAK;EAC/B,OAAO;AACH,WAAO,QAAQ,QAAQ,KAAK,SAAS,IAAI,OAAO,KAAK,CAAC,CAAC;EAC3D;AACJ;AAlBgB;AA6CV,SAAU,4BACZ,UACA,UACG,MAAO;AAEV,MAAI,iBAAiB,SAAS,MAAM,QAAQ,SAAS,sBAAsB,GAAG;AAC1E,UAAM,UAAU,oBAAO;EAC3B;AACA,SAAO,uBAAuB,UAAU,OAAO,GAAG,IAAI;AAC1D;AATgB;",
   "names": []
 }

package/build/cjs/lib/common/password.d.ts

@@ -28,10 +28,19 @@
  
  *
  */
+/** Set of password helper functions bound to a specific password */
 export interface PasswordReturnValue {
+    /** Check whether the password fulfills the complexity requirements */
     complexity: (password: string, callback: (isComplex: boolean) => void) => boolean;
+    /** Verify the password against the given stored hash */
     check: (hashedPassword: string, callback: (err?: Error | null, isOk?: boolean) => void) => void;
+    /** Create a salted PBKDF2 hash of the password */
     hash: (salt: string | null, iterations: number | null, callback: (err?: Error | null, hash?: string) => void) => void;
 }
+/**
+ * Create a set of helper functions (hash, check, complexity) bound to the given password
+ *
+ * @param pw The plain text password to operate on
+ */
 export declare function password(pw: string): PasswordReturnValue;
 //# sourceMappingURL=password.d.ts.map

package/build/cjs/lib/common/password.js

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 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 });
@@ -34,7 +35,7 @@ module.exports = __toCommonJS(password_exports);
 var import_node_crypto = __toESM(require("node:crypto"), 1);
 function password(pw) {
   return {
-    hash: (salt, iterations, callback) => {
+    hash: /* @__PURE__ */ __name((salt, iterations, callback) => {
       salt = salt || import_node_crypto.default.randomBytes(16).toString("hex");
       iterations = iterations || 1e4;
       import_node_crypto.default.pbkdf2(pw, salt, iterations, 256, "sha256", (err, key) => {
@@ -43,8 +44,8 @@ function password(pw) {
         }
         callback(null, `pbkdf2$${iterations}$${key.toString("hex")}$${salt}`);
       });
-    },
-    check: function(hashedPassword, callback) {
+    }, "hash"),
+    check: /* @__PURE__ */ __name(function(hashedPassword, callback) {
       if (!hashedPassword) {
         return callback(null, false);
       }
@@ -62,8 +63,8 @@ function password(pw) {
           callback(null, newHash === hashedPassword);
         }
       });
-    },
-    complexity: (password2, callback) => {
+    }, "check"),
+    complexity: /* @__PURE__ */ __name((password2, callback) => {
       let result = false;
       if (typeof password2 === "string") {
         result = password2.length >= 8 && // minimum length is 8
@@ -73,9 +74,10 @@ function password(pw) {
       }
       typeof callback === "function" && callback(result);
       return result;
-    }
+    }, "complexity")
   };
 }
+__name(password, "password");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   password

package/build/cjs/lib/common/password.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/lib/common/password.ts"],
-  "sourcesContent": ["/**\n *\n *      password hash and check\n *\n *      7'2014-2024 Bluefox <dogafox@gmail.com>\n *             2014 hobbyquaker <hq@ccu.io>\n *\n *      derived from https://github.com/florianheinemann/password-hash-and-salt/ (MIT License)\n *\n *      The created hash is of the following format: <algorithm>$<iterations>$<hash>$<salt>\n *\n *      Usage Example:\n \n var password = require('./lib/password.js');\n \n password('test').hash(null, null, function (err, res) {\n    console.log(res);\n \n    password('test').check(res, function (err, res) {\n        console.log('test: ' + res);\n    });\n \n    password('muh').check(res, function (err, res) {\n        console.log('muh: ' + res);\n    });\n \n });\n \n *\n */\n\nimport crypto from 'node:crypto';\n\nexport interface PasswordReturnValue {\n    complexity: (password: string, callback: (isComplex: boolean) => void) => boolean;\n    check: (hashedPassword: string, callback: (err?: Error | null, isOk?: boolean) => void) => void;\n    hash: (\n        salt: string | null,\n        iterations: number | null,\n        callback: (err?: Error | null, hash?: string) => void,\n    ) => void;\n}\n\nexport function password(pw: string): PasswordReturnValue {\n    return {\n        hash: (salt, iterations, callback) => {\n            salt = salt || crypto.randomBytes(16).toString('hex');\n            iterations = iterations || 10_000;\n\n            crypto.pbkdf2(pw, salt, iterations, 256, 'sha256', (err, key) => {\n                if (err) {\n                    return callback(err);\n                }\n\n                callback(null, `pbkdf2$${iterations}$${key.toString('hex')}$${salt}`);\n            });\n        },\n        check: function (hashedPassword, callback) {\n            if (!hashedPassword) {\n                return callback(null, false);\n            }\n            const key = hashedPassword.split('$');\n            if (key.length !== 4 || !key[2] || !key[3]) {\n                return callback(new Error('Hash not formatted correctly'));\n            }\n            if (key[0] !== 'pbkdf2') {\n                return callback(new Error('Unknown'));\n            }\n\n            this.hash(key[3], parseInt(key[1], 10), (error, newHash) => {\n                if (error) {\n                    callback(error);\n                } else {\n                    callback(null, newHash === hashedPassword);\n                }\n            });\n        },\n        complexity: (password, callback) => {\n            let result = false;\n            if (typeof password === 'string') {\n                result =\n                    password.length >= 8 && // minimum length is 8\n                    /\\d/.test(password) && // contains at least one digit\n                    /[a-z]/.test(password) && // contains at least one lower case letter\n                    /[A-Z]/.test(password); // contains at least one upper case letter\n            }\n            typeof callback === 'function' && callback(result);\n            return result; // true if the complexity OK\n        },\n    };\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AA+BA,yBAAmB;AAYb,SAAU,SAAS,IAAU;AAC/B,SAAO;IACH,MAAM,CAAC,MAAM,YAAY,aAAY;AACjC,aAAO,QAAQ,mBAAAA,QAAO,YAAY,EAAE,EAAE,SAAS,KAAK;AACpD,mBAAa,cAAc;AAE3B,yBAAAA,QAAO,OAAO,IAAI,MAAM,YAAY,KAAK,UAAU,CAAC,KAAK,QAAO;AAC5D,YAAI,KAAK;AACL,iBAAO,SAAS,GAAG;QACvB;AAEA,iBAAS,MAAM,UAAU,UAAU,IAAI,IAAI,SAAS,KAAK,CAAC,IAAI,IAAI,EAAE;MACxE,CAAC;IACL;IACA,OAAO,SAAU,gBAAgB,UAAQ;AACrC,UAAI,CAAC,gBAAgB;AACjB,eAAO,SAAS,MAAM,KAAK;MAC/B;AACA,YAAM,MAAM,eAAe,MAAM,GAAG;AACpC,UAAI,IAAI,WAAW,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG;AACxC,eAAO,SAAS,IAAI,MAAM,8BAA8B,CAAC;MAC7D;AACA,UAAI,IAAI,CAAC,MAAM,UAAU;AACrB,eAAO,SAAS,IAAI,MAAM,SAAS,CAAC;MACxC;AAEA,WAAK,KAAK,IAAI,CAAC,GAAG,SAAS,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,OAAO,YAAW;AACvD,YAAI,OAAO;AACP,mBAAS,KAAK;QAClB,OAAO;AACH,mBAAS,MAAM,YAAY,cAAc;QAC7C;MACJ,CAAC;IACL;IACA,YAAY,CAACC,WAAU,aAAY;AAC/B,UAAI,SAAS;AACb,UAAI,OAAOA,cAAa,UAAU;AAC9B,iBACIA,UAAS,UAAU;QACnB,KAAK,KAAKA,SAAQ;QAClB,QAAQ,KAAKA,SAAQ;QACrB,QAAQ,KAAKA,SAAQ;MAC7B;AACA,aAAO,aAAa,cAAc,SAAS,MAAM;AACjD,aAAO;IACX;;AAER;",
+  "sourcesContent": ["/**\n *\n *      password hash and check\n *\n *      7'2014-2024 Bluefox <dogafox@gmail.com>\n *             2014 hobbyquaker <hq@ccu.io>\n *\n *      derived from https://github.com/florianheinemann/password-hash-and-salt/ (MIT License)\n *\n *      The created hash is of the following format: <algorithm>$<iterations>$<hash>$<salt>\n *\n *      Usage Example:\n \n var password = require('./lib/password.js');\n \n password('test').hash(null, null, function (err, res) {\n    console.log(res);\n \n    password('test').check(res, function (err, res) {\n        console.log('test: ' + res);\n    });\n \n    password('muh').check(res, function (err, res) {\n        console.log('muh: ' + res);\n    });\n \n });\n \n *\n */\n\nimport crypto from 'node:crypto';\n\n/** Set of password helper functions bound to a specific password */\nexport interface PasswordReturnValue {\n    /** Check whether the password fulfills the complexity requirements */\n    complexity: (password: string, callback: (isComplex: boolean) => void) => boolean;\n    /** Verify the password against the given stored hash */\n    check: (hashedPassword: string, callback: (err?: Error | null, isOk?: boolean) => void) => void;\n    /** Create a salted PBKDF2 hash of the password */\n    hash: (\n        salt: string | null,\n        iterations: number | null,\n        callback: (err?: Error | null, hash?: string) => void,\n    ) => void;\n}\n\n/**\n * Create a set of helper functions (hash, check, complexity) bound to the given password\n *\n * @param pw The plain text password to operate on\n */\nexport function password(pw: string): PasswordReturnValue {\n    return {\n        hash: (salt, iterations, callback) => {\n            salt = salt || crypto.randomBytes(16).toString('hex');\n            iterations = iterations || 10_000;\n\n            crypto.pbkdf2(pw, salt, iterations, 256, 'sha256', (err, key) => {\n                if (err) {\n                    return callback(err);\n                }\n\n                callback(null, `pbkdf2$${iterations}$${key.toString('hex')}$${salt}`);\n            });\n        },\n        check: function (hashedPassword, callback) {\n            if (!hashedPassword) {\n                return callback(null, false);\n            }\n            const key = hashedPassword.split('$');\n            if (key.length !== 4 || !key[2] || !key[3]) {\n                return callback(new Error('Hash not formatted correctly'));\n            }\n            if (key[0] !== 'pbkdf2') {\n                return callback(new Error('Unknown'));\n            }\n\n            this.hash(key[3], parseInt(key[1], 10), (error, newHash) => {\n                if (error) {\n                    callback(error);\n                } else {\n                    callback(null, newHash === hashedPassword);\n                }\n            });\n        },\n        complexity: (password, callback) => {\n            let result = false;\n            if (typeof password === 'string') {\n                result =\n                    password.length >= 8 && // minimum length is 8\n                    /\\d/.test(password) && // contains at least one digit\n                    /[a-z]/.test(password) && // contains at least one lower case letter\n                    /[A-Z]/.test(password); // contains at least one upper case letter\n            }\n            typeof callback === 'function' && callback(result);\n            return result; // true if the complexity OK\n        },\n    };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AA+BA,yBAAmB;AAqBb,SAAU,SAAS,IAAU;AAC/B,SAAO;IACH,MAAM,wBAAC,MAAM,YAAY,aAAY;AACjC,aAAO,QAAQ,mBAAAA,QAAO,YAAY,EAAE,EAAE,SAAS,KAAK;AACpD,mBAAa,cAAc;AAE3B,yBAAAA,QAAO,OAAO,IAAI,MAAM,YAAY,KAAK,UAAU,CAAC,KAAK,QAAO;AAC5D,YAAI,KAAK;AACL,iBAAO,SAAS,GAAG;QACvB;AAEA,iBAAS,MAAM,UAAU,UAAU,IAAI,IAAI,SAAS,KAAK,CAAC,IAAI,IAAI,EAAE;MACxE,CAAC;IACL,GAXM;IAYN,OAAO,gCAAU,gBAAgB,UAAQ;AACrC,UAAI,CAAC,gBAAgB;AACjB,eAAO,SAAS,MAAM,KAAK;MAC/B;AACA,YAAM,MAAM,eAAe,MAAM,GAAG;AACpC,UAAI,IAAI,WAAW,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG;AACxC,eAAO,SAAS,IAAI,MAAM,8BAA8B,CAAC;MAC7D;AACA,UAAI,IAAI,CAAC,MAAM,UAAU;AACrB,eAAO,SAAS,IAAI,MAAM,SAAS,CAAC;MACxC;AAEA,WAAK,KAAK,IAAI,CAAC,GAAG,SAAS,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,OAAO,YAAW;AACvD,YAAI,OAAO;AACP,mBAAS,KAAK;QAClB,OAAO;AACH,mBAAS,MAAM,YAAY,cAAc;QAC7C;MACJ,CAAC;IACL,GAnBO;IAoBP,YAAY,wBAACC,WAAU,aAAY;AAC/B,UAAI,SAAS;AACb,UAAI,OAAOA,cAAa,UAAU;AAC9B,iBACIA,UAAS,UAAU;QACnB,KAAK,KAAKA,SAAQ;QAClB,QAAQ,KAAKA,SAAQ;QACrB,QAAQ,KAAKA,SAAQ;MAC7B;AACA,aAAO,aAAa,cAAc,SAAS,MAAM;AACjD,aAAO;IACX,GAXY;;AAapB;AA/CgB;",
   "names": ["crypto", "password"]
 }

package/build/cjs/lib/common/session.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 });
@@ -24,14 +25,17 @@ module.exports = __toCommonJS(session_exports);
 function createAdapterStore(session, defaultTtl = 3600) {
   const Store = session.Store;
   class AdapterStore extends Store {
+    static {
+      __name(this, "AdapterStore");
+    }
     adapter;
+    /**
+     * @param options Store options including the adapter instance used to read and write sessions
+     */
     constructor(options) {
       super(options);
       this.adapter = options.adapter;
-      options = options || {};
-      if (!options.cookie) {
-        options.cookie = { maxAge: defaultTtl };
-      }
+      options.cookie ||= { maxAge: defaultTtl };
       Store.call(this, options);
     }
     /**
@@ -65,7 +69,7 @@ function createAdapterStore(session, defaultTtl = 3600) {
         sess = ttl;
         ttl = sess?.cookie?.originalMaxAge ? Math.round(sess.cookie.originalMaxAge / 1e3) : defaultTtl;
       }
-      ttl = ttl || defaultTtl;
+      ttl ||= defaultTtl;
       this.adapter.setSession(sid, ttl, sess, function(err) {
         fn?.call(this, err);
       });
@@ -82,6 +86,7 @@ function createAdapterStore(session, defaultTtl = 3600) {
   }
   return AdapterStore;
 }
+__name(createAdapterStore, "createAdapterStore");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createAdapterStore

package/build/cjs/lib/common/session.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/lib/common/session.ts"],
-  "sourcesContent": ["type SessionData = Record<string, any>;\n\ntype Session = {\n    Store: any;\n};\n\n// TODO: in the long term move this file somewhere where we have types access it is nowhere used in controller itself and just exported for adapters so it should go to js-controller-adapter package\ninterface AdapterStoreOptions {\n    /** The ioBroker adapter */\n    adapter: any;\n    /** The cookie */\n    cookie?: {\n        maxAge?: number;\n        originalMaxAge?: number;\n    };\n}\n\n/**\n * Function to create an AdapterStore constructor\n *\n * @param session The session object, like \"express-session\"\n * @param defaultTtl the default time to live in seconds\n * @returns the constructor to create a new AdapterStore\n */\nexport function createAdapterStore(session: Session, defaultTtl = 3600): any {\n    const Store = session.Store;\n\n    class AdapterStore extends Store {\n        private readonly adapter: any;\n\n        constructor(options: AdapterStoreOptions) {\n            super(options);\n\n            this.adapter = options.adapter;\n\n            options = options || {};\n            if (!options.cookie) {\n                options.cookie = { maxAge: defaultTtl };\n            }\n            Store.call(this, options);\n        }\n\n        /**\n         * Attempt to fetch session by the given `sid`.\n         *\n         * @param sid Session ID\n         * @param fn callback\n         */\n        get(sid: string, fn: (err?: Error | string | null, obj?: SessionData) => void): void {\n            this.adapter.getSession(sid, (obj: SessionData): void => {\n                if (obj) {\n                    if (fn) {\n                        return fn(null, obj);\n                    }\n                } else if (fn) {\n                    return fn();\n                }\n            });\n        }\n\n        /**\n         * Commit the given `sess` object associated with the given `sid`.\n         *\n         * @param sid Session ID\n         * @param sess the session\n         * @param fn callback\n         */\n        set(sid: string, sess: SessionData, fn: (err?: Error | null) => void): void;\n        /**\n         * Commit the given `sess` object associated with the given `sid`.\n         *\n         * @param sid Session ID\n         * @param ttl Time to live\n         * @param sess the session\n         * @param fn callback\n         */\n        set(sid: string, ttl: number, sess: SessionData, fn: (err?: Error | null) => void): void;\n\n        /**\n         * Commit the given `sess` object associated with the given `sid`.\n         *\n         * @param sid Session ID\n         * @param ttl Time to live\n         * @param sess the session\n         * @param fn callback\n         */\n        set(sid: unknown, ttl: unknown, sess: unknown, fn?: unknown): void {\n            if (typeof sess === 'function') {\n                fn = sess as (err?: Error | null) => void;\n                sess = ttl;\n                // analyse if the session is stored directly from express session\n                ttl = (sess as SessionData)?.cookie?.originalMaxAge\n                    ? Math.round((sess as SessionData).cookie.originalMaxAge / 1000)\n                    : defaultTtl;\n            }\n            ttl = ttl || defaultTtl;\n            this.adapter.setSession(\n                sid as string,\n                ttl as number,\n                sess as SessionData,\n                function (err?: Error | null): void {\n                    // @ts-expect-error fix later\n                    fn?.call(this, err);\n                },\n            ); // do not use here => !!!\n        }\n\n        /**\n         * Destroy the session associated with the given `sid`.\n         *\n         * @param sid Session ID\n         * @param fn callback\n         */\n        destroy(sid: string, fn: () => void): void {\n            this.adapter.destroySession(sid, fn);\n        }\n    }\n\n    return AdapterStore;\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAiBA;;;;;AAOM,SAAU,mBAAmB,SAAkB,aAAa,MAAI;AAClE,QAAM,QAAQ,QAAQ;EAEtB,MAAM,qBAAqB,MAAK;IACX;IAEjB,YAAY,SAA4B;AACpC,YAAM,OAAO;AAEb,WAAK,UAAU,QAAQ;AAEvB,gBAAU,WAAW,CAAA;AACrB,UAAI,CAAC,QAAQ,QAAQ;AACjB,gBAAQ,SAAS,EAAE,QAAQ,WAAU;MACzC;AACA,YAAM,KAAK,MAAM,OAAO;IAC5B;;;;;;;IAQA,IAAI,KAAa,IAA4D;AACzE,WAAK,QAAQ,WAAW,KAAK,CAAC,QAA0B;AACpD,YAAI,KAAK;AACL,cAAI,IAAI;AACJ,mBAAO,GAAG,MAAM,GAAG;UACvB;QACJ,WAAW,IAAI;AACX,iBAAO,GAAE;QACb;MACJ,CAAC;IACL;;;;;;;;;IA4BA,IAAI,KAAc,KAAc,MAAe,IAAY;AACvD,UAAI,OAAO,SAAS,YAAY;AAC5B,aAAK;AACL,eAAO;AAEP,cAAO,MAAsB,QAAQ,iBAC/B,KAAK,MAAO,KAAqB,OAAO,iBAAiB,GAAI,IAC7D;MACV;AACA,YAAM,OAAO;AACb,WAAK,QAAQ,WACT,KACA,KACA,MACA,SAAU,KAAkB;AAExB,YAAI,KAAK,MAAM,GAAG;MACtB,CAAC;IAET;;;;;;;IAQA,QAAQ,KAAa,IAAc;AAC/B,WAAK,QAAQ,eAAe,KAAK,EAAE;IACvC;;AAGJ,SAAO;AACX;",
+  "sourcesContent": ["type Session = {\n    Store: any;\n};\n\n// TODO: in the long term move this file somewhere where we have types access it is nowhere used in controller itself and just exported for adapters so it should go to js-controller-adapter package\ninterface AdapterStoreOptions {\n    /** The ioBroker adapter */\n    adapter: {\n        getSession: (sid: string, callback: (obj: ioBroker.Session) => void) => void;\n        setSession: (sid: string, ttl: number, sess: ioBroker.Session, callback: (err?: Error | null) => void) => void;\n        destroySession: (sid: string, callback: () => void) => void;\n    };\n    /** The cookie */\n    cookie?: {\n        maxAge?: number;\n        originalMaxAge?: number;\n    };\n}\n\n/**\n * Function to create an AdapterStore constructor\n *\n * @param session The session object, like \"express-session\"\n * @param defaultTtl the default time to live in seconds\n * @returns the constructor to create a new AdapterStore\n */\nexport function createAdapterStore(session: Session, defaultTtl = 3600): any {\n    const Store = session.Store;\n\n    class AdapterStore extends Store {\n        private readonly adapter: {\n            getSession: (sid: string, callback: (obj: ioBroker.Session) => void) => void;\n            setSession: (\n                sid: string,\n                ttl: number,\n                sess: ioBroker.Session,\n                callback: (err?: Error | null) => void,\n            ) => void;\n            destroySession: (sid: string, callback: () => void) => void;\n        };\n\n        /**\n         * @param options Store options including the adapter instance used to read and write sessions\n         */\n        constructor(options: AdapterStoreOptions) {\n            super(options);\n\n            this.adapter = options.adapter;\n\n            options.cookie ||= { maxAge: defaultTtl };\n            Store.call(this, options);\n        }\n\n        /**\n         * Attempt to fetch session by the given `sid`.\n         *\n         * @param sid Session ID\n         * @param fn callback\n         */\n        get(sid: string, fn: (err?: Error | string | null, obj?: ioBroker.Session) => void): void {\n            this.adapter.getSession(sid, (obj: ioBroker.Session): void => {\n                if (obj) {\n                    if (fn) {\n                        return fn(null, obj);\n                    }\n                } else if (fn) {\n                    return fn();\n                }\n            });\n        }\n\n        /**\n         * Commit the given `sess` object associated with the given `sid`.\n         *\n         * @param sid Session ID\n         * @param sess the session\n         * @param fn callback\n         */\n        set(sid: string, sess: ioBroker.Session, fn: (err?: Error | null) => void): void;\n        /**\n         * Commit the given `sess` object associated with the given `sid`.\n         *\n         * @param sid Session ID\n         * @param ttl Time to live\n         * @param sess the session\n         * @param fn callback\n         */\n        set(sid: string, ttl: number, sess: ioBroker.Session, fn: (err?: Error | null) => void): void;\n\n        /**\n         * Commit the given `sess` object associated with the given `sid`.\n         *\n         * @param sid Session ID\n         * @param ttl Time to live\n         * @param sess the session\n         * @param fn callback\n         */\n        set(sid: unknown, ttl: unknown, sess: unknown, fn?: unknown): void {\n            if (typeof sess === 'function') {\n                fn = sess;\n                sess = ttl;\n                // analyse if the session is stored directly from express session\n                ttl = (sess as ioBroker.Session)?.cookie?.originalMaxAge\n                    ? Math.round((sess as ioBroker.Session).cookie!.originalMaxAge! / 1000)\n                    : defaultTtl;\n            }\n            ttl ||= defaultTtl;\n            this.adapter.setSession(\n                sid as string,\n                ttl as number,\n                sess as ioBroker.Session,\n                function (err?: Error | null): void {\n                    // @ts-expect-error \"this\" is OK\n                    (fn as (err?: Error | null) => void)?.call(this, err);\n                },\n            ); // do not use here => !!!\n        }\n\n        /**\n         * Destroy the session associated with the given `sid`.\n         *\n         * @param sid Session ID\n         * @param fn callback\n         */\n        destroy(sid: string, fn: () => void): void {\n            this.adapter.destroySession(sid, fn);\n        }\n    }\n\n    return AdapterStore;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAmBA;;;;;AAOM,SAAU,mBAAmB,SAAkB,aAAa,MAAI;AAClE,QAAM,QAAQ,QAAQ;EAEtB,MAAM,qBAAqB,MAAK;IAVpC,OAUoC;;;IACX;;;;IAcjB,YAAY,SAA4B;AACpC,YAAM,OAAO;AAEb,WAAK,UAAU,QAAQ;AAEvB,cAAQ,WAAW,EAAE,QAAQ,WAAU;AACvC,YAAM,KAAK,MAAM,OAAO;IAC5B;;;;;;;IAQA,IAAI,KAAa,IAAiE;AAC9E,WAAK,QAAQ,WAAW,KAAK,CAAC,QAA+B;AACzD,YAAI,KAAK;AACL,cAAI,IAAI;AACJ,mBAAO,GAAG,MAAM,GAAG;UACvB;QACJ,WAAW,IAAI;AACX,iBAAO,GAAE;QACb;MACJ,CAAC;IACL;;;;;;;;;IA4BA,IAAI,KAAc,KAAc,MAAe,IAAY;AACvD,UAAI,OAAO,SAAS,YAAY;AAC5B,aAAK;AACL,eAAO;AAEP,cAAO,MAA2B,QAAQ,iBACpC,KAAK,MAAO,KAA0B,OAAQ,iBAAkB,GAAI,IACpE;MACV;AACA,cAAQ;AACR,WAAK,QAAQ,WACT,KACA,KACA,MACA,SAAU,KAAkB;AAEvB,YAAqC,KAAK,MAAM,GAAG;MACxD,CAAC;IAET;;;;;;;IAQA,QAAQ,KAAa,IAAc;AAC/B,WAAK,QAAQ,eAAe,KAAK,EAAE;IACvC;;AAGJ,SAAO;AACX;AAxGgB;",
   "names": []
 }