kuzzle 2.19.2 → 2.19.5

package/lib/core/auth/tokenManager.js

@@ -82,21 +82,20 @@ class TokenManager {
             if (a.idx === b.idx) {
                 return 0;
             }
-            if (a.idx && a.idx[0] === '-') {
+            if (a.idx && a.idx[0] === "-") {
                 return 1;
             }
-            if (b.idx && b.idx[0] === '-') {
+            if (b.idx && b.idx[0] === "-") {
                 return -1;
             }
             return a.idx < b.idx ? -1 : 1;
         });
     }
     async init() {
-        const anonymous = await global.kuzzle.ask('core:security:user:anonymous:get');
+        const anonymous = await global.kuzzle.ask("core:security:user:anonymous:get");
         this.anonymousUserId = anonymous._id;
-        global.kuzzle.on('connection:remove', connection => {
-            this.removeConnection(connection.id)
-                .catch(err => global.kuzzle.log.info(err));
+        global.kuzzle.on("connection:remove", (connection) => {
+            this.removeConnection(connection.id).catch((err) => global.kuzzle.log.info(err));
         });
     }
     runTimer() {
@@ -186,7 +185,7 @@ class TokenManager {
             const managedToken = this.tokens.array[searchResult];
             for (const connectionId of managedToken.connectionIds) {
                 this.tokensByConnection.delete(connectionId);
-                await global.kuzzle.ask('core:realtime:connection:remove', connectionId);
+                await global.kuzzle.ask("core:realtime:connection:remove", connectionId);
             }
             this.deleteByIndex(searchResult);
         }
@@ -217,11 +216,13 @@ class TokenManager {
     async checkTokensValidity() {
         const arr = this.tokens.array;
         // API key can never expire (-1)
-        if (arr.length > 0 && (arr[0].expiresAt > 0 && arr[0].expiresAt < Date.now())) {
+        if (arr.length > 0 &&
+            arr[0].expiresAt > 0 &&
+            arr[0].expiresAt < Date.now()) {
             const managedToken = arr[0];
             arr.shift();
             for (const connectionId of managedToken.connectionIds) {
-                await global.kuzzle.ask('core:realtime:tokenExpired:notify', connectionId);
+                await global.kuzzle.ask("core:realtime:tokenExpired:notify", connectionId);
                 this.tokensByConnection.delete(connectionId);
             }
             setImmediate(() => this.checkTokensValidity());
@@ -257,7 +258,7 @@ class TokenManager {
     add(token, connectionIds) {
         const orderedToken = Object.assign({}, token, {
             connectionIds: new Set(connectionIds),
-            idx: ManagedToken.indexFor(token)
+            idx: ManagedToken.indexFor(token),
         });
         for (const connectionId of connectionIds) {
             this.tokensByConnection.set(connectionId, orderedToken);

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

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

package/lib/core/backend/applicationManager.js

@@ -23,8 +23,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApplicationManager = void 0;
 class ApplicationManager {
     constructor(application) {
-        Reflect.defineProperty(this, '_application', {
-            value: application
+        Reflect.defineProperty(this, "_application", {
+            value: application,
         });
     }
     get _kuzzle() {

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

@@ -1,6 +1,6 @@
-import { EmbeddedSDK } from '../shared/sdk/embeddedSdk';
-import { JSONObject } from '../../../index';
-import { BackendCluster, BackendConfig, BackendController, BackendHook, BackendImport, BackendPipe, BackendPlugin, BackendStorage, BackendVault, BackendOpenApi, InternalLogger, BackendErrors } from './index';
+import { EmbeddedSDK } from "../shared/sdk/embeddedSdk";
+import { EventDefinition, JSONObject } from "../../../index";
+import { BackendCluster, BackendConfig, BackendController, BackendHook, BackendImport, BackendPipe, BackendPlugin, BackendStorage, BackendVault, BackendOpenApi, InternalLogger, BackendErrors } from "./index";
 export declare class Backend {
     private _kuzzle;
     private _name;
@@ -149,7 +149,7 @@ export declare class Backend {
      *
      * @returns {Promise<any>}
      */
-    trigger(event: string, ...payload: any[]): Promise<any>;
+    trigger<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], ...payload: TEventDefinition["args"]): Promise<TEventDefinition["args"][0]>;
     /**
      * Register a method that will be executed only once on any given environment.
      * If this method throws, the app won't start.

package/lib/core/backend/backend.js

@@ -52,21 +52,21 @@ const kuzzle_1 = __importDefault(require("../../kuzzle"));
 const embeddedSdk_1 = require("../shared/sdk/embeddedSdk");
 const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
-const assertionError = kerror.wrap('plugin', 'assert');
-const runtimeError = kerror.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap("plugin", "assert");
+const runtimeError = kerror.wrap("plugin", "runtime");
 let _app = null;
-Reflect.defineProperty(global, 'app', {
+Reflect.defineProperty(global, "app", {
     configurable: true,
     enumerable: false,
     get() {
         if (_app === null) {
-            throw new Error('App instance not found. Are you sure you have already started your application?');
+            throw new Error("App instance not found. Are you sure you have already started your application?");
         }
         return _app;
     },
     set(value) {
         if (_app !== null) {
-            throw new Error('Cannot build an App instance: another one already exists');
+            throw new Error("Cannot build an App instance: another one already exists");
         }
         _app = value;
     },
@@ -85,11 +85,11 @@ class Backend {
         this._plugins = {};
         this._import = {
             mappings: {},
-            onExistingUsers: 'skip',
+            onExistingUsers: "skip",
             profiles: {},
             roles: {},
             userMappings: {},
-            users: {}
+            users: {},
         };
         this._installationsWaitingList = [];
         /**
@@ -109,30 +109,30 @@ class Backend {
         /**
          * Requiring the PluginObject on module top level creates cyclic dependency
          */
-        Reflect.defineProperty(this, 'PluginObject', {
-            value: require('../plugin/plugin')
+        Reflect.defineProperty(this, "PluginObject", {
+            value: require("../plugin/plugin"),
         });
         if (!this.PluginObject.checkName(name)) {
-            throw assertionError.get('invalid_application_name', name);
+            throw assertionError.get("invalid_application_name", name);
         }
         this._name = name;
-        Reflect.defineProperty(this, '_kuzzle', {
-            writable: true
+        Reflect.defineProperty(this, "_kuzzle", {
+            writable: true,
         });
-        Reflect.defineProperty(this, '_sdk', {
-            writable: true
+        Reflect.defineProperty(this, "_sdk", {
+            writable: true,
         });
         /**
          * Set the "started" property in this event so developers can use runtime
          * features in pipes/hooks attached to this event.
          */
-        this._pipes['kuzzle:state:ready'] = [
+        this._pipes["kuzzle:state:ready"] = [
             async () => {
                 this.started = true;
             },
         ];
         try {
-            const info = JSON.parse(fs_1.default.readFileSync('./package.json', 'utf8'));
+            const info = JSON.parse(fs_1.default.readFileSync("./package.json", "utf8"));
             this.version = info.version;
         }
         catch (error) {
@@ -164,7 +164,7 @@ class Backend {
      */
     async start() {
         if (this.started) {
-            throw runtimeError.get('already_started', 'start');
+            throw runtimeError.get("already_started", "start");
         }
         this._kuzzle = new kuzzle_1.default(this.config.content);
         for (const plugin of this.config.content.plugins.common.include) {
@@ -174,7 +174,10 @@ class Backend {
                 name: plugin,
             });
         }
-        const application = new this.PluginObject(this._instanceProxy, { application: true, name: this.name });
+        const application = new this.PluginObject(this._instanceProxy, {
+            application: true,
+            name: this.name,
+        });
         application.version = this.version;
         application.commit = this.commit;
         application.openApi = this.openApi.definition;
@@ -200,7 +203,7 @@ class Backend {
      */
     trigger(event, ...payload) {
         if (!this.started) {
-            throw runtimeError.get('unavailable_before_start', 'trigger');
+            throw runtimeError.get("unavailable_before_start", "trigger");
         }
         return this._kuzzle.pipe(event, ...payload);
     }
@@ -215,16 +218,16 @@ class Backend {
      */
     install(id, handler, description) {
         if (this.started) {
-            throw runtimeError.get('already_started', 'install');
+            throw runtimeError.get("already_started", "install");
         }
-        if (typeof id !== 'string') {
-            throw kerror.get('validation', 'assert', 'invalid_type', 'id', 'string');
+        if (typeof id !== "string") {
+            throw kerror.get("validation", "assert", "invalid_type", "id", "string");
         }
-        if (typeof handler !== 'function') {
-            throw kerror.get('validation', 'assert', 'invalid_type', 'handler', 'function');
+        if (typeof handler !== "function") {
+            throw kerror.get("validation", "assert", "invalid_type", "handler", "function");
         }
-        if (description && typeof description !== 'string') {
-            throw kerror.get('validation', 'assert', 'invalid_type', 'id', 'string');
+        if (description && typeof description !== "string") {
+            throw kerror.get("validation", "assert", "invalid_type", "id", "string");
         }
         this._installationsWaitingList.push({ description, handler, id });
     }
@@ -239,7 +242,7 @@ class Backend {
      */
     get sdk() {
         if (!this.started) {
-            throw runtimeError.get('unavailable_before_start', 'sdk');
+            throw runtimeError.get("unavailable_before_start", "sdk");
         }
         return this._sdk;
     }
@@ -248,7 +251,7 @@ class Backend {
      */
     get nodeId() {
         if (!this.started) {
-            throw runtimeError.get('unavailable_before_start', 'nodeId');
+            throw runtimeError.get("unavailable_before_start", "nodeId");
         }
         return this._kuzzle.id;
     }
@@ -275,12 +278,12 @@ class Backend {
         if (!fs_1.default.statSync(gitDir).isDirectory()) {
             return null;
         }
-        const ref = fs_1.default.readFileSync(`${dir}/.git/HEAD`, 'utf8').split('ref: ')[1];
-        const refFile = `${dir}/.git/${ref}`.replace('\n', '');
+        const ref = fs_1.default.readFileSync(`${dir}/.git/HEAD`, "utf8").split("ref: ")[1];
+        const refFile = `${dir}/.git/${ref}`.replace("\n", "");
         if (!fs_1.default.existsSync(refFile)) {
             return null;
         }
-        return fs_1.default.readFileSync(refFile, 'utf8').replace('\n', '');
+        return fs_1.default.readFileSync(refFile, "utf8").replace("\n", "");
     }
 }
 exports.Backend = Backend;

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

@@ -1,5 +1,4 @@
-import { JSONObject } from '../../../index';
-import { EventHandler } from '../../types';
+import { EventDefinition, ClusterEventHandler } from "../../../index";
 export declare class BackendCluster {
     /**
      * Broadcasts an event to listeners across all registered Kuzzle nodes
@@ -8,34 +7,34 @@ export declare class BackendCluster {
      * @param  {JSONObject}    payload
      * @return {Promise<void>}
      */
-    broadcast(event: string, payload: JSONObject): Promise<void>;
+    broadcast<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], payload: TEventDefinition["args"][0]): Promise<void>;
     /**
      * Registers a listener to the provided event name.
      *
      * @param  {string}        event
-     * @param  {EventHandler}      listener
+     * @param  {ClusterEventHandler}      listener
      * @return {Promise<void>}       [description]
      */
-    on(event: string, listener: EventHandler): Promise<void>;
+    on<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], listener: ClusterEventHandler<TEventDefinition>): Promise<void>;
     /**
      * Registers a listener to the provided event name. This listener can be
      * invoked only once, after which it will be removed from the listeners list.
      *
      * @param  {string}        event
-     * @param  {EventHandler}      listener
+     * @param  {ClusterEventHandler}      listener
      * @return {Promise<void>}
      */
-    once(event: string, listener: EventHandler): Promise<void>;
+    once<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], listener: ClusterEventHandler<TEventDefinition>): Promise<void>;
     /**
      * Removes a listener from an event.
      * If multiple instances of the same listener are registered, only the first
      * one is removed.
      *
      * @param  {string}        event
-     * @param  {EventHandler}      listener
+     * @param  {ClusterEventHandler}      listener
      * @return {Promise<void>}
      */
-    off(event: string, listener: EventHandler): Promise<void>;
+    off<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], listener: ClusterEventHandler<TEventDefinition>): Promise<void>;
     /**
      * Removes all listeners from an event.
      *

package/lib/core/backend/backendCluster.js

@@ -30,28 +30,28 @@ class BackendCluster {
      * @return {Promise<void>}
      */
     async broadcast(event, payload) {
-        await global.kuzzle.ask('cluster:event:broadcast', event, payload);
+        await global.kuzzle.ask("cluster:event:broadcast", event, payload);
     }
     /**
      * Registers a listener to the provided event name.
      *
      * @param  {string}        event
-     * @param  {EventHandler}      listener
+     * @param  {ClusterEventHandler}      listener
      * @return {Promise<void>}       [description]
      */
     async on(event, listener) {
-        await global.kuzzle.ask('cluster:event:on', event, listener);
+        await global.kuzzle.ask("cluster:event:on", event, listener);
     }
     /**
      * Registers a listener to the provided event name. This listener can be
      * invoked only once, after which it will be removed from the listeners list.
      *
      * @param  {string}        event
-     * @param  {EventHandler}      listener
+     * @param  {ClusterEventHandler}      listener
      * @return {Promise<void>}
      */
     async once(event, listener) {
-        await global.kuzzle.ask('cluster:event:once', event, listener);
+        await global.kuzzle.ask("cluster:event:once", event, listener);
     }
     /**
      * Removes a listener from an event.
@@ -59,11 +59,11 @@ class BackendCluster {
      * one is removed.
      *
      * @param  {string}        event
-     * @param  {EventHandler}      listener
+     * @param  {ClusterEventHandler}      listener
      * @return {Promise<void>}
      */
     async off(event, listener) {
-        await global.kuzzle.ask('cluster:event:off', event, listener);
+        await global.kuzzle.ask("cluster:event:off", event, listener);
     }
     /**
      * Removes all listeners from an event.
@@ -72,7 +72,7 @@ class BackendCluster {
      * @return {Promise<void>}
      */
     async removeAllListeners(event) {
-        await global.kuzzle.ask('cluster:event:removeAllListeners', event);
+        await global.kuzzle.ask("cluster:event:removeAllListeners", event);
     }
 }
 exports.BackendCluster = BackendCluster;

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

@@ -1,5 +1,5 @@
-import { ApplicationManager, Backend } from './index';
-import { KuzzleConfiguration } from '../../types/config/KuzzleConfiguration';
+import { ApplicationManager, Backend } from "./index";
+import { KuzzleConfiguration } from "../../types/config/KuzzleConfiguration";
 export declare class BackendConfig extends ApplicationManager {
     /**
      * Configuration content.

package/lib/core/backend/backendConfig.js

@@ -51,7 +51,7 @@ const lodash_1 = __importDefault(require("lodash"));
 const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
 const index_js_1 = require("../../config/index.js");
-const runtimeError = kerror.wrap('plugin', 'runtime');
+const runtimeError = kerror.wrap("plugin", "runtime");
 class BackendConfig extends index_1.ApplicationManager {
     constructor(application) {
         super(application);
@@ -67,7 +67,7 @@ class BackendConfig extends index_1.ApplicationManager {
      */
     set(path, value) {
         if (this._application.started) {
-            throw runtimeError.get('already_started', 'config');
+            throw runtimeError.get("already_started", "config");
         }
         lodash_1.default.set(this.content, path, value);
     }
@@ -80,7 +80,7 @@ class BackendConfig extends index_1.ApplicationManager {
      */
     merge(config) {
         if (this._application.started) {
-            throw runtimeError.get('already_started', 'config');
+            throw runtimeError.get("already_started", "config");
         }
         this.content = lodash_1.default.merge(this.content, config);
     }

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

@@ -1,5 +1,5 @@
-import { ControllerDefinition, Controller } from '../../types';
-import { ApplicationManager } from './index';
+import { ControllerDefinition, Controller } from "../../types";
+import { ApplicationManager } from "./index";
 export declare class BackendController extends ApplicationManager {
     /**
      * Registers a new controller.

package/lib/core/backend/backendController.js

@@ -51,8 +51,8 @@ const inflector_1 = require("../../util/inflector");
 const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
 const plugin_1 = __importDefault(require("../plugin/plugin"));
-const assertionError = kerror.wrap('plugin', 'assert');
-const runtimeError = kerror.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap("plugin", "assert");
+const runtimeError = kerror.wrap("plugin", "runtime");
 class BackendController extends index_1.ApplicationManager {
     /**
      * Registers a new controller.
@@ -76,7 +76,7 @@ class BackendController extends index_1.ApplicationManager {
      */
     register(name, definition) {
         if (this._application.started) {
-            throw runtimeError.get('already_started', 'controller');
+            throw runtimeError.get("already_started", "controller");
         }
         plugin_1.default.checkControllerDefinition(name, definition);
         this.add(name, definition);
@@ -146,21 +146,20 @@ class BackendController extends index_1.ApplicationManager {
      */
     use(controller) {
         if (this._application.started) {
-            throw runtimeError.get('already_started', 'controller');
+            throw runtimeError.get("already_started", "controller");
         }
         if (!controller.name) {
-            controller.name = inflector_1.Inflector.kebabCase(controller.constructor.name)
-                .replace('-controller', '');
+            controller.name = inflector_1.Inflector.kebabCase(controller.constructor.name).replace("-controller", "");
         }
         plugin_1.default.checkControllerDefinition(controller.name, controller.definition);
         for (const [action, definition] of Object.entries(controller.definition.actions)) {
-            if (typeof definition.handler !== 'function') {
-                throw assertionError.get('invalid_controller_definition', controller.name, `Handler for action "${action}" is not a function.`);
+            if (typeof definition.handler !== "function") {
+                throw assertionError.get("invalid_controller_definition", controller.name, `Handler for action "${action}" is not a function.`);
             }
             // 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') {
+            if (handlerName && typeof controller[handlerName] === "function") {
                 definition.handler = definition.handler.bind(controller);
             }
         }
@@ -174,7 +173,7 @@ class BackendController extends index_1.ApplicationManager {
      */
     add(name, definition) {
         if (this._application._controllers[name]) {
-            throw assertionError.get('invalid_controller_definition', name, 'A controller with this name already exists');
+            throw assertionError.get("invalid_controller_definition", name, "A controller with this name already exists");
         }
         this._application._controllers[name] = definition;
     }

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

@@ -1,6 +1,6 @@
-import { KuzzleError } from '../../kerror/errors';
-import { ApplicationManager, Backend } from './index';
-import { CustomErrorDefinition } from '../../types';
+import { KuzzleError } from "../../kerror/errors";
+import { ApplicationManager, Backend } from "./index";
+import { CustomErrorDefinition } from "../../types";
 export declare class BackendErrors extends ApplicationManager {
     private domains;
     constructor(application: Backend);

package/lib/core/backend/backendErrors.js

@@ -82,7 +82,8 @@ class BackendErrors extends index_1.ApplicationManager {
             };
         }
         this.domains[domain].subDomains[subDomain].errors[name] = {
-            code: Object.keys(this.domains[domain].subDomains[subDomain].errors).length,
+            code: Object.keys(this.domains[domain].subDomains[subDomain].errors)
+                .length,
             ...definition,
         };
     }

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

@@ -1,5 +1,5 @@
-import { EventHandler } from '../../types';
-import { ApplicationManager } from './index';
+import { HookEventHandler, EventDefinition } from "../../types";
+import { ApplicationManager } from "./index";
 export declare class BackendHook extends ApplicationManager {
     /**
      * Registers a new hook on an event
@@ -8,5 +8,5 @@ export declare class BackendHook extends ApplicationManager {
      * @param handler - Function to execute when the event is triggered
      *
      */
-    register(event: string, handler: EventHandler): void;
+    register<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], handler: HookEventHandler<TEventDefinition>): void;
 }

package/lib/core/backend/backendHook.js

@@ -46,8 +46,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackendHook = void 0;
 const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
-const assertionError = kerror.wrap('plugin', 'assert');
-const runtimeError = kerror.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap("plugin", "assert");
+const runtimeError = kerror.wrap("plugin", "runtime");
 class BackendHook extends index_1.ApplicationManager {
     /**
      * Registers a new hook on an event
@@ -58,10 +58,10 @@ class BackendHook extends index_1.ApplicationManager {
      */
     register(event, handler) {
         if (this._application.started) {
-            throw runtimeError.get('already_started', 'hook');
+            throw runtimeError.get("already_started", "hook");
         }
-        if (typeof handler !== 'function') {
-            throw assertionError.get('invalid_hook', event);
+        if (typeof handler !== "function") {
+            throw assertionError.get("invalid_hook", event);
         }
         if (!this._application._hooks[event]) {
             this._application._hooks[event] = [];

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

@@ -1,5 +1,5 @@
-import { ApplicationManager } from './index';
-import { JSONObject } from '../../../index';
+import { ApplicationManager } from "./index";
+import { JSONObject } from "../../../index";
 export declare type DefaultMappings = {
     [index: string]: {
         [collection: string]: {
@@ -80,6 +80,6 @@ export declare class BackendImport extends ApplicationManager {
      * @param options onExistingUsers: Default to `skip`. Strategy to adopt when trying to create an already existing user.
      */
     users(users: JSONObject, options?: {
-        onExistingUsers?: 'overwrite' | 'skip';
+        onExistingUsers?: "overwrite" | "skip";
     }): void;
 }