kuzzle 2.31.0 → 2.32.0-beta.1

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;

package/lib/kuzzle/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,7 +19,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-"use strict";
-
-module.exports = require("./kuzzle");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Kuzzle = void 0;
+const kuzzle_1 = require("./kuzzle");
+Object.defineProperty(exports, "Kuzzle", { enumerable: true, get: function () { return kuzzle_1.Kuzzle; } });
+exports.default = kuzzle_1.Kuzzle;
+//# sourceMappingURL=index.js.map

package/lib/kuzzle/kuzzle.d.ts

@@ -1,28 +1,40 @@
 /// <reference types="node" />
-import KuzzleEventEmitter from "./event/kuzzleEventEmitter";
-import { InstallationConfig, ImportConfig, SupportConfig, StartOptions } from "./../types/Kuzzle";
+import { Koncorde } from "koncorde";
+import Funnel from "../api/funnel";
+import PassportWrapper from "../core/auth/passportWrapper";
+import { TokenManager } from "../core/auth/tokenManager";
+import EntryPoint from "../core/network/entryPoint";
+import Router from "../core/network/router";
+import PluginsManager from "../core/plugin/pluginsManager";
+import Validation from "../core/validation";
 import { KuzzleConfiguration } from "../types/config/KuzzleConfiguration";
+import AsyncStore from "../util/asyncStore";
+import { ImportConfig, InstallationConfig, StartOptions, SupportConfig } from "./../types/Kuzzle";
+import KuzzleEventEmitter from "./event/KuzzleEventEmitter";
+import InternalIndexHandler from "./internalIndexHandler";
+import Logger from "./log";
+import vault from "./vault";
 export declare const BACKEND_IMPORT_KEY = "backend:init:import";
 declare class Kuzzle extends KuzzleEventEmitter {
-    private config;
+    config: KuzzleConfiguration;
     private _state;
-    private log;
+    log: Logger;
     private rootPath;
     /**
      * Internal index bootstrapper and accessor
      */
-    private internalIndex;
-    private pluginsManager;
-    private tokenManager;
-    private passport;
+    internalIndex: InternalIndexHandler;
+    pluginsManager: PluginsManager;
+    tokenManager: TokenManager;
+    passport: PassportWrapper;
     /**
      * The funnel dispatches messages to API controllers
      */
-    private funnel;
+    funnel: Funnel;
     /**
      * The router listens to client requests and pass them to the funnel
      */
-    private router;
+    router: Router;
     /**
      * Statistics core component
      */
@@ -30,11 +42,11 @@ declare class Kuzzle extends KuzzleEventEmitter {
     /**
      * Network entry point
      */
-    private entryPoint;
+    entryPoint: EntryPoint;
     /**
      * Validation core component
      */
-    private validation;
+    validation: Validation;
     /**
      * Dump generator
      */
@@ -42,11 +54,11 @@ declare class Kuzzle extends KuzzleEventEmitter {
     /**
      * Vault component (will be initialized after bootstrap)
      */
-    private vault;
+    vault: vault;
     /**
      * AsyncLocalStorage wrapper
      */
-    private asyncStore;
+    asyncStore: AsyncStore;
     /**
      * Kuzzle internal debugger
      */
@@ -60,8 +72,8 @@ declare class Kuzzle extends KuzzleEventEmitter {
      * List of differents imports types and their associated method
      */
     private importTypes;
-    private koncorde;
-    private secret;
+    koncorde: Koncorde;
+    secret: string;
     /**
      * Node unique ID amongst other cluster nodes
      */
@@ -96,9 +108,9 @@ declare class Kuzzle extends KuzzleEventEmitter {
      * @returns {Promise<void>}
      */
     install(installations: InstallationConfig[]): Promise<void>;
-    ask(...args: any[]): Promise<any>;
-    emit(...args: any[]): Promise<any>;
-    pipe(...args: any[]): Promise<any>;
+    ask(event: string, ...args: [payload?: any, ...rest: any]): Promise<any>;
+    emit(event: string, ...args: any[]): boolean;
+    pipe(event: string, ...args: any[]): Promise<any>;
     private importUserMappings;
     private importMappings;
     private importFixtures;
@@ -132,3 +144,4 @@ declare class Kuzzle extends KuzzleEventEmitter {
     dumpAndExit(suffix: any): Promise<void>;
 }
 export { Kuzzle };
+export default Kuzzle;

package/lib/kuzzle/kuzzle.js

@@ -48,39 +48,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Kuzzle = exports.BACKEND_IMPORT_KEY = void 0;
 const path_1 = __importDefault(require("path"));
-const murmurhash_native_1 = require("murmurhash-native");
+const bluebird_1 = __importDefault(require("bluebird"));
 const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
 const koncorde_1 = require("koncorde");
-const bluebird_1 = __importDefault(require("bluebird"));
-const node_segfault_handler_1 = __importDefault(require("node-segfault-handler"));
 const lodash_1 = __importDefault(require("lodash"));
-const kuzzleStateEnum_1 = __importDefault(require("./kuzzleStateEnum"));
-const kuzzleEventEmitter_1 = __importDefault(require("./event/kuzzleEventEmitter"));
-const entryPoint_1 = __importDefault(require("../core/network/entryPoint"));
+const murmurhash_native_1 = require("murmurhash-native");
+const node_segfault_handler_1 = __importDefault(require("node-segfault-handler"));
+const package_json_1 = require("../../package.json");
 const funnel_1 = __importDefault(require("../api/funnel"));
+const openapi_1 = require("../api/openapi");
+const cluster_1 = __importDefault(require("../cluster"));
 const passportWrapper_1 = __importDefault(require("../core/auth/passportWrapper"));
-const pluginsManager_1 = __importDefault(require("../core/plugin/pluginsManager"));
+const tokenManager_1 = require("../core/auth/tokenManager");
+const cacheEngine_1 = __importDefault(require("../core/cache/cacheEngine"));
+const kuzzleDebugger_1 = require("../core/debug/kuzzleDebugger");
+const entryPoint_1 = __importDefault(require("../core/network/entryPoint"));
 const router_1 = __importDefault(require("../core/network/router"));
+const pluginsManager_1 = __importDefault(require("../core/plugin/pluginsManager"));
+const realtime_1 = __importDefault(require("../core/realtime"));
+const security_1 = __importDefault(require("../core/security"));
 const statistics_1 = __importDefault(require("../core/statistics"));
-const tokenManager_1 = require("../core/auth/tokenManager");
+const storageEngine_1 = __importDefault(require("../core/storage/storageEngine"));
 const validation_1 = __importDefault(require("../core/validation"));
-const log_1 = __importDefault(require("./log"));
-const vault_1 = __importDefault(require("./vault"));
-const dumpGenerator_1 = __importDefault(require("./dumpGenerator"));
+const kerror = __importStar(require("../kerror"));
 const asyncStore_1 = __importDefault(require("../util/asyncStore"));
+const crypto_1 = require("../util/crypto");
 const mutex_1 = require("../util/mutex");
-const kerror = __importStar(require("../kerror"));
-const internalIndexHandler_1 = __importDefault(require("./internalIndexHandler"));
-const cacheEngine_1 = __importDefault(require("../core/cache/cacheEngine"));
-const storageEngine_1 = __importDefault(require("../core/storage/storageEngine"));
-const security_1 = __importDefault(require("../core/security"));
-const realtime_1 = __importDefault(require("../core/realtime"));
-const cluster_1 = __importDefault(require("../cluster"));
-const package_json_1 = require("../../package.json");
 const name_generator_1 = require("../util/name-generator");
-const openapi_1 = require("../api/openapi");
-const crypto_1 = require("../util/crypto");
-const kuzzleDebugger_1 = require("../core/debug/kuzzleDebugger");
+const dumpGenerator_1 = __importDefault(require("./dumpGenerator"));
+const KuzzleEventEmitter_1 = __importDefault(require("./event/KuzzleEventEmitter"));
+const internalIndexHandler_1 = __importDefault(require("./internalIndexHandler"));
+const kuzzleStateEnum_1 = __importDefault(require("./kuzzleStateEnum"));
+const log_1 = __importDefault(require("./log"));
+const vault_1 = __importDefault(require("./vault"));
 exports.BACKEND_IMPORT_KEY = "backend:init:import";
 let _kuzzle = null;
 Reflect.defineProperty(global, "kuzzle", {
@@ -99,7 +99,7 @@ Reflect.defineProperty(global, "kuzzle", {
         _kuzzle = value;
     },
 });
-class Kuzzle extends kuzzleEventEmitter_1.default {
+class Kuzzle extends KuzzleEventEmitter_1.default {
     constructor(config) {
         super(config.plugins.common.maxConcurrentPipes, config.plugins.common.pipesBufferSize);
         this._state = kuzzleStateEnum_1.default.STARTING;
@@ -240,7 +240,7 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
      * @returns {Promise<void>}
      */
     async install(installations) {
-        if (!installations || !installations.length) {
+        if (!installations?.length) {
             return;
         }
         const mutex = new mutex_1.Mutex("backend:installations");
@@ -269,16 +269,16 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
         }
     }
     // For testing purpose
-    async ask(...args) {
-        return super.ask(...args);
+    async ask(event, ...args) {
+        return super.ask(event, ...args);
     }
     // For testing purpose
-    async emit(...args) {
-        return super.emit(...args);
+    emit(event, ...args) {
+        return super.emit(event, ...args);
     }
     // For testing purpose
-    async pipe(...args) {
-        return super.pipe(...args);
+    async pipe(event, ...args) {
+        return super.pipe(event, ...args);
     }
     async importUserMappings(config, status) {
         if (!status.firstCall) {
@@ -584,5 +584,5 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
     }
 }
 exports.Kuzzle = Kuzzle;
-module.exports = Kuzzle;
+exports.default = Kuzzle;
 //# sourceMappingURL=kuzzle.js.map