kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/core/auth/tokenManager.js

@@ -59,7 +59,6 @@ const TIMEOUT_MAX = Math.pow(2, 31) - 1;
  */
 class TokenManager {
     constructor() {
-        this.anonymousUserId = null;
         /**
          * Map<connectionId, ManagedToken>
          */
@@ -99,9 +98,21 @@ class TokenManager {
             this.removeConnection(connection.id).catch((err) => this.logger.info(err));
         });
     }
+    /**
+     * The managed token filed under `idx`, or undefined when none is.
+     *
+     * `search` answers a position or `-1`, and indexing `array` with it is
+     * `| undefined` for every position under `noUncheckedIndexedAccess` — so the
+     * callers test one value rather than a position and then an element.
+     */
+    find(idx) {
+        const pos = this.tokens.search({ idx });
+        return pos === -1 ? undefined : this.tokens.array[pos];
+    }
     runTimer() {
-        if (this.tokens.array.length > 0) {
-            const delay = Math.min(this.tokens.array[0].expiresAt - Date.now(), TIMEOUT_MAX);
+        const next = this.tokens.array[0];
+        if (next !== undefined) {
+            const delay = Math.min((next.expiresAt ?? 0) - Date.now(), TIMEOUT_MAX);
             if (this.timer) {
                 clearTimeout(this.timer);
             }
@@ -127,13 +138,12 @@ class TokenManager {
             }
             this.removeConnectionLinkedToToken(connectionId, currentToken);
         }
-        const pos = this.tokens.search({ idx });
-        if (pos === -1) {
+        const managedToken = this.find(idx);
+        if (managedToken === undefined) {
             this.add(token, new Set([connectionId]));
             this.logger.trace(`connection "${connectionId}" from user "${token.userId}" linked to a new token`);
         }
         else {
-            const managedToken = this.tokens.array[pos];
             managedToken.connectionIds.add(connectionId);
             this.tokensByConnection.set(connectionId, managedToken);
             this.logger.trace(`connection "${connectionId}" from user "${token.userId}" linked to existing token`);
@@ -145,6 +155,12 @@ class TokenManager {
      * @param token
      * @param connectionId
      */
+    /**
+     * `Token | null`: a request whose connection never authenticated carries no
+     * token, and the trace below is the deliberate answer to that. The
+     * non-nullable parameter made `authController.logout` — the one caller —
+     * look like it had checked.
+     */
     unlink(token, connectionId) {
         if (!token) {
             this.logger.trace(`tried to unlink connection "${connectionId}" with no token`);
@@ -155,12 +171,12 @@ class TokenManager {
             return;
         }
         const idx = ManagedToken.indexFor(token);
-        const pos = this.tokens.search({ idx });
-        if (pos === -1) {
+        const managedToken = this.find(idx);
+        if (managedToken === undefined) {
             this.logger.trace(`tried to unlink connection "${connectionId}" with no token associated`);
             return;
         }
-        this.removeConnectionLinkedToToken(connectionId, this.tokens.array[pos]);
+        this.removeConnectionLinkedToToken(connectionId, managedToken);
         const currentToken = this.tokensByConnection.get(connectionId);
         if (currentToken && currentToken._id === token._id) {
             this.tokensByConnection.delete(connectionId);
@@ -194,8 +210,8 @@ class TokenManager {
         }
         const idx = ManagedToken.indexFor(token);
         const searchResult = this.tokens.search({ idx });
-        if (searchResult > -1) {
-            const managedToken = this.tokens.array[searchResult];
+        const managedToken = this.tokens.array[searchResult];
+        if (managedToken !== undefined) {
             for (const connectionId of managedToken.connectionIds) {
                 this.tokensByConnection.delete(connectionId);
                 await global.kuzzle.ask("core:realtime:connection:remove", connectionId);
@@ -220,8 +236,9 @@ class TokenManager {
         // within the same second) but, oh, well... it costs nothing to fix a
         // potentially very, very, very hard to debug random problem before it
         // occurs
-        if (pos > -1 && oldToken._id !== newToken._id) {
-            const connectionIds = this.tokens.array[pos].connectionIds;
+        const managedToken = pos === -1 ? undefined : this.tokens.array[pos];
+        if (managedToken !== undefined && oldToken._id !== newToken._id) {
+            const connectionIds = managedToken.connectionIds;
             this.add(newToken, connectionIds);
             // Delete old token
             this.deleteByIndex(pos);
@@ -230,11 +247,13 @@ class TokenManager {
     }
     async checkTokensValidity() {
         const arr = this.tokens.array;
+        const first = arr[0];
         // API key can never expire (-1)
-        if (arr.length > 0 &&
-            arr[0].expiresAt > 0 &&
-            arr[0].expiresAt < Date.now()) {
-            const managedToken = arr[0];
+        if (first !== undefined &&
+            first.expiresAt !== null &&
+            first.expiresAt > 0 &&
+            first.expiresAt < Date.now()) {
+            const managedToken = first;
             arr.shift();
             for (const connectionId of managedToken.connectionIds) {
                 await global.kuzzle.ask("core:realtime:tokenExpired:notify", connectionId);
@@ -248,9 +267,18 @@ class TokenManager {
         }
     }
     /**
-     * Gets the token matching user & connection if any
+     * Gets the token matching user & connection if any.
+     *
+     * `string | null` on both: this is a query, and a request that carries
+     * neither a connection nor a stored user is answered — `null` misses the
+     * map, and a null kuid matches no token's `userId` — rather than being a
+     * caller error. `authController.login` asks it of every login, including
+     * the ones where the strategy has not yet produced either.
      */
     getConnectedUserToken(userId, connectionId) {
+        if (connectionId === null) {
+            return null;
+        }
         const token = this.tokensByConnection.get(connectionId);
         return token && token.userId === userId ? token : null;
     }
@@ -279,7 +307,7 @@ class TokenManager {
             this.tokensByConnection.set(connectionId, orderedToken);
         }
         this.tokens.insert(orderedToken);
-        if (this.tokens.array[0].idx === orderedToken.idx) {
+        if (this.tokens.array[0]?.idx === orderedToken.idx) {
             this.runTimer();
         }
         this.logger.trace(`token from user ${token.userId} linked to connections ${Array.from(connectionIds)}`);

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

@@ -1,5 +1,5 @@
-import Kuzzle from "../../kuzzle/kuzzle";
-import { Backend } from "./index";
+import type Kuzzle from "../../kuzzle/kuzzle";
+import type { Backend } from "./index";
 export declare class ApplicationManager {
     protected _application: any;
     constructor(application: Backend);

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

@@ -1,14 +1,20 @@
-import { JSONObject } from "kuzzle-sdk";
+import type { JSONObject } from "../../types/JSONObject";
 import { EmbeddedSDK } from "../shared/sdk/embeddedSdk";
-import { EventDefinition } from "../../../index";
+import type { EventDefinition } from "../../../index";
 import { BackendCluster, BackendConfig, BackendController, BackendHook, BackendImport, BackendPipe, BackendPlugin, BackendStorage, BackendVault, BackendOpenApi, BackendErrors, BackendSubscription } from "./index";
 import { Logger } from "../../kuzzle/Logger";
+import Plugin from "../plugin/plugin";
 export declare class Backend {
     private _kuzzle;
     private _name;
+    /**
+     * Both are defined with `Reflect.defineProperty` in the constructor, so
+     * that they stay off the enumerable surface a plugin sees; the compiler
+     * does not read that as an initialisation.
+     */
     private _sdk;
     private _started;
-    protected _pipes: {};
+    protected _pipes: Record<string, Array<() => Promise<void>>>;
     protected _hooks: {};
     protected _controllers: {};
     protected _plugins: {};
@@ -28,9 +34,14 @@ export declare class Backend {
         handler: () => void;
     }>;
     /**
-     * Requiring the PluginObject on module top level creates cyclic dependency
+     * The `Plugin` wrapper class, held on the instance rather than imported at
+     * use site — see the `Reflect.defineProperty` in the constructor.
+     */
+    /**
+     * Defined with `Reflect.defineProperty` below, for the same reason as
+     * `_kuzzle` and `_sdk`.
      */
-    protected PluginObject: any;
+    protected PluginObject: typeof Plugin;
     /**
      * Application version
      */

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

@@ -54,6 +54,7 @@ const kerror = __importStar(require("../../kerror"));
 const index_1 = require("../../../index");
 const index_2 = require("./index");
 const Logger_1 = require("../../kuzzle/Logger");
+const plugin_1 = __importDefault(require("../plugin/plugin"));
 const assertionError = kerror.wrap("plugin", "assert");
 const runtimeError = kerror.wrap("plugin", "runtime");
 let _app = null;
@@ -80,6 +81,7 @@ class Backend {
      * @param name - Your application name
      */
     constructor(name) {
+        this._started = false;
         this._pipes = {};
         this._hooks = {};
         this._controllers = {};
@@ -93,6 +95,10 @@ class Backend {
             users: {},
         };
         this._installationsWaitingList = [];
+        /**
+         * Application version
+         */
+        this.version = "";
         /**
          * Current Git commit (if available)
          */
@@ -107,13 +113,10 @@ class Backend {
          *
          */
         this._support = {};
-        /**
-         * Requiring the PluginObject on module top level creates cyclic dependency
-         */
         Reflect.defineProperty(this, "PluginObject", {
-            value: require("../plugin/plugin"),
+            value: plugin_1.default,
         });
-        if (!this.PluginObject.checkName(name)) {
+        if (!plugin_1.default.checkName(name)) {
             throw assertionError.get("invalid_application_name", name);
         }
         this._name = name;
@@ -145,7 +148,7 @@ class Backend {
             const info = JSON.parse(node_fs_1.default.readFileSync("./package.json", "utf8"));
             this.version = info.version;
         }
-        catch (error) {
+        catch {
             // Silent if no version can be found
         }
         global.app = this;
@@ -286,7 +289,12 @@ class Backend {
         if (!node_fs_1.default.statSync(gitDir).isDirectory()) {
             return null;
         }
+        // A detached HEAD holds the hash itself, with no "ref: " prefix: there is
+        // no ref file to follow, and the split answered undefined for it.
         const ref = node_fs_1.default.readFileSync(`${dir}/.git/HEAD`, "utf8").split("ref: ")[1];
+        if (ref === undefined) {
+            return null;
+        }
         const refFile = `${dir}/.git/${ref}`.replace("\n", "");
         if (!node_fs_1.default.existsSync(refFile)) {
             return null;

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

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

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

@@ -1,10 +1,22 @@
-import { ApplicationManager, Backend } from "./index";
-import { KuzzleConfiguration } from "../../types/config/KuzzleConfiguration";
-export declare class BackendConfig extends ApplicationManager {
+import type { Backend } from "./index";
+import { ApplicationManager } from "./index";
+import type { IKuzzleConfiguration, KuzzleConfigurationOverrides } from "../../types/config/KuzzleConfiguration";
+/**
+ * `content` is declared here, as an accessor pair, rather than as a field of
+ * the class: read, it is the whole configuration, which it is once loaded;
+ * assigned, it takes a `Partial` one, which is what v2.56.0 declared it as.
+ * Code compiled against that assigns one, and must still compile; reads no
+ * longer need `?.` at every level. At runtime it is the plain property the
+ * constructor assigns, as it always was — an interface adds no accessor.
+ */
+export interface BackendConfig {
     /**
      * Configuration content.
      */
-    content: KuzzleConfiguration;
+    get content(): IKuzzleConfiguration;
+    set content(content: Partial<IKuzzleConfiguration>);
+}
+export declare class BackendConfig extends ApplicationManager {
     constructor(application: Backend);
     /**
      * Sets a configuration value
@@ -22,5 +34,5 @@ export declare class BackendConfig extends ApplicationManager {
      *
      * @param config - Configuration object to merge
      */
-    merge(config: KuzzleConfiguration): void;
+    merge(config: KuzzleConfigurationOverrides): void;
 }

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

@@ -52,6 +52,7 @@ const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
 const index_2 = require("../../config/index");
 const runtimeError = kerror.wrap("plugin", "runtime");
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging -- see the interface above
 class BackendConfig extends index_1.ApplicationManager {
     constructor(application) {
         super(application);

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

@@ -1,4 +1,4 @@
-import { ControllerDefinition, Controller } from "../../types";
+import type { ControllerDefinition, Controller } from "../../types";
 import { ApplicationManager } from "./index";
 export declare class BackendController extends ApplicationManager {
     /**

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

@@ -159,7 +159,14 @@ class BackendController extends index_1.ApplicationManager {
             // if the function handler is an instance method,
             // bind the context to the controller instance
             const handlerName = definition.handler.name;
-            if (handlerName && typeof controller[handlerName] === "function") {
+            // `Reflect.get`, not safeObject's `get`: a controller's actions are class
+            // methods and live on the prototype, which that helper deliberately does
+            // not read. Landed in an `unknown` so the reflective read's `any` goes no
+            // further than the `typeof` below.
+            const method = handlerName
+                ? Reflect.get(controller, handlerName)
+                : undefined;
+            if (typeof method === "function") {
                 definition.handler = definition.handler.bind(controller);
             }
         }

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

@@ -1,6 +1,8 @@
-import { KuzzleError } from "../../kerror/errors";
-import { ApplicationManager, Backend } from "./index";
-import { CustomErrorDefinition } from "../../types";
+import type { KuzzleError } from "../../kerror/errors";
+import * as kerror from "../../kerror";
+import type { Backend } from "./index";
+import { ApplicationManager } from "./index";
+import type { CustomErrorDefinition } from "../../types";
 export declare class BackendErrors extends ApplicationManager {
     private domains;
     constructor(application: Backend);
@@ -34,7 +36,7 @@ export declare class BackendErrors extends ApplicationManager {
      *
      * @returns Standardized KuzzleError
      */
-    get(domain: string, subDomain: string, name: string, ...placeholders: any[]): KuzzleError;
+    get(domain: string, subDomain: string, name: string, ...placeholders: unknown[]): KuzzleError;
     /**
      * Get a standardized KuzzleError from an existing error to keep the stacktrace
      *
@@ -46,16 +48,21 @@ export declare class BackendErrors extends ApplicationManager {
      *
      * @returns Standardized KuzzleError
      */
-    getFrom(source: Error, domain: string, subDomain: string, name: string, ...placeholders: any[]): KuzzleError;
+    getFrom(source: Error, domain: string, subDomain: string, name: string, ...placeholders: unknown[]): KuzzleError;
     /**
      * Wrap an error manager on the domain and subDomain
      *
      * @param domain Domain name
      * @param subDomain Subdomain to wrap to
+     *
+     * The error name is declared `unknown`, as v2.56.0's `any` accepted
+     * anything; one that is not a registered name gives
+     * `core.fatal.unexpected_error`, as it always has. Methods rather than
+     * function-typed properties, so that `kerror`'s `string`-typed ones fit.
      */
     wrap(domain: string, subDomain: string): {
-        get: (error: any, ...placeholders: any[]) => KuzzleError;
-        getFrom: (source: any, error: any, ...placeholders: any[]) => KuzzleError;
-        reject: (error: any, ...placeholders: any[]) => Promise<any>;
+        get(error: unknown, ...placeholders: unknown[]): KuzzleError;
+        getFrom(source: unknown, error: unknown, ...placeholders: unknown[]): KuzzleError;
+        reject(error: unknown, ...placeholders: unknown[]): ReturnType<typeof kerror.reject>;
     };
 }

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

@@ -118,6 +118,11 @@ class BackendErrors extends index_1.ApplicationManager {
      *
      * @param domain Domain name
      * @param subDomain Subdomain to wrap to
+     *
+     * The error name is declared `unknown`, as v2.56.0's `any` accepted
+     * anything; one that is not a registered name gives
+     * `core.fatal.unexpected_error`, as it always has. Methods rather than
+     * function-typed properties, so that `kerror`'s `string`-typed ones fit.
      */
     wrap(domain, subDomain) {
         return kerror.rawWrap(this.domains, domain, subDomain);

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

@@ -1,4 +1,4 @@
-import { HookEventHandler, EventDefinition } from "../../types";
+import type { HookEventHandler, EventDefinition } from "../../types";
 import { ApplicationManager } from "./index";
 export declare class BackendHook extends ApplicationManager {
     /**

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

@@ -1,4 +1,4 @@
-import { JSONObject } from "kuzzle-sdk";
+import type { JSONObject } from "../../types/JSONObject";
 import { ApplicationManager } from "./index";
 export type DefaultMappings = {
     [index: string]: {

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

@@ -1,5 +1,6 @@
-import { ApplicationManager, Backend } from "./index";
-import { OpenApiDefinition } from "../../types";
+import type { Backend } from "./index";
+import { ApplicationManager } from "./index";
+import type { OpenApiDefinition } from "../../types";
 export declare class BackendOpenApi extends ApplicationManager {
     /**
      * Application Open API definition

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

@@ -1,4 +1,4 @@
-import { EventDefinition, PipeEventHandler } from "../../types";
+import type { EventDefinition, PipeEventHandler } from "../../types";
 import { ApplicationManager } from "./index";
 export declare class BackendPipe extends ApplicationManager {
     /**

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

@@ -63,7 +63,15 @@ class BackendPipe extends index_1.ApplicationManager {
             throw assertionError.get("invalid_pipe", event);
         }
         if (this._application.started) {
-            return global.kuzzle.pluginsManager.registerPipe(global.kuzzle.pluginsManager.application, event, handler);
+            const application = global.kuzzle.pluginsManager.application;
+            // `started` is set by `kuzzle.start`, which registers the application
+            // with the plugins manager before it flips: an application that is
+            // running and unknown to the manager cannot happen, and the error says
+            // which half is missing rather than handing `undefined` on.
+            if (application === undefined) {
+                throw runtimeError.get("unavailable_before_start", "pipe.register");
+            }
+            return global.kuzzle.pluginsManager.registerPipe(application, event, handler);
         }
         if (!this._application._pipes[event]) {
             this._application._pipes[event] = [];

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

@@ -1,5 +1,5 @@
-import { JSONObject } from "kuzzle-sdk";
-import { Plugin } from "../../types";
+import type { JSONObject } from "../../types/JSONObject";
+import type { Plugin } from "../../types";
 import { ApplicationManager } from "./index";
 export declare class BackendPlugin extends ApplicationManager {
     /**

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

@@ -1,5 +1,5 @@
-import { JSONObject } from "kuzzle-sdk";
-import { Connection } from "../../api/request";
+import type { JSONObject } from "../../types/JSONObject";
+import type { Connection } from "../../api/request";
 import { ApplicationManager } from "./index";
 export declare class BackendSubscription extends ApplicationManager {
     /**

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

@@ -1,4 +1,4 @@
-import { JSONObject } from "kuzzle-sdk";
+import type { JSONObject } from "../../types/JSONObject";
 import { ApplicationManager } from "./index";
 export declare class BackendVault extends ApplicationManager {
     private decrypted;

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

@@ -35,6 +35,9 @@ class BackendVault extends index_1.ApplicationManager {
     constructor() {
         super(...arguments);
         this.decrypted = false;
+        // Empty until `secrets` loads the vault. It is never read before that: the
+        // only `return this._secrets` is below the load.
+        this._secrets = {};
     }
     /**
      * Secret key to decrypt encrypted secrets.
@@ -61,8 +64,12 @@ class BackendVault extends index_1.ApplicationManager {
         // We need to load the secrets before Kuzzle start so we can use them
         // in the configuration (e.g. configure ES X-Pack credentials)
         if (!this._application.started && !this.decrypted) {
-            const kuzzleVault = vault_1.default.load(this._application._vaultKey, this._application._secretsFile);
+            const kuzzleVault = vault_1.default.load(this._application._vaultKey, this._application._secretsFile, this._application.config.content.vault.newAlgorithm);
             this._secrets = kuzzleVault.secrets;
+            // `decrypted` was written once, at declaration, and never set — so this
+            // block re-decrypted the vault on every read before start, which is
+            // exactly what the flag exists to prevent.
+            this.decrypted = true;
         }
         if (this._application.started) {
             return this._kuzzle.vault.secrets;

package/dist/lib/core/cache/cacheEngine.d.ts

@@ -1,15 +1,18 @@
-export = CacheEngine;
+import Redis from "../../service/cache/redis";
+import type { Logger } from "../../kuzzle/Logger";
+import "../../types/Global";
 declare class CacheEngine {
     public: Redis;
     internal: Redis;
-    logger: import("../../kuzzle/Logger").Logger;
+    logger: Logger;
+    constructor();
     /**
      * Initializes the redis clients
      *
      * @returns {Promise}
      */
-    init(): Promise<any>;
+    init(): Promise<void>;
     registerInternalEvents(): void;
     registerPublicEvents(): void;
 }
-import Redis = require("../../service/cache/redis");
+export = CacheEngine;

package/dist/lib/core/cache/cacheEngine.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,14 +19,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const Bluebird = require("bluebird");
-const Redis = require("../../service/cache/redis");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const bluebird_1 = __importDefault(require("bluebird"));
+const redis_1 = __importDefault(require("../../service/cache/redis"));
+require("../../types/Global");
 class CacheEngine {
     constructor() {
         const config = global.kuzzle.config.services;
-        this.public = new Redis(config.memoryStorage, "public_adapter");
-        this.internal = new Redis(config.internalCache, "internal_adapter");
+        this.public = new redis_1.default(config.memoryStorage, "public_adapter");
+        this.internal = new redis_1.default(config.internalCache, "internal_adapter");
         this.logger = global.kuzzle.log.child("core:cache:cacheEngine");
     }
     /**
@@ -34,7 +38,7 @@ class CacheEngine {
      * @returns {Promise}
      */
     async init() {
-        await Bluebird.all([this.public.init(), this.internal.init()]);
+        await bluebird_1.default.all([this.public.init(), this.internal.init()]);
         this.registerInternalEvents();
         this.registerPublicEvents();
         this.logger.info("[✔] Cache initialized");
@@ -104,7 +108,7 @@ class CacheEngine {
          * @param {string} script
          */
         global.kuzzle.onAsk("core:cache:internal:script:define", (name, keys, script) => {
-            return this.internal.client.defineCommand(name, {
+            return this.internal.connectedClient.defineCommand(name, {
                 lua: script,
                 numberOfKeys: keys,
             });
@@ -116,7 +120,14 @@ class CacheEngine {
          * @param {...string} args -- script arguments
          * @return {*} script result (if any)
          */
-        global.kuzzle.onAsk("core:cache:internal:script:execute", (name, ...args) => this.internal.client[name](...args));
+        global.kuzzle.onAsk("core:cache:internal:script:execute", (name, ...args) => {
+            const client = this.internal.connectedClient;
+            // `defineCommand` attaches the script to the client INSTANCE, so it has
+            // to be invoked as a method: a detached reference loses `this` and
+            // ioredis' Commander throws on `this.options`. `Reflect.apply` keeps the
+            // receiver, which a plain `Reflect.get(...)(...)` does not.
+            return Reflect.apply(Reflect.get(client, name), client, args);
+        });
         /**
          * Convenience method for easy access to options NX and PX of the "set"
          * command.
@@ -139,6 +150,12 @@ class CacheEngine {
          * @param {Array} args -- command arguments
          */
         global.kuzzle.onAsk("core:cache:internal:execute", (command, ...args) => this.internal.exec(command, ...args));
+        /**
+         * Returns the raw ioredis client instance backing the internal cache.
+         * In-process only — never exposed over the network. Used by
+         * lib/util/distributedLock.ts to build its redis-semaphore mutexes.
+         */
+        global.kuzzle.onAsk("core:cache:internal:client:get", () => this.internal.client);
     }
     registerPublicEvents() {
         /**

package/dist/lib/core/debug/kuzzleDebugger.d.ts

@@ -1,5 +1,6 @@
-import { JSONObject } from "kuzzle-sdk";
+import type { JSONObject } from "../../types/JSONObject";
 export declare class KuzzleDebugger {
+    /** Built by `init()`, which is called before anything can reach the API. */
     private inspector;
     private debuggerStatus;
     /**