kuzzle 2.19.2 → 2.19.3

package/lib/config/index.js

@@ -19,29 +19,28 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const assert = require('assert');
+const assert = require("assert");
 
-const rc = require('rc');
-const defaultConfig = require('./default.config');
-const packageJson = require('../../package.json');
-const kerror = require('../kerror').wrap('core', 'configuration');
-const { isPlainObject } = require('../util/safeObject');
-const bytes = require('../util/bytes');
+const rc = require("rc");
+const defaultConfig = require("./default.config");
+const packageJson = require("../../package.json");
+const kerror = require("../kerror").wrap("core", "configuration");
+const { isPlainObject } = require("../util/safeObject");
+const bytes = require("../util/bytes");
 
 /**
  * Loads, interprets and checks configuration files
  * @returns {object}
  */
-function loadConfig () {
+function loadConfig() {
   let config;
 
   try {
-    config = rc('kuzzle', defaultConfig.default);
-  }
-  catch (e) {
-    throw kerror.get('cannot_parse', e.message);
+    config = rc("kuzzle", defaultConfig.default);
+  } catch (e) {
+    throw kerror.get("cannot_parse", e.message);
   }
 
   config = unstringify(config);
@@ -53,8 +52,8 @@ function loadConfig () {
 
   config.internal = {
     hash: {
-      seed: Buffer.from('^m&mOISKBvb1xpl1mRsrylaQXpjb&IJX')
-    }
+      seed: Buffer.from("^m&mOISKBvb1xpl1mRsrylaQXpjb&IJX"),
+    },
   };
 
   preprocessHttpOptions(config);
@@ -78,33 +77,34 @@ function loadConfig () {
  * @param {object} cfg - configuration loaded using RC
  * @returns {object} correctly typed configuration
  */
-function unstringify (cfg) {
+function unstringify(cfg) {
   Object.keys(cfg)
-    .filter(k => ! /version$/i.test(k) && (typeof cfg[k] === 'string' || cfg[k] instanceof Object))
-    .forEach(k => {
-      if (typeof cfg[k] === 'string') {
-        if (cfg[k] === 'true') {
+    .filter(
+      (k) =>
+        !/version$/i.test(k) &&
+        (typeof cfg[k] === "string" || cfg[k] instanceof Object)
+    )
+    .forEach((k) => {
+      if (typeof cfg[k] === "string") {
+        if (cfg[k] === "true") {
           cfg[k] = true;
-        }
-        else if (cfg[k] === 'false') {
+        } else if (cfg[k] === "false") {
           cfg[k] = false;
-        }
-        else if (cfg[k].startsWith('*json:')) {
+        } else if (cfg[k].startsWith("*json:")) {
           try {
-            cfg[k] = JSON.parse(cfg[k].replace(/^\*json:/, ''));
-          }
-          catch (e) {
-            throw kerror.get('cannot_parse', `the key "${k}" does not contain a valid stringified JSON (${cfg[k]})`);
+            cfg[k] = JSON.parse(cfg[k].replace(/^\*json:/, ""));
+          } catch (e) {
+            throw kerror.get(
+              "cannot_parse",
+              `the key "${k}" does not contain a valid stringified JSON (${cfg[k]})`
+            );
           }
-        }
-        else if (/^(-|\+)?([0-9]+)$/.test(cfg[k])) {
+        } else if (/^(-|\+)?([0-9]+)$/.test(cfg[k])) {
           cfg[k] = Number.parseInt(cfg[k]);
-        }
-        else if (/^(-|\+)?([0-9]+(\.[0-9]+)?)$/.test(cfg[k])) {
+        } else if (/^(-|\+)?([0-9]+(\.[0-9]+)?)$/.test(cfg[k])) {
           cfg[k] = parseFloat(cfg[k]);
         }
-      }
-      else {
+      } else {
         cfg[k] = unstringify(cfg[k]);
       }
     });
@@ -119,139 +119,202 @@ function unstringify (cfg) {
  *
  * @param {object} cfg
  */
-function checkLimitsConfig (cfg) {
+function checkLimitsConfig(cfg) {
   const limits = [
-    'concurrentRequests',
-    'documentsFetchCount',
-    'documentsWriteCount',
-    'loginsPerSecond',
-    'requestsBufferSize',
-    'requestsBufferWarningThreshold',
-    'subscriptionConditionsCount',
-    'subscriptionMinterms',
-    'subscriptionRooms',
-    'subscriptionDocumentTTL'
+    "concurrentRequests",
+    "documentsFetchCount",
+    "documentsWriteCount",
+    "loginsPerSecond",
+    "requestsBufferSize",
+    "requestsBufferWarningThreshold",
+    "subscriptionConditionsCount",
+    "subscriptionMinterms",
+    "subscriptionRooms",
+    "subscriptionDocumentTTL",
   ];
   const canBeZero = [
-    'subscriptionMinterms',
-    'subscriptionRooms',
-    'subscriptionDocumentTTL'
+    "subscriptionMinterms",
+    "subscriptionRooms",
+    "subscriptionDocumentTTL",
   ];
 
-  if (! isPlainObject(cfg.limits)) {
-    throw kerror.get('invalid_type', 'limits', 'object');
+  if (!isPlainObject(cfg.limits)) {
+    throw kerror.get("invalid_type", "limits", "object");
   }
 
   for (const opt of limits) {
-    if (typeof cfg.limits[opt] !== 'number') {
-      throw kerror.get('invalid_type', `limits.${opt}`, 'number');
+    if (typeof cfg.limits[opt] !== "number") {
+      throw kerror.get("invalid_type", `limits.${opt}`, "number");
     }
 
-    if ( cfg.limits[opt] < 0
-      || cfg.limits[opt] === 0 && ! canBeZero.includes(opt)
+    if (
+      cfg.limits[opt] < 0 ||
+      (cfg.limits[opt] === 0 && !canBeZero.includes(opt))
     ) {
-      const allowed = `>= ${canBeZero.includes(opt) ? '0' : '1'}`;
-      throw kerror.get('out_of_range', `limits.${opt}`, allowed);
+      const allowed = `>= ${canBeZero.includes(opt) ? "0" : "1"}`;
+      throw kerror.get("out_of_range", `limits.${opt}`, allowed);
     }
   }
 
   if (cfg.limits.concurrentRequests >= cfg.limits.requestsBufferSize) {
-    throw kerror.get('out_of_range', 'limits.concurrentRequests', 'lower than "limits.requestsBufferSize"');
+    throw kerror.get(
+      "out_of_range",
+      "limits.concurrentRequests",
+      'lower than "limits.requestsBufferSize"'
+    );
   }
 
-  if ( cfg.limits.requestsBufferWarningThreshold < cfg.limits.concurrentRequests
-    || cfg.limits.requestsBufferWarningThreshold > cfg.limits.requestsBufferSize
+  if (
+    cfg.limits.requestsBufferWarningThreshold < cfg.limits.concurrentRequests ||
+    cfg.limits.requestsBufferWarningThreshold > cfg.limits.requestsBufferSize
   ) {
     throw kerror.get(
-      'out_of_range',
-      'limits.requestsBufferWarningThreshold',
-      '[limits.concurrentRequests, limits.requestsBufferSize]');
+      "out_of_range",
+      "limits.requestsBufferWarningThreshold",
+      "[limits.concurrentRequests, limits.requestsBufferSize]"
+    );
   }
 }
 
-function checkWebSocketOptions (config) {
+function checkWebSocketOptions(config) {
   const cfg = config.server.protocols.websocket;
 
   if (cfg === undefined) {
     return;
   }
 
-  assert(typeof cfg.enabled === 'boolean', `[websocket] "enabled" parameter: invalid value "${cfg.enabled}" (boolean expected)`);
-  assert(Number.isInteger(cfg.idleTimeout) && cfg.idleTimeout >= 0, `[websocket] "idleTimeout" parameter: invalid value "${cfg.idleTimeout}" (integer >= 1000 expected)`);
-  assert(Number.isInteger(cfg.rateLimit) && cfg.rateLimit >= 0, `[websocket] "rateLimit" parameter: invalid value "${cfg.rateLimit}" (integer >= 0 expected)`);
-  assert(typeof cfg.compression === 'boolean', `[websocket] "compression" parameter: invalid value "${cfg.compression}" (boolean value expected)`);
+  assert(
+    typeof cfg.enabled === "boolean",
+    `[websocket] "enabled" parameter: invalid value "${cfg.enabled}" (boolean expected)`
+  );
+  assert(
+    Number.isInteger(cfg.idleTimeout) && cfg.idleTimeout >= 0,
+    `[websocket] "idleTimeout" parameter: invalid value "${cfg.idleTimeout}" (integer >= 1000 expected)`
+  );
+  assert(
+    Number.isInteger(cfg.rateLimit) && cfg.rateLimit >= 0,
+    `[websocket] "rateLimit" parameter: invalid value "${cfg.rateLimit}" (integer >= 0 expected)`
+  );
+  assert(
+    typeof cfg.compression === "boolean",
+    `[websocket] "compression" parameter: invalid value "${cfg.compression}" (boolean value expected)`
+  );
 }
 
-function checkHttpOptions (config) {
+function checkHttpOptions(config) {
   const cfg = config.server.protocols.http;
 
   if (cfg === undefined) {
     return;
   }
 
-  assert(typeof config.http.accessControlAllowOrigin === 'string' || Array.isArray(config.http.accessControlAllowOrigin), `[http] "accessControlAllowOrigin" parameter: invalid value "${config.http.accessControlAllowOrigin}" (array or string expected)`);
-  assert(typeof config.http.accessControlAllowOriginUseRegExp === 'boolean', `[http] "accessControlAllowOriginUseRegExp" parameter: invalid value "${cfg.accessControlAllowOriginUseRegExp}" (boolean expected)`);
-  assert(typeof cfg.enabled === 'boolean', `[http] "enabled" parameter: invalid value "${cfg.enabled}" (boolean expected)`);
-  assert(typeof cfg.allowCompression === 'boolean', `[http] "allowCompression" parameter: invalid value "${cfg.allowCompression}" (boolean expected)`);
-  assert(Number.isInteger(cfg.maxEncodingLayers) && cfg.maxEncodingLayers >= 1, `[http] "maxEncodingLayers" parameter: invalid value "${cfg.maxEncodingLayers}" (integer >= 1 expected)`);
+  assert(
+    typeof config.http.accessControlAllowOrigin === "string" ||
+      Array.isArray(config.http.accessControlAllowOrigin),
+    `[http] "accessControlAllowOrigin" parameter: invalid value "${config.http.accessControlAllowOrigin}" (array or string expected)`
+  );
+  assert(
+    typeof config.http.accessControlAllowOriginUseRegExp === "boolean",
+    `[http] "accessControlAllowOriginUseRegExp" parameter: invalid value "${cfg.accessControlAllowOriginUseRegExp}" (boolean expected)`
+  );
+  assert(
+    typeof cfg.enabled === "boolean",
+    `[http] "enabled" parameter: invalid value "${cfg.enabled}" (boolean expected)`
+  );
+  assert(
+    typeof cfg.allowCompression === "boolean",
+    `[http] "allowCompression" parameter: invalid value "${cfg.allowCompression}" (boolean expected)`
+  );
+  assert(
+    Number.isInteger(cfg.maxEncodingLayers) && cfg.maxEncodingLayers >= 1,
+    `[http] "maxEncodingLayers" parameter: invalid value "${cfg.maxEncodingLayers}" (integer >= 1 expected)`
+  );
 
   const maxFormFileSize = bytes(cfg.maxFormFileSize);
-  assert(Number.isInteger(maxFormFileSize) && maxFormFileSize >= 0, `[http] "maxFormFileSize" parameter: cannot parse "${cfg.maxFormFileSize}"`);
+  assert(
+    Number.isInteger(maxFormFileSize) && maxFormFileSize >= 0,
+    `[http] "maxFormFileSize" parameter: cannot parse "${cfg.maxFormFileSize}"`
+  );
   cfg.maxFormFileSize = maxFormFileSize;
-  assert(typeof config.http.cookieAuthentication === 'boolean', `[http] "cookieAuthentication" parameter: invalid value "${config.http.cookieAuthentication }" (boolean expected)`);
+  assert(
+    typeof config.http.cookieAuthentication === "boolean",
+    `[http] "cookieAuthentication" parameter: invalid value "${config.http.cookieAuthentication}" (boolean expected)`
+  );
 }
 
-
-function checkClusterOptions (config) {
+function checkClusterOptions(config) {
   const cfg = config.cluster;
 
-  for (const prop of ['heartbeat', 'joinTimeout', 'minimumNodes', 'activityDepth', 'syncTimeout']) {
-    assert(typeof cfg[prop] === 'number' && cfg[prop] > 0, `[CONFIG] kuzzlerc.cluster.${prop}: value must be a number greater than 0`);
+  for (const prop of [
+    "heartbeat",
+    "joinTimeout",
+    "minimumNodes",
+    "activityDepth",
+    "syncTimeout",
+  ]) {
+    assert(
+      typeof cfg[prop] === "number" && cfg[prop] > 0,
+      `[CONFIG] kuzzlerc.cluster.${prop}: value must be a number greater than 0`
+    );
   }
 
-  assert(cfg.syncTimeout < cfg.joinTimeout, '[CONFIG] kuzzlerc.cluster.syncTimeout: value must be lower than kuzzlerc.cluster.joinTimeout');
+  assert(
+    cfg.syncTimeout < cfg.joinTimeout,
+    "[CONFIG] kuzzlerc.cluster.syncTimeout: value must be lower than kuzzlerc.cluster.joinTimeout"
+  );
 
-  for (const prop of ['command', 'sync']) {
-    assert(typeof cfg.ports[prop] === 'number' && cfg.ports[prop] > 0, `[CONFIG] kuzzlerc.cluster.ports.${prop}: value must be a number greater than 0`);
+  for (const prop of ["command", "sync"]) {
+    assert(
+      typeof cfg.ports[prop] === "number" && cfg.ports[prop] > 0,
+      `[CONFIG] kuzzlerc.cluster.ports.${prop}: value must be a number greater than 0`
+    );
   }
 
-  assert(typeof cfg.ipv6 === 'boolean', '[CONFIG] kuzzlerc.cluster.ipv6: boolean expected');
+  assert(
+    typeof cfg.ipv6 === "boolean",
+    "[CONFIG] kuzzlerc.cluster.ipv6: boolean expected"
+  );
   // If config is passed with env variable, ip cannot be the value null
   // but only blank string or the string "null"
-  if (`${cfg.ip}`.length === 0 || cfg.ip === 'null') {
+  if (`${cfg.ip}`.length === 0 || cfg.ip === "null") {
     cfg.ip = null;
   }
-  assert(! cfg.ip || ['private', 'public'].includes(cfg.ip), '[CONFIG] kuzzlerc.cluster.ip: invalid value (accepted values: public, private)');
-
-  assert(! cfg.interface || typeof cfg.interface === 'string', '[CONFIG] kuzzlerc.cluster.interface: value must be either null, or a string');
+  assert(
+    !cfg.ip || ["private", "public"].includes(cfg.ip),
+    "[CONFIG] kuzzlerc.cluster.ip: invalid value (accepted values: public, private)"
+  );
+
+  assert(
+    !cfg.interface || typeof cfg.interface === "string",
+    "[CONFIG] kuzzlerc.cluster.interface: value must be either null, or a string"
+  );
 }
 
-function preprocessHttpOptions (config) {
+function preprocessHttpOptions(config) {
   const httpConfig = config.http;
 
   if (httpConfig === undefined) {
     return;
   }
 
-  if (typeof httpConfig.accessControlAllowOrigin === 'string') {
-    httpConfig.accessControlAllowOrigin =
-      httpConfig.accessControlAllowOrigin
-        .split(',')
-        .map(value => value.trim());
+  if (typeof httpConfig.accessControlAllowOrigin === "string") {
+    httpConfig.accessControlAllowOrigin = httpConfig.accessControlAllowOrigin
+      .split(",")
+      .map((value) => value.trim());
   }
 
   // Stored to avoid doing includes multiple times later
-  config.internal.allowAllOrigins = httpConfig.accessControlAllowOrigin.includes('*');
+  config.internal.allowAllOrigins =
+    httpConfig.accessControlAllowOrigin.includes("*");
 
   // If Regular Expression is enabled for accessControlAllowOrigin header we convert every string to a RegExp
   if (httpConfig.accessControlAllowOriginUseRegExp) {
     httpConfig.accessControlAllowOrigin =
-      httpConfig.accessControlAllowOrigin
-        .map(pattern => new RegExp(pattern));
+      httpConfig.accessControlAllowOrigin.map((pattern) => new RegExp(pattern));
   }
 }
 
-function preprocessProtocolsOptions (config) {
+function preprocessProtocolsOptions(config) {
   const protocols = config.server.protocols;
 
   config.internal.notifiableProtocols = [];
@@ -263,7 +326,7 @@ function preprocessProtocolsOptions (config) {
   }
 }
 
-function preprocessRedisOptions (redisConfig) {
+function preprocessRedisOptions(redisConfig) {
   // @deprecated Remove those lines for Kuzzle v3 then
   // remove also 'database' from .kuzzlerc.sample and default.config
   if (redisConfig.database) {

package/lib/config/sdkCompatibility.json

@@ -1,9 +1,9 @@
 {
-  "js":       { "min": 7 },
-  "csharp":   { "min": 2 },
-  "cpp":      { "min": 2 },
-  "java":     { "min": 3 },
-  "android":  { "min": 5 },
-  "go":       { "min": 3 },
-  "php":      { "min": 4 }
-}
+  "js": { "min": 7 },
+  "csharp": { "min": 2 },
+  "cpp": { "min": 2 },
+  "java": { "min": 3 },
+  "android": { "min": 5 },
+  "go": { "min": 3 },
+  "php": { "min": 4 }
+}

package/lib/core/auth/formatProcessing.js

@@ -19,7 +19,7 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 module.exports = {
   /**
@@ -28,7 +28,7 @@ module.exports = {
    * @param {Role} role
    * @returns {object}
    */
-  serializeProfile: profile => {
+  serializeProfile: (profile) => {
     const { _id, ..._source } = profile;
 
     return { _id, _source };
@@ -40,11 +40,11 @@ module.exports = {
    * @param {Profile} profile
    * @returns {Object}
    */
-  serializeRole: role => {
+  serializeRole: (role) => {
     const _source = {};
 
-    Object.keys(role).forEach(key => {
-      if (key !== '_id' && key !== 'restrictedTo') {
+    Object.keys(role).forEach((key) => {
+      if (key !== "_id" && key !== "restrictedTo") {
         _source[key] = role[key];
       }
     });
@@ -58,9 +58,9 @@ module.exports = {
    * @param {User} user
    * @returns {Object}
    */
-  serializeUser: user => {
+  serializeUser: (user) => {
     const { _id, ..._source } = user;
 
     return { _id, _source };
-  }
+  },
 };

package/lib/core/auth/passportResponse.js

@@ -19,7 +19,7 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 /*
 HTTP Response Mockup to emulate response objects for Passport Authentication
@@ -31,30 +31,30 @@ HTTP Response Mockup to emulate response objects for Passport Authentication
  * @class PassportResponse
  */
 class PassportResponse {
-  constructor () {
+  constructor() {
     this.headers = {};
     this.statusCode = 200;
     this.onEndListener = null;
   }
 
-  setHeader (field, value) {
+  setHeader(field, value) {
     this.headers[field] = value;
   }
 
-  end (statusCode) {
+  end(statusCode) {
     if (statusCode) {
       this.statusCode = statusCode;
     }
-    if (typeof this.onEndListener === 'function') {
+    if (typeof this.onEndListener === "function") {
       this.onEndListener();
     }
   }
 
-  getHeader (key) {
+  getHeader(key) {
     return this.headers[key];
   }
 
-  addEndListener (listener) {
+  addEndListener(listener) {
     this.onEndListener = listener;
   }
 }

package/lib/core/auth/passportWrapper.js

@@ -19,20 +19,20 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Bluebird = require('bluebird');
-const passport = require('passport');
+const Bluebird = require("bluebird");
+const passport = require("passport");
 
-const { KuzzleError } = require('../../kerror/errors');
-const kerror = require('../../kerror');
-const PassportResponse = require('./passportResponse');
+const { KuzzleError } = require("../../kerror/errors");
+const kerror = require("../../kerror");
+const PassportResponse = require("./passportResponse");
 
 /**
  * @class PassportWrapper
  */
 class PassportWrapper {
-  constructor () {
+  constructor() {
     this.options = {};
   }
 
@@ -41,7 +41,7 @@ class PassportWrapper {
    * @param strategyName
    * @returns {Promise.<*>}
    */
-  authenticate (request, strategyName) {
+  authenticate(request, strategyName) {
     const response = new PassportResponse();
 
     return new Bluebird((resolve, reject) => {
@@ -56,41 +56,45 @@ class PassportWrapper {
         if (err !== null) {
           if (err instanceof KuzzleError) {
             reject(err);
-          }
-          else {
+          } else {
             reject(
               kerror.getFrom(
                 err,
-                'plugin',
-                'runtime',
-                'unexpected_error',
-                err.message));
+                "plugin",
+                "runtime",
+                "unexpected_error",
+                err.message
+              )
+            );
           }
-        }
-        else if (! user) {
+        } else if (!user) {
           reject(
-            kerror.get('plugin', 'strategy', 'missing_user', info.message));
-        }
-        else {
+            kerror.get("plugin", "strategy", "missing_user", info.message)
+          );
+        } else {
           resolve(user);
         }
       };
 
       try {
-        passport.authenticate(strategyName, this.options[strategyName] || {}, authCB)(request, response);
-      }
-      catch (e) {
+        passport.authenticate(
+          strategyName,
+          this.options[strategyName] || {},
+          authCB
+        )(request, response);
+      } catch (e) {
         if (e instanceof KuzzleError) {
           reject(e);
-        }
-        else {
+        } else {
           reject(
             kerror.getFrom(
               e,
-              'plugin',
-              'runtime',
-              'unexpected_error',
-              e.message));
+              "plugin",
+              "runtime",
+              "unexpected_error",
+              e.message
+            )
+          );
         }
       }
     });
@@ -103,7 +107,7 @@ class PassportWrapper {
    * @param {object} strategy - instantiated strategy object
    * @param {object} opts - options to provide to authenticate with the strategy
    */
-  use (name, strategy, opts = {}) {
+  use(name, strategy, opts = {}) {
     passport.use(name, strategy);
     this.options[name] = opts;
   }
@@ -113,7 +117,7 @@ class PassportWrapper {
    *
    * @param  {string} name - name of the strategy to unregister
    */
-  unuse (name) {
+  unuse(name) {
     passport.unuse(name);
     delete this.options[name];
   }

package/lib/core/auth/tokenManager.d.ts

@@ -1,5 +1,5 @@
-import '../../types/Global';
-import { Token } from '../../model/security/token';
+import "../../types/Global";
+import { Token } from "../../model/security/token";
 /**
  * Maintains a list of valid tokens used by connected protocols.
  *