kuzzle 2.60.0-beta.1 → 2.60.0-beta.3

package/dist/lib/kuzzle/kuzzle.d.ts

@@ -17,6 +17,12 @@ import { Logger } from "./Logger";
 declare class Kuzzle extends KuzzleEventEmitter {
     config: IKuzzleConfiguration;
     private _state;
+    /** The running shutdown, which later `shutdown()` calls wait for (#3017) */
+    private shutdownPromise;
+    /** The highest exit code asked for by the `shutdown()` calls so far */
+    private shutdownExitCode;
+    /** Ends a failure's shutdown that does not finish in time */
+    private shutdownWatchdog;
     log: Logger;
     /** Read by `PluginsManager` to locate the plugins directories. */
     rootPath: string;
@@ -95,8 +101,12 @@ declare class Kuzzle extends KuzzleEventEmitter {
      * @param {Object} - Additional options (import, installations, plugins, secretsFile, support, vaultKey)
      *
      * @this {Kuzzle}
+     *
+     * The public signature takes `unknown`, which every call that compiled with
+     * v2.56.0's `any` still satisfies. `Backend.start()` is the one caller, and
+     * it hands the application wrapper the implementation reads.
      */
-    start(application: any, options?: StartOptions): Promise<void>;
+    start(application: unknown, options?: StartOptions): Promise<void>;
     /**
      * Generates the node ID.
      *
@@ -113,6 +123,7 @@ declare class Kuzzle extends KuzzleEventEmitter {
      * @returns {Promise}
      */
     shutdown(exitCode?: number): Promise<void>;
+    private runShutdown;
     /**
      * Execute multiple handlers only once on any given environment
      *
@@ -121,18 +132,19 @@ declare class Kuzzle extends KuzzleEventEmitter {
      * @returns {Promise<void>}
      */
     install(installations?: InstallationConfig[]): Promise<void>;
-    ask(event: string, ...args: [payload?: any, ...rest: any]): Promise<any>;
-    emit(event: string, ...args: any[]): boolean;
-    pipe(event: string, ...args: any[]): Promise<any>;
+    ask(event: string, ...args: [payload?: unknown, ...rest: unknown[]]): Promise<any>;
+    emit(event: string, ...args: unknown[]): boolean;
+    pipe(event: string, ...args: unknown[]): Promise<any>;
     private importUserMappings;
     private importMappings;
     private importFixtures;
     private importPermissions;
+    private isConfigsEmpty;
     /**
-     * Check if every import has been done, if one of them is not finished yet, wait for it
+     * Records the hash of the payload just imported (or found already imported)
+     * in both Redis and `%kuzzle.imports`, so that the next node or the next
+     * start can tell the import is done for this very payload
      */
-    private _waitForImportToFinish;
-    private isConfigsEmpty;
     private persistHashedImport;
     /**
      * Load into the app several imports
@@ -144,7 +156,7 @@ declare class Kuzzle extends KuzzleEventEmitter {
      */
     loadInitialState(toImport?: ImportConfig, toSupport?: SupportConfig): Promise<void>;
     dump(suffix: string): Promise<string>;
-    hash(input: any): number;
+    hash(input: unknown): number;
     get state(): kuzzleStateEnum;
     set state(value: kuzzleStateEnum);
     /**

package/dist/lib/kuzzle/kuzzle.js

@@ -35,13 +35,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -73,6 +83,7 @@ const validation_1 = __importDefault(require("../core/validation/validation"));
 const kerror = __importStar(require("../kerror"));
 const asyncStore_1 = __importDefault(require("../util/asyncStore"));
 const crypto_1 = require("../util/crypto");
+const distributedLock_1 = require("../util/distributedLock");
 const mutex_1 = require("../util/mutex");
 const dumpGenerator_1 = __importDefault(require("./dumpGenerator"));
 const KuzzleEventEmitter_1 = __importDefault(require("./event/KuzzleEventEmitter"));
@@ -82,6 +93,12 @@ const Logger_1 = require("./Logger");
 const vault_1 = __importDefault(require("./vault"));
 const name_generator_1 = require("../util/name-generator");
 let _kuzzle = null;
+/**
+ * How long a shutdown caused by a failure may run before the process exits
+ * anyway: a `kuzzle:shutdown` pipe or a lock release that never settles must
+ * not keep a failed node alive, which a bare `process.exit(1)` never did
+ */
+const FAILURE_SHUTDOWN_TIMEOUT = 30000;
 Reflect.defineProperty(global, "kuzzle", {
     configurable: true,
     enumerable: false,
@@ -102,6 +119,12 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
     constructor(config) {
         super(config.plugins.common.maxConcurrentPipes, config.plugins.common.pipesBufferSize);
         this._state = kuzzleStateEnum_1.default.STARTING;
+        /** The running shutdown, which later `shutdown()` calls wait for (#3017) */
+        this.shutdownPromise = null;
+        /** The highest exit code asked for by the `shutdown()` calls so far */
+        this.shutdownExitCode = 0;
+        /** Ends a failure's shutdown that does not finish in time */
+        this.shutdownWatchdog = null;
         global.kuzzle = this;
         this._state = kuzzleStateEnum_1.default.STARTING;
         this.config = config;
@@ -138,15 +161,7 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             userMappings: this.importUserMappings.bind(this),
         };
     }
-    /**
-     * Initializes all the needed components of Kuzzle.
-     *
-     * @param {Application} - Application Plugin instance
-     * @param {Object} - Additional options (import, installations, plugins, secretsFile, support, vaultKey)
-     *
-     * @this {Kuzzle}
-     */
-    async start(application, options = { import: {} }) {
+    async start(application, options) {
         this.registerSignalHandlers();
         try {
             this.log.info(`[ℹ] Starting Kuzzle ${this.version} ...`);
@@ -164,7 +179,7 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             await new security_1.default().init();
             // This will init the cluster module if enabled
             await this.initKuzzleNode();
-            this.vault = vault_1.default.load(options.vaultKey, options.secretsFile, this.config.vault?.newAlgorithm);
+            this.vault = vault_1.default.load(options?.vaultKey, options?.secretsFile, this.config.vault?.newAlgorithm);
             this.validation.init();
             await this.tokenManager.init();
             await this.funnel.init();
@@ -175,15 +190,15 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             await this.entryPoint.init();
             await this.debugger.init();
             this.pluginsManager.application = application;
-            const pluginImports = await this.pluginsManager.init(options.plugins);
-            const imports = lodash_1.default.merge({}, pluginImports, options.import);
+            const pluginImports = await this.pluginsManager.init(options?.plugins);
+            const imports = lodash_1.default.merge({}, pluginImports, options?.import);
             // Authentification plugins must be loaded before users import to avoid
             // credentials related error which would prevent Kuzzle from starting
-            await this.loadInitialState(imports, options.support);
+            await this.loadInitialState(imports, options?.support);
             await this.ask("core:security:verify");
             this.router.init();
             this.log.info("[✔] Core components loaded");
-            await this.install(options.installations);
+            await this.install(options?.installations);
             // `application` is the very wrapper handed to the plugins manager six
             // lines up, so reading the name back off the manager was a round trip
             // through a getter that can answer `undefined`.
@@ -201,6 +216,16 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         }
         catch (error) {
             this.log.error(`[X] Cannot start Kuzzle ${this.version}: ${error instanceof Error ? error.message : (0, node_util_1.inspect)(error)}`);
+            // A failed start cannot be retried (a second Kuzzle instance cannot be
+            // built), and what it did start keeps the process alive: in production,
+            // a node with no listener and an ID card still renewed (#3020). Not
+            // awaited, so the caller still gets the error before the process exits.
+            this.shutdown(1).catch((shutdownError) => {
+                this.log.error(`Unable to shut down after a failed start: ${shutdownError instanceof Error
+                    ? shutdownError.message
+                    : (0, node_util_1.inspect)(shutdownError)}`);
+                process.exit(1);
+            });
             throw error;
         }
     }
@@ -228,6 +253,22 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
      * @returns {Promise}
      */
     async shutdown(exitCode = 0) {
+        // Several sources can ask for it at once (a signal, a cluster eviction,
+        // the `exit` handler that `process.exit` below fires): they share the one
+        // shutdown, and a failure reported by any of them keeps the exit non-zero
+        this.shutdownExitCode = Math.max(this.shutdownExitCode, exitCode);
+        // Not for a requested shutdown: it waits for the requests still running,
+        // however long they take
+        if (exitCode !== 0) {
+            this.shutdownWatchdog ?? (this.shutdownWatchdog = setTimeout(() => {
+                this.log.error(`[shutdown] Not finished after ${FAILURE_SHUTDOWN_TIMEOUT}ms: exiting now`);
+                process.exit(this.shutdownExitCode);
+            }, FAILURE_SHUTDOWN_TIMEOUT));
+        }
+        this.shutdownPromise ?? (this.shutdownPromise = this.runShutdown());
+        return this.shutdownPromise;
+    }
+    async runShutdown() {
         this._state = kuzzleStateEnum_1.default.SHUTTING_DOWN;
         this.log.info("Initiating shutdown...");
         // Ask the network layer to stop accepting new request
@@ -241,7 +282,10 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         }
         // The other nodes may be waiting on a lock this one holds: a node leaving
         // mid-startup is often in the middle of one (F-13).
-        await mutex_1.Mutex.releaseAllBeforeExit(); // NOSONAR: frees locks taken through the deprecated API
+        await Promise.all([
+            (0, distributedLock_1.releaseAllLocksBeforeExit)(),
+            mutex_1.Mutex.releaseAllBeforeExit(), // NOSONAR: frees locks taken through the deprecated API
+        ]);
         this.log.info("Halted.");
         // flush both application and Kuzzle core loggers before leaving (Could happen even if some core/application components are not initialized)
         await this?.log?.flush?.();
@@ -251,7 +295,10 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         // `pluginsManager?.application?.log?.flush?.()` was a silent no-op and the
         // application's buffered logs were dropped on shutdown (TD-51).
         await this?.pluginsManager?.application?.instance?.log?.flush?.();
-        process.exit(exitCode);
+        if (this.shutdownWatchdog !== null) {
+            clearTimeout(this.shutdownWatchdog);
+        }
+        process.exit(this.shutdownExitCode);
     }
     /**
      * Execute multiple handlers only once on any given environment
@@ -266,9 +313,9 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         if (!installations?.length) {
             return;
         }
-        const mutex = new mutex_1.Mutex("backend:installations");
-        await mutex.lock();
-        try {
+        // No retry limit: another node is running the installations, and this
+        // one must not start before they are recorded
+        await (0, distributedLock_1.withLock)("backend:installations", async () => {
             for (const installation of installations) {
                 const isAlreadyInstalled = await this.ask("core:storage:private:document:exist", "kuzzle", "installations", installation.id);
                 if (!isAlreadyInstalled) {
@@ -286,10 +333,7 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
                     this.log.info(`[✔] Install code "${installation.id}" successfully executed`);
                 }
             }
-        }
-        finally {
-            await mutex.unlock();
-        }
+        }, { retryAttempts: Number.POSITIVE_INFINITY });
     }
     // For testing purpose
     async ask(event, ...args) {
@@ -322,11 +366,8 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         }
         else if (!lodash_1.default.isEmpty(toSupport.mappings)) {
             await this.ask("core:storage:public:mappings:import", toSupport.mappings, {
-                /**
-                 * If it's the first time the mapping are loaded and another node is already importing the mapping into the database
-                 * we just want to load the mapping in our own index cache and not in the database.
-                 */
-                indexCacheOnly: status.initialized || !status.locked,
+                // Already imported (by this node or another one): only fill the cache
+                indexCacheOnly: status.initialized,
                 propagate: false, // Each node needs to do the import themselves
                 rawMappings: true,
                 refresh: true,
@@ -335,11 +376,8 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         }
         else if (!lodash_1.default.isEmpty(toImport.mappings)) {
             await this.ask("core:storage:public:mappings:import", toImport.mappings, {
-                /**
-                 * If it's the first time the mapping are loaded and another node is already importing the mapping into the database
-                 * we just want to load the mapping in our own index cache and not in the database.
-                 */
-                indexCacheOnly: status.initialized || !status.locked,
+                // Already imported (by this node or another one): only fill the cache
+                indexCacheOnly: status.initialized,
                 propagate: false, // Each node needs to do the import themselves
                 refresh: true,
             });
@@ -392,19 +430,6 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             this.log.info("[✔] Permissions import successful");
         }
     }
-    /**
-     * Check if every import has been done, if one of them is not finished yet, wait for it
-     */
-    async _waitForImportToFinish() {
-        const importTypes = Object.keys(this.importTypes);
-        for (const importType of importTypes) {
-            // If the import is done, we pop it from the queue to check the next one
-            if (await this.ask("core:cache:internal:get", `backend:init:import:${importType}`)) {
-                return;
-            }
-            await bluebird_1.default.delay(1000);
-        }
-    }
     isConfigsEmpty(importConfig, supportConfig) {
         if (lodash_1.default.isEmpty(importConfig.mappings) &&
             lodash_1.default.isEmpty(importConfig.profiles) &&
@@ -418,10 +443,16 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         }
         return false;
     }
-    async persistHashedImport({ existingRedisHash, existingESHash, importPayloadHash, type, }) {
-        if (!existingRedisHash && !existingESHash) {
-            // If the import is not initialized in the redis cache and in the ES, we initialize it
-            this.log.info(`${type} import is not initialized, initializing...`);
+    /**
+     * Records the hash of the payload just imported (or found already imported)
+     * in both Redis and `%kuzzle.imports`, so that the next node or the next
+     * start can tell the import is done for this very payload
+     */
+    async persistHashedImport({ existingRedisHash, existingESHash, importPayloadHash, initialized, type, }) {
+        // Not initialized: the payload was just imported, and a hash left by a
+        // previous payload must be replaced, or every start would import it again
+        if (!initialized || !existingESHash) {
+            this.log.info(`Recording the ${type} import in %kuzzle.imports...`);
             // `createOrReplace`, not `create`: this document has a fixed id, so a
             // conflict on it means another node initialized the same import — an
             // outcome to converge on, not an error to die on. `create` made that
@@ -429,24 +460,9 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             await this.ask("core:storage:private:document:createOrReplace", "kuzzle", "imports", `backend:init:import:${type}`, {
                 hash: importPayloadHash,
             });
-            await this.ask("core:cache:internal:store", `backend:init:import:${type}`, importPayloadHash);
-        }
-        else if (existingRedisHash && !existingESHash) {
-            // If the import is initialized in the redis cache but not in the ES
-            // We initialize it in the ES
-            this.log.info(`${type} import is not initialized in %kuzzle.imports, initializing...`);
-            const redisCache = await this.ask("core:cache:internal:get", `backend:init:import:${type}`);
-            // Same reasoning as above: a fixed id, so a conflict is convergence.
-            await this.ask("core:storage:private:document:createOrReplace", "kuzzle", "imports", `backend:init:import:${type}`, {
-                hash: redisCache,
-            });
         }
-        else if (!existingRedisHash && existingESHash) {
-            // If the import is initialized in the ES but not in the redis cache
-            // We initialize it in the redis cache
-            this.log.info(`${type} import is not initialized in the redis cache, initializing...`);
-            const esDocument = await this.ask("core:storage:private:document:get", "kuzzle", "imports", `backend:init:import:${type}`);
-            await this.ask("core:cache:internal:store", `backend:init:import:${type}`, esDocument._source.hash);
+        if (!initialized || !existingRedisHash) {
+            await this.ask("core:cache:internal:store", `backend:init:import:${type}`, importPayloadHash);
         }
     }
     /**
@@ -461,42 +477,37 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         if (this.isConfigsEmpty(toImport, toSupport)) {
             return;
         }
-        const lockedMutex = [];
-        try {
-            for (const [type, importMethod] of Object.entries(this.importTypes)) {
-                const importPayload = {};
-                switch (type) {
-                    case "fixtures":
-                        lodash_1.default.set(importPayload, "toSupport.fixtures", toSupport.fixtures);
-                        break;
-                    case "mappings":
-                        lodash_1.default.set(importPayload, "toSupport.mappings", toSupport.mappings);
-                        lodash_1.default.set(importPayload, "toImport.mappings", toImport.mappings);
-                        break;
-                    case "permissions":
-                        lodash_1.default.set(importPayload, "toSupport.securities", toSupport.securities);
-                        lodash_1.default.set(importPayload, "toImport.profiles", toImport.profiles);
-                        lodash_1.default.set(importPayload, "toImport.roles", toImport.roles);
-                        lodash_1.default.set(importPayload, "toImport.users", toImport.users);
-                        break;
-                }
-                // `?? ""`: `json-stable-stringify` answers undefined for a value it
-                // cannot serialise, and the payload is built right above.
-                const importPayloadHash = (0, crypto_1.sha256)((0, json_stable_stringify_1.default)(importPayload) ?? "");
-                // `timeout: 0` means a single acquisition attempt: exactly one node
-                // runs the import and the others carry on with `locked: false`.
-                // The TTL has to outlive the import itself, because this lock is held
-                // until the `finally` below — across every import type and the wait
-                // that follows. It is still an upper bound rather than a guarantee,
-                // which is why the bookkeeping write below is idempotent (TD-69).
-                // NOSONAR: `Mutex` is deprecated in favour of `withLock`, but the two
-                // use incompatible acquisition/TTL formats and must not contend on the
-                // same key — every other node still takes this lock with `Mutex`, so
-                // swapping one site would remove the exclusion it exists for. Deferred
-                // to #2894, like the remaining call sites.
-                const lockOptions = { timeout: 0, ttl: 60000 };
-                const mutex = new mutex_1.Mutex(`backend:import:${type}`, lockOptions); // NOSONAR
-                const locked = await mutex.lock();
+        const importTypes = Object.entries(this.importTypes);
+        // Imports the types from `index` on. Each type's lock is taken around the
+        // remaining types, so that every lock taken is held until all the imports
+        // are done: a node waiting for the first lock starts only once the node
+        // ahead of it has imported everything.
+        const importFrom = async (index) => {
+            const next = importTypes[index];
+            if (!next) {
+                return;
+            }
+            const [type, importMethod] = next;
+            const importPayload = {};
+            switch (type) {
+                case "fixtures":
+                    lodash_1.default.set(importPayload, "toSupport.fixtures", toSupport.fixtures);
+                    break;
+                case "mappings":
+                    lodash_1.default.set(importPayload, "toSupport.mappings", toSupport.mappings);
+                    lodash_1.default.set(importPayload, "toImport.mappings", toImport.mappings);
+                    break;
+                case "permissions":
+                    lodash_1.default.set(importPayload, "toSupport.securities", toSupport.securities);
+                    lodash_1.default.set(importPayload, "toImport.profiles", toImport.profiles);
+                    lodash_1.default.set(importPayload, "toImport.roles", toImport.roles);
+                    lodash_1.default.set(importPayload, "toImport.users", toImport.users);
+                    break;
+            }
+            // `?? ""`: `json-stable-stringify` answers undefined for a value it
+            // cannot serialise, and the payload is built right above.
+            const importPayloadHash = (0, crypto_1.sha256)((0, json_stable_stringify_1.default)(importPayload) ?? "");
+            const importType = async () => {
                 // Read the bookkeeping *after* the lock, never before: a read taken
                 // before acquiring it is not protected by it, and the holder that
                 // acted on a stale "not initialized" used to create a document the
@@ -515,26 +526,31 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
                     initialized = esDocument._source.hash === importPayloadHash;
                 }
                 await importMethod({ toImport, toSupport }, {
-                    firstCall: !initialized && locked,
-                    initialized: initialized,
-                    locked,
+                    firstCall: !initialized,
+                    initialized,
                 });
-                if (locked) {
-                    lockedMutex.push(mutex);
-                    await this.persistHashedImport({
-                        existingESHash,
-                        existingRedisHash,
-                        importPayloadHash,
-                        type,
-                    });
-                }
-            }
-            await this._waitForImportToFinish();
-            this.log.info("[✔] Import successful");
-        }
-        finally {
-            await Promise.all(lockedMutex.map((mutex) => mutex.unlock()));
-        }
+                await this.persistHashedImport({
+                    existingESHash,
+                    existingRedisHash,
+                    importPayloadHash,
+                    initialized,
+                    type,
+                });
+                await importFrom(index + 1);
+            };
+            // No retry limit: the node holding it is running this import, and this
+            // one must not start before it is done. Once it gets the lock, it finds
+            // the import done for this payload and only fills its cache; if the
+            // node ahead died mid-import, it runs the import itself. The lock is
+            // refreshed while held; a lost lock fails the startup with
+            // `MutexLockLostError` (the bookkeeping write stays idempotent, TD-69).
+            await (0, distributedLock_1.withLock)(`backend:import:${type}`, importType, {
+                retryAttempts: Number.POSITIVE_INFINITY,
+                ttl: 60000,
+            });
+        };
+        await importFrom(0);
+        this.log.info("[✔] Import successful");
     }
     dump(suffix) {
         return this.dumpGenerator.dump(suffix);
@@ -633,7 +649,9 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
                 // nothing to do with that error
             }
         }
-        await this.shutdown();
+        // Only abnormal terminations get here: exit non-zero, so that an
+        // `on-failure` restart policy brings the node back (#3020)
+        await this.shutdown(1);
     }
 }
 exports.Kuzzle = Kuzzle;

package/dist/lib/model/security/profile.js

@@ -35,13 +35,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };

package/dist/lib/model/security/role.js

@@ -35,13 +35,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Role = void 0;
 const kerror = __importStar(require("../../kerror"));

package/dist/lib/model/security/user.js

@@ -35,13 +35,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };

package/dist/lib/model/storage/apiKey.d.ts

@@ -12,7 +12,7 @@ declare class ApiKey extends BaseModel {
     userId: string;
     description: string;
     expiresAt: number;
-    ttl: number | string;
+    ttl: number;
     token: string;
     fingerprint: string;
     constructor(_source: JSONObject, _id?: string | null);

package/dist/lib/model/storage/apiKey.js

@@ -35,13 +35,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };