kuzzle 2.19.2 → 2.19.3

package/lib/service/storage/esWrapper.js

@@ -21,140 +21,149 @@
 
 /* eslint sort-keys: 0 */
 
-'use strict';
+"use strict";
 
-const Bluebird = require('bluebird');
-const _ = require('lodash');
-const es = require('@elastic/elasticsearch');
+const Bluebird = require("bluebird");
+const _ = require("lodash");
+const es = require("@elastic/elasticsearch");
 
-const { KuzzleError } = require('../../kerror/errors');
-const debug = require('../../util/debug')('kuzzle:services:storage:ESCommon');
-const kerror = require('../../kerror').wrap('services', 'storage');
+const { KuzzleError } = require("../../kerror/errors");
+const debug = require("../../util/debug")("kuzzle:services:storage:ESCommon");
+const kerror = require("../../kerror").wrap("services", "storage");
 
 const errorMessagesMapping = [
   {
-    regex: /^\[es_rejected_execution_exception] rejected execution .*? on EsThreadPoolExecutor\[(.*?), .*$/,
-    subCode: 'too_many_operations',
-    getPlaceholders: (esError, matches) => [matches[1]]
+    regex:
+      /^\[es_rejected_execution_exception] rejected execution .*? on EsThreadPoolExecutor\[(.*?), .*$/,
+    subCode: "too_many_operations",
+    getPlaceholders: (esError, matches) => [matches[1]],
   },
   {
     // [illegal_argument_exception] object mapping [titi] can't be changed from nested to non-nested
-    regex: /^\[illegal_argument_exception] object mapping \[(.*?)] can't be changed from nested to non-nested$/,
-    subcode: 'cannot_change_mapping',
-    getPlaceholders: (esError, matches) => [matches[1]]
+    regex:
+      /^\[illegal_argument_exception] object mapping \[(.*?)] can't be changed from nested to non-nested$/,
+    subcode: "cannot_change_mapping",
+    getPlaceholders: (esError, matches) => [matches[1]],
   },
   {
     // [illegal_argument_exception] object mapping [baz] can't be changed from non-nested to nested
-    regex: /^\[illegal_argument_exception] object mapping \[(.*?)] can't be changed from non-nested to nested$/,
-    subcode: 'cannot_change_mapping',
-    getPlaceholders: (esError, matches) => [matches[1]]
+    regex:
+      /^\[illegal_argument_exception] object mapping \[(.*?)] can't be changed from non-nested to nested$/,
+    subcode: "cannot_change_mapping",
+    getPlaceholders: (esError, matches) => [matches[1]],
   },
   {
     // [illegal_argument_exception] Can't merge a non object mapping [aeaze] with an object mapping [aeaze]
-    regex: /^\[illegal_argument_exception] Can't merge a non object mapping \[(.*?)] with an object mapping \[(.*?)]$/,
-    subcode: 'cannot_change_mapping',
-    getPlaceholders: (esError, matches) => [matches[1]]
+    regex:
+      /^\[illegal_argument_exception] Can't merge a non object mapping \[(.*?)] with an object mapping \[(.*?)]$/,
+    subcode: "cannot_change_mapping",
+    getPlaceholders: (esError, matches) => [matches[1]],
   },
   {
     // [illegal_argument_exception] [tutu.tutu] is defined as an object in mapping [aze] but this name is already used for a field in other types
-    regex: /^\[illegal_argument_exception] \[(.*?)] is defined as an object in mapping \[(.*?)] but this name is already used for a field in other types$/,
-    subcode: 'duplicate_field_mapping',
-    getPlaceholders: (esError, matches) => [matches[1], matches[2]]
+    regex:
+      /^\[illegal_argument_exception] \[(.*?)] is defined as an object in mapping \[(.*?)] but this name is already used for a field in other types$/,
+    subcode: "duplicate_field_mapping",
+    getPlaceholders: (esError, matches) => [matches[1], matches[2]],
   },
   {
     // [illegal_argument_exception] mapper [source.flags] of different type, current_type [string], merged_type [long]
-    regex: /^mapper \[(.*?)] of different type, current_type \[(.*?)], merged_type \[(.*?)]$/,
-    subcode: 'cannot_change_mapping',
-    getPlaceholders: (esError, matches) => [matches[1]]
+    regex:
+      /^mapper \[(.*?)] of different type, current_type \[(.*?)], merged_type \[(.*?)]$/,
+    subcode: "cannot_change_mapping",
+    getPlaceholders: (esError, matches) => [matches[1]],
   },
   {
     // [mapper_parsing_exception] Mapping definition for [flags] has unsupported parameters:  [index : not_analyzed]
     // eslint-disable-next-line no-regex-spaces
-    regex: /^\[mapper_parsing_exception] Mapping definition for \[(.*?)] has unsupported parameters: \[(.*?)]$/,
-    subcode: 'unexpected_properties',
-    getPlaceholders: (esError, matches) => [matches[2], matches[1]]
+    regex:
+      /^\[mapper_parsing_exception] Mapping definition for \[(.*?)] has unsupported parameters: \[(.*?)]$/,
+    subcode: "unexpected_properties",
+    getPlaceholders: (esError, matches) => [matches[2], matches[1]],
   },
   {
     // [mapper_parsing_exception] No handler for type [boolean] declared on field [not]
-    regex: /^\[mapper_parsing_exception] No handler for type \[(.*?)] declared on field \[(.*?)]$/,
-    subcode: 'invalid_mapping_type',
-    getPlaceholders: (esError, matches) => [matches[2], matches[1]]
+    regex:
+      /^\[mapper_parsing_exception] No handler for type \[(.*?)] declared on field \[(.*?)]$/,
+    subcode: "invalid_mapping_type",
+    getPlaceholders: (esError, matches) => [matches[2], matches[1]],
   },
   {
     // [mapper_parsing_exception] failed to parse [conditions.host.flags]
     regex: /^\[mapper_parsing_exception] failed to parse \[(.*?)]$/,
-    subcode: 'wrong_mapping_property',
-    getPlaceholders: (esError, matches) => [matches[1]]
+    subcode: "wrong_mapping_property",
+    getPlaceholders: (esError, matches) => [matches[1]],
   },
   {
     // Failed to parse mapping [_doc]: Expected map for property [fields] on field [enabled] but got a class java.lang.String
-    regex: /^Failed to parse mapping \[.*\]: Expected \w+ for property \[(.*)\] on field \[(.*)\]/,
-    subcode: 'wrong_mapping_property',
-    getPlaceholders: (esError, matches) => [`${matches[2]}.${matches[1]}`]
+    regex:
+      /^Failed to parse mapping \[.*\]: Expected \w+ for property \[(.*)\] on field \[(.*)\]/,
+    subcode: "wrong_mapping_property",
+    getPlaceholders: (esError, matches) => [`${matches[2]}.${matches[1]}`],
   },
   {
     // [index_not_found_exception] no such index, with { resource.type=index_or_alias & resource.id=foso & index=foso }
     regex: /^no such index \[([%&])(.*)\.(.*)\]$/,
-    subcode: 'unknown_collection',
-    getPlaceholders: (esError, matches) => [
-      matches[2],
-      matches[3]
-    ]
+    subcode: "unknown_collection",
+    getPlaceholders: (esError, matches) => [matches[2], matches[3]],
   },
   {
     // [mapper_parsing_exception] Expected map for property [fields] on field [foo] but got a class java.lang.String
-    regex: /^\[mapper_parsing_exception] Expected map for property \[(.*?)] on field \[(.*?)] but got a class java\.lang\.String$/,
-    subcode: 'wrong_mapping_property',
-    getPlaceholders: (esError, matches) => [`${matches[2]}.${matches[1]}`]
+    regex:
+      /^\[mapper_parsing_exception] Expected map for property \[(.*?)] on field \[(.*?)] but got a class java\.lang\.String$/,
+    subcode: "wrong_mapping_property",
+    getPlaceholders: (esError, matches) => [`${matches[2]}.${matches[1]}`],
   },
   {
-    regex: /^\[version_conflict_engine_exception] \[data]\[(.*?)]: version conflict.*$/,
-    subcode: 'too_many_changes',
-    getPlaceholders: (esError, matches) => [matches[1]]
+    regex:
+      /^\[version_conflict_engine_exception] \[data]\[(.*?)]: version conflict.*$/,
+    subcode: "too_many_changes",
+    getPlaceholders: (esError, matches) => [matches[1]],
   },
   {
     //[liia]: version conflict, document already exists (current version [2])
     regex: /^\[(.*)\]: version conflict, document already exists.*/,
-    subcode: 'document_already_exists',
-    getPlaceholders: () => []
+    subcode: "document_already_exists",
+    getPlaceholders: () => [],
   },
   {
     // Unknown key for a START_OBJECT in [term].
     regex: /^Unknown key for a START_OBJECT in \[(.*)\].*/,
-    subcode: 'invalid_search_query',
-    getPlaceholders: (esError, matches) => [matches[1]]
+    subcode: "invalid_search_query",
+    getPlaceholders: (esError, matches) => [matches[1]],
   },
   {
     // mapping set to strict, dynamic introduction of [lehuong] within [_doc] is not allowed
-    regex: /^mapping set to strict, dynamic introduction of \[(.+)\] within \[.+\] is not allowed/,
-    subcode: 'strict_mapping_rejection',
+    regex:
+      /^mapping set to strict, dynamic introduction of \[(.+)\] within \[.+\] is not allowed/,
+    subcode: "strict_mapping_rejection",
     getPlaceholders: (esError, matches) => {
       // "/%26index.collection/_doc"
       const esPath = esError.meta.meta.request.params.path;
       // keep only "index"
-      const index = esPath.split('.')[0].split('%26')[1];
+      const index = esPath.split(".")[0].split("%26")[1];
       // keep only "collection"
-      const collection = esPath.substr(esPath.indexOf('.') + 1).split('/')[0];
+      const collection = esPath.substr(esPath.indexOf(".") + 1).split("/")[0];
 
       return [matches[1], index, collection];
-    }
+    },
   },
   {
     // [and] query malformed, no start_object after query name
     regex: /^\[(.*)\] query malformed, no start_object after query name/,
-    subcode: 'unknown_query_keyword',
-    getPlaceholders: (esError, matches) => [matches[1]]
+    subcode: "unknown_query_keyword",
+    getPlaceholders: (esError, matches) => [matches[1]],
   },
   {
     // no [query] registered for [equals]
     regex: /^no \[query\] registered for \[(.*)\]/,
-    subcode: 'unknown_query_keyword',
-    getPlaceholders: (esError, matches) => [matches[1]]
+    subcode: "unknown_query_keyword",
+    getPlaceholders: (esError, matches) => [matches[1]],
   },
 ];
 
 class ESWrapper {
-  constructor (client) {
+  constructor(client) {
     this.client = client;
   }
 
@@ -164,12 +173,12 @@ class ESWrapper {
    * @param {Error} error
    * @returns {KuzzleError}
    */
-  formatESError (error) {
+  formatESError(error) {
     if (error instanceof KuzzleError) {
       return error;
     }
 
-    global.kuzzle.emit('services:storage:error', {
+    global.kuzzle.emit("services:storage:error", {
       message: `Elasticsearch Client error: ${error.message}`,
       // /!\ not all ES error classes have a "meta" property
       meta: error.meta || null,
@@ -177,9 +186,9 @@ class ESWrapper {
     });
 
     if (error instanceof es.errors.NoLivingConnectionsError) {
-      throw kerror.get('not_connected');
+      throw kerror.get("not_connected");
     }
-    const message = _.get(error, 'meta.body.error.reason', error.message);
+    const message = _.get(error, "meta.body.error.reason", error.message);
 
     // Try to match a known elasticsearch error
     for (const betterError of errorMessagesMapping) {
@@ -188,7 +197,8 @@ class ESWrapper {
       if (matches) {
         return kerror.get(
           betterError.subcode,
-          ...betterError.getPlaceholders(error, matches));
+          ...betterError.getPlaceholders(error, matches)
+        );
       }
     }
 
@@ -209,45 +219,45 @@ class ESWrapper {
     return this._handleUnknownError(error, message);
   }
 
-  reject (error) {
+  reject(error) {
     return Bluebird.reject(this.formatESError(error));
   }
 
-  _handleConflictError (error, message) {
+  _handleConflictError(error, message) {
     debug('unhandled "Conflict" elasticsearch error: %a', error);
 
-    return kerror.get('unexpected_error', message);
+    return kerror.get("unexpected_error", message);
   }
 
-  _handleNotFoundError (error, message) {
+  _handleNotFoundError(error, message) {
     let errorMessage = message;
 
     // _index= "&nyc-open-data.yellow-taxi"
-    const index = error.body._index.split('.')[0].slice(1);
-    const collection = error.body._index.split('.')[1];
+    const index = error.body._index.split(".")[0].slice(1);
+    const collection = error.body._index.split(".")[1];
 
     // 404 on a GET document
     if (error.body.found === false) {
-      return kerror.get('not_found', error.body._id, index, collection);
+      return kerror.get("not_found", error.body._id, index, collection);
     }
 
     // 404 on DELETE document (ES error payloads are so cool!)
     if (error.meta.body._id) {
-      return kerror.get('not_found', error.meta.body._id, index, collection);
+      return kerror.get("not_found", error.meta.body._id, index, collection);
     }
 
     if (error.meta.body && error.meta.body.error) {
       errorMessage = error.meta.body.error
-        ? `${error.meta.body.error.reason}: ${error.meta.body.error['resource.id']}`
+        ? `${error.meta.body.error.reason}: ${error.meta.body.error["resource.id"]}`
         : `${error.message}: ${error.body._id}`;
     }
 
     debug('unhandled "NotFound" elasticsearch error: %a', error);
 
-    return kerror.get('unexpected_not_found', errorMessage);
+    return kerror.get("unexpected_not_found", errorMessage);
   }
 
-  _handleBadRequestError (error, message) {
+  _handleBadRequestError(error, message) {
     let errorMessage = message;
 
     if (error.meta.body && error.meta.body.error) {
@@ -256,24 +266,31 @@ class ESWrapper {
         : error.meta.body.error.reason;
 
       // empty query throws exception with ES 7
-      if ( error.meta.body.error.type === 'parsing_exception'
-        && _.get(error, 'meta.body.error.caused_by.type') === 'illegal_argument_exception') {
+      if (
+        error.meta.body.error.type === "parsing_exception" &&
+        _.get(error, "meta.body.error.caused_by.type") ===
+          "illegal_argument_exception"
+      ) {
         errorMessage = error.meta.body.error.caused_by.reason;
       }
     }
 
-    debug('unhandled "BadRequest" elasticsearch error: %a', _.get(error, 'meta.body.error.reason', error.message));
+    debug(
+      'unhandled "BadRequest" elasticsearch error: %a',
+      _.get(error, "meta.body.error.reason", error.message)
+    );
 
-    return kerror.get('unexpected_bad_request', errorMessage);
+    return kerror.get("unexpected_bad_request", errorMessage);
   }
 
-  _handleUnknownError (error, message) {
+  _handleUnknownError(error, message) {
     debug(
-      'unhandled elasticsearch error (unhandled type: %s): %o',
-      _.get(error, 'error.meta.statusCode', '<no status code>'),
-      error);
+      "unhandled elasticsearch error (unhandled type: %s): %o",
+      _.get(error, "error.meta.statusCode", "<no status code>"),
+      error
+    );
 
-    return kerror.get('unexpected_error', message);
+    return kerror.get("unexpected_error", message);
   }
 }
 

package/lib/service/storage/queryTranslator.js

@@ -19,105 +19,99 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 class KeywordError extends Error {
-  constructor (type, name) {
-    super(`The ${type} "${name}" of Koncorde DSL is not supported for search queries.`);
+  constructor(type, name) {
+    super(
+      `The ${type} "${name}" of Koncorde DSL is not supported for search queries.`
+    );
 
     this.keyword = { name, type };
   }
 }
 
-const KONCORDE_OPERATORS = ['and', 'or', 'not', 'bool'];
+const KONCORDE_OPERATORS = ["and", "or", "not", "bool"];
 
 const KONCORDE_CLAUSES_TO_ES = {
-  equals: content => ({
+  equals: (content) => ({
     term: {
-      ...content
-    }
+      ...content,
+    },
   }),
-  exists: field => ({
+  exists: (field) => ({
     exists: {
-      field
-    }
+      field,
+    },
   }),
-  geoBoundingBox: content => ({
+  geoBoundingBox: (content) => ({
     geo_bounding_box: {
-      ...content
-    }
+      ...content,
+    },
   }),
-  geoDistance: content => ({
+  geoDistance: (content) => ({
     geo_distance: {
-      ...content
-    }
+      ...content,
+    },
   }),
-  geoDistanceRange: content => ({
+  geoDistanceRange: (content) => ({
     geo_distance_range: {
-      ...content
-    }
+      ...content,
+    },
   }),
-  geoPolygon: content => ({
+  geoPolygon: (content) => ({
     geo_polygon: {
-      ...content
-    }
+      ...content,
+    },
   }),
-  ids: content => ({
+  ids: (content) => ({
     ids: {
-      ...content
-    }
+      ...content,
+    },
   }),
-  in: content => ({
+  in: (content) => ({
     terms: {
-      ...content
-    }
+      ...content,
+    },
   }),
-  missing: field => ({
+  missing: (field) => ({
     bool: {
-      must_not: [
-        { exists: { field } }
-      ]
-    }
+      must_not: [{ exists: { field } }],
+    },
   }),
-  range: content => ({
+  range: (content) => ({
     range: {
-      ...content
-    }
+      ...content,
+    },
   }),
   regexp: undefined,
 };
 
 const KONCORDE_OPERATORS_TO_ES = {
-  and: content => ({
+  and: (content) => ({
     bool: {
-      filter: [
-        ...content
-      ]
-    }
+      filter: [...content],
+    },
   }),
   bool: undefined,
-  not: content => {
+  not: (content) => {
     const [name, value] = Object.entries(content[0])[0];
 
     return {
       bool: {
-        must_not: [
-          { [name]: value }
-        ]
-      }
+        must_not: [{ [name]: value }],
+      },
     };
   },
-  or: content => ({
+  or: (content) => ({
     bool: {
-      should: [
-        ...content
-      ]
-    }
+      should: [...content],
+    },
   }),
 };
 
 class QueryTranslator {
-  translate (filters) {
+  translate(filters) {
     const [name, value] = Object.entries(filters)[0];
 
     if (KONCORDE_OPERATORS.includes(name)) {
@@ -127,19 +121,18 @@ class QueryTranslator {
     return this._translateClause(name, value);
   }
 
-  _translateOperator (operator, operands) {
+  _translateOperator(operator, operands) {
     const converter = KONCORDE_OPERATORS_TO_ES[operator];
 
     if (converter === undefined) {
-      throw new KeywordError('operator', operator);
+      throw new KeywordError("operator", operator);
     }
 
     const esOperands = [];
 
-    if (operator === 'not') {
+    if (operator === "not") {
       esOperands.push(this.translate(operands));
-    }
-    else {
+    } else {
       for (const operand of operands) {
         esOperands.push(this.translate(operand));
       }
@@ -148,11 +141,11 @@ class QueryTranslator {
     return converter(esOperands);
   }
 
-  _translateClause (clause, content) {
+  _translateClause(clause, content) {
     const converter = KONCORDE_CLAUSES_TO_ES[clause];
 
     if (converter === undefined) {
-      throw new KeywordError('clause', clause);
+      throw new KeywordError("clause", clause);
     }
 
     return converter(content);

package/lib/types/Controller.d.ts

@@ -1,6 +1,6 @@
-import { Backend } from '../core/backend';
-import { ControllerDefinition } from './ControllerDefinition';
-import { EmbeddedSDK } from '../core/shared/sdk/embeddedSdk';
+import { Backend } from "../core/backend";
+import { ControllerDefinition } from "./ControllerDefinition";
+import { EmbeddedSDK } from "../core/shared/sdk/embeddedSdk";
 /**
  * Base class to declare a controller class
  */

package/lib/types/ControllerDefinition.d.ts

@@ -1,5 +1,5 @@
-import { JSONObject } from 'kuzzle-sdk';
-import { KuzzleRequest } from '../api/request';
+import { JSONObject } from "kuzzle-sdk";
+import { KuzzleRequest } from "../api/request";
 /**
  * API controller definition.
  *
@@ -68,7 +68,7 @@ export declare type HttpRoute = {
     /**
      * HTTP verb.
      */
-    verb: 'get' | 'head' | 'post' | 'put' | 'delete' | 'patch' | 'options';
+    verb: "get" | "head" | "post" | "put" | "delete" | "patch" | "options";
     /**
      * Route path.
      * A route starting with `/` will be prefixed by `/_` otherwise the route

package/lib/types/DebugModule.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import EventEmitter from 'events';
-import Inspector from 'inspector';
+import EventEmitter from "events";
+import Inspector from "inspector";
 export declare type DebugModuleOptions = {
     methods?: string[];
     events?: string[];

package/lib/types/DebugModule.js

@@ -12,7 +12,7 @@ class DebugModule extends events_1.default {
         this.methods = options.methods || [];
         this.events = options.events || [];
         if (!this.name || this.name.length === 0) {
-            throw new Error('DebugModule should have a name');
+            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`);

package/lib/types/Global.d.ts

@@ -1,4 +1,4 @@
-import { Backend } from '../core/backend';
+import { Backend } from "../core/backend";
 declare global {
     namespace NodeJS {
         interface Global {

package/lib/types/HttpStream.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Readable } from 'stream';
+import { Readable } from "stream";
 export declare type HttpStreamProperties = {
     totalBytes?: number;
 };
@@ -11,6 +11,7 @@ export declare class HttpStream {
     readonly stream: Readable;
     readonly totalBytes: number;
     private _destroyed;
+    private get readableState();
     constructor(readableStream: Readable, { totalBytes }?: HttpStreamProperties);
     /**
      * Returns if the stream is errored

package/lib/types/HttpStream.js

@@ -32,20 +32,22 @@ class HttpStream {
         this.totalBytes = totalBytes;
         this._destroyed = readableStream.destroyed;
     }
+    get readableState() {
+        // @ts-ignore
+        return this.stream._readableState;
+    }
     /**
      * Returns if the stream is errored
      */
     get errored() {
-        // @ts-ignore
-        return this.stream._readableState.errored !== null // @ts-ignore
-            && this.stream._readableState.errored !== undefined;
+        return (this.readableState.errored !== null &&
+            this.readableState.errored !== undefined);
     }
     /**
      * Get the error
      */
     get error() {
-        // @ts-ignore
-        return this.stream._readableState.errored;
+        return this.readableState.errored;
     }
     /**
      * Returns if the stream has been destroyed

package/lib/types/Kuzzle.d.ts

@@ -1,4 +1,4 @@
-import { JSONObject } from '../../index';
+import { JSONObject } from "../../index";
 export declare type InstallationConfig = {
     id: string;
     handler: () => Promise<void>;

package/lib/types/KuzzleDocument.d.ts

@@ -1,4 +1,4 @@
-import { JSONObject } from 'kuzzle-sdk';
+import { JSONObject } from "kuzzle-sdk";
 /**
  * @deprecated Use KDocument instead (See https://docs.kuzzle.io/sdk/js/7/essentials/strong-typing/)
  */

package/lib/types/OpenApiDefinition.d.ts

@@ -1,4 +1,4 @@
-import { JSONObject } from 'kuzzle-sdk';
+import { JSONObject } from "kuzzle-sdk";
 export declare type OpenApiDefinition = {
     swagger?: string;
     openapi?: string;