kuzzle 2.20.2 → 2.21.0

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/config/default.config.js

@@ -420,6 +420,7 @@ const defaultConfig = {
                 onUpdateConflictRetries: 0,
                 scrollTTL: "15s",
             },
+            generateMissingAliases: true,
         },
     },
     stats: {

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/core/storage/clientAdapter.js

@@ -175,10 +175,12 @@ class ClientAdapter {
   /**
    * Populates the index cache with existing index/collection.
    * Also checks for duplicated index names.
-   *
-   * @returns {Promise}
    */
   async populateCache() {
+    if (global.kuzzle.config.services.storageEngine.generateMissingAliases) {
+      await this.client.generateMissingAliases();
+    }
+
     const schema = await this.client.getSchema();
 
     for (const [index, collections] of Object.entries(schema)) {

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 });
@@ -1894,10 +1908,6 @@ class ElasticSearch extends Service {
    * @returns {Object.<String, String[]>} Object<index, collections>
    */
   async getSchema() {
-    // This check avoids a breaking change for those who were using Kuzzle before
-    // alias attribution for each indice was the standard ('auto-version')
-    await this._ensureAliasConsistency();
-
     let body;
     try {
       ({ body } = await this._client.cat.aliases({ format: "json" }));
@@ -3044,9 +3054,9 @@ class ElasticSearch extends Service {
    * When the latter is missing, create one based on the indice name.
    *
    * This check avoids a breaking change for those who were using Kuzzle before
-   * alias attribution for each indice turned into a standard ('auto-version').
+   * alias attribution for each indice turned into a standard (appear in 2.14.0).
    */
-  async _ensureAliasConsistency() {
+  async generateMissingAliases() {
     try {
       const { body } = await this._client.cat.indices({ format: "json" });
       const indices = body.map(({ index: indice }) => indice);

package/lib/types/config/storageEngine/StorageEngineElasticsearchConfiguration.d.ts

@@ -318,9 +318,21 @@ export type StorageEngineElasticsearch = {
             };
         };
     };
-    maxScrollDuration: "1m";
+    maxScrollDuration: string;
     defaults: {
-        onUpdateConflictRetries: 0;
-        scrollTTL: "15s";
+        onUpdateConflictRetries: number;
+        scrollTTL: string;
     };
+    /**
+     * If true, Kuzzle will generate aliases for collections that don't have one.
+     *
+     * Typically, if an indice named `&platform.devices` does not have an alias
+     * named `@&platform.devices` and pointing on the indice then it will be generated
+     * even if another alias already exists on the indice.
+     *
+     * This option should be true only for retro-compatibility with Kuzzle < 2.14.0
+     *
+     * Also see https://github.com/kuzzleio/kuzzle/pull/2117
+     */
+    generateMissingAliases: boolean;
 };

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.2",
+  "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