kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/service/cache/redis.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,26 +19,68 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { flatten, uniq } = require("lodash");
-const Bluebird = require("bluebird");
-const IORedis = require("ioredis");
-const kerror = require("../../kerror").wrap("services", "cache");
-const Service = require("../service");
+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 node_util_1 = require("node:util");
+const bluebird_1 = __importDefault(require("bluebird"));
+const lodash_1 = require("lodash");
+const ioredis_1 = __importStar(require("ioredis"));
+const service_1 = __importDefault(require("../service"));
+const kerrorLib = __importStar(require("../../kerror"));
+require("../../types/Global");
+const kerror = kerrorLib.wrap("services", "cache");
 /**
  * @class Redis
  * @extends Service
- * @param {object} config
- * @property service
  */
-class Redis extends Service {
+class Redis extends service_1.default {
+    /**
+     * The connected client.
+     *
+     * `client` is null until `init()` builds it, and every consumer is wired up
+     * by `cacheEngine.init()` *after* that — so "not connected" is a programming
+     * error, stated once here where it can actually happen, rather than a null
+     * check at each call site where it cannot.
+     */
+    get connectedClient() {
+        if (this.client === null) {
+            throw kerrorLib.get("core", "fatal", "assertion_failed", `redis adapter "${this.adapterName}" is not connected`);
+        }
+        return this.client;
+    }
     constructor(config, name) {
         super("redis", config);
         this.connected = false;
         this.client = null;
+        // Populated by setCommands() once the client is built; empty until then,
+        // exactly like the plain object this field held before.
         this.commands = {};
-        this.adapterName = name;
         this.pingIntervalID = null;
+        this.adapterName = name;
         this.logger = global.kuzzle.log.child // It means we're in the main Kuzzle process
             ? global.kuzzle.log.child("services:cache:redis")
             : global.kuzzle.log;
@@ -45,29 +88,32 @@ class Redis extends Service {
     /**
      * Initialize the redis client, select the service associated database and
      * flush it to make sure we start from a clean state
-     *
-     * @returns {Promise}
      */
     _initSequence() {
-        const config = JSON.parse(JSON.stringify(this._config));
+        // A copy, so the DNS lookup override below does not leak into the
+        // service configuration. `cloneDeep` rather than `structuredClone`: a
+        // config set from code may hold functions (e.g. an ioredis
+        // `retryStrategy`), which `structuredClone` refuses to copy.
+        const config = (0, lodash_1.cloneDeep)(this._config); // NOSONAR structuredClone throws on functions, see above
         // Only way to connect to AWS ELastiCache
         // https://github.com/luin/ioredis#special-note-aws-elasticache-clusters-with-tls
         if (config.overrideDnsLookup) {
             config.clusterOptions.dnsLookup = (address, callback) => callback(null, address);
         }
-        if (config.nodes) {
-            this.client = this._buildClusterClient({
+        // Built into a local and then published: `this.client` is the nullable
+        // field the accessor guards, and reading it back seven times here is what
+        // made every one of those reads a null check.
+        const client = config.nodes
+            ? this._buildClusterClient({
                 ...config.clusterOptions,
                 redisOptions: config.options,
-            });
-        }
-        else {
-            this.client = this._buildClient(config.options);
-        }
-        this.client.on("ready", () => {
+            })
+            : this._buildClient(config.options ?? {});
+        this.client = client;
+        client.on("ready", () => {
             this.connected = true;
         });
-        this.client.on("error", (error) => {
+        client.on("error", (error) => {
             if (this.connected) {
                 global.kuzzle.log.error(`Redis service seem to be down, see original error for more info:\n${error.message}`);
             }
@@ -78,12 +124,12 @@ class Redis extends Service {
         if (config.pingKeepAlive && config.pingKeepAlive > 0) {
             this._setupKeepAlive(config.pingKeepAlive);
         }
-        return new Bluebird((resolve, reject) => {
-            this.client.once("ready", async () => {
-                await this.client.client("SETNAME", `${this.adapterName}/${global.kuzzle.id}`);
+        return new bluebird_1.default((resolve, reject) => {
+            client.once("ready", async () => {
+                await client.client("SETNAME", `${this.adapterName}/${global.kuzzle.id}`);
                 resolve();
             });
-            this.client.once("error", (error) => {
+            client.once("error", (error) => {
                 reject(error);
             });
         });
@@ -93,12 +139,12 @@ class Redis extends Service {
      * Every 60 seconds a ping is sent to Redis
      */
     _setupKeepAlive(delay) {
-        this.client.on("ready", async () => {
+        this.connectedClient.on("ready", async () => {
             await this._ping();
             this.pingIntervalID = setInterval(this._ping.bind(this), delay);
         });
-        this.client.on("error", () => {
-            clearInterval(this.pingIntervalID);
+        this.connectedClient.on("error", () => {
+            clearInterval(this.pingIntervalID ?? undefined);
             this.pingIntervalID = null;
         });
     }
@@ -107,49 +153,78 @@ class Redis extends Service {
      */
     async _ping() {
         try {
-            await this.client.ping();
+            await this.connectedClient.ping();
         }
         catch (error) {
-            global.kuzzle.log.error(`Failed to PING Redis to keep connection alive:\n${error.message}`);
+            global.kuzzle.log.error(`Failed to PING Redis to keep connection alive:\n${error instanceof Error ? error.message : (0, node_util_1.inspect)(error)}`);
         }
     }
     /**
      * Initializes the Redis commands list, and add transformers when necessary
      */
     setCommands() {
-        const commandsList = this.client.getBuiltinCommands();
+        const commandsList = this.connectedClient.getBuiltinCommands();
+        // Command names are only known at runtime (from getBuiltinCommands()),
+        // so this dispatch table can't be built against RedisCommander's named
+        // members directly -- this is the one place that bridges the two. Both
+        // this list and RedisCommander are generated from the same upstream
+        // ioredis command set, so the cast reflects a real guarantee, not a
+        // hand-wave.
+        const commands = this.commands;
+        const client = this.connectedClient;
         for (const command of commandsList) {
-            this.commands[command] = async (...args) => {
+            const implementation = client[command];
+            // `getBuiltinCommands()` lists what the client exposes, so the lookup
+            // is the same object answering about itself — the indexed read was the
+            // only thing the compiler could not follow.
+            if (implementation === undefined) {
+                continue;
+            }
+            commands[command] = async (...args) => {
                 if (!this.connected) {
-                    throw kerror.get("notconnected");
+                    // `not_connected`, with the underscore the code is declared with.
+                    // `notconnected` matches nothing, so every command issued while
+                    // the adapter was down raised `core.fatal.unexpected_error`
+                    // instead of "Unable to connect to the cache server".
+                    throw kerror.get("not_connected");
                 }
-                return this.client[command](...args);
+                // `Reflect.apply`, not `implementation(...args)`: ioredis' commands
+                // live on the `Commander` prototype and read `this.options`, so
+                // calling the result of an indexed read drops the receiver and
+                // every command throws. This is the bug sprint 5's Build and Run
+                // job caught in `funnel.doAction`, reintroduced here by hoisting
+                // the lookup out of the call — see `pluginsManager`'s note on the
+                // same line.
+                return Reflect.apply(implementation, client, args);
             };
         }
     }
     /**
      * Return some basic information about this service
      * @override
-     *
-     * @returns {Promise} service informations
      */
     async info() {
         const result = await this.commands.info();
-        const arr = result.replace(/\r\n/g, "\n").split("\n");
+        const arr = result.replaceAll("\r\n", "\n").split("\n");
         const info = {};
-        arr.forEach((item) => {
-            item = item.trim();
+        for (const rawItem of arr) {
+            const item = rawItem.trim();
             if (item.length > 0 && !item.startsWith("#")) {
-                const keyValuePair = item.split(":");
-                info[keyValuePair[0]] = keyValuePair[1];
+                const [key, value] = item.split(":");
+                // A line with no colon carries no value. It was stored as
+                // `info[key] = undefined`, which the five reads below then answered
+                // with while claiming `string`.
+                if (key !== undefined && value !== undefined) {
+                    info[key] = value;
+                }
             }
-        });
+        }
         return {
-            memoryPeak: info.used_memory_peak_human,
-            memoryUsed: info.used_memory_human,
-            mode: info.redis_mode,
+            memoryPeak: info.used_memory_peak_human ?? "",
+            memoryUsed: info.used_memory_human ?? "",
+            mode: info.redis_mode ?? "",
             type: "redis",
-            version: info.redis_version,
+            version: info.redis_version ?? "",
         };
     }
     /**
@@ -158,47 +233,45 @@ class Redis extends Service {
      * /!\ We don't use `keys` to avoid blocking Redis if using a big dataset
      * cf: http://redis.io/commands/keys
      *     and http://redis.io/commands/scan
-     *
-     * @param pattern
-     * @returns {Promise.<string[]>} promise resolving to an array of keys
      */
     async searchKeys(pattern) {
-        if (this.client instanceof IORedis.Cluster) {
-            const keys = await Bluebird.map(this.client.nodes("master"), (node) => {
+        const client = this.connectedClient;
+        if (client instanceof ioredis_1.Cluster) {
+            const keys = await bluebird_1.default.map(client.nodes("master"), (node) => {
                 return this._searchNodeKeys(node, pattern);
             });
-            return uniq(flatten(keys));
+            return [...new Set(keys.flat())];
         }
-        return this._searchNodeKeys(this.client, pattern);
+        return this._searchNodeKeys(client, pattern);
     }
     /**
      * Executes multiple client commands in a single action
-     *
-     * @returns {Promise}
      */
     mExecute(commands) {
         if (!Array.isArray(commands) || commands.length === 0) {
-            return Bluebird.resolve([]);
+            return bluebird_1.default.resolve([]);
         }
-        return this.client.multi(commands).exec();
+        return this.connectedClient.multi(commands).exec();
     }
     _searchNodeKeys(node, pattern) {
-        return new Bluebird((resolve) => {
+        return new bluebird_1.default((resolve) => {
             let keys = [];
             const stream = node.scanStream({ match: pattern });
             stream.on("data", (resultKeys) => {
                 keys = keys.concat(resultKeys);
             });
             stream.on("end", () => {
-                resolve(uniq(keys));
+                resolve([...new Set(keys)]);
             });
         });
     }
     _buildClient(options) {
-        return new IORedis({ ...this._config.node, ...options });
+        return new ioredis_1.default({ ...this._config.node, ...options });
     }
     _buildClusterClient(options) {
-        return new IORedis.Cluster(this._config.nodes, options);
+        // The caller only reaches here when `nodes` is set; `?? []` is what the
+        // Cluster constructor would have been handed otherwise.
+        return new ioredis_1.Cluster(this._config.nodes ?? [], options);
     }
     /**
      * Convenience method: set a key and its value
@@ -206,11 +279,6 @@ class Redis extends Service {
      * Options:
      *   - onlyIfNew: if true, set the NX option
      *   - ttl: if true, set the PX option
-     *
-     * @param  {string} key
-     * @param  {string} value
-     * @param  {{onlyIfNew: boolean, ttl: number}} [options]
-     * @return {boolean} true if the key was set, false otherwise
      */
     async store(key, value, { onlyIfNew = false, ttl = 0 } = {}) {
         const command = [key, value];
@@ -220,17 +288,26 @@ class Redis extends Service {
         if (ttl > 0) {
             command.push("PX", ttl);
         }
+        // The flag combination is built dynamically above, so it can't match a
+        // single RedisCommander.set(...) overload (which expects a fixed
+        // positional tuple per combination) -- same escape hatch as setCommands().
         const result = await this.commands.set(...command);
         return result === "OK";
     }
     /**
      * Executes a client command
-     * @param  {string} command
-     * @param  {Array} args
-     * @return {Promise.<*>}
      */
     exec(command, ...args) {
-        return this.commands[command](...args);
+        // command is an arbitrary name chosen at runtime by this method's own
+        // caller (see its ask-handler callers in cacheEngine.js) -- same
+        // escape hatch as setCommands().
+        const commands = this.commands;
+        const implementation = commands[command];
+        if (implementation === undefined) {
+            throw kerrorLib.get("core", "fatal", "assertion_failed", `redis adapter "${this.adapterName}" has no command "${command}"`);
+        }
+        // Same reason as `setCommands()`: the receiver goes with the call.
+        return Reflect.apply(implementation, commands, args);
     }
 }
 module.exports = Redis;

package/dist/lib/service/service.d.ts

@@ -1,30 +1,25 @@
-export = Service;
+import "../types/Global";
 /**
  * Services base class
- *
  */
-declare class Service {
-    constructor(name: any, config: any);
-    _name: any;
-    _config: any;
-    _initTimeout: any;
-    get config(): any;
-    get name(): any;
+declare abstract class Service<TConfig = unknown, TInfo = unknown> {
+    protected _name: string;
+    protected _config: TConfig;
+    protected _initTimeout: number;
+    constructor(name: string, config: TConfig);
+    get config(): TConfig;
+    get name(): string;
     /**
      * Call _initSequence to initialize the service
      * and throw an error if timeout exceed
-     *
-     * @returns {Promise}
      */
-    init(): Promise<any>;
-    /**
-     * @abstract
-     * @returns {Promise}
-     */
-    _initSequence(): Promise<any>;
+    init(): Promise<void>;
+    protected abstract _initSequence(): Promise<void>;
     /**
+     * Return some basic information about this service
+     *
      * @abstract
-     * @returns {Promise}
      */
-    info(): Promise<any>;
+    info(): Promise<TInfo>;
 }
+export = Service;

package/dist/lib/service/service.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,20 +19,45 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const Bluebird = require("bluebird");
-const kerror = require("../kerror");
+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 kerror = __importStar(require("../kerror"));
+require("../types/Global");
 /**
  * Services base class
- *
  */
 class Service {
     constructor(name, config) {
         this._name = name;
         this._config = config;
+        const { initTimeout } = (config ?? {});
         this._initTimeout =
-            config.initTimeout ||
-                global.kuzzle.config.services.common.defaultInitTimeout;
+            initTimeout || global.kuzzle.config.services.common.defaultInitTimeout;
     }
     get config() {
         return this._config;
@@ -42,29 +68,22 @@ class Service {
     /**
      * Call _initSequence to initialize the service
      * and throw an error if timeout exceed
-     *
-     * @returns {Promise}
      */
-    init() {
-        return Bluebird.resolve(this._initSequence())
-            .timeout(this._initTimeout)
-            .catch((e) => {
-            if (e instanceof Bluebird.TimeoutError) {
+    async init() {
+        try {
+            await bluebird_1.default.resolve(this._initSequence()).timeout(this._initTimeout);
+        }
+        catch (e) {
+            if (e instanceof bluebird_1.default.TimeoutError) {
                 throw kerror.get("core", "fatal", "service_timeout", this._name);
             }
             throw e;
-        });
-    }
-    /**
-     * @abstract
-     * @returns {Promise}
-     */
-    _initSequence() {
-        throw new Error("Not implemented");
+        }
     }
     /**
+     * Return some basic information about this service
+     *
      * @abstract
-     * @returns {Promise}
      */
     info() {
         throw new Error("Not implemented");