kuzzle 2.60.0-beta.5 → 2.60.0-beta.7

package/dist/lib/api/controllers/adminController.js

@@ -162,7 +162,8 @@ class AdminController extends baseController_1.NativeController {
             throw kerror.get("api", "process", "action_locked", "Kuzzle is already shutting down.");
         }
         this.shuttingDown = true;
-        global.kuzzle.shutdown();
+        // Not awaited, so that this request is answered first. It never rejects.
+        void global.kuzzle.shutdown();
         return { acknowledge: true };
     }
     /**

package/dist/lib/api/funnel.js

@@ -1011,16 +1011,22 @@ function doAction(controller, request) {
     const ret = Reflect.apply(Reflect.get(controller, action), controller, [
         request,
     ]);
-    // Same duck-type check as before, spelled so it narrows: a truthy non-object
-    // used to reach `ret.then` and read `undefined`, which took this branch too.
-    if (!ret ||
-        typeof ret !== "object" ||
-        !("then" in ret) ||
-        typeof ret.then !== "function") {
+    if (!isThenable(ret)) {
         return kerror.reject("plugin", "controller", "invalid_action_response", request.input.controller, request.input.action);
     }
     return ret;
 }
+/**
+ * Same duck-type check as before, spelled as a guard so that it narrows to
+ * what `await` takes: a truthy non-object used to reach `ret.then` and read
+ * `undefined`, which failed the check too.
+ */
+function isThenable(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "then" in value &&
+        typeof value.then === "function");
+}
 /**
  * Very straightforward function to check only if the version satisfies
  * the major version requirements

package/dist/lib/cluster/command.d.ts

@@ -101,7 +101,8 @@ declare class ClusterCommand {
      * Listens to incoming requests and answer to them.
      * Do NOT await this method, it's meant to run indefinitely until the close()
      * method is invoked.
-     * This method can (and should) never return a rejected promise.
+     * It rejects when a receive or a reply fails while it is running, which
+     * ends the loop: `init()` logs it.
      */
     listen(): Promise<void>;
     /**

package/dist/lib/cluster/command.js

@@ -55,6 +55,7 @@ var __importStar = (this && this.__importStar) || (function () {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+const node_util_1 = require("node:util");
 const bluebird_1 = __importDefault(require("bluebird"));
 const long_1 = __importDefault(require("long"));
 const protobuf = __importStar(require("protobufjs"));
@@ -142,7 +143,11 @@ class ClusterCommand {
     async init() {
         await this.loadProtobuf();
         await this.serve();
-        this.listen();
+        // Never awaited (it loops until `dispose()`), and it rethrows a failed
+        // receive or reply: logged rather than left unhandled.
+        this.listen().catch((error) => {
+            this.logger.error(`[CLUSTER] Command layer stopped listening: ${error instanceof Error ? error.message : (0, node_util_1.inspect)(error)}`);
+        });
     }
     async serve() {
         this.server = new zeromq_1.Reply();
@@ -152,7 +157,8 @@ class ClusterCommand {
      * Listens to incoming requests and answer to them.
      * Do NOT await this method, it's meant to run indefinitely until the close()
      * method is invoked.
-     * This method can (and should) never return a rejected promise.
+     * It rejects when a receive or a reply fails while it is running, which
+     * ends the loop: `init()` logs it.
      */
     async listen() {
         this.state = stateEnum.RUNNING;

package/dist/lib/cluster/subscriber.js

@@ -184,7 +184,12 @@ class ClusterSubscriber {
         this.socket.connect(this.remoteNodeAddress);
         this.socket.subscribe();
         this.heartbeatTimer = setInterval(() => this.checkHeartbeat(), this.heartbeatDelay);
-        this.listen();
+        // Never awaited (it loops until the remote node is evicted), and it can
+        // still reject: a failed read evicts the remote node, which removes its
+        // ID card from Redis.
+        this.listen().catch((error) => {
+            this.logger.error(`[CLUSTER] Stopped listening to node ${this.remoteNodeId}: ${error instanceof Error ? error.message : (0, node_util_1.inspect)(error)}`);
+        });
     }
     /**
      * Starts subscribing to other nodes
@@ -353,7 +358,8 @@ class ClusterSubscriber {
             await Reflect.apply(this.handlers[topic], this, [message]);
         }
         catch (e) {
-            this.localNode.evictSelf(`Unable to process sync message (topic: ${topic}, message: ${JSON.stringify(message)}`, e instanceof Error ? e : new Error((0, node_util_1.inspect)(e)));
+            // Cannot reject: it logs, broadcasts, and shuts down, which never rejects
+            void this.localNode.evictSelf(`Unable to process sync message (topic: ${topic}, message: ${JSON.stringify(message)}`, e instanceof Error ? e : new Error((0, node_util_1.inspect)(e)));
         }
     }
     /**
@@ -392,7 +398,7 @@ class ClusterSubscriber {
         if (message.nodeId === this.localNode.nodeId) {
             this.logger.error(`[CLUSTER] Node evicted by ${message.evictor}. Reason: ${message.reason}`);
             // A failure, like `evictSelf`'s: exit non-zero (#2785).
-            global.kuzzle.shutdown(1);
+            void global.kuzzle.shutdown(1);
             return;
         }
         await this.localNode.evictNode(message.nodeId, {
@@ -563,7 +569,11 @@ class ClusterSubscriber {
      */
     handleDumpRequest(message) {
         debug("Dump generation request received from node %s", this.remoteNodeId);
-        global.kuzzle.dump(message.suffix);
+        // Nothing awaits it: a failure (another dump running, an unwritable dump
+        // path) is logged rather than left unhandled, as on SIGTRAP.
+        global.kuzzle.dump(message.suffix).catch((error) => {
+            this.logger.error(`[CLUSTER] Unable to dump on request from node ${this.remoteNodeId}: ${error instanceof Error ? error.message : (0, node_util_1.inspect)(error)}`);
+        });
     }
     /**
      * Handles cluster-wide shutdown
@@ -571,7 +581,7 @@ class ClusterSubscriber {
     handleShutdown() {
         debug("Cluster-wide shutdown request received from node %s", this.remoteNodeId);
         this.logger.error(`[CLUSTER] Cluster wide shutdown from ${this.remoteNodeId}`);
-        global.kuzzle.shutdown();
+        void global.kuzzle.shutdown();
     }
     /**
      * Handles changes on document validators

package/dist/lib/kuzzle/event/KuzzleEventEmitter.js

@@ -193,7 +193,8 @@ class KuzzleEventEmitter extends eventemitter3_1.default {
             targetEvent: eventName,
         };
         if (funcs.length === 0) {
-            pipeCallback.call(callbackContext, null, ...payload);
+            // Never rejects: it settles `promback` instead
+            void pipeCallback.call(callbackContext, null, ...payload);
         }
         else {
             this.pipeRunner.run(funcs, payload, pipeCallback, callbackContext);
@@ -326,12 +327,21 @@ async function pipeCallback(error, ...updated) {
         this.promback.reject(error);
         return;
     }
-    const corePipes = this.corePipes.get(this.targetEvent);
-    if (corePipes) {
-        await bluebird_1.default.map(corePipes, (fn) => fn(...updated));
+    // Nothing awaits this function: a core pipe or a listener that throws
+    // settles the pipe, rather than leaving it pending forever and the error
+    // unhandled.
+    try {
+        const corePipes = this.corePipes.get(this.targetEvent);
+        if (corePipes) {
+            await bluebird_1.default.map(corePipes, (fn) => fn(...updated));
+        }
+        for (const element of this.events) {
+            this.superEmit(element, ...updated);
+        }
     }
-    for (const element of this.events) {
-        this.superEmit(element, ...updated);
+    catch (e) {
+        this.promback.reject(e);
+        return;
     }
     this.promback.resolve(updated[0]);
     /* eslint-enable no-invalid-this */

package/dist/lib/kuzzle/kuzzle.js

@@ -239,13 +239,9 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             // 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);
-            });
+            // awaited, so the caller still gets the error before the process exits;
+            // `shutdown` never rejects, and exits even when it fails.
+            void this.shutdown(1);
             throw error;
         }
     }
@@ -322,7 +318,17 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
                 process.exit(this.shutdownExitCode);
             }, FAILURE_SHUTDOWN_TIMEOUT));
         }
-        this.shutdownPromise ?? (this.shutdownPromise = this.runShutdown());
+        // Never rejects: every caller but one fires it and forgets it (signal
+        // handlers, cluster eviction, admin:shutdown), so a failure here used to
+        // be an unhandled rejection, and the process stayed up with its network
+        // layer already closed. It exits non-zero instead.
+        this.shutdownPromise ?? (this.shutdownPromise = this.runShutdown().catch((error) => {
+            this.log.error(`[shutdown] Unable to shut down gracefully: ${error instanceof Error ? error.message : (0, node_util_1.inspect)(error)}`);
+            if (this.shutdownWatchdog !== null) {
+                clearTimeout(this.shutdownWatchdog);
+            }
+            process.exit(Math.max(this.shutdownExitCode, 1));
+        }));
         return this.shutdownPromise;
     }
     async runShutdown() {
@@ -646,7 +652,7 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
     registerSignalHandlers() {
         process.removeAllListeners("unhandledRejection");
         process.on("exit", () => {
-            this.shutdown();
+            void this.shutdown();
         });
         process.on("unhandledRejection", (reason, promise) => {
             if (reason !== undefined) {
@@ -672,14 +678,14 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         process.removeAllListeners("uncaughtException");
         process.on("uncaughtException", (err) => {
             this.log.error(`ERROR: uncaughtException: ${err.message}\n${err.stack}`);
-            this.dumpAndExit("uncaught-exception");
+            void this.dumpAndExit("uncaught-exception");
         });
         // abnormal termination signals => generate a core dump
         for (const signal of ["SIGQUIT", "SIGABRT"]) {
             process.removeAllListeners(signal);
             process.on(signal, () => {
                 this.log.error(`ERROR: Caught signal: ${signal}`);
-                this.dumpAndExit("signal-".concat(signal.toLowerCase()));
+                void this.dumpAndExit("signal-".concat(signal.toLowerCase()));
             });
         }
         // signal SIGTRAP is used to generate a kuzzle dump without stopping it
@@ -697,7 +703,7 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
             process.removeAllListeners(signal);
             process.on(signal, () => {
                 this.log.info(`Caught signal ${signal} => gracefully exit`);
-                this.shutdown();
+                void this.shutdown();
             });
         }
     }

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

@@ -468,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

@@ -1081,7 +1081,11 @@ class ES7 {
             });
         }
         finally {
-            this.clearScroll(scrollId);
+            // Not awaited, but not left unhandled either: a scroll that cannot be
+            // cleared expires on its own.
+            this.clearScroll(scrollId).catch((error) => {
+                this.logger.warn(`Unable to clear scroll ${scrollId}: ${error instanceof Error ? error.message : String(error)}`);
+            });
         }
         return results;
     }
@@ -1214,12 +1218,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

@@ -459,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

@@ -1236,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/util/dump-collection.js

@@ -299,11 +299,12 @@ function dumpCollectionDocuments(index, collection, query = {}, format = "jsonl"
     switch (format.toLowerCase()) {
         case "csv":
             dumper = new CSVDumper(index, collection, query, writableStream, options, fields);
-            dumper.dump();
+            // Errors are written to the stream, which is what the client reads
+            void dumper.dump();
             break;
         default:
             dumper = new JSONLDumper(index, collection, query, writableStream, options);
-            dumper.dump();
+            void dumper.dump();
             break;
     }
     return new types_1.HttpStream(writableStream);

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "kuzzle",
     "author": "The Kuzzle Team <support@kuzzle.io>",
-    "version": "2.60.0-beta.5",
+    "version": "2.60.0-beta.7",
     "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",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kuzzle",
   "author": "The Kuzzle Team <support@kuzzle.io>",
-  "version": "2.60.0-beta.5",
+  "version": "2.60.0-beta.7",
   "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",