kuzzle 2.60.0-beta.3 → 2.60.0-beta.5

package/dist/lib/core/backend/backend.js

@@ -61,8 +61,8 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const kuzzle_1 = __importDefault(require("../../kuzzle"));
 const embeddedSdk_1 = require("../shared/sdk/embeddedSdk");
 const kerror = __importStar(require("../../kerror"));
-const index_1 = require("../../../index");
-const index_2 = require("./index");
+const name_generator_1 = require("../../util/name-generator");
+const index_1 = require("./index");
 const Logger_1 = require("../../kuzzle/Logger");
 const plugin_1 = __importDefault(require("../plugin/plugin"));
 const assertionError = kerror.wrap("plugin", "assert");
@@ -130,7 +130,7 @@ class Backend {
             throw assertionError.get("invalid_application_name", name);
         }
         this._name = name;
-        this.nodeId = index_1.NameGenerator.generateRandomName({ prefix: "knode" });
+        this.nodeId = name_generator_1.NameGenerator.generateRandomName({ prefix: "knode" });
         Reflect.defineProperty(this, "_kuzzle", {
             writable: true,
         });
@@ -162,18 +162,18 @@ class Backend {
             // Silent if no version can be found
         }
         global.app = this;
-        this.pipe = new index_2.BackendPipe(this);
-        this.hook = new index_2.BackendHook(this);
-        this.config = new index_2.BackendConfig(this);
-        this.vault = new index_2.BackendVault(this);
-        this.controller = new index_2.BackendController(this);
-        this.plugin = new index_2.BackendPlugin(this);
-        this.storage = new index_2.BackendStorage(this);
-        this.import = new index_2.BackendImport(this);
-        this.cluster = new index_2.BackendCluster();
-        this.openApi = new index_2.BackendOpenApi(this);
-        this.errors = new index_2.BackendErrors(this);
-        this.subscription = new index_2.BackendSubscription(this);
+        this.pipe = new index_1.BackendPipe(this);
+        this.hook = new index_1.BackendHook(this);
+        this.config = new index_1.BackendConfig(this);
+        this.vault = new index_1.BackendVault(this);
+        this.controller = new index_1.BackendController(this);
+        this.plugin = new index_1.BackendPlugin(this);
+        this.storage = new index_1.BackendStorage(this);
+        this.import = new index_1.BackendImport(this);
+        this.cluster = new index_1.BackendCluster();
+        this.openApi = new index_1.BackendOpenApi(this);
+        this.errors = new index_1.BackendErrors(this);
+        this.subscription = new index_1.BackendSubscription(this);
         this.log = new Logger_1.Logger(this.config.content, "kuzzle:app");
         this.kerror = kerror;
         try {

package/dist/lib/core/backend/backendCluster.d.ts

@@ -1,4 +1,4 @@
-import type { EventDefinition, ClusterEventHandler } from "../../../index";
+import type { EventDefinition, ClusterEventHandler } from "../../types/EventHandler";
 export declare class BackendCluster {
     /**
      * Broadcasts an event to listeners across all registered Kuzzle nodes

package/dist/lib/core/backend/internalLogger.d.ts

@@ -1,4 +1,10 @@
 import { ApplicationManager } from "./index";
+/**
+ * Kuzzle no longer creates instances of this class: `Backend.log` is a
+ * `Logger` since 2.45.0.
+ *
+ * @deprecated Use `Logger` (`app.log`) instead.
+ */
 export declare class InternalLogger extends ApplicationManager {
     /**
      * Logs a trace message

package/dist/lib/core/backend/internalLogger.js

@@ -26,6 +26,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalLogger = void 0;
 const util_1 = __importDefault(require("util"));
 const index_1 = require("./index");
+/**
+ * Kuzzle no longer creates instances of this class: `Backend.log` is a
+ * `Logger` since 2.45.0.
+ *
+ * @deprecated Use `Logger` (`app.log`) instead.
+ */
 class InternalLogger extends index_1.ApplicationManager {
     /**
      * Logs a trace message

package/dist/lib/core/network/router.d.ts

@@ -32,9 +32,27 @@ declare class Router {
      * Transmit HTTP requests to the funnel controller and forward its response
      * back to the client
      *
+     * Triggers the `http:<verb>` pipe with the verb lowercased, as documented.
+     * A route declared with another case (e.g. `verb: 'GET'`) also triggers the
+     * event under the declared case (`http:GET`), which is the one it used to
+     * trigger: see docs/v3-breaking-changes.md.
+     *
+     * @param verb - the route's HTTP verb, as declared
      * @param request - includes URL and POST query data
      * @param cb - callback to invoke with the result
      */
     _executeFromHttp(verb: string, request: Request, cb: RouteCallback): void;
+    /**
+     * Triggers an `http:<verb>` pipe, and answers its error through `cb` or
+     * hands the piped request over to `next`.
+     *
+     * Callbacks rather than promises: this runs before the funnel.
+     */
+    private _pipeHttpEvent;
+    /**
+     * Executes the piped request in the funnel and answers its result through
+     * `cb`, falling back on the original request when there is none.
+     */
+    private _executeInFunnel;
 }
 export = Router;

package/dist/lib/core/network/router.js

@@ -190,25 +190,59 @@ class Router {
      * Transmit HTTP requests to the funnel controller and forward its response
      * back to the client
      *
+     * Triggers the `http:<verb>` pipe with the verb lowercased, as documented.
+     * A route declared with another case (e.g. `verb: 'GET'`) also triggers the
+     * event under the declared case (`http:GET`), which is the one it used to
+     * trigger: see docs/v3-breaking-changes.md.
+     *
+     * @param verb - the route's HTTP verb, as declared
      * @param request - includes URL and POST query data
      * @param cb - callback to invoke with the result
      */
     _executeFromHttp(verb, request, cb) {
-        global.kuzzle.pipe(`http:${verb}`, request, (error, mutatedRequest) => {
+        const event = `http:${verb.toLowerCase()}`;
+        const declaredEvent = `http:${verb}`;
+        this._pipeHttpEvent(event, request, cb, (pipedRequest) => {
+            if (declaredEvent === event) {
+                this._executeInFunnel(pipedRequest, request, cb);
+                return;
+            }
+            // @deprecated - declared-case event, to drop in v3
+            this._pipeHttpEvent(declaredEvent, pipedRequest, cb, (legacyRequest) => {
+                this._executeInFunnel(legacyRequest, request, cb);
+            });
+        });
+    }
+    /**
+     * Triggers an `http:<verb>` pipe, and answers its error through `cb` or
+     * hands the piped request over to `next`.
+     *
+     * Callbacks rather than promises: this runs before the funnel.
+     */
+    _pipeHttpEvent(event, request, cb, next) {
+        // callback form: the outcome, error included, goes through the callback
+        void global.kuzzle.pipe(event, request, (error, mutatedRequest) => {
             if (error) {
                 request.setError(error);
                 cb(request);
                 return;
             }
-            global.kuzzle.funnel.execute(mutatedRequest, (err, result) => {
-                const _res = result || request;
-                if (err && !_res.error) {
-                    _res.setError(err);
-                }
-                // no sanitisation here: `_res` is a KuzzleRequest, and the stack
-                // is stripped by the protocols, on the serialized response
-                cb(_res);
-            });
+            next(mutatedRequest);
+        });
+    }
+    /**
+     * Executes the piped request in the funnel and answers its result through
+     * `cb`, falling back on the original request when there is none.
+     */
+    _executeInFunnel(pipedRequest, request, cb) {
+        global.kuzzle.funnel.execute(pipedRequest, (err, result) => {
+            const _res = result || request;
+            if (err && !_res.error) {
+                _res.setError(err);
+            }
+            // no sanitisation here: `_res` is a KuzzleRequest, and the stack
+            // is stripped by the protocols, on the serialized response
+            cb(_res);
         });
     }
 }

package/dist/lib/core/security/authTokenSettings.d.ts

@@ -0,0 +1,21 @@
+import type { SecurityConfiguration } from "../../types/config/SecurityConfiguration";
+type AuthTokenSettings = SecurityConfiguration["authToken"];
+/**
+ * The settings for which a value set under the deprecated `security.jwt`
+ * wins over one set under `security.authToken`: `gracePeriod` used to be
+ * read from `jwt` only, so a configuration setting both keeps working as it
+ * did. To drop in v3 (docs/v3-breaking-changes.md).
+ */
+export declare const LEGACY_FIRST: ReadonlySet<string>;
+/**
+ * Reads one authentication token setting: the value set under
+ * `security.authToken` wins, then the one set under its deprecated spelling
+ * `security.jwt`, then the packaged default (except for {@link LEGACY_FIRST}).
+ *
+ * `loadConfig()` already resolves both sections from what the configuration
+ * files and the environment set. This covers a change made afterwards, e.g.
+ * `app.config.set("security.jwt.expiresIn", "2h")` before `app.start()`: a
+ * value that differs from the packaged default is one somebody set.
+ */
+export declare function authTokenSetting<K extends keyof AuthTokenSettings>(key: K): AuthTokenSettings[K];
+export {};

package/dist/lib/core/security/authTokenSettings.js

@@ -0,0 +1,61 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_FIRST = void 0;
+exports.authTokenSetting = authTokenSetting;
+const default_config_1 = __importDefault(require("../../config/default.config"));
+/**
+ * The settings for which a value set under the deprecated `security.jwt`
+ * wins over one set under `security.authToken`: `gracePeriod` used to be
+ * read from `jwt` only, so a configuration setting both keeps working as it
+ * did. To drop in v3 (docs/v3-breaking-changes.md).
+ */
+exports.LEGACY_FIRST = new Set(["gracePeriod"]);
+function isSet(value) {
+    return value !== undefined && value !== null;
+}
+/**
+ * Reads one authentication token setting: the value set under
+ * `security.authToken` wins, then the one set under its deprecated spelling
+ * `security.jwt`, then the packaged default (except for {@link LEGACY_FIRST}).
+ *
+ * `loadConfig()` already resolves both sections from what the configuration
+ * files and the environment set. This covers a change made afterwards, e.g.
+ * `app.config.set("security.jwt.expiresIn", "2h")` before `app.start()`: a
+ * value that differs from the packaged default is one somebody set.
+ */
+function authTokenSetting(key) {
+    const { authToken, jwt } = global.kuzzle.config.security; // NOSONAR: the deprecated section is read on purpose, as the documented fallback
+    const packaged = default_config_1.default.security.authToken[key];
+    const current = authToken?.[key];
+    const legacy = jwt?.[key]; // NOSONAR
+    const candidates = exports.LEGACY_FIRST.has(key)
+        ? [legacy, current]
+        : [current, legacy];
+    return (candidates.find((value) => isSet(value) && value !== packaged) ??
+        candidates.find(isSet) ??
+        packaged);
+}
+//# sourceMappingURL=authTokenSettings.js.map

package/dist/lib/core/security/tokenRepository.js

@@ -66,15 +66,8 @@ const token_1 = require("../../model/security/token");
 const apiKey_1 = __importDefault(require("../../model/storage/apiKey"));
 const ObjectRepository_1 = require("../shared/ObjectRepository");
 const crypto_1 = require("../../util/crypto");
+const authTokenSettings_1 = require("./authTokenSettings");
 const securityError = kerror.wrap("security", "token");
-/**
- * The deprecated `security.jwt` section, which the `authToken` settings fall
- * back to. The packaged defaults always ship it; the type says optional only
- * because v2.56.0's did (see SecurityConfiguration.jwt).
- */
-function legacyJwtConfig() {
-    return global.kuzzle.config.security.jwt; // NOSONAR: the deprecated section is read on purpose, as the documented fallback
-}
 class TokenRepository extends ObjectRepository_1.ObjectRepository {
     constructor(opts = {}) {
         super();
@@ -83,7 +76,11 @@ class TokenRepository extends ObjectRepository_1.ObjectRepository {
         if (opts.ttl !== undefined) {
             this.ttl = opts.ttl;
         }
-        this.tokenGracePeriod = Math.floor(legacyJwtConfig().gracePeriod);
+        this.tokenGracePeriod = Math.floor((0, authTokenSettings_1.authTokenSetting)("gracePeriod"));
+        const deprecated = global.kuzzle.config.internal?.deprecatedSettings;
+        if (deprecated?.length) {
+            global.kuzzle.log.warn(`[DEPRECATED] The configuration section "security.jwt" is deprecated, use "security.authToken" instead (set: ${deprecated.join(", ")}). A value set under "security.authToken" takes precedence.`);
+        }
         this.anonymousToken = new token_1.Token({ userId: "-1" });
     }
     async init() {
@@ -194,17 +191,14 @@ class TokenRepository extends ObjectRepository_1.ObjectRepository {
      *
      * @returns {Promise.<Object>} { _id, jwt, userId, ttl, expiresAt }
      */
-    async generateToken(user, { algorithm = global.kuzzle.config.security.authToken.algorithm ??
-        legacyJwtConfig().algorithm, expiresIn = global.kuzzle.config.security.authToken.expiresIn ??
-        legacyJwtConfig().expiresIn, bypassMaxTTL = false, type = "authToken", singleUse = false, } = {}) {
+    async generateToken(user, { algorithm = (0, authTokenSettings_1.authTokenSetting)("algorithm"), expiresIn = (0, authTokenSettings_1.authTokenSetting)("expiresIn"), bypassMaxTTL = false, type = "authToken", singleUse = false, } = {}) {
         if (!user || user._id === null) {
             throw securityError.get("unknown_user");
         }
         const parsedExpiresIn = parseTimespan(expiresIn);
         const maxTTL = type === "apiKey"
             ? global.kuzzle.config.security.apiKey.maxTTL
-            : (global.kuzzle.config.security.authToken.maxTTL ??
-                legacyJwtConfig().maxTTL);
+            : (0, authTokenSettings_1.authTokenSetting)("maxTTL");
         if (!bypassMaxTTL &&
             maxTTL > -1 &&
             (parsedExpiresIn > maxTTL || parsedExpiresIn === -1)) {

package/dist/lib/core/shared/KoncordeWrapper.d.ts

@@ -29,6 +29,15 @@ export declare class NormalizedFilterV3 {
     normalized: JSONObject[][];
     constructor(index: string, collection: string, normalized: JSONObject);
 }
+/**
+ * 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.
+ */
 export declare class Koncorde {
     private filterIdIndexMap;
     private koncorde;

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/shared/store.js

@@ -156,6 +156,10 @@ class Store {
             }
             const exist = await global.kuzzle.ask(`core:storage:${this.scope}:collection:exist`, this.index, collection);
             if (exist) {
+                // Another node created it, maybe so recently that its primary
+                // shards are still initializing: a document request on it would
+                // get a 503 until they are active
+                await global.kuzzle.ask(`core:storage:${this.scope}:collection:shards:wait`, this.index, collection);
                 // @deprecated
                 const dynamicSettings = isConfigDeprecated
                     ? null

package/dist/lib/core/storage/clientAdapter.d.ts

@@ -41,6 +41,12 @@ declare class ClientAdapter {
      * Also checks for duplicated index names.
      */
     populateCache(): Promise<void>;
+    /**
+     * Adds the indexes and collections found in storage to the index cache,
+     * then reloads the collection write locks. Unlike `populateCache`, it never
+     * writes to storage.
+     */
+    reloadCache(): Promise<void>;
     /**
      * Replaces the cached collection write locks with the cluster-wide ones,
      * stored in Redis.

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

@@ -56,6 +56,7 @@ const Elasticsearch_1 = require("../../service/storage/Elasticsearch");
 const indexCache_1 = require("./indexCache");
 const safeObject_1 = require("../../util/safeObject");
 const kerror = __importStar(require("../../kerror"));
+const kuzzleError_1 = require("../../kerror/errors/kuzzleError");
 const distributedLock_1 = require("../../util/distributedLock");
 require("../../types/Global");
 const servicesError = kerror.wrap("services", "storage");
@@ -93,10 +94,16 @@ class ClientAdapter {
         this.registerMappingEvents();
         this.registerCacheEvents();
         this.registerLockEvents();
-        // The locks were first loaded with the cache, before this node joined the
-        // cluster: one taken in between was broadcast before this node could hear
-        // it. Reading them again once the cluster is joined closes that gap.
-        global.kuzzle.onPipe("kuzzle:state:live", () => this.loadLocks());
+        // 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. `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
         /**
          * Manually refresh the index cache (e.g. after alias creation)
@@ -120,7 +127,20 @@ class ClientAdapter {
             throw servicesError.get("index_already_exists", this.scope, index);
         }
         if (!indexCacheOnly) {
-            await this.client.createIndex(index);
+            try {
+                await this.client.createIndex(index);
+            }
+            catch (error) {
+                // The index exists in storage but not in this node's cache: a peer
+                // created it and its cache broadcast never reached this node (e.g. the
+                // peer stopped before this node joined the cluster). Cache it so that
+                // the next request to that index finds it, then report the conflict.
+                if (error instanceof kuzzleError_1.KuzzleError &&
+                    error.id === "services.storage.index_already_exists") {
+                    this.cache.addIndex(index);
+                }
+                throw error;
+            }
         }
         this.cache.addIndex(index);
         if (propagate) {
@@ -191,6 +211,14 @@ class ClientAdapter {
         if (global.kuzzle.config.services.storageEngine.generateMissingAliases) {
             await this.client.generateMissingAliases();
         }
+        await this.reloadCache();
+    }
+    /**
+     * Adds the indexes and collections found in storage to the index cache,
+     * then reloads the collection write locks. Unlike `populateCache`, it never
+     * writes to storage.
+     */
+    async reloadCache() {
         // `client` is untyped (see the field's comment), so the schema shape is
         // stated here: index name -> its collection names.
         const schema = await this.client.getSchema();
@@ -311,6 +339,13 @@ class ClientAdapter {
             this.cache.assertCollectionExists(index, collection);
             return this.client.getSettings(index, collection);
         });
+        /**
+         * Wait, for a bounded time, until the primary shards of a collection
+         * another node has just created are active
+         * @param {string} index
+         * @param {string} collection
+         */
+        global.kuzzle.onAsk(`core:storage:${this.scope}:collection:shards:wait`, (index, collection) => this.client.waitForCollectionShards(index, collection));
         /**
          * Check a collection existence
          * @param {string} index

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");
@@ -132,8 +133,11 @@ class InternalIndexHandler extends store_1.Store {
                     return;
                 }
                 await bluebird_1.default.resolve(this._bootstrapSequence()).timeout(this.timeout);
-                await this.create("config", { timestamp: Date.now() }, {
-                    id: this._BOOTSTRAP_DONE_ID,
+                // A node that stopped while holding the lock may still have its
+                // own bootstrap in flight, and write this marker after the check
+                // above: replacing it keeps this node from failing on it
+                await this.createOrReplace("config", this._BOOTSTRAP_DONE_ID, {
+                    timestamp: Date.now(),
                 });
             }
             catch (error) {
@@ -154,9 +158,11 @@ class InternalIndexHandler extends store_1.Store {
         await this.createInitialValidations();
         debug("Bootstrapping JWT secret");
         await this._initSecret();
-        // Create datamodel version
-        await this.create("config", { version: dataModelVersion }, {
-            id: this._DATAMODEL_VERSION_ID,
+        // Replaced rather than created: a bootstrap interrupted after this write
+        // but before the `.done` marker leaves it behind, and the next attempt
+        // must not fail on it (every step above is idempotent too)
+        await this.createOrReplace("config", this._DATAMODEL_VERSION_ID, {
+            version: dataModelVersion,
         });
     }
     /**
@@ -186,16 +192,27 @@ 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) {
                 storedSeed = node_crypto_1.default.randomBytes(512).toString("hex");
-                await this.create("config", { seed: storedSeed }, { id: this._JWT_SECRET_ID });
+                try {
+                    await this.create("config", { seed: storedSeed }, { id: this._JWT_SECRET_ID });
+                }
+                catch (error) {
+                    // An interrupted bootstrap stored one in the meantime: it is the
+                    // seed other nodes may already sign with, so keep it, and read it
+                    // back below
+                    const alreadyStored = error instanceof Error &&
+                        "id" in error &&
+                        error.id === "services.storage.document_already_exists";
+                    if (!alreadyStored) {
+                        throw error;
+                    }
+                }
             }
             this.logger.warn("[!] Kuzzle is using a generated seed for authentication. This is suitable for development but should NEVER be used in production. See https://docs.kuzzle.io/core/2/guides/getting-started/deploy-your-application/");
         }

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.
      *