kuzzle 2.18.0 → 2.19.1

package/lib/kuzzle/kuzzle.js

@@ -46,6 +46,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BACKEND_IMPORT_KEY = void 0;
 const path_1 = __importDefault(require("path"));
 const murmurhash_native_1 = require("murmurhash-native");
 const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
@@ -78,7 +79,8 @@ 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 BACKEND_IMPORT_KEY = 'backend:init:import';
+const crypto_1 = require("../util/crypto");
+exports.BACKEND_IMPORT_KEY = 'backend:init:import';
 let _kuzzle = null;
 Reflect.defineProperty(global, 'kuzzle', {
     configurable: true,
@@ -201,7 +203,7 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
             this.log.info('[✔] Cluster initialized');
         }
         else {
-            id = (0, name_generator_1.generateRandomName)('knode');
+            id = name_generator_1.NameGenerator.generateRandomName({ prefix: 'knode' });
             this.log.info('[X] Cluster disabled: single node mode.');
         }
         return id;
@@ -368,11 +370,10 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
      */
     async _waitForImportToFinish() {
         const importTypes = Object.keys(this.importTypes);
-        while (importTypes.length) {
+        for (const importType of importTypes) {
             // If the import is done, we pop it from the queue to check the next one
-            if (await this.ask('core:cache:internal:get', `${BACKEND_IMPORT_KEY}:${importTypes[0]}`)) {
-                importTypes.shift();
-                continue;
+            if (await this.ask('core:cache:internal:get', `${exports.BACKEND_IMPORT_KEY}:${importType}`)) {
+                return;
             }
             await bluebird_1.default.delay(1000);
         }
@@ -399,8 +400,26 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
         const lockedMutex = [];
         try {
             for (const [type, importMethod] of Object.entries(this.importTypes)) {
+                const importPayload = {};
+                switch (type) {
+                    case 'fixtures':
+                        lodash_1.default.set(importPayload, 'toSupport.fixtures', toSupport.fixtures);
+                        break;
+                    case 'mappings':
+                        lodash_1.default.set(importPayload, 'toSupport.mappings', toSupport.mappings);
+                        lodash_1.default.set(importPayload, 'toImport.mappings', toImport.mappings);
+                        break;
+                    case 'permissions':
+                        lodash_1.default.set(importPayload, 'toSupport.securities', toSupport.securities);
+                        lodash_1.default.set(importPayload, 'toImport.profiles', toImport.profiles);
+                        lodash_1.default.set(importPayload, 'toImport.roles', toImport.roles);
+                        lodash_1.default.set(importPayload, 'toImport.users', toImport.users);
+                        break;
+                }
+                const importPayloadHash = (0, crypto_1.sha256)((0, json_stable_stringify_1.default)(importPayload));
                 const mutex = new mutex_1.Mutex(`backend:import:${type}`, { timeout: 0 });
-                const initialized = await this.ask('core:cache:internal:get', `${BACKEND_IMPORT_KEY}:${type}`) === '1';
+                const existingHash = await this.ask('core:cache:internal:get', `${exports.BACKEND_IMPORT_KEY}:${type}`);
+                const initialized = existingHash === importPayloadHash;
                 const locked = await mutex.lock();
                 await importMethod({ toImport, toSupport }, {
                     firstCall: !initialized && locked,
@@ -409,7 +428,7 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
                 });
                 if (!initialized && locked) {
                     lockedMutex.push(mutex);
-                    await this.ask('core:cache:internal:store', `${BACKEND_IMPORT_KEY}:${type}`, 1, { ttl: 5 * 60 * 1000 });
+                    await this.ask('core:cache:internal:store', `${exports.BACKEND_IMPORT_KEY}:${type}`, importPayloadHash);
                 }
             }
             await this._waitForImportToFinish();

package/lib/model/storage/apiKey.js

@@ -21,16 +21,11 @@
 
 'use strict';
 
-const crypto = require('crypto');
-
+const { sha256 } = require('../../util/crypto');
 const debug = require('../../util/debug')('models:storage:apiKey');
 const kerror = require('../../kerror');
 const BaseModel = require('./baseModel');
 
-function sha256 (string) {
-  return crypto.createHash('sha256').update(string).digest('hex');
-}
-
 class ApiKey extends BaseModel {
   constructor (_source, _id = null) {
     super(_source, _id);

package/lib/service/storage/elasticsearch.js

@@ -182,7 +182,7 @@ class ElasticSearch extends Service {
   /**
    * Translate Koncorde filters to Elasticsearch query
    *
-   * @param {Object} koncordeFilters - Set of valid Koncorde filters
+   * @param {Object} filters - Set of valid Koncorde filters
    * @returns {Object} Equivalent Elasticsearch query
    */
   translateKoncordeFilters (filters) {
@@ -1435,10 +1435,9 @@ class ElasticSearch extends Service {
     // rollback the whole operation. Since mappings can't be rollback, we try to
     // update the settings first, then the mappings and we rollback the settings
     // if putMappings fail.
-    let indiceSettings;
+    let indexSettings;
     try {
-      const response = await this._client.indices.getSettings(esRequest);
-      indiceSettings = response.body[esRequest.index].settings;
+      indexSettings = await this._getSettings(esRequest);
     }
     catch (error) {
       throw this._esWrapper.formatESError(error);
@@ -1460,11 +1459,7 @@ class ElasticSearch extends Service {
       }
     }
     catch (error) {
-      const allowedSettings = {
-        index: _.omit(
-          indiceSettings.index,
-          ['creation_date', 'provided_name', 'uuid', 'version'])
-      };
+      const allowedSettings = this.getAllowedIndexSettings(indexSettings);
 
       // Rollback to previous settings
       if (! _.isEmpty(settings)) {
@@ -1477,6 +1472,20 @@ class ElasticSearch extends Service {
     return null;
   }
 
+  /**
+   * Given index settings we return a new version of index settings
+   * only with allowed settings that can be set (during update or create index).
+   * @param indexSettings the index settings
+   * @returns {{index: *}} a new index settings with only allowed settings.
+   */
+  getAllowedIndexSettings (indexSettings) {
+    return {
+      index: _.omit(
+        indexSettings.index,
+        ['creation_date', 'provided_name', 'uuid', 'version'])
+    };
+  }
+
   /**
   * Sends an empty UpdateByQuery request to update the search index
   *
@@ -1583,7 +1592,7 @@ class ElasticSearch extends Service {
   }
 
   /**
-   * Empties the content of a collection. Keep the existing mapping.
+   * Empties the content of a collection. Keep the existing mapping and settings.
    *
    * @param {String} index - Index name
    * @param {String} collection - Collection name
@@ -1592,6 +1601,7 @@ class ElasticSearch extends Service {
    */
   async truncateCollection (index, collection) {
     let mappings;
+    let settings;
 
     const esRequest = {
       index: await this._getIndice(index, collection)
@@ -1599,7 +1609,11 @@ class ElasticSearch extends Service {
 
     try {
       mappings = await this.getMapping(index, collection, { includeKuzzleMeta: true });
-
+      settings = await this._getSettings(esRequest);
+      settings = {
+        ...settings,
+        ...this.getAllowedIndexSettings(settings)
+      };
       await this._client.indices.delete(esRequest);
 
       await this._client.indices.create({
@@ -1608,7 +1622,8 @@ class ElasticSearch extends Service {
           aliases: {
             [this._getAlias(index, collection)]: {}
           },
-          mappings
+          mappings,
+          settings
         }
       });
 
@@ -2535,7 +2550,7 @@ class ElasticSearch extends Service {
    *
    * @param {String} index - Index name
    * @param {String} collection - Collection name
-   * @param {Array.<String>} documents - Documents IDs
+   * @param {Array.<String>} ids - Documents IDs
    * @param {Object} options - timeout (undefined), refresh (undefined)
    *
    * @returns {Promise.<{ documents, errors }>
@@ -2857,6 +2872,18 @@ class ElasticSearch extends Service {
     return body[0].index;
   }
 
+  /**
+   * Given an ES Request returns the settings of the corresponding indice.
+   *
+   * @param esRequest the ES Request with wanted settings.
+   * @return {Promise<*>} the settings of the indice.
+   * @private
+   */
+  async _getSettings (esRequest) {
+    const response = await this._client.indices.getSettings(esRequest);
+    return response.body[esRequest.index].settings;
+  }
+
   /**
    * Given index + collection, returns an available indice name.
    * Use this function when creating the associated indice. Otherwise use `_getAlias`.

package/lib/types/DebugModule.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import Inspector from 'inspector';
+export declare 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

@@ -0,0 +1,39 @@
+"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

package/lib/types/config/SecurityConfiguration.d.ts

@@ -2,6 +2,16 @@
 import { JSONObject } from '../../../index';
 import { RoleDefinition, ProfileDefinition } from '../index';
 export declare type SecurityConfiguration = {
+    /**
+     * Debugger configuration
+     */
+    debug: {
+        /**
+         * Allow to use the Chrome DevTools Protocol directly
+         * through `debug:post`
+         */
+        native_debug_protocol: boolean;
+    };
     /**
      * The profileIds applied to a user created with the API action
      * `security:createRestrictedUser`.

package/lib/util/crypto.d.ts

@@ -0,0 +1 @@
+export declare function sha256(string: string): string;

package/lib/util/crypto.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+function sha256(string) {
+    return crypto_1.default.createHash('sha256').update(string).digest('hex');
+}
+exports.sha256 = sha256;
+//# sourceMappingURL=crypto.js.map

package/lib/util/name-generator.d.ts

@@ -0,0 +1,79 @@
+export declare type GenerateRandomNameOpts = {
+    /**
+     * Optional prefix.
+     */
+    prefix?: string;
+    /**
+     * Optional separator. Defaults to `-`.
+     */
+    separator?: string;
+    /**
+     * Optional postfix random number range. Set to `false` to disable postfix. Defaults to `{ min: 0, max: 100000 }`
+     */
+    postfixRandRange?: {
+        /**
+         * Optional minimum postfix random number (inclusive). Defaults to `0`.
+         */
+        min?: number;
+        /**
+         * Maximum postfix random number (exclusive).
+         */
+        max: number;
+    } | false;
+};
+export declare class NameGenerator {
+    /**
+     * Returns a random name.
+     *
+     * # Usage:
+     *
+     * ```js
+     * const name = NameGenerator.getRandomName(); // 'verdi'
+     * ```
+     *
+     * @returns a random name
+     */
+    static getRandomName(): string;
+    /**
+     * Returns a random adjective.
+     *
+     * # Usage
+     *
+     * ```js
+     * const adj = NameGenerator.getRandomAdjective(); // 'absent'
+     * ```
+     *
+     * @returns a random adjective
+     */
+    static getRandomAdjective(): string;
+    /**
+     * Generates a random formatted name that consists of an optional prefix, a random adjective,
+     * a random name and an optional random number separated by separator (default: '-').
+     *
+     * Format: `[prefix<separator>]<adjective><separator><name>[<separator>random number]`
+     *
+     * Format example: `something-dashing-euler-1164`
+     *
+     * ## Usage
+     *
+     * ```js
+     * let name = NameGenerator.generateRandomName({
+     *   prefix: 'my',
+     *   separator: '_',
+     *   postfixRandRange: { min: 1, max: 10 }
+     * }); // 'my_abandoned_yogi_5'
+     *
+     * name = NameGenerator.generateRandomName({
+     *   separator: ' ',
+     *   postfixRandRange: false
+     * }); // 'amused vampire'
+     * ```
+     *
+     * @param {GenerateRandomNameOpts} opts Optional options
+     *
+     * @returns a random formatted name
+     */
+    static generateRandomName({ prefix, separator, postfixRandRange, }?: GenerateRandomNameOpts): string;
+}
+export declare function randomNumber(max: number): number;
+export declare function randomNumber(min: number, max: number): number;