kuzzle 2.19.2 → 2.19.3

package/lib/kerror/codes/1-services.json

@@ -131,7 +131,7 @@
           "message": "The \"_routing\" keyword is forbidden.",
           "class": "BadRequestError"
         },
-        "not_connected":{
+        "not_connected": {
           "description": "Unable to connect to the storage instance",
           "code": 24,
           "message": "Elasticsearch service is not connected.",
@@ -287,6 +287,12 @@
           "message": "The %s (\"%s\") contains invalid characters \",+*\" or is equal to \"_all\" which is forbidden",
           "code": 50,
           "class": "BadRequestError"
+        },
+        "wrong_es_static_settings_for_collection_recreation": {
+          "description": "The ES static settings specified at the creation of an existing collection does not match existing settings",
+          "message": "Attempt to recreate an existing collection %s of index %s of scope %s with non matching static setting : %s at %s while existing one is at %s",
+          "code": 51,
+          "class": "BadRequestError"
         }
       }
     },

package/lib/kerror/codes/4-plugin.json

@@ -3,7 +3,7 @@
   "subDomains": {
     "assert": {
       "code": 1,
-      "errors" : {
+      "errors": {
         "invalid_plugins_dir": {
           "description": "The enabled plugins directory cannot be opened",
           "code": 1,
@@ -164,7 +164,7 @@
     },
     "strategy": {
       "code": 3,
-      "errors" : {
+      "errors": {
         "invalid_description": {
           "description": "The strategy.description field must be an object",
           "code": 1,

package/lib/kerror/codes/index.js

@@ -19,160 +19,182 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const assert = require('assert');
+const assert = require("assert");
 
-const errors = require('../errors');
-const { has, isPlainObject } = require('../../util/safeObject');
+const errors = require("../errors");
+const { has, isPlainObject } = require("../../util/safeObject");
 
 // codes
 const domains = {
-  api: require('./2-api'),
-  cluster: require('./8-cluster.json'),
-  core: require('./0-core'),
-  network: require('./3-network'),
-  plugin: require('./4-plugin'),
-  protocol: require('./6-protocol'),
-  security: require('./7-security'),
-  services: require('./1-services'),
-  validation: require('./5-validation'),
+  api: require("./2-api"),
+  cluster: require("./8-cluster.json"),
+  core: require("./0-core"),
+  network: require("./3-network"),
+  plugin: require("./4-plugin"),
+  protocol: require("./6-protocol"),
+  security: require("./7-security"),
+  services: require("./1-services"),
+  validation: require("./5-validation"),
 };
 
 /** Check the format of the error codes files
  *  @param {object} - error config file domain
  */
 
-function checkErrors (subdomain, domain, options) {
+function checkErrors(subdomain, domain, options) {
   const codes = new Set();
 
   for (const [name, error] of Object.entries(subdomain.errors)) {
     assert(
-      has(error, 'code'),
-      `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+      has(error, "code"),
+      `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+    );
     assert(
       Number.isInteger(error.code),
-      `Error configuration file : Field 'code' must be an integer (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+      `Error configuration file : Field 'code' must be an integer (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+    );
     assert(
-      error.code > 0x0000 && error.code <= 0xFFFF,
-      `Error configuration file : Field 'code' must be between 1 and 65535 (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+      error.code > 0x0000 && error.code <= 0xffff,
+      `Error configuration file : Field 'code' must be between 1 and 65535 (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+    );
     assert(
-      ! codes.has(error.code),
-      `Error configuration file : code ${error.code} for error '${name}' is not unique (domain: ${domain.code}, subdomain: ${subdomain.code}).`);
+      !codes.has(error.code),
+      `Error configuration file : code ${error.code} for error '${name}' is not unique (domain: ${domain.code}, subdomain: ${subdomain.code}).`
+    );
 
     codes.add(error.code);
 
     assert(
-      has(error, 'message'),
-      `Error configuration file : Missing required 'message' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+      has(error, "message"),
+      `Error configuration file : Missing required 'message' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+    );
     assert(
-      typeof error.message === 'string' && error.message.length > 0,
-      `Error configuration file : Field 'message' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+      typeof error.message === "string" && error.message.length > 0,
+      `Error configuration file : Field 'message' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+    );
 
     assert(
-      has(error, 'class'),
-      `Error configuration file : Missing required 'class' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+      has(error, "class"),
+      `Error configuration file : Missing required 'class' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+    );
     assert(
-      typeof error.class === 'string',
-      `Error configuration file : Field 'class' must be a string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+      typeof error.class === "string",
+      `Error configuration file : Field 'class' must be a string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+    );
     assert(
       has(errors, error.class),
-      `Error configuration file : Field 'class' must target a known KuzzleError object (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}), '${name.class}' does not exist.`);
+      `Error configuration file : Field 'class' must target a known KuzzleError object (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}), '${name.class}' does not exist.`
+    );
 
     // plugin errors aren't required to have descriptions
-    if (! options.plugin) {
+    if (!options.plugin) {
       assert(
-        typeof error.description === 'string' && error.description.length > 0,
-        `Error configuration file : Field 'description' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        typeof error.description === "string" && error.description.length > 0,
+        `Error configuration file : Field 'description' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+      );
     }
 
     if (error.deprecated !== undefined && error.deprecated !== null) {
       assert(
-        typeof error.deprecated === 'string' && error.deprecated.length > 0,
-        `Error configuration file : Field 'deprecated' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        typeof error.deprecated === "string" && error.deprecated.length > 0,
+        `Error configuration file : Field 'deprecated' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+      );
     }
   }
 }
 
-function checkSubdomains (domain, options) {
+function checkSubdomains(domain, options) {
   const subdomainCodes = new Set();
 
   for (const subdomainName of Object.keys(domain.subDomains)) {
     const subdomain = domain.subDomains[subdomainName];
 
     // Subdomain code for plugins is not required and is automatically set to 0
-    if (! options.plugin) {
+    if (!options.plugin) {
       assert(
-        has(subdomain, 'code'),
-        `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomainName}).`);
-    }
-    else if (! has(subdomain, 'code')) {
+        has(subdomain, "code"),
+        `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomainName}).`
+      );
+    } else if (!has(subdomain, "code")) {
       subdomain.code = 0;
     }
 
     assert(
       Number.isInteger(subdomain.code),
-      `Error configuration file : Field 'code' must be an integer (domain: ${domain.code}, subdomain: ${subdomainName}).`);
+      `Error configuration file : Field 'code' must be an integer (domain: ${domain.code}, subdomain: ${subdomainName}).`
+    );
     assert(
-      subdomain.code >= 0x00 && subdomain.code <= 0xFF,
-      `Error configuration file : Field 'code' must be between 0 and 255 (domain: ${domain.code}, subdomain: ${subdomainName}).`);
+      subdomain.code >= 0x00 && subdomain.code <= 0xff,
+      `Error configuration file : Field 'code' must be between 0 and 255 (domain: ${domain.code}, subdomain: ${subdomainName}).`
+    );
     assert(
-      ! subdomainCodes.has(subdomain.code),
-      `Error configuration file : code ${subdomain.code} for subdomain '${subdomainName}' is not unique (domain: ${domain.code}).`);
+      !subdomainCodes.has(subdomain.code),
+      `Error configuration file : code ${subdomain.code} for subdomain '${subdomainName}' is not unique (domain: ${domain.code}).`
+    );
 
     // We don't allow duplicates, except for defaulted plugin subdomain codes
-    if (! options.plugin || subdomain.code > 0) {
+    if (!options.plugin || subdomain.code > 0) {
       subdomainCodes.add(subdomain.code);
     }
 
     assert(
-      has(subdomain, 'errors'),
-      `Error configuration file : Missing required 'errors' field (domain: ${domain.code}, subdomain: ${subdomainName}).`);
+      has(subdomain, "errors"),
+      `Error configuration file : Missing required 'errors' field (domain: ${domain.code}, subdomain: ${subdomainName}).`
+    );
     assert(
       isPlainObject(subdomain.errors),
-      `Error configuration file : Field 'errors' must be an object (domain: ${domain.code}, subdomain: ${subdomainName}).`);
+      `Error configuration file : Field 'errors' must be an object (domain: ${domain.code}, subdomain: ${subdomainName}).`
+    );
 
     checkErrors(subdomain, domain, options);
   }
 }
 
-function checkDomains (errorCodesFiles, options = { plugin: false }) {
+function checkDomains(errorCodesFiles, options = { plugin: false }) {
   const domainCodes = new Set();
 
   for (const domainName of Object.keys(errorCodesFiles)) {
     const domain = errorCodesFiles[domainName];
 
     assert(
-      has(domain, 'code'),
-      `Error configuration file : Missing required 'code' field. (domain: '${domainName}').`);
+      has(domain, "code"),
+      `Error configuration file : Missing required 'code' field. (domain: '${domainName}').`
+    );
     assert(
       Number.isInteger(domain.code),
-      `Error configuration file : Field 'code' must be an integer. (domain: '${domainName}').`);
+      `Error configuration file : Field 'code' must be an integer. (domain: '${domainName}').`
+    );
     assert(
-      domain.code >= 0x00 && domain.code <= 0xFF,
-      `Error configuration file : Field 'code' must be between 0 and 255. (domain: '${domainName}').`);
+      domain.code >= 0x00 && domain.code <= 0xff,
+      `Error configuration file : Field 'code' must be between 0 and 255. (domain: '${domainName}').`
+    );
     assert(
-      ! domainCodes.has(domain.code),
-      `Error configuration file : code ${domain.code} for domain ${domainName} is not unique.`);
+      !domainCodes.has(domain.code),
+      `Error configuration file : code ${domain.code} for domain ${domainName} is not unique.`
+    );
 
     domainCodes.add(domain.code);
 
     assert(
-      has(domain, 'subDomains'),
-      `Error configuration file : Missing required 'subDomains' field. (domain: '${domainName}').`);
+      has(domain, "subDomains"),
+      `Error configuration file : Missing required 'subDomains' field. (domain: '${domainName}').`
+    );
     assert(
       isPlainObject(domain.subDomains),
-      `Error configuration file : Field 'subDomains' must be an object. (domain: '${domainName}').`);
+      `Error configuration file : Field 'subDomains' must be an object. (domain: '${domainName}').`
+    );
 
     checkSubdomains(domain, options);
   }
 }
 
-function loadPluginsErrors (pluginManifest, pluginCode) {
+function loadPluginsErrors(pluginManifest, pluginCode) {
   // @todo this should be in its own, independant domain
   domains.plugin.subDomains[pluginManifest.name] = {
     code: pluginCode,
-    errors: pluginManifest.errors
+    errors: pluginManifest.errors,
   };
   checkDomains({ plugin: domains.plugin }, { plugin: true });
 }

package/lib/kerror/errors/badRequestError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class BadRequestError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/externalServiceError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class ExternalServiceError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/forbiddenError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class ForbiddenError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/gatewayTimeoutError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class GatewayTimeoutError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/index.d.ts

@@ -1,15 +1,15 @@
-export * from './badRequestError';
-export * from './externalServiceError';
-export * from './forbiddenError';
-export * from './gatewayTimeoutError';
-export * from './internalError';
-export * from './kuzzleError';
-export * from './multipleErrorsError';
-export * from './notFoundError';
-export * from './partialError';
-export * from './pluginImplementationError';
-export * from './serviceUnavailableError';
-export * from './sizeLimitError';
-export * from './unauthorizedError';
-export * from './preconditionError';
-export * from './tooManyRequestsError';
+export * from "./badRequestError";
+export * from "./externalServiceError";
+export * from "./forbiddenError";
+export * from "./gatewayTimeoutError";
+export * from "./internalError";
+export * from "./kuzzleError";
+export * from "./multipleErrorsError";
+export * from "./notFoundError";
+export * from "./partialError";
+export * from "./pluginImplementationError";
+export * from "./serviceUnavailableError";
+export * from "./sizeLimitError";
+export * from "./unauthorizedError";
+export * from "./preconditionError";
+export * from "./tooManyRequestsError";

package/lib/kerror/errors/internalError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class InternalError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/kuzzleError.d.ts

@@ -1,4 +1,4 @@
-import { JSONObject } from 'kuzzle-sdk';
+import { JSONObject } from "kuzzle-sdk";
 /**
  * API error are instances of this class.
  * See https://docs.kuzzle.io/core/2/api/errors/types/

package/lib/kerror/errors/multipleErrorsError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class MultipleErrorsError extends KuzzleError {
     errors: Array<KuzzleError>;
     count: number;

package/lib/kerror/errors/multipleErrorsError.js

@@ -32,7 +32,7 @@ class MultipleErrorsError extends kuzzleError_1.KuzzleError {
         const serialized = super.toJSON();
         serialized.count = this.count;
         try {
-            serialized.errors = this.errors.map(error => error.toJSON());
+            serialized.errors = this.errors.map((error) => error.toJSON());
         }
         catch (error) {
             serialized.errors = this.errors;

package/lib/kerror/errors/notFoundError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class NotFoundError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/partialError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class PartialError extends KuzzleError {
     errors: Array<KuzzleError>;
     count: number;

package/lib/kerror/errors/partialError.js

@@ -24,7 +24,7 @@ exports.PartialError = void 0;
 const kuzzleError_1 = require("./kuzzleError");
 class PartialError extends kuzzleError_1.KuzzleError {
     constructor(message, body, id, code) {
-        if (code === undefined && typeof id === 'number') {
+        if (code === undefined && typeof id === "number") {
             code = id;
             id = body;
             body = [];

package/lib/kerror/errors/pluginImplementationError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class PluginImplementationError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/pluginImplementationError.js

@@ -25,7 +25,8 @@ const kuzzleError_1 = require("./kuzzleError");
 class PluginImplementationError extends kuzzleError_1.KuzzleError {
     constructor(message, id, code) {
         super(message, 500, id, code);
-        this.message += '\nThis is probably not a Kuzzle error, but a problem with a plugin implementation.';
+        this.message +=
+            "\nThis is probably not a Kuzzle error, but a problem with a plugin implementation.";
     }
 }
 exports.PluginImplementationError = PluginImplementationError;

package/lib/kerror/errors/preconditionError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class PreconditionError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/serviceUnavailableError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class ServiceUnavailableError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/sizeLimitError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class SizeLimitError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/tooManyRequestsError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class TooManyRequestsError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/errors/unauthorizedError.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleError } from './kuzzleError';
+import { KuzzleError } from "./kuzzleError";
 export declare class UnauthorizedError extends KuzzleError {
     constructor(message: any, id?: any, code?: any);
 }

package/lib/kerror/index.d.ts

@@ -1,6 +1,6 @@
-import * as errors from './errors';
-import { KuzzleError } from './errors';
-import { ErrorDomains } from '../types';
+import * as errors from "./errors";
+import { KuzzleError } from "./errors";
+import { ErrorDomains } from "../types";
 /**
  * Construct and return the corresponding error
  *

package/lib/kerror/index.js

@@ -81,22 +81,24 @@ function rawGet(domains, domain, subdomain, error, ...placeholders) {
     }
     const kuzzleError = lodash_1.default.get(domains, `${domain}.subDomains.${subdomain}.errors.${error}`);
     if (!kuzzleError) {
-        return get('core', 'fatal', 'unexpected_error', `${domain}.${subdomain}.${error}`);
+        return get("core", "fatal", "unexpected_error", `${domain}.${subdomain}.${error}`);
     }
     let body = null;
-    if (kuzzleError.class === 'PartialError' || kuzzleError.class === 'MultipleErrorsError') {
+    if (kuzzleError.class === "PartialError" ||
+        kuzzleError.class === "MultipleErrorsError") {
         body = placeholders.splice(-1)[0];
     }
     const message = options.message || (0, util_1.format)(kuzzleError.message, ...placeholders);
     const id = `${domain}.${subdomain}.${error}`;
-    const code = domains[domain].code << 24
-        | domains[domain].subDomains[subdomain].code << 16
-        | domains[domain].subDomains[subdomain].errors[error].code;
+    const code = (domains[domain].code << 24) |
+        (domains[domain].subDomains[subdomain].code << 16) |
+        domains[domain].subDomains[subdomain].errors[error].code;
     let kerror;
-    if (kuzzleError.class === 'PartialError' || kuzzleError.class === 'MultipleErrorsError') {
+    if (kuzzleError.class === "PartialError" ||
+        kuzzleError.class === "MultipleErrorsError") {
         kerror = new errors[kuzzleError.class](message, body, id, code);
     }
-    else if (kuzzleError.class === 'KuzzleError') {
+    else if (kuzzleError.class === "KuzzleError") {
         const status = kuzzleError.status || 500;
         kerror = new errors.KuzzleError(message, status, id, code);
     }
@@ -104,7 +106,7 @@ function rawGet(domains, domain, subdomain, error, ...placeholders) {
         kerror = new errors[kuzzleError.class](message, id, code);
     }
     kerror.props = placeholders;
-    if (kuzzleError.class !== 'InternalError') {
+    if (kuzzleError.class !== "InternalError") {
         cleanStackTrace(kerror);
     }
     return kerror;
@@ -123,13 +125,12 @@ exports.rawGet = rawGet;
  */
 function cleanStackTrace(error) {
     // Keep the original error message
-    const messageLength = error.message.split('\n').length;
+    const messageLength = error.message.split("\n").length;
     const currentFileName = _getCurrentFileName();
     // we keep the new error instantiation line ("new ...Error (") on purpose:
     // this will allow us to replace it without inserting a new line in the array,
     // saving us from building a new array
-    const newStack = error.stack.split('\n')
-        .filter((line, index) => {
+    const newStack = error.stack.split("\n").filter((line, index) => {
         if (index < messageLength) {
             return true;
         }
@@ -137,8 +138,8 @@ function cleanStackTrace(error) {
         return !line.includes(currentFileName);
     });
     // insert a deletion message in place of the new error instantiation line
-    newStack[messageLength] = '      [...Kuzzle internal calls deleted...]';
-    error.stack = newStack.join('\n');
+    newStack[messageLength] = "      [...Kuzzle internal calls deleted...]";
+    error.stack = newStack.join("\n");
 }
 /**
  * Returns a promise rejected with the corresponding error
@@ -169,12 +170,12 @@ function rawGetFrom(domains, source, domain, subdomain, error, ...placeholders)
     // If a stacktrace is present, we need to modify the first line because it
     // still contains the original error message
     if (derivedError.stack && derivedError.stack.length) {
-        const stackArray = source.stack.split('\n');
+        const stackArray = source.stack.split("\n");
         stackArray.shift();
         derivedError.stack = [
             `${derivedError.constructor.name}: ${derivedError.message}`,
-            ...stackArray
-        ].join('\n');
+            ...stackArray,
+        ].join("\n");
     }
     return derivedError;
 }