kuzzle 2.20.3 → 2.21.0

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

@@ -4,23 +4,10 @@ import { NativeController } from "./baseController";
  * @class DebugController
  */
 export declare class DebugController extends NativeController {
-    private inspector;
-    private debuggerStatus;
-    /**
-     * Map<eventName, Set<connectionId>>
-     */
-    private events;
-    /**
-     * Map of functions from the DebugModules
-     */
-    private kuzzlePostMethods;
+    constructor();
     /**
-     * List of DebugModule for DebugController
-     * Used to add new methods and events to the protocol
+     * Return the node version of the current Kuzzle instance
      */
-    private modules;
-    constructor();
-    init(): Promise<void>;
     nodeVersion(): Promise<string>;
     /**
      * Connect the debugger
@@ -44,16 +31,4 @@ export declare class DebugController extends NativeController {
      * Remove the websocket connection from the events' listeners
      */
     removeListener(request: KuzzleRequest): Promise<void>;
-    /**
-     * Execute a method using the Chrome Debug Protocol
-     * @param method Chrome Debug Protocol method to execute
-     * @param params
-     * @returns
-     */
-    private inspectorPost;
-    /**
-     * Sends a direct notification to a websocket connection without having to listen to a specific room
-     */
-    private notifyConnection;
-    private notifyGlobalListeners;
 }

package/lib/api/controllers/debugController.js

@@ -42,16 +42,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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 });
 exports.DebugController = void 0;
 const baseController_1 = require("./baseController");
-const inspector_1 = __importDefault(require("inspector"));
 const kerror = __importStar(require("../../kerror"));
-const get_1 = __importDefault(require("lodash/get"));
-const DEBUGGER_EVENT = "kuzzle-debugger-event";
 /**
  * @class DebugController
  */
@@ -65,53 +59,10 @@ class DebugController extends baseController_1.NativeController {
             "addListener",
             "removeListener",
         ]);
-        this.debuggerStatus = false;
-        /**
-         * Map<eventName, Set<connectionId>>
-         */
-        this.events = new Map();
-        /**
-         * Map of functions from the DebugModules
-         */
-        this.kuzzlePostMethods = new Map();
-        /**
-         * List of DebugModule for DebugController
-         * Used to add new methods and events to the protocol
-         */
-        this.modules = [];
-    }
-    async init() {
-        super.init();
-        this.inspector = new inspector_1.default.Session();
-        // Remove connection id from the list of listeners for each event
-        global.kuzzle.on("connection:remove", (connectionId) => {
-            if (!this.debuggerStatus) {
-                return;
-            }
-            for (const listener of this.events.values()) {
-                listener.delete(connectionId);
-            }
-        });
-        this.inspector.on("inspectorNotification", async (payload) => {
-            if (!this.debuggerStatus) {
-                return;
-            }
-            await this.notifyGlobalListeners(payload.method, payload);
-            const listeners = this.events.get(payload.method);
-            if (!listeners) {
-                return;
-            }
-            const promises = [];
-            for (const connectionId of listeners) {
-                promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
-                    event: payload.method,
-                    result: payload,
-                }));
-            }
-            // No need to catch, notify is already try-catched
-            await Promise.all(promises);
-        });
     }
+    /**
+     * Return the node version of the current Kuzzle instance
+     */
     async nodeVersion() {
         return process.version;
     }
@@ -119,82 +70,22 @@ class DebugController extends baseController_1.NativeController {
      * Connect the debugger
      */
     async enable() {
-        if (this.debuggerStatus) {
-            return;
-        }
-        this.inspector.connect();
-        this.debuggerStatus = true;
-        for (const module of this.modules) {
-            await module.init(this.inspector);
-            for (const methodName of module.methods) {
-                if (!module[methodName]) {
-                    throw new Error(`Missing implementation of method "${methodName}" inside DebugModule "${module.name}"`);
-                }
-                this.kuzzlePostMethods.set(`Kuzzle.${module.name}.${methodName}`, module[methodName].bind(module));
-            }
-            for (const eventName of module.events) {
-                module.on(eventName, async (payload) => {
-                    if (!this.debuggerStatus) {
-                        return;
-                    }
-                    const event = `Kuzzle.${module.name}.${eventName}`;
-                    await this.notifyGlobalListeners(event, payload);
-                    const listeners = this.events.get(event);
-                    if (!listeners) {
-                        return;
-                    }
-                    const promises = [];
-                    for (const connectionId of listeners) {
-                        promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
-                            event,
-                            result: payload,
-                        }));
-                    }
-                    // No need to catch, notify is already try-catched
-                    await Promise.all(promises);
-                });
-            }
-        }
+        await global.kuzzle.ask("core:debugger:enable");
     }
     /**
      * Disconnect the debugger and clears all the events listeners
      */
     async disable() {
-        if (!this.debuggerStatus) {
-            return;
-        }
-        for (const module of this.modules) {
-            for (const eventName of module.events) {
-                module.removeAllListeners(eventName);
-            }
-            await module.cleanup();
-        }
-        this.inspector.disconnect();
-        this.debuggerStatus = false;
-        this.events.clear();
-        this.kuzzlePostMethods.clear();
+        await global.kuzzle.ask("core:debugger:disable");
     }
     /**
      * Trigger action from debugger directly following the Chrome Debug Protocol
      * See: https://chromedevtools.github.io/devtools-protocol/v8/
      */
     async post(request) {
-        if (!this.debuggerStatus) {
-            throw kerror.get("core", "debugger", "not_enabled");
-        }
         const method = request.getBodyString("method");
         const params = request.getBodyObject("params", {});
-        if (method.startsWith("Kuzzle.")) {
-            const debugModuleMethod = this.kuzzlePostMethods.get(method);
-            if (debugModuleMethod) {
-                return debugModuleMethod(params);
-            }
-            throw kerror.get("core", "debugger", "method_not_found", method);
-        }
-        if (!(0, get_1.default)(global.kuzzle.config, "security.debug.native_debug_protocol")) {
-            throw kerror.get("core", "debugger", "native_debug_protocol_usage_denied");
-        }
-        return this.inspectorPost(method, params);
+        return global.kuzzle.ask("core:debugger:post", method, params);
     }
     /**
      * Make the websocket connection listen and receive events from Chrome Debug Protocol
@@ -204,16 +95,8 @@ class DebugController extends baseController_1.NativeController {
         if (request.context.connection.protocol !== "websocket") {
             throw kerror.get("api", "assert", "unsupported_protocol", request.context.connection.protocol, "debug:addListener");
         }
-        if (!this.debuggerStatus) {
-            throw kerror.get("core", "debugger", "not_enabled");
-        }
         const event = request.getBodyString("event");
-        let listeners = this.events.get(event);
-        if (!listeners) {
-            listeners = new Set();
-            this.events.set(event, listeners);
-        }
-        listeners.add(request.context.connection.id);
+        await global.kuzzle.ask("core:debugger:addListener", event, request.context.connection.id);
     }
     /**
      * Remove the websocket connection from the events' listeners
@@ -222,65 +105,8 @@ class DebugController extends baseController_1.NativeController {
         if (request.context.connection.protocol !== "websocket") {
             throw kerror.get("api", "assert", "unsupported_protocol", request.context.connection.protocol, "debug:removeListener");
         }
-        if (!this.debuggerStatus) {
-            throw kerror.get("core", "debugger", "not_enabled");
-        }
         const event = request.getBodyString("event");
-        const listeners = this.events.get(event);
-        if (listeners) {
-            listeners.delete(request.context.connection.id);
-        }
-    }
-    /**
-     * Execute a method using the Chrome Debug Protocol
-     * @param method Chrome Debug Protocol method to execute
-     * @param params
-     * @returns
-     */
-    async inspectorPost(method, params) {
-        if (!this.debuggerStatus) {
-            throw kerror.get("core", "debugger", "not_enabled");
-        }
-        let resolve;
-        const promise = new Promise((res) => {
-            resolve = res;
-        });
-        this.inspector.post(method, params, (err, res) => {
-            if (err) {
-                resolve({
-                    error: JSON.stringify(Object.getOwnPropertyDescriptors(err)),
-                });
-            }
-            else {
-                resolve(res);
-            }
-        });
-        return promise;
-    }
-    /**
-     * Sends a direct notification to a websocket connection without having to listen to a specific room
-     */
-    async notifyConnection(connectionId, event, payload) {
-        global.kuzzle.entryPoint._notify({
-            channels: [event],
-            connectionId,
-            payload,
-        });
-    }
-    async notifyGlobalListeners(event, payload) {
-        const listeners = this.events.get("*");
-        if (!listeners) {
-            return;
-        }
-        const promises = [];
-        for (const connectionId of listeners) {
-            promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
-                event,
-                result: payload,
-            }));
-        }
-        // No need to catch, notify is already try-catched
-        await Promise.all(promises);
+        await global.kuzzle.ask("core:debugger:removeListener", event, request.context.connection.id);
     }
 }
 exports.DebugController = DebugController;

package/lib/api/controllers/documentController.js

@@ -390,12 +390,34 @@ class DocumentController extends NativeController {
 
     const validated = await global.kuzzle.validation.validate(request, false);
 
+    // Add metadata
+    const pipeMetadataResult = await this.pipe(
+      "generic:document:injectMetadata",
+      {
+        metadata: {
+          author: userId,
+          createdAt: Date.now(),
+          updatedAt: null,
+          updater: null,
+        },
+        request,
+      }
+    );
+
     const created = await this.ask(
       "core:storage:public:document:create",
       index,
       collection,
-      validated.getBody(),
-      { id, refresh, userId }
+      {
+        ...validated.getBody(),
+        _kuzzle_info: pipeMetadataResult.metadata,
+      },
+      {
+        id,
+        injectKuzzleMeta: false,
+        refresh,
+        userId,
+      }
     );
 
     if (!silent) {
@@ -440,13 +462,34 @@ class DocumentController extends NativeController {
       false
     );
 
+    // Add metadata
+    const pipeMetadataResult = await this.pipe(
+      "generic:document:injectMetadata",
+      {
+        metadata: {
+          author: userId,
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+          updater: userId,
+        },
+        request,
+      }
+    );
+
     const response = await this.ask(
       "core:storage:public:document:createOrReplace",
       index,
       collection,
       id,
-      content,
-      { refresh, userId }
+      {
+        ...content,
+        _kuzzle_info: pipeMetadataResult.metadata,
+      },
+      {
+        injectKuzzleMeta: false,
+        refresh,
+        userId,
+      }
     );
 
     if (!silent) {
@@ -493,13 +536,33 @@ class DocumentController extends NativeController {
       false
     );
 
+    // Add metadata
+    const pipeMetadataResult = await this.pipe(
+      "generic:document:injectMetadata",
+      {
+        metadata: {
+          updatedAt: Date.now(),
+          updater: userId,
+        },
+        request,
+      }
+    );
+
     const updatedDocument = await this.ask(
       "core:storage:public:document:update",
       index,
       collection,
       id,
-      content,
-      { refresh, retryOnConflict, userId }
+      {
+        ...content,
+        _kuzzle_info: pipeMetadataResult.metadata,
+      },
+      {
+        injectKuzzleMeta: false,
+        refresh,
+        retryOnConflict,
+        userId,
+      }
     );
 
     const _updatedFields = extractFields(content, {
@@ -548,13 +611,41 @@ class DocumentController extends NativeController {
     const source = request.getBoolean("source");
     const { index, collection } = request.getIndexAndCollection();
 
+    // Add metadata
+    const pipeMetadataResult = await this.pipe(
+      "generic:document:injectMetadata",
+      {
+        defaultMetadata: {
+          author: userId,
+          createdAt: Date.now(),
+        },
+        metadata: {
+          updatedAt: Date.now(),
+          updater: userId,
+        },
+        request,
+      }
+    );
+
     const updatedDocument = await this.ask(
       "core:storage:public:document:upsert",
       index,
       collection,
       id,
-      content,
-      { defaultValues, refresh, retryOnConflict, userId }
+      {
+        ...content,
+        _kuzzle_info: pipeMetadataResult.metadata,
+      },
+      {
+        defaultValues: {
+          ...defaultValues,
+          _kuzzle_info: pipeMetadataResult.defaultMetadata,
+        },
+        injectKuzzleMeta: false,
+        refresh,
+        retryOnConflict,
+        userId,
+      }
     );
 
     if (!silent && updatedDocument.created) {
@@ -633,13 +724,34 @@ class DocumentController extends NativeController {
       false
     );
 
+    // Add metadata
+    const pipeMetadataResult = await this.pipe(
+      "generic:document:injectMetadata",
+      {
+        metadata: {
+          author: userId,
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+          updater: userId,
+        },
+        request,
+      }
+    );
+
     const response = await this.ask(
       "core:storage:public:document:replace",
       index,
       collection,
       id,
-      content,
-      { refresh, userId }
+      {
+        ...content,
+        _kuzzle_info: pipeMetadataResult.metadata,
+      },
+      {
+        injectKuzzleMeta: false,
+        refresh,
+        userId,
+      }
     );
 
     if (!silent) {

package/lib/api/request/kuzzleRequest.d.ts

@@ -135,6 +135,14 @@ export declare class KuzzleRequest {
         status: number;
         timestamp: number;
     };
+    /**
+     * Return the requested controller
+     */
+    getController(): string;
+    /**
+     * Returns the requested controller's action
+     */
+    getAction(): string;
     /**
      * Returns the `lang` param of the request.
      *

package/lib/api/request/kuzzleRequest.js

@@ -324,6 +324,18 @@ class KuzzleRequest {
             timestamp: this.timestamp,
         };
     }
+    /**
+     * Return the requested controller
+     */
+    getController() {
+        return this[_input].controller;
+    }
+    /**
+     * Returns the requested controller's action
+     */
+    getAction() {
+        return this[_input].action;
+    }
     /**
      * Returns the `lang` param of the request.
      *

package/lib/cluster/idCardHandler.js

@@ -25,7 +25,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClusterIdCardHandler = exports.IdCard = void 0;
 const name_generator_1 = require("../util/name-generator");
-const worker_threads_1 = require("worker_threads");
+const child_process_1 = require("child_process");
 const bluebird_1 = __importDefault(require("bluebird"));
 require("../types");
 const REDIS_PREFIX = "{cluster/node}/";
@@ -110,14 +110,16 @@ class ClusterIdCardHandler {
         } while (!reserved);
         await this.addIdCardToIndex();
         this.refreshWorker = this.constructWorker(`${__dirname}/workers/IDCardRenewer.js`);
-        this.refreshWorker.unref();
         this.refreshWorker.on("message", async (message) => {
             if (message.error) {
                 await this.node.evictSelf(message.error);
             }
         });
+        this.refreshWorker.on("close", () => {
+            this.disposed = true;
+        });
         // Transfer informations to the worker
-        this.refreshWorker.postMessage({
+        this.refreshWorker.send({
             action: "start",
             kuzzle: {
                 config: global.kuzzle.config,
@@ -138,7 +140,7 @@ class ClusterIdCardHandler {
      * Helper method to mock worker instantiation in unit tests
      */
     constructWorker(path) {
-        return new worker_threads_1.Worker(path);
+        return (0, child_process_1.fork)(path);
     }
     /**
      * Start refreshing the ID Card before the worker starts to ensure the ID Card
@@ -163,9 +165,20 @@ class ClusterIdCardHandler {
         });
     }
     async dispose() {
+        if (this.disposed) {
+            return;
+        }
         this.disposed = true;
-        if (this.refreshWorker) {
-            this.refreshWorker.postMessage({ action: "dispose" });
+        if (this.refreshWorker &&
+            this.refreshWorker.connected &&
+            !this.refreshWorker.killed &&
+            this.refreshWorker.channel) {
+            try {
+                this.refreshWorker.send({ action: "dispose" });
+            }
+            catch (e) {
+                // It could happens that the worker has been killed before the dispose causing send to fail
+            }
         }
     }
     /**

package/lib/cluster/node.js

@@ -249,6 +249,15 @@ class ClusterNode {
     this.command.dispose();
   }
 
+  /**
+   * Notify other nodes to not evict this node
+   *
+   * @param {bool} evictionPrevented
+   */
+  preventEviction(evictionPrevented) {
+    this.publisher.sendNodePreventEviction(evictionPrevented);
+  }
+
   /**
    * Adds a new remote node, and subscribes to it.
    * @param {string} id            - remote node ID
@@ -678,6 +687,10 @@ class ClusterNode {
    * Registers ask events
    */
   registerAskEvents() {
+    global.kuzzle.onAsk("cluster:node:preventEviction", (state) => {
+      this.preventEviction(state);
+    });
+
     /**
      * Removes a room from the full state, and only for this node.
      * Removes the room from Koncorde if, and only if, no other node uses it.
@@ -816,7 +829,11 @@ class ClusterNode {
       this.onAuthStrategyRemoved(name, pluginName)
     );
 
-    global.kuzzle.on("admin:afterDump", (suffix) => this.onDumpRequest(suffix));
+    global.kuzzle.on("admin:afterDump", (request) => {
+      const suffix = request.getString("suffix", "manual-api-action");
+
+      return this.onDumpRequest(suffix);
+    });
 
     global.kuzzle.on("admin:afterResetSecurity", () => this.onSecurityReset());
 

package/lib/cluster/protobuf/sync.proto

@@ -21,6 +21,11 @@ message NodeShutdown {
   string nodeId = 2;
 }
 
+message NodePreventEviction {
+  uint64 messageId = 1;
+  bool evictionPrevented = 2;
+}
+
 message NewRealtimeRoom {
   uint64 messageId = 1;
   string index = 2;

package/lib/cluster/publisher.js

@@ -270,6 +270,16 @@ class ClusterPublisher {
     return this.send("NodeShutdown", { nodeId });
   }
 
+  /**
+   * Publishes an event about the node being in debug mode
+   * @param {bool} evictionPrevented
+   *
+   * @returns {Long} ID of the message sent
+   */
+  sendNodePreventEviction(evictionPrevented) {
+    return this.send("NodePreventEviction", { evictionPrevented });
+  }
+
   /**
    * Publishes an event about a node being evicted
    *

package/lib/cluster/subscriber.js

@@ -55,6 +55,8 @@ class ClusterSubscriber {
     this.remoteNodeIP = remoteNodeIP;
     this.remoteNodeAddress = `tcp://${remoteNodeIP}:${this.localNode.config.ports.sync}`;
     this.remoteNodeId = remoteNodeId;
+    // Used in debug mode when the node might be slower
+    this.remoteNodeEvictionPrevented = false;
     this.socket = null;
     this.protoroot = null;
 
@@ -87,6 +89,7 @@ class ClusterSubscriber {
       NewAuthStrategy: this.handleNewAuthStrategy,
       NewRealtimeRoom: this.handleNewRealtimeRoom,
       NodeEvicted: this.handleNodeEviction,
+      NodePreventEviction: this.handleNodePreventEviction,
       NodeShutdown: this.handleNodeShutdown,
       RefreshIndexCache: this.handleRefreshIndexCache,
       RefreshValidators: this.handleRefreshValidators,
@@ -229,6 +232,10 @@ class ClusterSubscriber {
     }
   }
 
+  async handleNodePreventEviction(message) {
+    this.remoteNodeEvictionPrevented = message.evictionPrevented;
+  }
+
   /**
    * Handles a heartbeat from the remote node
    *
@@ -673,7 +680,7 @@ class ClusterSubscriber {
    * to recover, otherwise we evict it from the cluster.
    */
   async checkHeartbeat() {
-    if (this.state === stateEnum.EVICTED) {
+    if (this.state === stateEnum.EVICTED || this.remoteNodeEvictionPrevented) {
       return;
     }
 

package/lib/cluster/workers/IDCardRenewer.js

@@ -1,11 +1,9 @@
 "use strict";
 
-const { isMainThread, parentPort } = require("worker_threads");
 const Redis = require("../../service/cache/redis");
 
 class IDCardRenewer {
   constructor() {
-    this.parentPort = parentPort;
     this.redis = null;
     this.refreshTimer = null;
     this.nodeIdKey = null;
@@ -50,7 +48,7 @@ class IDCardRenewer {
     }
 
     // Notify that the worker is running and updating the ID Card
-    this.parentPort.postMessage({ initialized: true });
+    process.send({ initialized: true });
   }
 
   async initRedis(config, name) {
@@ -73,13 +71,13 @@ class IDCardRenewer {
       // => this node is too slow, we need to remove it from the cluster
       if (refreshed === 0) {
         await this.dispose();
-        this.parentPort.postMessage({
+        process.send({
           error: "Node too slow: ID card expired",
         });
       }
     } catch (error) {
       await this.dispose();
-      this.parentPort.postMessage({
+      process.send({
         error: `Failed to refresh ID Card: ${error.message}`,
       });
     }
@@ -112,26 +110,25 @@ class IDCardRenewer {
   }
 }
 
-if (!isMainThread) {
-  const idCardRenewer = new IDCardRenewer();
-
-  parentPort.on("message", async (message) => {
-    if (message.action === "start") {
-      // Simulate basic global Kuzzle Context
-      global.kuzzle = { ...message.kuzzle };
-      global.kuzzle.log = {
-        debug: console.debug, // eslint-disable-line no-console
-        error: console.error, // eslint-disable-line no-console
-        info: console.info, // eslint-disable-line no-console
-        warn: console.warn, // eslint-disable-line no-console
-      };
-      // Should never throw
-      await idCardRenewer.init(message);
-    } else if (message.action === "dispose") {
-      // Should never throw
-      await idCardRenewer.dispose();
-    }
-  });
-}
+const idCardRenewer = new IDCardRenewer();
+
+process.on("message", async (message) => {
+  if (message.action === "start") {
+    // Simulate basic global Kuzzle Context
+    global.kuzzle = { ...message.kuzzle };
+    global.kuzzle.log = {
+      debug: console.debug, // eslint-disable-line no-console
+      error: console.error, // eslint-disable-line no-console
+      info: console.info, // eslint-disable-line no-console
+      warn: console.warn, // eslint-disable-line no-console
+    };
+    // Should never throw
+    await idCardRenewer.init(message);
+  } else if (message.action === "dispose") {
+    // Should never throw
+    await idCardRenewer.dispose();
+    process.exit(0);
+  }
+});
 
 module.exports = { IDCardRenewer };

package/lib/core/debug/kuzzleDebugger.d.ts

@@ -0,0 +1,45 @@
+import { JSONObject } from "kuzzle-sdk";
+export declare class KuzzleDebugger {
+    private inspector;
+    private debuggerStatus;
+    /**
+     * Map<eventName, Set<connectionId>>
+     */
+    private events;
+    init(): Promise<void>;
+    registerAsks(): Promise<void>;
+    /**
+     * Connect the debugger
+     */
+    enable(): Promise<void>;
+    /**
+     * Disconnect the debugger and clears all the events listeners
+     */
+    disable(): Promise<void>;
+    /**
+     * Trigger action from debugger directly following the Chrome Debug Protocol
+     * See: https://chromedevtools.github.io/devtools-protocol/v8/
+     */
+    post(method: string, params?: JSONObject): Promise<JSONObject>;
+    /**
+     * Make the websocket connection listen and receive events from Chrome Debug Protocol
+     * See events from: https://chromedevtools.github.io/devtools-protocol/v8/
+     */
+    addListener(event: string, connectionId: string): Promise<void>;
+    /**
+     * Remove the websocket connection from the events" listeners
+     */
+    removeListener(event: string, connectionId: string): Promise<void>;
+    /**
+     * Execute a method using the Chrome Debug Protocol
+     * @param method Chrome Debug Protocol method to execute
+     * @param params
+     * @returns
+     */
+    private inspectorPost;
+    /**
+     * Sends a direct notification to a websocket connection without having to listen to a specific room
+     */
+    private notifyConnection;
+    private notifyGlobalListeners;
+}

package/lib/core/debug/kuzzleDebugger.js

@@ -0,0 +1,205 @@
+"use strict";
+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 });
+exports.KuzzleDebugger = void 0;
+const inspector_1 = __importDefault(require("inspector"));
+const kerror = __importStar(require("../../kerror"));
+const get_1 = __importDefault(require("lodash/get"));
+const DEBUGGER_EVENT = "kuzzle-debugger-event";
+class KuzzleDebugger {
+    constructor() {
+        this.debuggerStatus = false;
+        /**
+         * Map<eventName, Set<connectionId>>
+         */
+        this.events = new Map();
+    }
+    async init() {
+        this.inspector = new inspector_1.default.Session();
+        // Remove connection id from the list of listeners for each event
+        global.kuzzle.on("connection:remove", (connectionId) => {
+            if (!this.debuggerStatus) {
+                return;
+            }
+            for (const listener of this.events.values()) {
+                listener.delete(connectionId);
+            }
+        });
+        this.inspector.on("inspectorNotification", async (payload) => {
+            if (!this.debuggerStatus) {
+                return;
+            }
+            await this.notifyGlobalListeners(payload.method, payload);
+            const listeners = this.events.get(payload.method);
+            if (!listeners) {
+                return;
+            }
+            const promises = [];
+            for (const connectionId of listeners) {
+                promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
+                    event: payload.method,
+                    result: payload,
+                }));
+            }
+            // No need to catch, notify is already try-catched
+            await Promise.all(promises);
+        });
+        await this.registerAsks();
+    }
+    async registerAsks() {
+        global.kuzzle.onAsk("core:debugger:enable", () => this.enable());
+        global.kuzzle.onAsk("core:debugger:disable", () => this.disable());
+        global.kuzzle.onAsk("core:debugger:post", (method, params) => this.post(method, params));
+        global.kuzzle.onAsk("core:debugger:isEnabled", () => this.debuggerStatus);
+        global.kuzzle.onAsk("core:debugger:removeListener", (event, connectionId) => this.removeListener(event, connectionId));
+        global.kuzzle.onAsk("core:debugger:addListener", (event, connectionId) => this.addListener(event, connectionId));
+    }
+    /**
+     * Connect the debugger
+     */
+    async enable() {
+        if (this.debuggerStatus) {
+            return;
+        }
+        this.inspector.connect();
+        this.debuggerStatus = true;
+        await global.kuzzle.ask("cluster:node:preventEviction", true);
+    }
+    /**
+     * Disconnect the debugger and clears all the events listeners
+     */
+    async disable() {
+        if (!this.debuggerStatus) {
+            return;
+        }
+        this.inspector.disconnect();
+        this.debuggerStatus = false;
+        await global.kuzzle.ask("cluster:node:preventEviction", false);
+        this.events.clear();
+    }
+    /**
+     * Trigger action from debugger directly following the Chrome Debug Protocol
+     * See: https://chromedevtools.github.io/devtools-protocol/v8/
+     */
+    async post(method, params = {}) {
+        if (!this.debuggerStatus) {
+            throw kerror.get("core", "debugger", "not_enabled");
+        }
+        if (!(0, get_1.default)(global.kuzzle.config, "security.debug.native_debug_protocol")) {
+            throw kerror.get("core", "debugger", "native_debug_protocol_usage_denied");
+        }
+        // Always disable report progress because this params causes a segfault.
+        // The reason this happens is because the inspector is running inside the same thread
+        // as the Kuzzle Process and reportProgress forces the inspector to send events
+        // to the main thread, while it is being inspected by the HeapProfiler, which causes javascript code
+        // to be executed as the HeapProfiler is running, which causes a segfault.
+        // See: https://github.com/nodejs/node/issues/44634
+        params.reportProgress = false;
+        return this.inspectorPost(method, params);
+    }
+    /**
+     * Make the websocket connection listen and receive events from Chrome Debug Protocol
+     * See events from: https://chromedevtools.github.io/devtools-protocol/v8/
+     */
+    async addListener(event, connectionId) {
+        if (!this.debuggerStatus) {
+            throw kerror.get("core", "debugger", "not_enabled");
+        }
+        let listeners = this.events.get(event);
+        if (!listeners) {
+            listeners = new Set();
+            this.events.set(event, listeners);
+        }
+        listeners.add(connectionId);
+    }
+    /**
+     * Remove the websocket connection from the events" listeners
+     */
+    async removeListener(event, connectionId) {
+        if (!this.debuggerStatus) {
+            throw kerror.get("core", "debugger", "not_enabled");
+        }
+        const listeners = this.events.get(event);
+        if (listeners) {
+            listeners.delete(connectionId);
+        }
+    }
+    /**
+     * Execute a method using the Chrome Debug Protocol
+     * @param method Chrome Debug Protocol method to execute
+     * @param params
+     * @returns
+     */
+    async inspectorPost(method, params) {
+        if (!this.debuggerStatus) {
+            throw kerror.get("core", "debugger", "not_enabled");
+        }
+        let resolve;
+        const promise = new Promise((res) => {
+            resolve = res;
+        });
+        this.inspector.post(method, params, (err, res) => {
+            if (err) {
+                resolve({
+                    error: JSON.stringify(Object.getOwnPropertyDescriptors(err)),
+                });
+            }
+            else {
+                resolve(res);
+            }
+        });
+        return promise;
+    }
+    /**
+     * Sends a direct notification to a websocket connection without having to listen to a specific room
+     */
+    async notifyConnection(connectionId, event, payload) {
+        global.kuzzle.entryPoint._notify({
+            channels: [event],
+            connectionId,
+            payload,
+        });
+    }
+    async notifyGlobalListeners(event, payload) {
+        const listeners = this.events.get("*");
+        if (!listeners) {
+            return;
+        }
+        const promises = [];
+        for (const connectionId of listeners) {
+            promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
+                event,
+                result: payload,
+            }));
+        }
+        // No need to catch, notify is already try-catched
+        await Promise.all(promises);
+    }
+}
+exports.KuzzleDebugger = KuzzleDebugger;
+//# sourceMappingURL=kuzzleDebugger.js.map

package/lib/kuzzle/dumpGenerator.js

@@ -228,7 +228,7 @@ class DumpGenerator {
     while (dumps.length >= config.history.reports) {
       const dir = dumps.shift().path;
 
-      fs.removeSync(dir);
+      fs.rmdirSync(dir, { recursive: true });
     }
 
     for (let i = 0; i < dumps.length - config.history.coredump; i++) {

package/lib/kuzzle/kuzzle.js

@@ -80,6 +80,7 @@ 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");
 exports.BACKEND_IMPORT_KEY = "backend:init:import";
 let _kuzzle = null;
 Reflect.defineProperty(global, "kuzzle", {
@@ -119,6 +120,7 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
         this.dumpGenerator = new dumpGenerator_1.default();
         this.vault = null;
         this.asyncStore = new asyncStore_1.default();
+        this.debugger = new kuzzleDebugger_1.KuzzleDebugger();
         this.version = package_json_1.version;
         this.importTypes = {
             fixtures: this.importFixtures.bind(this),
@@ -146,6 +148,7 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
                 regExpEngine: this.config.realtime.pcreSupport ? "js" : "re2",
                 seed: this.config.internal.hash.seed,
             });
+            await this.debugger.init();
             await new cacheEngine_1.default().init();
             await new storageEngine_1.default().init();
             await new realtime_1.default().init();

package/lib/service/storage/elasticsearch.js

@@ -681,7 +681,7 @@ class ElasticSearch extends Service {
     index,
     collection,
     content,
-    { id, refresh, userId = null } = {}
+    { id, refresh, userId = null, injectKuzzleMeta = true } = {}
   ) {
     assertIsObject(content);
 
@@ -697,12 +697,14 @@ class ElasticSearch extends Service {
     assertWellFormedRefresh(esRequest);
 
     // Add metadata
-    esRequest.body._kuzzle_info = {
-      author: getKuid(userId),
-      createdAt: Date.now(),
-      updatedAt: null,
-      updater: null,
-    };
+    if (injectKuzzleMeta) {
+      esRequest.body._kuzzle_info = {
+        author: getKuid(userId),
+        createdAt: Date.now(),
+        updatedAt: null,
+        updater: null,
+      };
+    }
 
     debug("Create document: %o", esRequest);
 
@@ -789,7 +791,7 @@ class ElasticSearch extends Service {
     collection,
     id,
     content,
-    { refresh, userId = null, retryOnConflict } = {}
+    { refresh, userId = null, retryOnConflict, injectKuzzleMeta = true } = {}
   ) {
     const esRequest = {
       _source: true,
@@ -804,11 +806,13 @@ class ElasticSearch extends Service {
     assertNoRouting(esRequest);
     assertWellFormedRefresh(esRequest);
 
-    // Add metadata
-    esRequest.body.doc._kuzzle_info = {
-      updatedAt: Date.now(),
-      updater: getKuid(userId),
-    };
+    if (injectKuzzleMeta) {
+      // Add metadata
+      esRequest.body.doc._kuzzle_info = {
+        updatedAt: Date.now(),
+        updater: getKuid(userId),
+      };
+    }
 
     debug("Update document: %o", esRequest);
 
@@ -841,7 +845,13 @@ class ElasticSearch extends Service {
     collection,
     id,
     content,
-    { defaultValues = {}, refresh, userId = null, retryOnConflict } = {}
+    {
+      defaultValues = {},
+      refresh,
+      userId = null,
+      retryOnConflict,
+      injectKuzzleMeta = true,
+    } = {}
   ) {
     const esRequest = {
       _source: true,
@@ -863,14 +873,16 @@ class ElasticSearch extends Service {
     const user = getKuid(userId);
     const now = Date.now();
 
-    esRequest.body.doc._kuzzle_info = {
-      updatedAt: now,
-      updater: user,
-    };
-    esRequest.body.upsert._kuzzle_info = {
-      author: user,
-      createdAt: now,
-    };
+    if (injectKuzzleMeta) {
+      esRequest.body.doc._kuzzle_info = {
+        updatedAt: now,
+        updater: user,
+      };
+      esRequest.body.upsert._kuzzle_info = {
+        author: user,
+        createdAt: now,
+      };
+    }
 
     debug("Upsert document: %o", esRequest);
 
@@ -904,7 +916,7 @@ class ElasticSearch extends Service {
     collection,
     id,
     content,
-    { refresh, userId = null } = {}
+    { refresh, userId = null, injectKuzzleMeta = true } = {}
   ) {
     const alias = this._getAlias(index, collection);
     const esRequest = {
@@ -917,13 +929,15 @@ class ElasticSearch extends Service {
     assertNoRouting(esRequest);
     assertWellFormedRefresh(esRequest);
 
-    // Add metadata
-    esRequest.body._kuzzle_info = {
-      author: getKuid(userId),
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-      updater: getKuid(userId),
-    };
+    if (injectKuzzleMeta) {
+      // Add metadata
+      esRequest.body._kuzzle_info = {
+        author: getKuid(userId),
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        updater: getKuid(userId),
+      };
+    }
 
     try {
       const { body: exists } = await this._client.exists({ id, index: alias });

package/lib/types/events/EventGenericDocument.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleRequest, KDocument, JSONObject } from "../../../";
+import { KuzzleRequest, KDocument, JSONObject, PipeEventHandler } from "../../../";
 /**
  * Events with documents only having the `_id`
  */
@@ -23,4 +23,24 @@ export type EventGenericDocumentAfterWrite<KDocumentContent = JSONObject> = Even
 export type EventGenericDocumentBeforeUpdate<KDocumentContent = JSONObject> = EventGenericDocument<"beforeUpdate", KDocumentContent>;
 export type EventGenericDocumentAfterUpdate<KDocumentContent = JSONObject> = EventGenericDocument<"afterUpdate", KDocumentContent>;
 export type EventGenericDocumentAfterGet<KDocumentContent = JSONObject> = EventGenericDocument<"afterGet", KDocumentContent>;
+export type EventGenericDocumentInjectMetadata = {
+    name: `generic:document:injectMetadata`;
+    args: [
+        {
+            /**
+             * Kuzzle Request that triggered the event
+             */
+            request: KuzzleRequest;
+            /**
+             * Metadata of the document
+             */
+            metadata: JSONObject;
+            /**
+             * Default metadata of the document.
+             * Only used when calling document:upsert.
+             */
+            defaultMetadata?: JSONObject;
+        }
+    ];
+} & PipeEventHandler;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kuzzle",
   "author": "The Kuzzle Team <support@kuzzle.io>",
-  "version": "2.20.3",
+  "version": "2.21.0",
   "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
   "bin": "bin/start-kuzzle-server",
   "scripts": {

package/lib/types/DebugModule.d.ts

@@ -1,24 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import EventEmitter from "events";
-import Inspector from "inspector";
-export type DebugModuleOptions = {
-    methods?: string[];
-    events?: string[];
-};
-export declare abstract class DebugModule extends EventEmitter {
-    name: string;
-    methods: string[];
-    events: string[];
-    /**
-     * Called when the module is loaded, after the debugger has been enabled
-     */
-    abstract init(inspector: Inspector.Session): Promise<void>;
-    /**
-     * Called when the module should be cleaned up.
-     * - After the Debug Controller has been disabled
-     * - Before the debugger is disconnected
-     */
-    abstract cleanup(): Promise<void>;
-    constructor(name: string, options?: DebugModuleOptions);
-}

package/lib/types/DebugModule.js

@@ -1,39 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DebugModule = void 0;
-const events_1 = __importDefault(require("events"));
-class DebugModule extends events_1.default {
-    constructor(name, options = {}) {
-        super();
-        this.name = name;
-        this.methods = options.methods || [];
-        this.events = options.events || [];
-        if (!this.name || this.name.length === 0) {
-            throw new Error("DebugModule should have a name");
-        }
-        if (this.name.charAt(0) !== this.name.charAt(0).toUpperCase()) {
-            throw new Error(`Debug Module name "${name}" should start with an uppercase letter`);
-        }
-        for (const event of this.events) {
-            if (event.length === 0) {
-                throw new Error(`Event name should not be empty for "${name}"`);
-            }
-            if (event.charAt(0) !== event.charAt(0).toLowerCase()) {
-                throw new Error(`Event name "${event}" should start with a lowercase letter for module "${name}"`);
-            }
-        }
-        for (const method of this.methods) {
-            if (method.length === 0) {
-                throw new Error(`Method name should not be empty for Debug Module "${name}"`);
-            }
-            if (method.charAt(0) !== method.charAt(0).toLowerCase()) {
-                throw new Error(`Method name "${method}" should start with a lowercase letter for module "${name}"`);
-            }
-        }
-    }
-}
-exports.DebugModule = DebugModule;
-//# sourceMappingURL=DebugModule.js.map