kuzzle 2.31.0 → 2.32.0-elasticsearch-8.1

package/lib/api/controllers/authController.d.ts

@@ -1,3 +1,4 @@
+import Bluebird from "bluebird";
 import { KuzzleRequest } from "../request";
 import { NativeController } from "./baseController";
 export declare class AuthController extends NativeController {
@@ -78,7 +79,7 @@ export declare class AuthController extends NativeController {
      * @param {KuzzleRequest} request
      * @returns {Promise<Object>}
      */
-    getCurrentUser(request: any): any;
+    getCurrentUser(request: any): Bluebird<any>;
     /**
      * Returns the rights of the user identified by the given jwt token
      *
@@ -115,7 +116,7 @@ export declare class AuthController extends NativeController {
      *
      * @returns {Promise.<string[]>}
      */
-    getStrategies(): any;
+    getStrategies(): Bluebird<any>;
     /**
      * @param {KuzzleRequest} request
      * @returns {Promise.<Object>}

package/lib/api/funnel.js

@@ -754,7 +754,8 @@ class Funnel {
   async executePluginRequest(request) {
     try {
       if (request.input.triggerEvents) {
-        return await this.processRequest(request);
+        const response = await this.processRequest(request);
+        return { ...response.result };
       }
       return await doAction(this.getController(request), request);
     } catch (e) {

package/lib/config/default.config.js

@@ -275,6 +275,7 @@ const defaultConfig = {
             bootstrapLockTimeout: 60000,
         },
         storageEngine: {
+            majorVersion: "7",
             aliases: ["storageEngine"],
             backend: "elasticsearch",
             client: {

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

@@ -1,19 +1,17 @@
-import { Client } from "@elastic/elasticsearch";
-import { ApplicationManager, Backend } from "./index";
+import { ApplicationManager } from "./index";
 export declare class BackendStorage extends ApplicationManager {
     private _client;
     private _Client;
-    constructor(application: Backend);
     /**
      * Storage client constructor.
      * (Currently Elasticsearch)
      *
      * @param clientConfig Overload configuration for the underlaying storage client
      */
-    get StorageClient(): new (clientConfig?: any) => Client;
+    get StorageClient(): new (clientConfig?: any) => any;
     /**
      * Access to the underlaying storage engine client.
      * (Currently Elasticsearch)
      */
-    get storageClient(): Client;
+    get storageClient(): any;
 }

package/lib/core/backend/backendStorage.js

@@ -19,16 +19,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackendStorage = void 0;
-const elasticsearch_1 = __importDefault(require("../../service/storage/elasticsearch"));
+const Elasticsearch_1 = require("../../service/storage/Elasticsearch");
 const index_1 = require("./index");
 class BackendStorage extends index_1.ApplicationManager {
-    constructor(application) {
-        super(application);
+    constructor() {
+        super(...arguments);
         this._client = null;
         this._Client = null;
     }
@@ -39,13 +36,13 @@ class BackendStorage extends index_1.ApplicationManager {
      * @param clientConfig Overload configuration for the underlaying storage client
      */
     get StorageClient() {
+        const kuzzle = this._kuzzle;
         if (!this._Client) {
-            const kuzzle = this._kuzzle;
             this._Client = function ESClient(clientConfig = {}) {
-                return elasticsearch_1.default.buildClient({
+                return Elasticsearch_1.Elasticsearch.buildClient({
                     ...kuzzle.config.services.storageEngine.client,
                     ...clientConfig,
-                });
+                }, kuzzle.config.services.storageEngine.majorVersion);
             };
         }
         return this._Client;
@@ -55,8 +52,9 @@ class BackendStorage extends index_1.ApplicationManager {
      * (Currently Elasticsearch)
      */
     get storageClient() {
+        const kuzzle = this._kuzzle;
         if (!this._client) {
-            this._client = elasticsearch_1.default.buildClient(this._kuzzle.config.services.storageEngine.client);
+            this._client = Elasticsearch_1.Elasticsearch.buildClient(kuzzle.config.services.storageEngine.client, kuzzle.config.services.storageEngine.majorVersion);
         }
         return this._client;
     }

package/lib/core/plugin/pluginContext.d.ts

@@ -1,6 +1,5 @@
-import { Client } from "@elastic/elasticsearch";
-import { JSONObject } from "kuzzle-sdk";
 import { Koncorde } from "../shared/KoncordeWrapper";
+import { JSONObject } from "kuzzle-sdk";
 import { KuzzleRequest, RequestContext, RequestInput } from "../../../index";
 import { Mutex } from "../../util/mutex";
 import { BackendCluster } from "../backend";
@@ -122,7 +121,7 @@ export declare class PluginContext {
         /**
          * Constructor for Elasticsearch SDK Client
          */
-        ESClient: typeof Client;
+        ESClient: new () => any;
     };
     /**
      * @deprecated import directly: `import { BadRequestError, ... } from 'kuzzle'`

package/lib/core/plugin/pluginContext.js

@@ -52,7 +52,7 @@ const KoncordeWrapper_1 = require("../shared/KoncordeWrapper");
 const index_1 = require("../../../index");
 const kerror = __importStar(require("../../kerror"));
 const errors_1 = require("../../kerror/errors");
-const elasticsearch_1 = __importDefault(require("../../service/storage/elasticsearch"));
+const Elasticsearch_1 = require("../../service/storage/Elasticsearch");
 const mutex_1 = require("../../util/mutex");
 const promback_1 = __importDefault(require("../../util/promback"));
 const safeObject_1 = require("../../util/safeObject");
@@ -111,9 +111,8 @@ class PluginContext {
                 update: (...args) => pluginRepository.update(...args),
             };
         }
-        // eslint-disable-next-line no-inner-declarations
         function PluginContextESClient() {
-            return elasticsearch_1.default.buildClient(global.kuzzle.config.services.storageEngine.client);
+            return Elasticsearch_1.Elasticsearch.buildClient(global.kuzzle.config.services.storageEngine.client);
         }
         this.constructors = {
             BaseValidationType: require("../validation/baseType"),
@@ -252,7 +251,10 @@ function instantiateRequest(request, data, options = {}) {
             target.input.jwt = _request.input.jwt;
         }
         if (_data) {
-            target.input.volatile = Object.assign({}, _request.input.volatile, _data.volatile);
+            target.input.volatile = {
+                ..._request.input.volatile,
+                ..._data.volatile,
+            };
         }
         else {
             target.input.volatile = _request.input.volatile;

package/lib/core/security/tokenRepository.d.ts

@@ -69,5 +69,5 @@ export declare class TokenRepository extends ObjectRepository<Token> {
      *
      * So we need to override the TTL auto-refresh function to disable it
      */
-    refreshCacheTTL(): void;
+    refreshCacheTTL(): Promise<void>;
 }

package/lib/core/security/tokenRepository.js

@@ -374,7 +374,7 @@ class TokenRepository extends ObjectRepository_1.ObjectRepository {
      *
      * So we need to override the TTL auto-refresh function to disable it
      */
-    refreshCacheTTL() {
+    async refreshCacheTTL() {
         // This comment is here to please Sonarqube. It requires a comment
         // explaining why a function is empty, but there is no sense
         // duplicating what has been just said in the JSDoc.

package/lib/core/shared/ObjectRepository.d.ts

@@ -117,7 +117,7 @@ export declare class ObjectRepository<TObject extends {
     refreshCacheTTL(object: JSONObject, options?: {
         key?: string;
         ttl?: number;
-    }): any;
+    }): Promise<any>;
     /**
      * @param object
      * @param options.key - if provided, stores the object to the given key instead of the default one (<collection>/<id>)

package/lib/core/storage/clientAdapter.js

@@ -21,7 +21,7 @@
 
 "use strict";
 
-const Elasticsearch = require("../../service/storage/elasticsearch");
+const { Elasticsearch } = require("../../service/storage/Elasticsearch");
 const { IndexCache } = require("./indexCache");
 const { isPlainObject } = require("../../util/safeObject");
 const kerror = require("../../kerror");
@@ -38,16 +38,17 @@ class ClientAdapter {
    * @param {storeScopeEnum} scope
    */
   constructor(scope) {
-    this.client = new Elasticsearch(
+    this.es = new Elasticsearch(
       global.kuzzle.config.services.storageEngine,
       scope,
     );
+    this.client = this.es.client;
     this.scope = scope;
     this.cache = new IndexCache();
   }
 
   async init() {
-    await this.client.init();
+    await this.es.init();
     await this.populateCache();
 
     this.registerCollectionEvents();
@@ -202,6 +203,7 @@ class ClientAdapter {
      * @return {Promise}
      * @throws
      */
+
     global.kuzzle.onAsk(
       `core:storage:${this.scope}:collection:create`,
       (index, collection, opts, creationOptions) =>
@@ -454,7 +456,7 @@ class ClientAdapter {
      * @param {string} collection
      * @param {Object} query
      * @param {Object} [opts] -- see Elasticsearch "deleteByQuery" options
-     * @returns {Promise.<{ documents, total, deleted, failures: [ _shardId, reason ] }>}
+     * @returns {Promise.<{ documents, total, deleted, failures: [ id, reason ] }>}
      */
     global.kuzzle.onAsk(
       `core:storage:${this.scope}:document:deleteByQuery`,

package/lib/core/storage/storageEngine.js

@@ -21,8 +21,6 @@
 
 "use strict";
 
-const Bluebird = require("bluebird");
-
 const kerror = require("../../kerror").wrap("services", "storage");
 const ClientAdapter = require("./clientAdapter");
 const { storeScopeEnum } = require("./storeScopeEnum");
@@ -42,11 +40,12 @@ class StorageEngine {
    * @returns {Promise}
    */
   async init() {
-    await Bluebird.all([this.public.init(), this.private.init()]);
+    await Promise.all([this.public.init(), this.private.init()]);
 
-    const privateIndexes = await this.private.cache.listIndexes();
+    const privateIndexes = this.private.cache.listIndexes();
+    const publicIndexes = this.public.cache.listIndexes();
 
-    for (const publicIndex of await this.public.cache.listIndexes()) {
+    for (const publicIndex of publicIndexes) {
       if (privateIndexes.includes(publicIndex)) {
         throw kerror.get("index_already_exists", "public", publicIndex);
       }

package/lib/kuzzle/event/KuzzleEventEmitter.d.ts

@@ -0,0 +1,70 @@
+import EventEmitter from "eventemitter3";
+import { AskEventDefinition, AskEventHandler, CallEventHandler, EventDefinition, HookEventHandler, PipeEventHandler } from "../../types/EventHandler";
+declare class KuzzleEventEmitter extends EventEmitter {
+    private coreAnswerers;
+    private coreSyncedAnswerers;
+    private corePipes;
+    private pipeRunner;
+    private pluginPipes;
+    private pluginPipeDefinitions;
+    private superEmit;
+    constructor(maxConcurrentPipes: number, pipesBufferSize: number);
+    /**
+     * Registers a core method on a pipe
+     * Note: core methods cannot listen to wildcarded events, only exact matching
+     * works here.
+     */
+    onPipe<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], fn: PipeEventHandler<TEventDefinition>): void;
+    /**
+     * Registers a core 'ask' event answerer
+     * There can only be 0 or 1 answerer per ask event.
+     */
+    onAsk<TAskEventDefinition extends AskEventDefinition = AskEventDefinition>(event: TAskEventDefinition["name"], fn: AskEventHandler<TAskEventDefinition>): void;
+    /**
+     * Registers a core 'callback' answerer
+     * There can only be 0 or 1 answerer per callback event.
+     */
+    onCall<TAskEventDefinition extends AskEventDefinition = AskEventDefinition>(event: TAskEventDefinition["name"], fn: CallEventHandler<TAskEventDefinition>): void;
+    /**
+     * Emits an event and all its wildcarded versions
+     *
+     * @warning Critical section of code
+     */
+    emit(event: string | symbol, ...args: any[]): boolean;
+    /**
+     * Emits a pipe event, which triggers the following, in that order:
+     * 1. Plugin pipes are invoked one after another (waterfall). Each plugin must
+     *    resolve the pipe (with a callback or a promise) with a similar payload
+     *    than the one received
+     * 2. Core pipes are invoked in parallel. They are awaited for (promises-only)
+     *    but their responses are neither evaluated nor used
+     * 3. Hooks are invoked in parallel. They are not awaited.
+     *
+     * Accepts a callback argument (to be used by pipes invoked before the funnel
+     * overload-protection mechanism). If a callback is provided, this method
+     * doesn't return a promise.
+     *
+     * @warning Critical section of code
+     */
+    pipe<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], ...payload: TEventDefinition["args"]): Promise<TEventDefinition["args"][0]> | null;
+    /**
+     * Emits an "ask" event to get information about the provided payload
+     */
+    ask<TAskEventDefinition extends AskEventDefinition = AskEventDefinition>(event: TAskEventDefinition["name"], ...args: [payload?: TAskEventDefinition["payload"], ...rest: any]): Promise<TAskEventDefinition["result"]>;
+    /**
+     * Calls a callback to get information about the provided payload
+     */
+    call<TAskEventDefinition extends AskEventDefinition = AskEventDefinition>(event: TAskEventDefinition["name"], ...args: [payload?: TAskEventDefinition["payload"], ...rest: any]): TAskEventDefinition["result"];
+    /**
+     * Registers a plugin hook.
+     * Catch any error in the handler and emit the hook:onError event.
+     */
+    registerPluginHook<TEventDefinition extends EventDefinition = EventDefinition>(pluginName: string, event: TEventDefinition["name"], fn: HookEventHandler<TEventDefinition>): void;
+    registerPluginPipe<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], handler: PipeEventHandler<TEventDefinition>): string;
+    unregisterPluginPipe(pipeId: string): void;
+    /**
+     * Checks if an ask event has an answerer
+     */
+    hasAskAnswerer(event: string): boolean;
+}
+export default KuzzleEventEmitter;

package/lib/kuzzle/event/KuzzleEventEmitter.js

@@ -0,0 +1,328 @@
+"use strict";
+/*
+ * 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.
+ */
+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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Most of the functions exposed in this file should be viewed as
+// critical section of code.
+const assert_1 = __importDefault(require("assert"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+const uuid_1 = require("uuid");
+const debug_1 = __importDefault(require("../../util/debug"));
+const kerror = __importStar(require("../../kerror"));
+const memoize_1 = __importDefault(require("../../util/memoize"));
+const promback_1 = __importDefault(require("../../util/promback"));
+const pipeRunner_1 = __importDefault(require("./pipeRunner"));
+const debug = (0, debug_1.default)("kuzzle:events");
+class PluginPipeDefinition {
+    constructor(event, handler, pipeId = null) {
+        this.event = event;
+        this.handler = handler;
+        this.pipeId = pipeId || (0, uuid_1.v4)();
+    }
+}
+class KuzzleEventEmitter extends eventemitter3_1.default {
+    constructor(maxConcurrentPipes, pipesBufferSize) {
+        super();
+        this.superEmit = super.emit;
+        this.pipeRunner = new pipeRunner_1.default(maxConcurrentPipes, pipesBufferSize);
+        /**
+         * Map of plugin pipe handler functions by event
+         */
+        this.pluginPipes = new Map();
+        /**
+         * Map of plugin pipe definitions by pipeId
+         */
+        this.pluginPipeDefinitions = new Map();
+        this.corePipes = new Map();
+        this.coreAnswerers = new Map();
+        this.coreSyncedAnswerers = new Map();
+    }
+    /**
+     * Registers a core method on a pipe
+     * Note: core methods cannot listen to wildcarded events, only exact matching
+     * works here.
+     */
+    onPipe(event, fn) {
+        (0, assert_1.default)(typeof fn === "function", `Cannot listen to pipe event ${event}: "${fn}" is not a function`);
+        if (!this.corePipes.has(event)) {
+            this.corePipes.set(event, []);
+        }
+        this.corePipes.get(event).push(fn);
+    }
+    /**
+     * Registers a core 'ask' event answerer
+     * There can only be 0 or 1 answerer per ask event.
+     */
+    onAsk(event, fn) {
+        (0, assert_1.default)(typeof fn === "function", `Cannot listen to ask event "${event}": "${fn}" is not a function`);
+        (0, assert_1.default)(!this.coreAnswerers.has(event), `Cannot add a listener to the ask event "${event}": event has already an answerer`);
+        this.coreAnswerers.set(event, fn);
+    }
+    /**
+     * Registers a core 'callback' answerer
+     * There can only be 0 or 1 answerer per callback event.
+     */
+    onCall(event, fn) {
+        (0, assert_1.default)(typeof fn === "function", `Cannot register callback for event "${event}": "${fn}" is not a function`);
+        (0, assert_1.default)(!this.coreSyncedAnswerers.has(event), `Cannot register callback for event "${event}": a callback has already been registered`);
+        this.coreSyncedAnswerers.set(event, fn);
+    }
+    /**
+     * Emits an event and all its wildcarded versions
+     *
+     * @warning Critical section of code
+     */
+    emit(event, ...args) {
+        const events = getWildcardEvents(event);
+        debug('Triggering event "%s" with data: %o', event, args);
+        if (events.length === 0) {
+            debug('No listeners for event "%s"', event);
+            return false;
+        }
+        for (const element of events) {
+            super.emit(element, ...args);
+        }
+        return true;
+    }
+    /**
+     * Emits a pipe event, which triggers the following, in that order:
+     * 1. Plugin pipes are invoked one after another (waterfall). Each plugin must
+     *    resolve the pipe (with a callback or a promise) with a similar payload
+     *    than the one received
+     * 2. Core pipes are invoked in parallel. They are awaited for (promises-only)
+     *    but their responses are neither evaluated nor used
+     * 3. Hooks are invoked in parallel. They are not awaited.
+     *
+     * Accepts a callback argument (to be used by pipes invoked before the funnel
+     * overload-protection mechanism). If a callback is provided, this method
+     * doesn't return a promise.
+     *
+     * @warning Critical section of code
+     */
+    pipe(event, ...payload) {
+        debug('Triggering pipe "%s" with payload: %o', event, payload);
+        let callback = null;
+        // safe: a pipe's payload can never contain functions
+        if (payload.length > 0 &&
+            typeof payload[payload.length - 1] === "function") {
+            callback = payload.pop();
+        }
+        const events = getWildcardEvents(event);
+        const funcs = [];
+        for (const element of events) {
+            const targets = this.pluginPipes.get(element);
+            if (targets) {
+                for (const t of targets) {
+                    funcs.push(t);
+                }
+            }
+        }
+        // Create a context for the emitPluginPipe callback
+        const promback = new promback_1.default(callback);
+        const callbackContext = {
+            events,
+            instance: this,
+            promback,
+            targetEvent: event,
+        };
+        if (funcs.length === 0) {
+            pipeCallback.call(callbackContext, null, ...payload);
+        }
+        else {
+            this.pipeRunner.run(funcs, payload, pipeCallback, callbackContext);
+        }
+        return promback.deferred;
+    }
+    /**
+     * Emits an "ask" event to get information about the provided payload
+     */
+    async ask(event, ...args) {
+        debug('Triggering ask "%s" with payload: %o', event, args);
+        const fn = this.coreAnswerers.get(event);
+        if (!fn) {
+            throw kerror.get("core", "fatal", "assertion_failed", `the requested ask event '${event}' doesn't have an answerer`);
+        }
+        const response = await fn(...args);
+        for (const ev of getWildcardEvents(event)) {
+            super.emit(ev, {
+                args,
+                response,
+            });
+        }
+        return response;
+    }
+    /**
+     * Calls a callback to get information about the provided payload
+     */
+    call(event, ...args) {
+        debug('Triggering callback "%s" with payload: %o', event, args);
+        const fn = this.coreSyncedAnswerers.get(event);
+        if (!fn) {
+            throw kerror.get("core", "fatal", "assertion_failed", `the requested callback event '${event}' doesn't have an answerer`);
+        }
+        const response = fn(...args);
+        for (const ev of getWildcardEvents(event)) {
+            super.emit(ev, {
+                args,
+                response,
+            });
+        }
+        return response;
+    }
+    /**
+     * Registers a plugin hook.
+     * Catch any error in the handler and emit the hook:onError event.
+     */
+    registerPluginHook(pluginName, event, fn) {
+        this.on(event, (...args) => {
+            try {
+                const ret = fn(...args, event);
+                if (typeof ret === "object" && typeof ret.catch === "function") {
+                    ret.catch((error) => {
+                        if (event !== "hook:onError") {
+                            this.emit("hook:onError", { error, event, pluginName });
+                        }
+                        else {
+                            this.emit("plugin:hook:loop-error", { error, pluginName });
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                if (event !== "hook:onError") {
+                    this.emit("hook:onError", { error, event, pluginName });
+                }
+                else {
+                    this.emit("plugin:hook:loop-error", { error, pluginName });
+                }
+            }
+        });
+    }
+    registerPluginPipe(event, handler) {
+        if (!this.pluginPipes.has(event)) {
+            this.pluginPipes.set(event, []);
+        }
+        this.pluginPipes.get(event).push(handler);
+        const definition = new PluginPipeDefinition(event, handler);
+        this.pluginPipeDefinitions.set(definition.pipeId, definition);
+        return definition.pipeId;
+    }
+    unregisterPluginPipe(pipeId) {
+        const definition = this.pluginPipeDefinitions.get(pipeId);
+        if (!definition) {
+            throw kerror.get("plugin", "runtime", "unknown_pipe", pipeId);
+        }
+        const handlers = this.pluginPipes.get(definition.event);
+        handlers.splice(handlers.indexOf(definition.handler), 1);
+        if (handlers.length > 0) {
+            this.pluginPipes.set(definition.event, handlers);
+        }
+        else {
+            this.pluginPipes.delete(definition.event);
+        }
+        this.pluginPipeDefinitions.delete(pipeId);
+    }
+    /**
+     * Checks if an ask event has an answerer
+     */
+    hasAskAnswerer(event) {
+        return this.coreAnswerers.has(event);
+    }
+}
+/**
+ * We declare the callback used by Kuzzle.pipe one time instead
+ * of redeclaring a closure each time we want to run the pipes.
+ *
+ * The context of this callback must be bound to this following object:
+ * { instance: (kuzzle instance), promback, events }
+ *
+ * @warning Critical section of code
+ */
+async function pipeCallback(error, ...updated) {
+    /* eslint-disable no-invalid-this */
+    if (error) {
+        this.promback.reject(error);
+        return;
+    }
+    const corePipes = this.instance.corePipes.get(this.targetEvent);
+    if (corePipes) {
+        await bluebird_1.default.map(corePipes, (fn) => fn(...updated));
+    }
+    for (const element of this.events) {
+        this.instance.superEmit(element, ...updated);
+    }
+    this.promback.resolve(updated[0]);
+    /* eslint-enable no-invalid-this */
+}
+/**
+ * For a specific event, returns the event and all its wildcarded versions
+ * @example
+ *  getWildcardEvents('data:create') // return ['data:create', 'data:*']
+ *  getWildcardEvents('data:beforeCreate') // return ['data:beforeCreate',
+ *                                         //         'data:*', 'data:before*']
+ *
+ * @warning Critical section of code
+ */
+const getWildcardEvents = (0, memoize_1.default)((event) => {
+    const events = [event];
+    const delimIndex = event.lastIndexOf(":");
+    if (delimIndex === -1) {
+        return events;
+    }
+    const scope = event.slice(0, delimIndex);
+    const name = event.slice(delimIndex + 1);
+    for (const prefix of ["before", "after"]) {
+        if (name.startsWith(prefix)) {
+            events.push(`${scope}:${prefix}*`);
+        }
+    }
+    events.push(`${scope}:*`);
+    return events;
+});
+exports.default = KuzzleEventEmitter;
+//# sourceMappingURL=KuzzleEventEmitter.js.map

package/lib/kuzzle/index.d.ts

@@ -0,0 +1,3 @@
+import { Kuzzle } from "./kuzzle";
+export { Kuzzle };
+export default Kuzzle;