kuzzle 2.17.8 → 2.19.0

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) {
@@ -243,7 +243,8 @@ class ElasticSearch extends Service {
         continue;
       }
 
-      const alias = await this._getAliasFromIndice(indice);
+      const aliases = await this._getAliasFromIndice(indice);
+      const alias = aliases[0];
       const indexName = this._extractIndex(alias);
       const collectionName = this._extractCollection(alias);
 
@@ -303,20 +304,20 @@ class ElasticSearch extends Service {
       }
     }
 
-    let fetched = await global.kuzzle.ask('core:cache:internal:get', cacheKey);
+    const stringifiedScrollInfo = await global.kuzzle.ask('core:cache:internal:get', cacheKey);
 
-    if (! fetched) {
+    if (! stringifiedScrollInfo) {
       throw kerror.get('unknown_scroll_id');
     }
 
-    fetched = Number.parseInt(fetched);
+    const scrollInfo = JSON.parse(stringifiedScrollInfo);
 
     try {
       const { body } = await this._client.scroll(esRequest);
 
-      fetched += body.hits.hits.length;
+      scrollInfo.fetched += body.hits.hits.length;
 
-      if (fetched >= body.hits.total.value) {
+      if (scrollInfo.fetched >= body.hits.total.value) {
         debug('Last scroll page fetched: deleting scroll %s', body._scroll_id);
         await global.kuzzle.ask('core:cache:internal:del', cacheKey);
         await this.clearScroll(body._scroll_id);
@@ -325,15 +326,15 @@ class ElasticSearch extends Service {
         await global.kuzzle.ask(
           'core:cache:internal:store',
           cacheKey,
-          fetched,
+          JSON.stringify(scrollInfo),
           {
             ttl: ms(_scrollTTL) || this.scrollTTL,
           });
       }
 
-      body.remaining = body.hits.total.value - fetched;
+      body.remaining = body.hits.total.value - scrollInfo.fetched;
 
-      return await this._formatSearchResult(body);
+      return await this._formatSearchResult(body, scrollInfo);
     }
     catch (error) {
       throw this._esWrapper.formatESError(error);
@@ -401,35 +402,101 @@ class ElasticSearch extends Service {
         await global.kuzzle.ask(
           'core:cache:internal:store',
           SCROLL_CACHE_PREFIX + global.kuzzle.hash(body._scroll_id),
-          body.hits.hits.length,
+          JSON.stringify({
+            collection,
+            fetched: body.hits.hits.length,
+            index,
+            targets
+          }),
           { ttl });
 
         body.remaining = body.hits.total.value - body.hits.hits.length;
       }
 
-      return await this._formatSearchResult(body);
+      return await this._formatSearchResult(body, {
+        collection,
+        index,
+        targets
+      });
     }
     catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
 
-  async _formatSearchResult (body) {
+  /**
+   * Generate a map that associate an alias to a pair of index and collection
+   * 
+   * @param {*} targets 
+   * @returns 
+   */
+  _mapTargetsToAlias (targets) {
+    const aliasToTargets = {};
+
+    for (const target of targets) {
+      for (const targetCollection of target.collections) {
+        const alias = this._getAlias(target.index, targetCollection);
+        if (! aliasToTargets[alias]) {
+          aliasToTargets[alias] = {
+            collection: targetCollection,
+            index: target.index,
+          };
+        }
+      }
+    }
+
+    return aliasToTargets;
+  }
+
+  async _formatSearchResult (body, searchInfo = {}) {
+    let aliasToTargets = {};
+    const aliasCache = new Map();
+
+    if (searchInfo.targets) {
+      /**
+       * We need to map the alias to the target index and collection,
+       * so we can later retrieve informations about an index & collection
+       * based on its alias.
+       */
+      aliasToTargets = this._mapTargetsToAlias(searchInfo.targets);
+    }
 
     const formatHit = async (hit) => {
-      let alias = null;
+      let index = searchInfo.index;
+      let collection = searchInfo.collection;
+
+      /**
+       * If the search has been done on multiple targets, we need to
+       * retrieve the appropriate index and collection based on the alias
+       */
+      if (hit._index && searchInfo.targets) {
+
+        // Caching to reduce call to ES
+        let aliases = aliasCache.get(hit._index);
+        if (! aliases) {
+          // Retrieve all the alias associated to one index
+          aliases = await this._getAliasFromIndice(hit._index);
+          aliasCache.set(hit._index, aliases);
+        }
 
-      if (hit._index) {
-        alias = await this._getAliasFromIndice(hit._index);
+        /**
+         * Since multiple alias can point to the same index in ES, we need to
+         * find the first alias that exists in the map of aliases associated
+         * to the targets.
+         */
+        const alias = aliases.find(_alias => aliasToTargets[_alias]);
+        // Retrieve index and collection information based on the matching alias
+        index = aliasToTargets[alias].index;
+        collection = aliasToTargets[alias].collection;
       }
 
       return {
         _id: hit._id,
         _score: hit._score,
         _source: hit._source,
-        collection: alias ? this._extractCollection(alias) : undefined,
+        collection,
         highlight: hit.highlight,
-        index: alias ? this._extractIndex(alias) : undefined,
+        index,
       };
     };
 
@@ -1368,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);
@@ -1393,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)) {
@@ -1410,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
   *
@@ -1516,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
@@ -1525,6 +1601,7 @@ class ElasticSearch extends Service {
    */
   async truncateCollection (index, collection) {
     let mappings;
+    let settings;
 
     const esRequest = {
       index: await this._getIndice(index, collection)
@@ -1532,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({
@@ -1541,7 +1622,8 @@ class ElasticSearch extends Service {
           aliases: {
             [this._getAlias(index, collection)]: {}
           },
-          mappings
+          mappings,
+          settings
         }
       });
 
@@ -1819,22 +1901,14 @@ class ElasticSearch extends Service {
       index: await this._getIndice(index, collection)
     };
 
-    const mutex = new Mutex(`hiddenCollection/delete/${index}`);
     try {
       await this._client.indices.delete(esRequest);
 
-      await mutex.lock();
-
-      if (! await this._hasHiddenCollection(index)) {
-        await this._createHiddenCollection(index);
-      }
+      await this._createHiddenCollection(index);
     }
     catch (e) {
       throw this._esWrapper.formatESError(e);
     }
-    finally {
-      await mutex.unlock();
-    }
 
     return null;
   }
@@ -2476,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 }>
@@ -2792,12 +2866,24 @@ class ElasticSearch extends Service {
       throw kerror.get('unknown_index_collection');
     }
     else if (body.length > 1) {
-      throw kerror.get('multiple_indice_alias', 'alias', 'indices');
+      throw kerror.get('multiple_indice_alias', `"alias" starting with "${ALIAS_PREFIX}"`, '"indices"');
     }
 
     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`.
@@ -2838,20 +2924,19 @@ class ElasticSearch extends Service {
    * @param {String} indice
    *
    * @returns {String} Alias name (eg: '@&nepali.liia')
-   * @throws If there is not exactly one alias associated
+   * @throws If there is not exactly one alias associated that is prefixed with @
    */
   async _getAliasFromIndice (indice) {
     const { body } = await this._client.indices.getAlias({ index: indice });
-    const aliases = Object.keys(body[indice].aliases);
+    const aliases =
+      Object.keys(body[indice].aliases)
+        .filter(alias => alias.startsWith(ALIAS_PREFIX));
 
     if (aliases.length < 1) {
       throw kerror.get('unknown_index_collection');
     }
-    else if (aliases.length > 1) {
-      throw kerror.get('multiple_indice_alias', 'indice', 'aliases');
-    }
 
-    return aliases[0];
+    return aliases;
   }
 
   /**
@@ -2960,13 +3045,21 @@ class ElasticSearch extends Service {
   }
 
   /**
-   * Creates the hidden collection on the provided index.
+   * Creates the hidden collection on the provided index if it does not already
+   * exists
    *
    * @param {String} index Index name
    */
   async _createHiddenCollection (index) {
+    const mutex = new Mutex(`hiddenCollection/${index}`);
 
     try {
+      await mutex.lock();
+
+      if (await this._hasHiddenCollection(index)) {
+        return;
+      }
+
       await this._client.indices.create({
         body: {
           aliases: {
@@ -2983,6 +3076,9 @@ class ElasticSearch extends Service {
     catch (e) {
       throw this._esWrapper.formatESError(e);
     }
+    finally {
+      await mutex.unlock();
+    }
   }
 
   /**

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/types/index.d.ts

@@ -2,7 +2,6 @@ export * from './Plugin';
 export * from './Controller';
 export * from './ControllerDefinition';
 export * from './ControllerRights';
-export * from './RequestPayload';
 export * from './ResponsePayload';
 export * from './Deprecation';
 export * from './EventHandler';

package/lib/types/index.js

@@ -38,7 +38,6 @@ __exportStar(require("./Plugin"), exports);
 __exportStar(require("./Controller"), exports);
 __exportStar(require("./ControllerDefinition"), exports);
 __exportStar(require("./ControllerRights"), exports);
-__exportStar(require("./RequestPayload"), exports);
 __exportStar(require("./ResponsePayload"), exports);
 __exportStar(require("./Deprecation"), exports);
 __exportStar(require("./EventHandler"), exports);

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/dump-collection.d.ts

@@ -1,3 +1,38 @@
 import { JSONObject } from '../../index';
 import { HttpStream } from '../types';
+/**
+ * Flatten an object transform:
+ * {
+ *  title: "kuzzle",
+ *  info : {
+ *    tag: "news"
+ *  }
+ * }
+ *
+ * Into an object like:
+ * {
+ *  title: "kuzzle",
+ *  info.tag: news
+ * }
+ *
+ * @param {Object} target the object we have to flatten
+ * @returns {Object} the flattened object
+ */
+export declare function flattenObject(target: JSONObject): JSONObject;
+/**
+ * Extract fields from mapping by removing the properties from es mapping
+ *
+ * @param mapping
+ * @returns
+ */
+export declare function extractMappingFields(mapping: JSONObject): any;
+/**
+ * An iteration-order-safe version of lodash.values
+ *
+ * @param object The object containing the values
+ * @param fields The field names to pick in the right order
+ * @returns The values in the same order as the fields
+ * @see https://lodash.com/docs/4.17.15#values
+ */
+export declare function pickValues(object: any, fields: string[]): any[];
 export declare function dumpCollectionDocuments(index: string, collection: string, query?: any, format?: string, fields?: string[], options?: JSONObject): HttpStream;

package/lib/util/dump-collection.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dumpCollectionDocuments = void 0;
+exports.dumpCollectionDocuments = exports.pickValues = exports.extractMappingFields = exports.flattenObject = void 0;
 const ndjson_1 = __importDefault(require("ndjson"));
 const get_1 = __importDefault(require("lodash/get"));
 const isObject_1 = __importDefault(require("lodash/isObject"));
@@ -56,6 +56,7 @@ function flattenObject(target) {
     flattenStep(output, target);
     return output;
 }
+exports.flattenObject = flattenObject;
 function flattenStep(output, object, prev = null) {
     const keys = Object.keys(object);
     for (let i = 0; i < keys.length; i++) {
@@ -63,8 +64,8 @@ function flattenStep(output, object, prev = null) {
         const value = object[key];
         const newKey = prev ? prev + '.' + key : key;
         if (Object.prototype.toString.call(value) === '[object Object]') {
-            output[newKey] = value;
             flattenStep(output, value, newKey);
+            continue;
         }
         output[newKey] = value;
     }
@@ -77,19 +78,20 @@ function flattenStep(output, object, prev = null) {
  */
 function extractMappingFields(mapping) {
     const newMapping = {};
+    if (mapping.properties) {
+        return extractMappingFields(mapping.properties);
+    }
     for (const key of Object.keys(mapping)) {
-        if (key === 'properties' && (0, isObject_1.default)(mapping[key])) {
-            newMapping[key] = extractMappingFields(mapping[key]);
-        }
-        else if ((0, isObject_1.default)(mapping[key]) && mapping[key].type) {
+        if ((0, isObject_1.default)(mapping[key]) && mapping[key].type) {
             newMapping[key] = mapping[key].type;
         }
-        else {
-            newMapping[key] = mapping[key];
+        else if ((0, isObject_1.default)(mapping[key])) {
+            newMapping[key] = extractMappingFields(mapping[key]);
         }
     }
     return newMapping;
 }
+exports.extractMappingFields = extractMappingFields;
 /**
  * An iteration-order-safe version of lodash.values
  *
@@ -101,6 +103,7 @@ function extractMappingFields(mapping) {
 function pickValues(object, fields) {
     return fields.map(f => formatValueForCSV((0, get_1.default)(object, f)));
 }
+exports.pickValues = pickValues;
 /**
  * Formats the value for correct CSV output, avoiding to return
  * values that would badly serialize in CSV.

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;