kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/cluster/command.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,42 +19,123 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { Reply, Request } = require("zeromq");
-const protobuf = require("protobufjs");
-const Bluebird = require("bluebird");
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const bluebird_1 = __importDefault(require("bluebird"));
+const long_1 = __importDefault(require("long"));
+const protobuf = __importStar(require("protobufjs"));
+const zeromq_1 = require("zeromq");
+const commandMessages_1 = require("./protobuf/commandMessages");
+/**
+ * Annotated `number` rather than left to infer `1 | 2 | 3`: `state` is moved to
+ * `CLOSED` by `dispose()` while `listen()` is awaiting a socket read, and
+ * TypeScript's control-flow narrowing does not model that. Under the literal
+ * types the `while (state === RUNNING)` loop narrows `state` to `RUNNING`
+ * inside its own body, and the deliberate `state !== CLOSED` re-check after the
+ * `await` is then reported as a comparison with no overlap. That re-check is
+ * the point: it is how a socket error during shutdown is told apart from a real
+ * one.
+ */
 /* eslint-disable sort-keys */
 const stateEnum = Object.freeze({
     INITIALIZING: 1,
     RUNNING: 2,
     CLOSED: 3,
 });
-const topicEnum = Object.freeze({
-    FULLSTATE: "fullstate",
-    HANDSHAKE: "handshake",
-    DISCARDED: "discarded", // 0 byte message expected
-});
-/* eslint-enable sort-keys */
 // Handles bidirectional requests between this node and other nodes
 class ClusterCommand {
     /**
-     * @constructor
-     * @param {ClusterNode} localNode
+     * The REP socket and the protobuf schema, both built by `init()`.
+     *
+     * Every method below runs on a command layer that has been initialised —
+     * `listen()` is started by `init()` itself, and the rest answer requests it
+     * received — and all eleven dereferenced them unchecked. Same shape as
+     * `Protocol.entryPoint`: said once, where it can fail.
+     */
+    get server() {
+        if (this._server === null) {
+            throw new Error("[CLUSTER] Command server used before init()");
+        }
+        return this._server;
+    }
+    set server(server) {
+        this._server = server;
+    }
+    get protoroot() {
+        if (this._protoroot === null) {
+            throw new Error("[CLUSTER] Command protobuf schema loaded by init()");
+        }
+        return this._protoroot;
+    }
+    set protoroot(protoroot) {
+        this._protoroot = protoroot;
+    }
+    /**
+     * Whether `listen()`'s loop is running: `init()` starts it without awaiting
+     * it, and `dispose()` is what stops it.
+     *
+     * The flag itself stays private — its values are this file's business — but
+     * *whether the command layer is listening* is a legitimate question from
+     * outside, and it is the one the spec was reading `state` to answer. See
+     * docs/adr-001/steps/14-test-program-strict.md (M6).
+     */
+    get running() {
+        return this.state === stateEnum.RUNNING;
+    }
+    /**
+     * @param localNode the cluster node this command layer belongs to
      */
     constructor(localNode) {
         this.node = localNode;
-        this.server = null;
-        this.protoroot = null;
+        this._server = null;
+        this._protoroot = null;
         this.state = stateEnum.INITIALIZING;
         this.logger = global.kuzzle.log.child("cluster:command");
     }
-    async init() {
+    /**
+     * Loads the wire schema, and nothing else.
+     *
+     * This class is two things: the **server** every node runs, and the
+     * **client** `getFullState()` and `broadcastHandshake()` use to call its
+     * peers. Both need the codec; only the first needs a bound port. `init()`
+     * did both, so a client-only use had to either bind a port it does not serve
+     * on — the port it means to *dial*, which is already taken — or reach into
+     * `protoroot`, which is what the spec did before step 14's M6.
+     */
+    async loadProtobuf() {
         this.protoroot = await protobuf.load(`${__dirname}/protobuf/command.proto`);
+    }
+    async init() {
+        await this.loadProtobuf();
         await this.serve();
         this.listen();
     }
     async serve() {
-        this.server = new Reply();
+        this.server = new zeromq_1.Reply();
         await this.server.bind(`tcp://*:${this.node.config.ports.command}`);
     }
     /**
@@ -61,25 +143,37 @@ class ClusterCommand {
      * 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.
-     *
-     * @returns {void}
      */
     async listen() {
         this.state = stateEnum.RUNNING;
         while (this.state === stateEnum.RUNNING) {
             try {
                 const [type, data] = await this.server.receive();
-                switch (type.toString()) {
-                    case topicEnum.FULLSTATE:
+                // A REQ frame carries a topic and, for a handshake, a payload. A
+                // request missing either is answered with DISCARDED, which is what
+                // this socket owes every REQ — the two frames were read unchecked.
+                switch (type?.toString()) {
+                    case commandMessages_1.commandTopic.FULLSTATE:
                         await this.sendFullState();
                         break;
-                    case topicEnum.HANDSHAKE:
+                    case commandMessages_1.commandTopic.HANDSHAKE:
+                        if (data === undefined) {
+                            await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
+                            break;
+                        }
                         await this.handleHandshake(data);
                         break;
+                    case commandMessages_1.commandTopic.RETRANSMIT:
+                        if (data === undefined) {
+                            await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
+                            break;
+                        }
+                        await this.handleRetransmit(data);
+                        break;
                     default:
                         // REP/REQ sockets expect a reply to each request made, so we have
                         // to send some kind of response on an invalid request received
-                        await this.server.send([topicEnum.DISCARDED, null]);
+                        await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
                 }
             }
             catch (e) {
@@ -91,72 +185,153 @@ class ClusterCommand {
     }
     /**
      * Closes opened sockets and marks this server as closed.
-     * @return {void}
      */
     dispose() {
         this.state = stateEnum.CLOSED;
-        this.server.close();
+        // `?.`: a command that never bound has nothing to close, and disposing of
+        // one is what the specs do to release the port after a failed init.
+        this._server?.close();
     }
     /**
      * Sends back the full state to the requesting node
-     * @return {void}
      */
     async sendFullState() {
-        const fullState = this.node.fullState.serialize();
-        fullState.activity = this.node.activity;
-        fullState.nodesState = [];
+        const serialized = this.node.fullState.serialize();
+        const nodesState = [];
         for (const [id, subscriber] of this.node.remoteNodes.entries()) {
-            fullState.nodesState.push({
-                id,
-                lastMessageId: subscriber.lastMessageId,
-            });
+            nodesState.push({ id, lastMessageId: subscriber.lastMessageId });
         }
-        fullState.nodesState.push({
+        nodesState.push({
             id: this.node.nodeId,
             lastMessageId: this.node.publisher.lastMessageId,
         });
+        const fullState = {
+            activity: this.node.activity,
+            authStrategies: serialized.authStrategies,
+            nodesState,
+            rooms: serialized.rooms,
+        };
         const protoEncode = this.protoroot.lookupType("FullStateResponse");
         const buffer = protoEncode.encode(protoEncode.create(fullState)).finish();
-        await this.server.send([topicEnum.FULLSTATE, buffer]);
+        await this.server.send([commandMessages_1.commandTopic.FULLSTATE, buffer]);
     }
     /**
      * Handles a handshake request from a remote node
-     * @return {void}
      */
     async handleHandshake(data) {
         const decoder = this.protoroot.lookupType("HandshakeRequest");
-        const { nodeId, ip, lastMessageId } = decoder.toObject(decoder.decode(data));
-        const added = await this.node.addNode(nodeId, ip, lastMessageId);
+        // Annotated, not asserted: `toObject()` returns an index-signature object,
+        // so the schema type is a declaration of what the wire carries rather than
+        // a claim overriding the compiler. Same shape as `subscriber.ts`.
+        const request = decoder.toObject(decoder.decode(data));
+        const { nodeId, ip, lastMessageId } = request;
+        // Protobuf leaves an absent field undefined. A handshake that names no
+        // node or no address is not one this node can add; it is told so through
+        // the `added: false` the response already carries for a duplicate.
+        const added = nodeId === undefined || ip === undefined || lastMessageId === undefined
+            ? false
+            : await this.node.addNode(nodeId, ip, lastMessageId);
         const encoder = this.protoroot.lookupType("HandshakeResponse");
         const response = {
             added,
             lastMessageId: this.node.publisher.lastMessageId,
         };
         const buffer = encoder.encode(encoder.create(response)).finish();
-        await this.server.send([topicEnum.HANDSHAKE, buffer]);
+        await this.server.send([commandMessages_1.commandTopic.HANDSHAKE, buffer]);
+    }
+    /**
+     * Answers a peer that missed messages of this node's sync stream with those
+     * messages, as they were published — or with DISCARDED when they are no
+     * longer kept, which the peer treats as it treats a node that predates
+     * retransmission: it evicts itself (#2785).
+     */
+    async handleRetransmit(data) {
+        const decoder = this.protoroot.lookupType("RetransmitRequest");
+        const request = decoder.toObject(decoder.decode(data));
+        const frames = request.from === undefined || request.to === undefined
+            ? null
+            : this.node.publisher.replay(long_1.default.fromValue(request.from), long_1.default.fromValue(request.to));
+        if (frames === null) {
+            await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
+            return;
+        }
+        const encoder = this.protoroot.lookupType("RetransmitResponse");
+        const response = { frames };
+        const buffer = encoder.encode(encoder.create(response)).finish();
+        await this.server.send([commandMessages_1.commandTopic.RETRANSMIT, buffer]);
+    }
+    /**
+     * Asks the node at `ip` for the messages of its sync stream with ids `from`
+     * to `to`, both included.
+     *
+     * @returns the messages in order, as `[topic, data]` frames, or `null` if
+     *          the node could not provide all of them: it no longer keeps them,
+     *          predates retransmission (it answers DISCARDED to an unknown
+     *          topic), or did not answer within `cluster.syncTimeout`.
+     */
+    async requestRetransmit(ip, from, to) {
+        const encoder = this.protoroot.lookupType("RetransmitRequest");
+        const payload = { from, to };
+        const encoded = encoder.encode(encoder.create(payload)).finish();
+        const req = new zeromq_1.Request();
+        req.receiveTimeout = this.node.config.syncTimeout;
+        req.connect(`tcp://${ip}:${this.node.config.ports.command}`);
+        let topic;
+        let response;
+        try {
+            await req.send([commandMessages_1.commandTopic.RETRANSMIT, encoded]);
+            [topic, response] = await req.receive();
+        }
+        catch {
+            return null;
+        }
+        finally {
+            req.close();
+        }
+        if (topic?.toString() !== commandMessages_1.commandTopic.RETRANSMIT || !response) {
+            return null;
+        }
+        const decoder = this.protoroot.lookupType("RetransmitResponse");
+        const decoded = decoder.toObject(decoder.decode(response));
+        const frames = decoded.frames ?? [];
+        // All of them or nothing: a partial answer cannot close the gap.
+        if (frames.length !== to.subtract(from).toNumber() + 1) {
+            return null;
+        }
+        return frames.map(({ data, topic: frameTopic }) => [
+            frameTopic,
+            Buffer.from(data),
+        ]);
     }
     /**
      * Request the full state from ONE of the remote nodes of the cluster, AT
      * RANDOM (necessary to make sure we distribute the full state serialization
      * load across all nodes)
      *
-     * @param  {Array.<IdCard>} nodes
-     * @return {Object|null} Returns the fetched full state, or null if no node answered
+     * @returns the fetched full state, or null if no node answered
      */
     async getFullState(nodes) {
-        let idx = Math.floor(Math.random() * Math.floor(nodes.length));
+        // NOSONAR (S2245): this picks which peer to ask for the full state, and the
+        // point is only to spread the serialization cost over the cluster instead
+        // of always loading the same node. Nothing here is a secret, a token or an
+        // identifier — a predictable choice would cost performance, not security.
+        let idx = Math.floor(Math.random() * Math.floor(nodes.length)); // NOSONAR
         let fullState = null;
         for (let retries = 0; fullState === null && retries < nodes.length; retries++) {
-            const { id, ip } = nodes[idx];
-            const req = new Request();
+            const node = nodes[idx];
+            if (node === undefined) {
+                break;
+            }
+            const { id, ip } = node;
+            const req = new zeromq_1.Request();
             req.receiveTimeout = this.node.config.syncTimeout;
             req.connect(`tcp://${ip}:${this.node.config.ports.command}`);
             // No payload message for a full state request
-            await req.send([topicEnum.FULLSTATE, null]);
+            await req.send([commandMessages_1.commandTopic.FULLSTATE, null]);
             try {
-                [, fullState] = await req.receive();
+                [, fullState = null] = await req.receive();
             }
-            catch (e) {
+            catch {
                 // no response from the remote node in a timely fashion... retrying
                 // with another one
                 this.logger.warn(`Unable to fetch a full state from node ${id} (no response received)`);
@@ -170,19 +345,14 @@ class ClusterCommand {
             return null;
         }
         const decoder = this.protoroot.lookupType("FullStateResponse");
-        return decoder.toObject(decoder.decode(fullState));
+        const decoded = decoder.toObject(decoder.decode(fullState));
+        return decoded;
     }
     /**
      * Sends a handshake request to other remote nodes and process their response
-     * Returns an object with the following structure:
-     *
-     * {
-     *   [nodeId]: { added: <boolean>, lastMessageId: <number> },
-     *   [nodeId]: null, // no response received, node is probably dead
-     * }
      *
-     * @param  {Array.<IdCard>} nodes
-     * @return {Object}
+     * @returns one entry per node: its decoded response, or `null` if it never
+     *          answered (the node is probably dead)
      */
     async broadcastHandshake(nodes) {
         const payload = {
@@ -192,38 +362,40 @@ class ClusterCommand {
         };
         const encoder = this.protoroot.lookupType("HandshakeRequest");
         const encoded = encoder.encode(encoder.create(payload)).finish();
-        const responses = await Bluebird.map(nodes, ({ id, ip }) => this._sendSingleHandshake(id, ip, encoded));
+        const responses = await bluebird_1.default.map(nodes, ({ id, ip }) => this._sendSingleHandshake(id, ip, encoded));
         const decoder = this.protoroot.lookupType("HandshakeResponse");
         const result = {};
-        for (let i = 0; i < nodes.length; i++) {
-            if (responses[i] === null) {
-                result[nodes[i].id] = null;
-            }
-            else {
-                result[nodes[i].id] = decoder.toObject(decoder.decode(responses[i]));
+        // `entries()`: the two lists are built in step by `Bluebird.map`, which
+        // is what indexing one with the other's counter relied on.
+        for (const [i, node] of nodes.entries()) {
+            const response = responses[i];
+            if (response === null || response === undefined) {
+                result[node.id] = null;
+                continue;
             }
+            const decoded = decoder.toObject(decoder.decode(response));
+            result[node.id] = decoded;
         }
         return result;
     }
     /**
      * Sends a handshake payload to a remote node, and waits for its response
      *
-     * @param  {string} id      - remote node ID
-     * @param  {string} ip      - remote node IP address
-     * @param  {Buffer} payload - handshake payload (protobuf encoded)
-     * @return {Object|null}    - handshake encoded response, or null if no
-     *                            response was received
+     * @param id      remote node ID
+     * @param ip      remote node IP address
+     * @param payload handshake payload (protobuf encoded)
+     * @returns the handshake encoded response, or null if none was received
      */
     async _sendSingleHandshake(id, ip, payload) {
-        const req = new Request();
+        const req = new zeromq_1.Request();
         req.receiveTimeout = 2000;
         req.connect(`tcp://${ip}:${this.node.config.ports.command}`);
-        await req.send([topicEnum.HANDSHAKE, payload]);
+        await req.send([commandMessages_1.commandTopic.HANDSHAKE, payload]);
         let response = null;
         try {
-            [, response] = await req.receive();
+            [, response = null] = await req.receive();
         }
-        catch (e) {
+        catch {
             this.logger.warn(`Couldn't complete handshake with node ${id}: no response received`);
         }
         finally {

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

@@ -13,15 +13,17 @@ export declare class IdCard {
      *
      * knode-pensive-einstein-844221
      */
-    private id;
+    /** Read by `node.ts` (consistency checks, status, logs): the class never
+     * reassigns it after construction, and nothing outside writes it. */
+    readonly id: string;
     /**
      * Node IP address
      */
-    private ip;
+    readonly ip: string;
     /**
      * Node creation timestamp
      */
-    private birthdate;
+    readonly birthdate: number;
     /**
      * Node known topology composed of node IDs
      *
@@ -43,7 +45,7 @@ export declare class ClusterIdCardHandler {
     /**
      * Local node ID Card
      */
-    idCard: IdCard;
+    idCard: IdCard | null;
     /**
      * Local node IP address
      */
@@ -69,7 +71,8 @@ export declare class ClusterIdCardHandler {
     /**
      * Local node ID
      */
-    private nodeId;
+    /** Read by `node.ts` once `createIdCard()` has reserved it. */
+    nodeId: string | null;
     /**
      * Local node Redis key
      */
@@ -86,6 +89,16 @@ export declare class ClusterIdCardHandler {
     /**
      * Generates and reserves a unique ID for this node instance.
      * Makes sure that the ID is not already taken by another node instance.
+     *
+     * The first candidate is `global.nodeId` — the id the rest of the process
+     * logs under. It used to draw its own from the same generator with the same
+     * `knode` prefix, so every node carried two indistinguishable identities and
+     * no cluster log line could be matched to a process (TD-59, #2764).
+     *
+     * The loop stays: `global.nodeId` is itself a random draw, but a stale IdCard
+     * left in Redis by a crashed incarnation can still hold the key, and Kuzzle
+     * can run without a `Backend`, in which case there is no `global.nodeId` at
+     * all. Either way the next turn draws a fresh name, exactly as before.
      */
     createIdCard(): Promise<void>;
     /**

package/dist/lib/cluster/idCardHandler.js

@@ -25,7 +25,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClusterIdCardHandler = exports.IdCard = void 0;
 const name_generator_1 = require("../util/name-generator");
-const child_process_1 = require("child_process");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
 const bluebird_1 = __importDefault(require("bluebird"));
 require("../types");
 const REDIS_PREFIX = "{cluster/node}/";
@@ -75,6 +76,7 @@ class ClusterIdCardHandler {
         /**
          * Local node ID
          */
+        /** Read by `node.ts` once `createIdCard()` has reserved it. */
         this.nodeId = null;
         /**
          * Local node Redis key
@@ -95,11 +97,26 @@ class ClusterIdCardHandler {
     /**
      * Generates and reserves a unique ID for this node instance.
      * Makes sure that the ID is not already taken by another node instance.
+     *
+     * The first candidate is `global.nodeId` — the id the rest of the process
+     * logs under. It used to draw its own from the same generator with the same
+     * `knode` prefix, so every node carried two indistinguishable identities and
+     * no cluster log line could be matched to a process (TD-59, #2764).
+     *
+     * The loop stays: `global.nodeId` is itself a random draw, but a stale IdCard
+     * left in Redis by a crashed incarnation can still hold the key, and Kuzzle
+     * can run without a `Backend`, in which case there is no `global.nodeId` at
+     * all. Either way the next turn draws a fresh name, exactly as before.
      */
     async createIdCard() {
-        let reserved = false;
+        let reserved;
+        // `undefined` after the first turn, which is what makes the `??` below
+        // fall through to a fresh draw — so the declaration has to admit it.
+        let candidate = global.nodeId;
         do {
-            this.nodeId = name_generator_1.NameGenerator.generateRandomName({ prefix: "knode" });
+            this.nodeId =
+                candidate ?? name_generator_1.NameGenerator.generateRandomName({ prefix: "knode" });
+            candidate = undefined;
             this.nodeIdKey = `${REDIS_PREFIX}${this.nodeId}`;
             this.idCard = new IdCard({
                 birthdate: Date.now(),
@@ -110,20 +127,30 @@ class ClusterIdCardHandler {
             reserved = await this.save({ creation: true });
         } while (!reserved);
         await this.addIdCardToIndex();
-        this.refreshWorker = this.constructWorker(`${__dirname}/workers/IDCardRenewer.js`);
-        this.refreshWorker.on("message", async (message) => {
+        // Same extension as this module, not a hard-coded `.js`: the functional
+        // cluster starts Kuzzle from source with `-r ts-node/register`, where this
+        // file is `lib/cluster/idCardHandler.ts` and its neighbour is a `.ts` too;
+        // a built Kuzzle runs the same code from `dist/` with both as `.js`.
+        // `fork()` inherits `process.execArgv`, so a child spawned from a `.ts`
+        // parent gets the same loader and can require a `.ts`.
+        // Held in a local as well as on `this`: the field is nullable (it has no
+        // worker before this line) and the compiler drops that narrowing across the
+        // callbacks registered below.
+        const refreshWorker = this.constructWorker(`${__dirname}/workers/IDCardRenewer${(0, node_path_1.extname)(__filename)}`);
+        this.refreshWorker = refreshWorker;
+        refreshWorker.on("message", async (message) => {
             if (message.error) {
                 await this.node.evictSelf(message.error);
             }
         });
-        this.refreshWorker.on("close", async () => {
+        refreshWorker.on("close", async () => {
             if (!this.disposed) {
                 this.disposed = true;
                 await this.node.evictSelf("ID Card renewer worker closed unexpectedly");
             }
         });
         // Transfer informations to the worker
-        this.refreshWorker.send({
+        refreshWorker.send({
             action: "start", // start the worker
             kuzzle: {
                 config: global.kuzzle.config,
@@ -138,19 +165,19 @@ class ClusterIdCardHandler {
             refreshDelay: this.refreshDelay,
             refreshMultiplier: this.refreshMultiplier,
         });
-        this.startTemporaryRefresh();
+        this.startTemporaryRefresh(refreshWorker);
     }
     /**
      * Helper method to mock worker instantiation in unit tests
      */
     constructWorker(path) {
-        const childProcess = (0, child_process_1.fork)(path);
+        const childProcess = (0, node_child_process_1.fork)(path);
         const exitHandler = () => {
             if (!childProcess.killed || childProcess.connected) {
                 try {
                     childProcess.disconnect();
                 }
-                catch (e) {
+                catch {
                     // It could happens that the worker has been killed before the dispose causing disconnect to fail
                 }
             }
@@ -166,7 +193,7 @@ class ClusterIdCardHandler {
      *
      * Once the worker starts, this timer will be stopped.
      */
-    startTemporaryRefresh() {
+    startTemporaryRefresh(refreshWorker) {
         this.refreshTimer = setInterval(async () => {
             try {
                 await this.save();
@@ -175,7 +202,10 @@ class ClusterIdCardHandler {
                 this.logger.error(`An error occurred while refreshing the ID card during WorkerThread startup: ${error}`);
             }
         }, this.refreshDelay * this.refreshMultiplier);
-        this.refreshWorker.on("message", ({ initialized }) => {
+        // Handed the worker rather than reading `this.refreshWorker`, for the
+        // reason already stated where that field is assigned: it is nullable, and
+        // this method runs on the line after it is filled.
+        refreshWorker.on("message", ({ initialized }) => {
             if (initialized) {
                 clearInterval(this.refreshTimer);
                 this.refreshTimer = null;
@@ -194,7 +224,7 @@ class ClusterIdCardHandler {
             try {
                 this.refreshWorker.send({ action: "dispose" });
             }
-            catch (e) {
+            catch {
                 // It could happens that the worker has been killed before the dispose causing send to fail
             }
         }
@@ -225,14 +255,17 @@ class ClusterIdCardHandler {
         }
         const rawIdCards = await global.kuzzle.ask("core:cache:internal:mget", keys);
         const expiredIdCards = [];
-        for (let i = 0; i < keys.length; i++) {
+        // `entries()` over the keys: `rawIdCards` is the answer to a mget over
+        // exactly these keys, so the pair is what the loop is really walking.
+        for (const [i, key] of keys.entries()) {
             // filter keys that might have expired between the key search and their
             // values retrieval
-            if (rawIdCards[i] !== null) {
-                idCards.push(IdCard.unserialize(JSON.parse(rawIdCards[i])));
+            const raw = rawIdCards[i];
+            if (raw !== null && raw !== undefined) {
+                idCards.push(IdCard.unserialize(JSON.parse(raw)));
             }
             else {
-                expiredIdCards.push(keys[i]);
+                expiredIdCards.push(key);
             }
         }
         // Clean expired ID Card's keys in the index
@@ -245,7 +278,7 @@ class ClusterIdCardHandler {
      * Adds a remote node IdCard to the node known topology
      */
     async addNode(id) {
-        if (this.disposed || this.idCard.topology.has(id)) {
+        if (this.disposed || this.idCard === null || this.idCard.topology.has(id)) {
             return;
         }
         this.idCard.topology.add(id);
@@ -255,7 +288,7 @@ class ClusterIdCardHandler {
      * Removes a remote node IdCard from the node known topology
      */
     async removeNode(id) {
-        if (!this.disposed && this.idCard.topology.delete(id)) {
+        if (!this.disposed && this.idCard?.topology.delete(id)) {
             await this.save();
         }
     }