kuzzle 2.60.0-beta.4 → 2.60.0-beta.6

package/dist/lib/core/shared/KoncordeWrapper.js

@@ -35,14 +35,14 @@ class NormalizedFilterV3 {
     }
 }
 exports.NormalizedFilterV3 = NormalizedFilterV3;
-/*
-  @deprecated
-
-  Exposes Koncorde v4 through an interface emulating Koncorde v3, to prevent
-  breaking changes in Kuzzle.
-
-  This class should either be removed entirely in the next major version, or
-  perhaps proposed in a compatibility mode to help clients migrate smoothly.
+/**
+ * Exposes Koncorde v4 through an interface emulating Koncorde v3, to prevent
+ * breaking changes in Kuzzle.
+ *
+ * This class should either be removed entirely in the next major version, or
+ * perhaps proposed in a compatibility mode to help clients migrate smoothly.
+ *
+ * @deprecated Use the `koncorde` package (v4) directly.
  */
 class Koncorde {
     constructor(options = {}) {

package/dist/lib/core/storage/clientAdapter.js

@@ -96,8 +96,13 @@ class ClientAdapter {
         this.registerLockEvents();
         // The cache and the locks were first loaded before this node joined the
         // cluster: an index, a collection or a lock a peer added in between was
-        // broadcast before this node could hear it. Reading them again once the
-        // cluster is joined closes that gap.
+        // broadcast before this node could hear it. `Kuzzle.start()` asks for this
+        // reload right after the cluster is joined, before the plugins' `init()`
+        // runs (#3044).
+        global.kuzzle.onAsk(`core:storage:${this.scope}:cache:reload`, () => this.reloadCache());
+        // Read again once the node goes live: a peer that joined after this node
+        // may have created indexes or collections before its own join (e.g. its
+        // internal index), and that broadcast reached no one.
         global.kuzzle.onPipe("kuzzle:state:live", () => this.reloadCache());
         // Global store events registration
         /**

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

@@ -28,5 +28,9 @@ export declare class Logger extends KuzzleLogger {
     verbose(message: string): void;
     getLevel(): string;
     setLevel(level: string): void;
+    /**
+     * Creates a child logger with the given namespace, appended to the parent's
+     * one. Its level follows the parent's until it is set on the child.
+     */
     child(namespace: string): Logger;
 }

package/dist/lib/kuzzle/Logger.js

@@ -128,9 +128,16 @@ class Logger extends kuzzle_logger_1.KuzzleLogger {
     setLevel(level) {
         this.level = level;
     }
+    /**
+     * Creates a child logger with the given namespace, appended to the parent's
+     * one. Its level follows the parent's until it is set on the child.
+     */
     child(namespace) {
-        // TODO, this is fishy we will probably need to properly remove the "as Logger"
-        return super.child(namespace);
+        // kuzzle-logger builds the child as a plain KuzzleLogger (no getLevel,
+        // setLevel, silly, verbose): give it this class's prototype so it is the
+        // Logger it is declared to be. Its state is all KuzzleLogger's, and the
+        // deprecation flags start unset, as on a new Logger.
+        return Object.setPrototypeOf(super.child(namespace), Logger.prototype);
     }
 }
 exports.Logger = Logger;

package/dist/lib/kuzzle/internalIndexHandler.js

@@ -57,6 +57,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const bluebird_1 = __importDefault(require("bluebird"));
+const authTokenSettings_1 = require("../core/security/authTokenSettings");
 const store_1 = require("../core/shared/store");
 const storeScopeEnum_1 = require("../core/storage/storeScopeEnum");
 const specification_1 = require("../core/validation/specification");
@@ -191,11 +192,9 @@ class InternalIndexHandler extends store_1.Store {
         await bluebird_1.default.all(promises);
     }
     async _initSecret() {
-        // NOSONAR: `jwt` is the deprecated spelling of `authToken`, read second so
-        // an existing configuration keeps working. Dropping it is a breaking change
-        // for anyone who has not migrated, not a conversion's to make.
-        const { authToken, jwt } = global.kuzzle.config.security; // NOSONAR
-        const configSeed = authToken?.secret ?? jwt?.secret; // NOSONAR
+        // `jwt` is the deprecated spelling of `authToken`, read second so an
+        // existing configuration keeps working (see authTokenSetting).
+        const configSeed = (0, authTokenSettings_1.authTokenSetting)("secret");
         let storedSeed = await this.exists("config", this._JWT_SECRET_ID);
         if (!configSeed) {
             if (!storedSeed) {

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

@@ -107,6 +107,23 @@ declare class Kuzzle extends KuzzleEventEmitter {
      * it hands the application wrapper the implementation reads.
      */
     start(application: unknown, options?: StartOptions): Promise<void>;
+    /**
+     * A node asked to stop while it starts must not go on taking cluster-wide
+     * locks or running the application's installations: if it is killed before
+     * its shutdown releases them, the other nodes wait for their TTL (#3045).
+     */
+    private stopIfShuttingDown;
+    /**
+     * The shutdown began during the startup, which stopped (or failed because
+     * of it): no "Cannot start" error and no second shutdown, the one running
+     * keeps its exit code and ends the process.
+     *
+     * The returned promise never settles, as `withLock` once the process is
+     * exiting: rejecting would send the caller down its failed-start path
+     * (often a `process.exit(1)`, which would cut the shutdown short), and
+     * resolving would tell it that Kuzzle is running.
+     */
+    private leaveStartupToShutdown;
     /**
      * Generates the node ID.
      *

package/dist/lib/kuzzle/kuzzle.js

@@ -99,6 +99,17 @@ let _kuzzle = null;
  * not keep a failed node alive, which a bare `process.exit(1)` never did
  */
 const FAILURE_SHUTDOWN_TIMEOUT = 30000;
+/**
+ * Stops the startup sequence once a shutdown has begun (#3045): `start()`
+ * catches it and leaves the shutdown to end the process. Internal: never
+ * handed to the caller of `start()`.
+ */
+class StartupInterruptedError extends Error {
+    constructor() {
+        super("Kuzzle is shutting down");
+        this.name = "StartupInterruptedError";
+    }
+}
 Reflect.defineProperty(global, "kuzzle", {
     configurable: true,
     enumerable: false,
@@ -175,9 +186,11 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             await new cacheEngine_1.default().init();
             await new storageEngine_1.default().init();
             await new realtime_1.default().init();
+            this.stopIfShuttingDown();
             await this.internalIndex.init();
             await new security_1.default().init();
             // This will init the cluster module if enabled
+            this.stopIfShuttingDown();
             await this.initKuzzleNode();
             this.vault = vault_1.default.load(options?.vaultKey, options?.secretsFile, this.config.vault?.newAlgorithm);
             this.validation.init();
@@ -189,21 +202,25 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             // before opening connections to external users
             await this.entryPoint.init();
             await this.debugger.init();
+            this.stopIfShuttingDown();
             this.pluginsManager.application = application;
             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
+            this.stopIfShuttingDown();
             await this.loadInitialState(imports, options?.support);
             await this.ask("core:security:verify");
             this.router.init();
             this.log.info("[✔] Core components loaded");
+            this.stopIfShuttingDown();
             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`.
             this.log.info(`[✔] Start "${application.name}" application`);
             this.openApiManager = new openapi_1.OpenApiManager(application.openApi, this.config.http.routes, this.pluginsManager.routes);
+            this.stopIfShuttingDown();
             // @deprecated
             await this.pipe("kuzzle:start");
             await this.pipe("kuzzle:state:live");
@@ -215,6 +232,9 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             this._state = kuzzleStateEnum_1.default.RUNNING;
         }
         catch (error) {
+            if (this._state === kuzzleStateEnum_1.default.SHUTTING_DOWN) {
+                return this.leaveStartupToShutdown(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,
@@ -229,6 +249,36 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             throw error;
         }
     }
+    /**
+     * A node asked to stop while it starts must not go on taking cluster-wide
+     * locks or running the application's installations: if it is killed before
+     * its shutdown releases them, the other nodes wait for their TTL (#3045).
+     */
+    stopIfShuttingDown() {
+        if (this._state === kuzzleStateEnum_1.default.SHUTTING_DOWN) {
+            throw new StartupInterruptedError();
+        }
+    }
+    /**
+     * The shutdown began during the startup, which stopped (or failed because
+     * of it): no "Cannot start" error and no second shutdown, the one running
+     * keeps its exit code and ends the process.
+     *
+     * The returned promise never settles, as `withLock` once the process is
+     * exiting: rejecting would send the caller down its failed-start path
+     * (often a `process.exit(1)`, which would cut the shutdown short), and
+     * resolving would tell it that Kuzzle is running.
+     */
+    leaveStartupToShutdown(error) {
+        let message = "[ℹ] Startup stopped: Kuzzle is shutting down";
+        // A step that failed because of the shutdown, rather than stopped by it
+        if (!(error instanceof StartupInterruptedError)) {
+            const reason = error instanceof Error ? error.message : (0, node_util_1.inspect)(error);
+            message += ` (${reason})`;
+        }
+        this.log.info(message);
+        return new Promise(() => undefined);
+    }
     /**
      * Generates the node ID.
      *
@@ -238,6 +288,13 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         if (this.config.cluster.enabled) {
             await new cluster_1.default().init();
             this.log.info("[✔] Cluster initialized");
+            // The storage caches were loaded before the join: what a peer created
+            // in between was broadcast before this node could hear it. Read them
+            // again before the plugins' `init()` relies on them (#3044).
+            await Promise.all([
+                this.ask("core:storage:public:cache:reload"),
+                this.ask("core:storage:private:cache:reload"),
+            ]);
         }
         else {
             this.log.info("[X] Cluster disabled: single node mode.");
@@ -317,6 +374,9 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         // one must not start before they are recorded
         await (0, distributedLock_1.withLock)("backend:installations", async () => {
             for (const installation of installations) {
+                // The lock may come long after it was asked for, once the node
+                // holding it is done: by then, this one may be shutting down
+                this.stopIfShuttingDown();
                 const isAlreadyInstalled = await this.ask("core:storage:private:document:exist", "kuzzle", "installations", installation.id);
                 if (!isAlreadyInstalled) {
                     try {
@@ -508,6 +568,8 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             // 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 () => {
+                // Same as for the installations: the lock may come after a SIGTERM
+                this.stopIfShuttingDown();
                 // 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

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

@@ -1,6 +1,19 @@
 import { Vault } from "kuzzle-vault";
+/**
+ * The default secrets file, `config/secrets.enc.json` at the project root.
+ *
+ * Installed as an npm package (KaaF), Kuzzle lives under `node_modules/kuzzle`
+ * and the project root is above it: from `node_modules/kuzzle/dist/lib/kuzzle`
+ * since the build outputs to `dist/` (2.50.0), from
+ * `node_modules/kuzzle/lib/kuzzle` before. Anywhere else (a Kuzzle checkout),
+ * the file is the checkout's own `config/secrets.enc.json`.
+ *
+ * @param dirname - the directory of this module
+ */
+declare function defaultSecretsFile(dirname: string): string;
 declare function load(vaultKey?: string, secretsFile?: string, useNewAlgorithm?: boolean): Vault;
 declare const _default: {
+    defaultSecretsFile: typeof defaultSecretsFile;
     load: typeof load;
 };
 export = _default;

package/dist/lib/kuzzle/vault.js

@@ -35,15 +35,33 @@ const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
 // strict while being false for every read before that first assignment
 // (TD-57, #2760).
 let ENV_VAULT_KEY;
+/**
+ * The default secrets file, `config/secrets.enc.json` at the project root.
+ *
+ * Installed as an npm package (KaaF), Kuzzle lives under `node_modules/kuzzle`
+ * and the project root is above it: from `node_modules/kuzzle/dist/lib/kuzzle`
+ * since the build outputs to `dist/` (2.50.0), from
+ * `node_modules/kuzzle/lib/kuzzle` before. Anywhere else (a Kuzzle checkout),
+ * the file is the checkout's own `config/secrets.enc.json`.
+ *
+ * @param dirname - the directory of this module
+ */
+function defaultSecretsFile(dirname) {
+    const dir = dirname.split(node_path_1.default.sep).join("/");
+    for (const installed of [
+        "/node_modules/kuzzle/dist/lib/kuzzle",
+        "/node_modules/kuzzle/lib/kuzzle",
+    ]) {
+        if (dir.endsWith(installed)) {
+            return node_path_1.default.resolve(dirname.slice(0, dirname.length - installed.length + 1), "config/secrets.enc.json");
+        }
+    }
+    return node_path_1.default.resolve(dirname, "../../config/secrets.enc.json");
+}
 function load(vaultKey, secretsFile, useNewAlgorithm = false) {
-    // Using KaaF kuzzle is an npm package and is located under node_modules folder
-    // We need to get back to root folder of the project to get the secret file
-    const defaultEncryptedSecretsFile = __dirname.endsWith("/node_modules/kuzzle/lib/kuzzle")
-        ? node_path_1.default.resolve(`${__dirname}/../../../../config/secrets.enc.json`)
-        : node_path_1.default.resolve(`${__dirname}/../../config/secrets.enc.json`);
     const encryptedSecretsFile = secretsFile ||
         process.env.KUZZLE_SECRETS_FILE ||
-        defaultEncryptedSecretsFile;
+        defaultSecretsFile(__dirname);
     let key = vaultKey;
     if ((0, isEmpty_1.default)(vaultKey) &&
         (!(0, isEmpty_1.default)(process.env.KUZZLE_VAULT_KEY) || !(0, isEmpty_1.default)(ENV_VAULT_KEY))) {
@@ -71,5 +89,5 @@ function load(vaultKey, secretsFile, useNewAlgorithm = false) {
     }
     return vault;
 }
-module.exports = { load };
+module.exports = { defaultSecretsFile, load };
 //# sourceMappingURL=vault.js.map

package/dist/lib/service/storage/7/elasticsearch.d.ts

@@ -452,6 +452,12 @@ export declare class ES7 {
         mappings?: TypeMapping;
         settings?: JSONObject;
     }): Promise<null>;
+    /**
+     * Applies the mappings and settings of a `createCollection` call to a
+     * collection that already exists because another request created it,
+     * maybe so recently that its primary shards are still initializing.
+     */
+    private _updateConcurrentlyCreatedCollection;
     /**
      * Waits until the primary shards of a collection are active, for at most
      * `timeout`, and rejects if they are not by then.
@@ -462,6 +468,12 @@ export declare class ES7 {
      * collection waits for its shards (`wait_for_active_shards`); a node that
      * finds it already there calls this instead. It answers at once when the
      * shards are already active.
+     *
+     * A `yellow` status alone does not wait: Elasticsearch reports a new index
+     * whose primaries are still initializing as `yellow` (#3074). Asking for as
+     * many active shard copies as the index has primaries does, and, unlike
+     * `wait_for_no_initializing_shards`, does not also wait for replicas that
+     * are recovering, which a collection with data may take longer to do.
      */
     waitForCollectionShards(index: string, collection: string, timeout?: string): Promise<void>;
     /**

package/dist/lib/service/storage/7/elasticsearch.js

@@ -1149,23 +1149,23 @@ class ES7 {
         this._checkDynamicProperty(mappings);
         const exists = await this.hasCollection(index, collection);
         if (exists) {
-            // Another node created it, maybe so recently that its primary shards
-            // are still initializing
-            await this.waitForCollectionShards(index, collection);
-            return this.updateCollection(index, collection, { mappings, settings });
+            return this._updateConcurrentlyCreatedCollection(index, collection, mappings, settings);
         }
         this._checkMappings(mappings);
+        // Copies, not in-place changes: the race branch below must hand the
+        // caller's own mappings and settings to `updateCollection`
         requestBody.mappings = {
             _meta: mappings._meta || this._config.commonMapping._meta,
             dynamic: mappings.dynamic || this._config.commonMapping.dynamic,
-            properties: lodash_1.default.merge(mappings.properties, this._config.commonMapping.properties),
+            properties: lodash_1.default.merge({}, mappings.properties, this._config.commonMapping.properties),
+        };
+        requestBody.settings = {
+            ...settings,
+            number_of_replicas: settings.number_of_replicas ||
+                this._config.defaultSettings.number_of_replicas,
+            number_of_shards: settings.number_of_shards ||
+                this._config.defaultSettings.number_of_shards,
         };
-        settings.number_of_replicas =
-            settings.number_of_replicas ||
-                this._config.defaultSettings.number_of_replicas;
-        settings.number_of_shards =
-            settings.number_of_shards ||
-                this._config.defaultSettings.number_of_shards;
         try {
             await this._client.indices.create(esRequest);
         }
@@ -1174,9 +1174,9 @@ class ES7 {
                 "resource_already_exists_exception") {
                 // race condition: the indice has been created between the "exists"
                 // check above and this "create" attempt, by a request that may not
-                // have waited for its shards yet
-                await this.waitForCollectionShards(index, collection);
-                return null;
+                // have waited for its shards yet. This request's mappings and
+                // settings must still be applied, as if it had seen it exist
+                return this._updateConcurrentlyCreatedCollection(index, collection, mappings, settings);
             }
             throw this._esWrapper.formatESError(error);
         }
@@ -1195,6 +1195,15 @@ class ES7 {
         }
         return null;
     }
+    /**
+     * Applies the mappings and settings of a `createCollection` call to a
+     * collection that already exists because another request created it,
+     * maybe so recently that its primary shards are still initializing.
+     */
+    async _updateConcurrentlyCreatedCollection(index, collection, mappings, settings) {
+        await this.waitForCollectionShards(index, collection);
+        return this.updateCollection(index, collection, { mappings, settings });
+    }
     /**
      * Waits until the primary shards of a collection are active, for at most
      * `timeout`, and rejects if they are not by then.
@@ -1205,12 +1214,25 @@ class ES7 {
      * collection waits for its shards (`wait_for_active_shards`); a node that
      * finds it already there calls this instead. It answers at once when the
      * shards are already active.
+     *
+     * A `yellow` status alone does not wait: Elasticsearch reports a new index
+     * whose primaries are still initializing as `yellow` (#3074). Asking for as
+     * many active shard copies as the index has primaries does, and, unlike
+     * `wait_for_no_initializing_shards`, does not also wait for replicas that
+     * are recovering, which a collection with data may take longer to do.
      */
     async waitForCollectionShards(index, collection, timeout = COLLECTION_SHARDS_TIMEOUT) {
+        const alias = this._getAlias(index, collection);
         try {
+            const { body } = await this._client.indices.getSettings({
+                index: alias,
+                name: "index.number_of_shards",
+            });
+            const primaries = Object.values(body)[0]?.settings?.index?.number_of_shards;
             await this._client.cluster.health({
-                index: this._getAlias(index, collection),
+                index: alias,
                 timeout,
+                wait_for_active_shards: String(primaries ?? 1),
                 wait_for_status: "yellow",
             });
         }

package/dist/lib/service/storage/8/elasticsearch.d.ts

@@ -443,6 +443,12 @@ export declare class ES8 {
         mappings?: estypes.MappingTypeMapping;
         settings?: estypes.IndicesIndexSettings;
     }): Promise<null>;
+    /**
+     * Applies the mappings and settings of a `createCollection` call to a
+     * collection that already exists because another request created it,
+     * maybe so recently that its primary shards are still initializing.
+     */
+    private _updateConcurrentlyCreatedCollection;
     /**
      * Waits until the primary shards of a collection are active, for at most
      * `timeout`, and rejects if they are not by then.
@@ -453,6 +459,12 @@ export declare class ES8 {
      * collection waits for its shards (`wait_for_active_shards`); a node that
      * finds it already there calls this instead. It answers at once when the
      * shards are already active.
+     *
+     * A `yellow` status alone does not wait: Elasticsearch reports a new index
+     * whose primaries are still initializing as `yellow` (#3074). Asking for as
+     * many active shard copies as the index has primaries does, and, unlike
+     * `wait_for_no_initializing_shards`, does not also wait for replicas that
+     * are recovering, which a collection with data may take longer to do.
      */
     waitForCollectionShards(index: string, collection: string, timeout?: string): Promise<void>;
     /**

package/dist/lib/service/storage/8/elasticsearch.js

@@ -1171,23 +1171,23 @@ class ES8 {
         this._checkDynamicProperty(mappings);
         const exists = await this.hasCollection(index, collection);
         if (exists) {
-            // Another node created it, maybe so recently that its primary shards
-            // are still initializing
-            await this.waitForCollectionShards(index, collection);
-            return this.updateCollection(index, collection, { mappings, settings });
+            return this._updateConcurrentlyCreatedCollection(index, collection, mappings, settings);
         }
         this._checkMappings(mappings);
+        // Copies, not in-place changes: the race branch below must hand the
+        // caller's own mappings and settings to `updateCollection`
         esRequest.mappings = {
             _meta: mappings._meta || this._config.commonMapping._meta,
             dynamic: mappings.dynamic || this._config.commonMapping.dynamic,
-            properties: lodash_1.default.merge(mappings.properties, this._config.commonMapping.properties),
+            properties: lodash_1.default.merge({}, mappings.properties, this._config.commonMapping.properties),
+        };
+        esRequest.settings = {
+            ...settings,
+            number_of_replicas: settings.number_of_replicas ||
+                this._config.defaultSettings.number_of_replicas,
+            number_of_shards: settings.number_of_shards ||
+                this._config.defaultSettings.number_of_shards,
         };
-        settings.number_of_replicas =
-            settings.number_of_replicas ||
-                this._config.defaultSettings.number_of_replicas;
-        settings.number_of_shards =
-            settings.number_of_shards ||
-                this._config.defaultSettings.number_of_shards;
         try {
             await this._client.indices.create(esRequest);
         }
@@ -1196,9 +1196,9 @@ class ES8 {
                 "resource_already_exists_exception") {
                 // race condition: the indice has been created between the "exists"
                 // check above and this "create" attempt, by a request that may not
-                // have waited for its shards yet
-                await this.waitForCollectionShards(index, collection);
-                return null;
+                // have waited for its shards yet. This request's mappings and
+                // settings must still be applied, as if it had seen it exist
+                return this._updateConcurrentlyCreatedCollection(index, collection, mappings, settings);
             }
             throw this._esWrapper.formatESError(error);
         }
@@ -1217,6 +1217,15 @@ class ES8 {
         }
         return null;
     }
+    /**
+     * Applies the mappings and settings of a `createCollection` call to a
+     * collection that already exists because another request created it,
+     * maybe so recently that its primary shards are still initializing.
+     */
+    async _updateConcurrentlyCreatedCollection(index, collection, mappings, settings) {
+        await this.waitForCollectionShards(index, collection);
+        return this.updateCollection(index, collection, { mappings, settings });
+    }
     /**
      * Waits until the primary shards of a collection are active, for at most
      * `timeout`, and rejects if they are not by then.
@@ -1227,12 +1236,25 @@ class ES8 {
      * collection waits for its shards (`wait_for_active_shards`); a node that
      * finds it already there calls this instead. It answers at once when the
      * shards are already active.
+     *
+     * A `yellow` status alone does not wait: Elasticsearch reports a new index
+     * whose primaries are still initializing as `yellow` (#3074). Asking for as
+     * many active shard copies as the index has primaries does, and, unlike
+     * `wait_for_no_initializing_shards`, does not also wait for replicas that
+     * are recovering, which a collection with data may take longer to do.
      */
     async waitForCollectionShards(index, collection, timeout = COLLECTION_SHARDS_TIMEOUT) {
+        const alias = this._getAlias(index, collection);
         try {
+            const body = await this._client.indices.getSettings({
+                index: alias,
+                name: "index.number_of_shards",
+            });
+            const primaries = Object.values(body)[0]?.settings?.index?.number_of_shards;
             await this._client.cluster.health({
-                index: this._getAlias(index, collection),
+                index: alias,
                 timeout,
+                wait_for_active_shards: Number(primaries ?? 1),
                 wait_for_status: "yellow",
             });
         }

package/dist/lib/types/config/KuzzleConfiguration.d.ts

@@ -163,6 +163,13 @@ export interface IKuzzleConfiguration {
          * Optional here for the reason given on {@link IKuzzleConfiguration.version}.
          */
         allowAllOrigins?: boolean;
+        /**
+         * Derived at startup: the deprecated configuration keys the user set
+         * (today, those of "security.jwt"), logged as a warning.
+         *
+         * Optional here for the reason given on {@link IKuzzleConfiguration.version}.
+         */
+        deprecatedSettings?: string[];
     };
     /**
      * Collection specifications to apply at startup, by index then collection.

package/dist/lib/types/config/SecurityConfiguration.d.ts

@@ -21,9 +21,10 @@ export type SecurityConfiguration = {
     /**
      * @deprecated Use `security.authToken` instead.
      *
-     * `default.config.ts` always ships it, and `authToken`'s readers fall back
-     * to it — `authToken.algorithm ?? jwt.algorithm`. Optional all the same, as
-     * v2.56.0 declared it: a required member breaks code that builds this type.
+     * Each setting the configuration sets here applies unless `authToken` sets
+     * it too (`loadConfig()` resolves both sections to the values in effect,
+     * see `authTokenSetting`). Optional all the same, as v2.56.0 declared it:
+     * a required member breaks code that builds this type.
      */
     jwt?: JSONObject;
     /**

package/dist/lib/types/controllers/ControllerDefinition.d.ts

@@ -54,8 +54,8 @@ export type ControllerDefinition = {
             handler: (request: KuzzleRequest) => Promise<any>;
             /**
              * Declare HTTP routes (optional).
-             * Http routes will be auto-generated unless at least one is provided
-             * or an empty array is provided.
+             * When omitted or empty, a default route is generated:
+             * `GET /_/<controller>/<action>`, both names in kebab-case.
              */
             http?: HttpRoute[];
         };
@@ -71,8 +71,8 @@ export type HttpRoute = {
     verb: "get" | "head" | "post" | "put" | "delete" | "patch" | "options";
     /**
      * Route path.
-     * A route starting with `/` will be prefixed by `/_` otherwise the route
-     * will be prefixed by `/_/<application-name>/`.
+     * A route starting with `/` is used as is, any other route is prefixed
+     * with `/_/`.
      */
     path: string;
     /**

package/dist/lib/util/mutex.d.ts

@@ -86,9 +86,9 @@ export declare class Mutex {
      *
      * @return {Promise.<boolean>} True if the ressource has been unlocked before the `timeout`
      */
-    wait({ attemptDelay, timeout, }: {
-        attemptDelay?: number | undefined;
-        timeout?: number | undefined;
+    wait({ attemptDelay, timeout, }?: {
+        attemptDelay?: number;
+        timeout?: number;
     }): Promise<boolean>;
     /**
      * Frees every lock this process holds, and stops it from taking new ones.

package/dist/lib/util/mutex.js

@@ -196,7 +196,7 @@ class Mutex {
      *
      * @return {Promise.<boolean>} True if the ressource has been unlocked before the `timeout`
      */
-    async wait({ attemptDelay = this.attemptDelay, timeout = this.timeout, }) {
+    async wait({ attemptDelay = this.attemptDelay, timeout = this.timeout, } = {}) {
         let duration = 0;
         let isLocked;
         do {

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "kuzzle",
     "author": "The Kuzzle Team <support@kuzzle.io>",
-    "version": "2.60.0-beta.4",
+    "version": "2.60.0-beta.6",
     "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
     "scripts": {
         "build": "rm -Rf ./dist && tsc && node -r ts-node/register/transpile-only ./bin/copy-binaries.ts",