kuzzle 2.49.1 → 2.50.0-beta.4

package/dist/lib/model/storage/baseModel.d.ts

@@ -0,0 +1,100 @@
+export = BaseModel;
+declare class BaseModel {
+    /**
+     * Register a new model
+     *
+     * @param {Model} ModelClass
+     */
+    static register(ModelClass: Model): void;
+    /**
+     * Loads an instance from the database
+     *
+     * @param {String} id
+     *
+     * @returns {BaseModel}
+     */
+    static load(id: string): BaseModel;
+    /**
+     * Deletes all instances matching the given query.
+     *  - the instance delete method will be called on each occurence
+     *
+     * @param {Object} query - Search query (e.g. { match_all: {} })
+     * @param {Object} options - refresh (undefined)
+     *
+     * @returns {Promise}
+     */
+    static deleteByQuery(query: any, { refresh }?: any): Promise<any>;
+    /**
+     * Returns instances matching the given query
+     *
+     * @param {Object} searchBody
+     * @param {Object} options - from, size, scroll
+     *
+     * @returns {Promise<BaseModel[]>} - Array of instances
+     */
+    static search(searchBody: any, options: any): Promise<BaseModel[]>;
+    /**
+     * Deletes all instances of the collection
+     *
+     * @param {Object} options - refresh (undefined)
+     *
+     * @returns {Promise}
+     */
+    static truncate({ refresh }?: any): Promise<any>;
+    static batchExecute(query: any, callback: any): Promise<any>;
+    /**
+     * Must be overriden by children
+     */
+    static get collection(): void;
+    /**
+     * Must be overriden by children
+     */
+    static get fields(): void;
+    /**
+     * Instantiate the model from a document
+     *
+     * @param {Object} document - { _id, _source }
+     *
+     * @returns {BaseModel}
+     */
+    static _instantiateFromDb({ _id, _source }: any): BaseModel;
+    constructor(_source?: {}, _id?: any);
+    __id: any;
+    __source: {};
+    set _id(_id: any);
+    get _id(): any;
+    set _source(_source: {});
+    get _source(): {};
+    /**
+     * Save the current instance in the database.
+     *  - use update if the instance already exists
+     *  - use create otherwise
+     *
+     * @param {Object} options - userId (null), refresh (undefined)
+     *
+     * @returns {Promise}
+     */
+    save({ userId, refresh }?: any): Promise<any>;
+    __persisted: boolean;
+    /**
+     * Delete the current instance from the database.
+     *  - call the _afterDelete hook after deletion
+     *
+     * @param {Object} options - refresh (undefined)
+     *
+     * @returns {Promise}
+     */
+    delete({ refresh }?: any): Promise<any>;
+    /**
+     * Returns a plain object representing the instance
+     *
+     * @returns {Object} { _id, _source }
+     */
+    serialize(): any;
+    /**
+     * Hook called in the delete method after deletion from the database
+     *
+     * @returns {Promise}
+     */
+    _afterDelete(): Promise<any>;
+}

package/dist/lib/model/storage/baseModel.js

@@ -0,0 +1,211 @@
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+const Bluebird = require("bluebird");
+class BaseModel {
+    constructor(_source = {}, _id = null) {
+        this.__id = null;
+        this.__source = {};
+        Reflect.defineProperty(this, "__persisted", {
+            value: false,
+            writable: true,
+        });
+        this._id = _id;
+        this._source = _source;
+    }
+    // static private methods ====================================================
+    /**
+     * Register a new model
+     *
+     * @param {Model} ModelClass
+     */
+    static register(ModelClass) {
+        if (this !== BaseModel) {
+            throw new Error("Incorrect usage of BaseModel.register");
+        }
+        // Define getters and setters for Model fields
+        for (const field of ModelClass.fields) {
+            Reflect.defineProperty(ModelClass.prototype, field, {
+                get() {
+                    return this.__source[field];
+                },
+                set(value) {
+                    this.__source[field] = value;
+                },
+            });
+        }
+    }
+    // Public methods ============================================================
+    /**
+     * Save the current instance in the database.
+     *  - use update if the instance already exists
+     *  - use create otherwise
+     *
+     * @param {Object} options - userId (null), refresh (undefined)
+     *
+     * @returns {Promise}
+     */
+    async save({ userId = null, refresh } = {}) {
+        if (!this.__persisted) {
+            const { _id, _source } = await global.kuzzle.internalIndex.create(this.constructor.collection, this._source, { id: this._id, refresh, userId });
+            this._id = _id;
+            this._source = _source;
+            this.__persisted = true;
+        }
+        else {
+            await global.kuzzle.internalIndex.update(this.constructor.collection, this._id, this._source, { refresh, userId });
+        }
+    }
+    /**
+     * Delete the current instance from the database.
+     *  - call the _afterDelete hook after deletion
+     *
+     * @param {Object} options - refresh (undefined)
+     *
+     * @returns {Promise}
+     */
+    async delete({ refresh } = {}) {
+        if (!this.__persisted) {
+            return;
+        }
+        await global.kuzzle.internalIndex.delete(this.constructor.collection, this._id, { refresh });
+        await this._afterDelete();
+        this.__persisted = false;
+    }
+    /**
+     * Returns a plain object representing the instance
+     *
+     * @returns {Object} { _id, _source }
+     */
+    serialize() {
+        return {
+            _id: this._id,
+            _source: this._source,
+        };
+    }
+    // Protected methods =========================================================
+    /**
+     * Hook called in the delete method after deletion from the database
+     *
+     * @returns {Promise}
+     */
+    async _afterDelete() {
+        return null;
+    }
+    // Getter/Setter =============================================================
+    get _id() {
+        return this.__id;
+    }
+    set _id(_id) {
+        this.__id = _id;
+    }
+    get _source() {
+        return this.__source;
+    }
+    set _source(_source) {
+        for (const key of Object.keys(_source)) {
+            if (this.constructor.fields.includes(key)) {
+                this.__source[key] = _source[key];
+            }
+        }
+    }
+    // Static public methods =====================================================
+    /**
+     * Loads an instance from the database
+     *
+     * @param {String} id
+     *
+     * @returns {BaseModel}
+     */
+    static async load(id) {
+        const result = await global.kuzzle.internalIndex.get(this.collection, id);
+        return this._instantiateFromDb(result);
+    }
+    /**
+     * Deletes all instances matching the given query.
+     *  - the instance delete method will be called on each occurence
+     *
+     * @param {Object} query - Search query (e.g. { match_all: {} })
+     * @param {Object} options - refresh (undefined)
+     *
+     * @returns {Promise}
+     */
+    static async deleteByQuery(query, { refresh } = {}) {
+        const { documents } = await global.kuzzle.internalIndex.deleteByQuery(this.collection, query);
+        await Bluebird.map(documents, (document) => this._instantiateFromDb(document)._afterDelete(), { concurrency: 10 }); // limits the load on storage services
+        if (refresh) {
+            await global.kuzzle.internalIndex.refreshCollection(this.collection);
+        }
+    }
+    /**
+     * Returns instances matching the given query
+     *
+     * @param {Object} searchBody
+     * @param {Object} options - from, size, scroll
+     *
+     * @returns {Promise<BaseModel[]>} - Array of instances
+     */
+    static async search(searchBody, options) {
+        const resp = await global.kuzzle.internalIndex.search(this.collection, searchBody, options);
+        return resp.hits.map((hit) => this._instantiateFromDb(hit));
+    }
+    /**
+     * Deletes all instances of the collection
+     *
+     * @param {Object} options - refresh (undefined)
+     *
+     * @returns {Promise}
+     */
+    static truncate({ refresh } = {}) {
+        return this.deleteByQuery({ match_all: {} }, { refresh });
+    }
+    // ? This looks not in use anymore ?
+    static batchExecute(query, callback) {
+        return global.kuzzle.internalIndex.mExecute(this.collection, query, callback);
+    }
+    /**
+     * Must be overriden by children
+     */
+    static get collection() {
+        throw new Error("Model.collection must be defined");
+    }
+    /**
+     * Must be overriden by children
+     */
+    static get fields() {
+        throw new Error("Model.fields must be defined");
+    }
+    // Static protected methods ==================================================
+    /**
+     * Instantiate the model from a document
+     *
+     * @param {Object} document - { _id, _source }
+     *
+     * @returns {BaseModel}
+     */
+    static _instantiateFromDb({ _id, _source }) {
+        const model = new this(_source, _id); // NOSONAR
+        model.__persisted = true;
+        return model;
+    }
+}
+module.exports = BaseModel;
+//# sourceMappingURL=baseModel.js.map

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

@@ -0,0 +1,74 @@
+export = Redis;
+/**
+ * @class Redis
+ * @extends Service
+ * @param {object} config
+ * @property service
+ */
+declare class Redis extends Service {
+    connected: boolean;
+    client: any;
+    commands: {};
+    adapterName: any;
+    pingIntervalID: NodeJS.Timeout;
+    logger: import("../../kuzzle/Logger").Logger;
+    /**
+     * Setup a ping interval to keep the connection alive
+     * Every 60 seconds a ping is sent to Redis
+     */
+    _setupKeepAlive(delay: any): void;
+    /**
+     * Ping Redis
+     */
+    _ping(): Promise<void>;
+    /**
+     * Initializes the Redis commands list, and add transformers when necessary
+     */
+    setCommands(): void;
+    /**
+     * Returns all the keys matching a given pattern.
+     *
+     * /!\ 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
+     */
+    searchKeys(pattern: any): Promise<string[]>;
+    /**
+     * Executes multiple client commands in a single action
+     *
+     * @returns {Promise}
+     */
+    mExecute(commands: any): Promise<any>;
+    _searchNodeKeys(node: any, pattern: any): Bluebird<any>;
+    _buildClient(options: any): any;
+    _buildClusterClient(options: any): IORedis.Cluster;
+    /**
+     * Convenience method: set a key and its value
+     *
+     * 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
+     */
+    store(key: string, value: string, { onlyIfNew, ttl }?: {
+        onlyIfNew: boolean;
+        ttl: number;
+    }): boolean;
+    /**
+     * Executes a client command
+     * @param  {string} command
+     * @param  {Array} args
+     * @return {Promise.<*>}
+     */
+    exec(command: string, ...args: any[]): Promise<any>;
+}
+import Service = require("../service");
+import Bluebird = require("bluebird");
+import IORedis = require("ioredis");

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

@@ -0,0 +1,237 @@
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"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");
+/**
+ * @class Redis
+ * @extends Service
+ * @param {object} config
+ * @property service
+ */
+class Redis extends Service {
+    constructor(config, name) {
+        super("redis", config);
+        this.connected = false;
+        this.client = null;
+        this.commands = {};
+        this.adapterName = name;
+        this.pingIntervalID = null;
+        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;
+    }
+    /**
+     * 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));
+        // 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({
+                ...config.clusterOptions,
+                redisOptions: config.options,
+            });
+        }
+        else {
+            this.client = this._buildClient(config.options);
+        }
+        this.client.on("ready", () => {
+            this.connected = true;
+        });
+        this.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}`);
+            }
+            this.connected = false;
+        });
+        this.setCommands();
+        // TODO: Remove this when IORedis does support application level pings to keep connection to Azure Redis alive
+        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}`);
+                resolve();
+            });
+            this.client.once("error", (error) => {
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Setup a ping interval to keep the connection alive
+     * Every 60 seconds a ping is sent to Redis
+     */
+    _setupKeepAlive(delay) {
+        this.client.on("ready", async () => {
+            await this._ping();
+            this.pingIntervalID = setInterval(this._ping.bind(this), delay);
+        });
+        this.client.on("error", () => {
+            clearInterval(this.pingIntervalID);
+            this.pingIntervalID = null;
+        });
+    }
+    /**
+     * Ping Redis
+     */
+    async _ping() {
+        try {
+            await this.client.ping();
+        }
+        catch (error) {
+            global.kuzzle.log.error(`Failed to PING Redis to keep connection alive:\n${error.message}`);
+        }
+    }
+    /**
+     * Initializes the Redis commands list, and add transformers when necessary
+     */
+    setCommands() {
+        const commandsList = this.client.getBuiltinCommands();
+        for (const command of commandsList) {
+            this.commands[command] = async (...args) => {
+                if (!this.connected) {
+                    throw kerror.get("notconnected");
+                }
+                return this.client[command](...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 info = {};
+        arr.forEach((item) => {
+            item = item.trim();
+            if (item.length > 0 && !item.startsWith("#")) {
+                const keyValuePair = item.split(":");
+                info[keyValuePair[0]] = keyValuePair[1];
+            }
+        });
+        return {
+            memoryPeak: info.used_memory_peak_human,
+            memoryUsed: info.used_memory_human,
+            mode: info.redis_mode,
+            type: "redis",
+            version: info.redis_version,
+        };
+    }
+    /**
+     * Returns all the keys matching a given pattern.
+     *
+     * /!\ 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) => {
+                return this._searchNodeKeys(node, pattern);
+            });
+            return uniq(flatten(keys));
+        }
+        return this._searchNodeKeys(this.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 this.client.multi(commands).exec();
+    }
+    _searchNodeKeys(node, pattern) {
+        return new Bluebird((resolve) => {
+            let keys = [];
+            const stream = node.scanStream({ match: pattern });
+            stream.on("data", (resultKeys) => {
+                keys = keys.concat(resultKeys);
+            });
+            stream.on("end", () => {
+                resolve(uniq(keys));
+            });
+        });
+    }
+    _buildClient(options) {
+        return new IORedis({ ...this._config.node, ...options });
+    }
+    _buildClusterClient(options) {
+        return new IORedis.Cluster(this._config.nodes, options);
+    }
+    /**
+     * Convenience method: set a key and its value
+     *
+     * 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];
+        if (onlyIfNew) {
+            command.push("NX");
+        }
+        if (ttl > 0) {
+            command.push("PX", ttl);
+        }
+        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);
+    }
+}
+module.exports = Redis;
+//# sourceMappingURL=redis.js.map

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

@@ -0,0 +1,30 @@
+export = Service;
+/**
+ * Services base class
+ *
+ */
+declare class Service {
+    constructor(name: any, config: any);
+    _name: any;
+    _config: any;
+    _initTimeout: any;
+    get config(): any;
+    get name(): any;
+    /**
+     * Call _initSequence to initialize the service
+     * and throw an error if timeout exceed
+     *
+     * @returns {Promise}
+     */
+    init(): Promise<any>;
+    /**
+     * @abstract
+     * @returns {Promise}
+     */
+    _initSequence(): Promise<any>;
+    /**
+     * @abstract
+     * @returns {Promise}
+     */
+    info(): Promise<any>;
+}