kuzzle 2.56.0 → 2.57.0-beta.2

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,12 +19,47 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { sha256 } = require("../../util/crypto");
-const debug = require("../../util/debug")("models:storage:apiKey");
-const kerror = require("../../kerror");
-const BaseModel = require("./baseModel");
-class ApiKey extends BaseModel {
+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 crypto_1 = require("../../util/crypto");
+const safeObject_1 = require("../../util/safeObject");
+const debug_1 = __importDefault(require("../../util/debug"));
+const kerror = __importStar(require("../../kerror"));
+const baseModel_1 = __importDefault(require("./baseModel"));
+const debug = (0, debug_1.default)("models:storage:apiKey");
+/*
+ * ApiKey.load(userId, id) intentionally takes an extra ownership argument that
+ * BaseModel.load(id) does not, so the two static sides are deliberately not
+ * structurally compatible. This is an accepted, pre-existing design divergence
+ * (ApiKey scopes a load to its owner); the conversion changes no runtime
+ * behaviour.
+ */
+// @ts-expect-error -- intentional static-signature divergence of load() vs BaseModel (TS2417)
+class ApiKey extends baseModel_1.default {
     constructor(_source, _id = null) {
         super(_source, _id);
     }
@@ -66,20 +102,18 @@ class ApiKey extends BaseModel {
     /**
      * Creates a new API key for an user
      *
-     * @param {User} user
-     * @param {String} expiresIn - API key expiration date in ms format
-     * @param {String} description
-     * @param {Object} options - creatorId (null), apiKeyId (null), refresh (null), bypassMaxTTL (false)
-     *
-     * @returns {Promise<ApiKey>}
+     * @param user
+     * @param expiresIn - API key expiration date in ms format
+     * @param description
+     * @param options - creatorId (null), apiKeyId (null), refresh (null), bypassMaxTTL (false)
      */
-    static async create(user, expiresIn, description, { creatorId = null, apiKeyId = null, refresh, bypassMaxTTL = false } = {}) {
+    static async create(user, expiresIn, description, { creatorId = null, apiKeyId = null, refresh, bypassMaxTTL = false, } = {}) {
         const token = await global.kuzzle.ask("core:security:token:create", user, {
             bypassMaxTTL,
             expiresIn,
             type: "apiKey",
         });
-        const fingerprint = sha256(token.jwt);
+        const fingerprint = (0, crypto_1.sha256)(token.jwt);
         const apiKey = new ApiKey({
             description,
             expiresAt: token.expiresAt,
@@ -94,13 +128,11 @@ class ApiKey extends BaseModel {
     /**
      * Loads an user API key from the database
      *
-     * @param {String} userId - User ID
-     * @param {String} id - API key ID
-     *
-     * @returns {Promise<ApiKey>}
+     * @param userId - User ID
+     * @param id - API key ID
      */
     static async load(userId, id) {
-        const apiKey = await super.load(id);
+        const apiKey = (await super.load(id));
         if (userId !== apiKey.userId) {
             throw kerror.get("services", "storage", "not_found", id, {
                 message: `ApiKey "${id}" not found for user "${userId}".`,
@@ -109,18 +141,59 @@ class ApiKey extends BaseModel {
         return apiKey;
     }
     /**
-     * Deletes API keys for an user
+     * Loads an user API key from the database by its fingerprint
+     *
+     * @param userId - User ID
+     * @param fingerprint - API key fingerprint
+     */
+    static async loadByFingerprint(userId, fingerprint) {
+        const [apiKey] = await this.search({
+            query: {
+                bool: {
+                    filter: { term: { fingerprint } },
+                    must: { term: { userId } },
+                },
+            },
+        }, { size: 1 });
+        if (!apiKey) {
+            throw kerror.get("services", "storage", "not_found", fingerprint, {
+                message: `ApiKey with fingerprint "${fingerprint}" not found for user "${userId}".`,
+            });
+        }
+        // @ts-expect-error We fetch from the api key collection so this is safe
+        return apiKey;
+    }
+    /**
+     * Loads a user's API key from a request, identified by its `_id`, its
+     * clear-text `key` or its `fingerprint` (in that order of precedence).
      *
-     * @param {User} user
-     * @param {Object} options - refresh (null)
+     * @param userId - User ID
+     * @param request - Request carrying the `_id`, `key` or `fingerprint` argument
+     */
+    static async loadFromRequest(userId, request) {
+        const apiKeyId = request.getId({ ifMissing: "ignore" });
+        if (apiKeyId) {
+            return this.load(userId, apiKeyId);
+        }
+        if ((0, safeObject_1.has)(request.input.args, "key")) {
+            return this.loadByFingerprint(userId, (0, crypto_1.sha256)(request.getString("key")));
+        }
+        if ((0, safeObject_1.has)(request.input.args, "fingerprint")) {
+            return this.loadByFingerprint(userId, request.getString("fingerprint"));
+        }
+        throw kerror.get("api", "assert", "missing_argument", "_id, key or fingerprint");
+    }
+    /**
+     * Deletes API keys for an user
      *
-     * @returns {Promise}
+     * @param user
+     * @param options - refresh (null)
      */
     static deleteByUser(user, { refresh } = {}) {
         debug("Delete ApiKeys for user %a", user);
         return this.deleteByQuery({ term: { userId: user._id } }, { refresh });
     }
 }
-BaseModel.register(ApiKey);
+baseModel_1.default.register(ApiKey);
 module.exports = ApiKey;
 //# sourceMappingURL=apiKey.js.map

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

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

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,8 +19,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const Bluebird = require("bluebird");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const bluebird_1 = __importDefault(require("bluebird"));
 class BaseModel {
     constructor(_source = {}, _id = null) {
         this.__id = null;
@@ -35,7 +38,7 @@ class BaseModel {
     /**
      * Register a new model
      *
-     * @param {Model} ModelClass
+     * @param ModelClass
      */
     static register(ModelClass) {
         if (this !== BaseModel) {
@@ -59,11 +62,9 @@ class BaseModel {
      *  - use update if the instance already exists
      *  - use create otherwise
      *
-     * @param {Object} options - userId (null), refresh (undefined)
-     *
-     * @returns {Promise}
+     * @param options - userId (null), refresh (undefined)
      */
-    async save({ userId = null, refresh } = {}) {
+    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;
@@ -78,11 +79,9 @@ class BaseModel {
      * Delete the current instance from the database.
      *  - call the _afterDelete hook after deletion
      *
-     * @param {Object} options - refresh (undefined)
-     *
-     * @returns {Promise}
+     * @param options - refresh (undefined)
      */
-    async delete({ refresh } = {}) {
+    async delete({ refresh, } = {}) {
         if (!this.__persisted) {
             return;
         }
@@ -92,8 +91,6 @@ class BaseModel {
     }
     /**
      * Returns a plain object representing the instance
-     *
-     * @returns {Object} { _id, _source }
      */
     serialize() {
         return {
@@ -104,11 +101,9 @@ class BaseModel {
     // Protected methods =========================================================
     /**
      * Hook called in the delete method after deletion from the database
-     *
-     * @returns {Promise}
      */
     async _afterDelete() {
-        return null;
+        // Nothing to do by default; subclasses override this.
     }
     // Getter/Setter =============================================================
     get _id() {
@@ -131,9 +126,7 @@ class BaseModel {
     /**
      * Loads an instance from the database
      *
-     * @param {String} id
-     *
-     * @returns {BaseModel}
+     * @param id
      */
     static async load(id) {
         const result = await global.kuzzle.internalIndex.get(this.collection, id);
@@ -143,14 +136,12 @@ class 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}
+     * @param query - Search query (e.g. { match_all: {} })
+     * @param options - refresh (undefined)
      */
     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
+        await bluebird_1.default.map(documents, (document) => this._instantiateFromDb(document)._afterDelete(), { concurrency: 10 }); // limits the load on storage services
         if (refresh) {
             await global.kuzzle.internalIndex.refreshCollection(this.collection);
         }
@@ -158,10 +149,10 @@ class BaseModel {
     /**
      * Returns instances matching the given query
      *
-     * @param {Object} searchBody
-     * @param {Object} options - from, size, scroll
+     * @param searchBody
+     * @param options - from, size, scroll
      *
-     * @returns {Promise<BaseModel[]>} - Array of instances
+     * @returns Array of instances
      */
     static async search(searchBody, options) {
         const resp = await global.kuzzle.internalIndex.search(this.collection, searchBody, options);
@@ -170,11 +161,9 @@ class BaseModel {
     /**
      * Deletes all instances of the collection
      *
-     * @param {Object} options - refresh (undefined)
-     *
-     * @returns {Promise}
+     * @param options - refresh (undefined)
      */
-    static truncate({ refresh } = {}) {
+    static truncate({ refresh, } = {}) {
         return this.deleteByQuery({ match_all: {} }, { refresh });
     }
     // ? This looks not in use anymore ?
@@ -197,9 +186,7 @@ class BaseModel {
     /**
      * Instantiate the model from a document
      *
-     * @param {Object} document - { _id, _source }
-     *
-     * @returns {BaseModel}
+     * @param document - { _id, _source }
      */
     static _instantiateFromDb({ _id, _source }) {
         const model = new this(_source, _id); // NOSONAR

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

@@ -1,74 +1,91 @@
-export = Redis;
+import type { RedisCommander } from "ioredis";
+import IORedis, { Cluster } from "ioredis";
+import Service from "../service";
+import "../../types/Global";
+import type { InternalCacheConfiguration } from "../../types/config/internalCache/InternalCacheRedisConfiguration";
+import type { PublicCacheRedisConfiguration } from "../../types/config/publicCache/PublicCacheRedisConfiguration";
+type RedisClient = IORedis | Cluster;
+type RedisServiceConfig = InternalCacheConfiguration | PublicCacheRedisConfiguration;
+interface RedisInfo {
+    memoryPeak: string;
+    memoryUsed: string;
+    mode: string;
+    type: "redis";
+    version: string;
+}
 /**
  * @class Redis
  * @extends Service
- * @param {object} config
- * @property service
  */
-declare class Redis extends Service {
+declare class Redis extends Service<RedisServiceConfig, RedisInfo> {
     connected: boolean;
-    client: any;
-    commands: {};
-    adapterName: any;
-    pingIntervalID: NodeJS.Timeout;
-    logger: import("../../kuzzle/Logger").Logger;
+    client: RedisClient | null;
+    commands: RedisCommander;
+    adapterName: string;
+    private pingIntervalID;
+    private readonly logger;
+    /**
+     * 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(): RedisClient;
+    constructor(config: RedisServiceConfig, name: string);
+    /**
+     * Initialize the redis client, select the service associated database and
+     * flush it to make sure we start from a clean state
+     */
+    protected _initSequence(): Promise<void>;
     /**
      * Setup a ping interval to keep the connection alive
      * Every 60 seconds a ping is sent to Redis
      */
-    _setupKeepAlive(delay: any): void;
+    private _setupKeepAlive;
     /**
      * Ping Redis
      */
-    _ping(): Promise<void>;
+    private _ping;
     /**
      * Initializes the Redis commands list, and add transformers when necessary
      */
     setCommands(): void;
+    /**
+     * Return some basic information about this service
+     * @override
+     */
+    info(): Promise<RedisInfo>;
     /**
      * 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[]>;
+    searchKeys(pattern: string): 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;
+    mExecute(commands: unknown[][]): Promise<[error: Error | null, result: unknown][] | null>;
+    private _searchNodeKeys;
+    private _buildClient;
+    private _buildClusterClient;
     /**
      * 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;
+        onlyIfNew?: boolean;
+        ttl?: number;
+    }): Promise<boolean>;
     /**
      * Executes a client command
-     * @param  {string} command
-     * @param  {Array} args
-     * @return {Promise.<*>}
      */
-    exec(command: string, ...args: any[]): Promise<any>;
+    exec(command: string, ...args: unknown[]): Promise<unknown>;
 }
-import Service = require("../service");
-import Bluebird = require("bluebird");
-import IORedis = require("ioredis");
+export = Redis;