kuzzle 2.19.2 → 2.19.3

package/lib/api/controllers/baseController.js

@@ -19,26 +19,26 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Bluebird = require('bluebird');
+const Bluebird = require("bluebird");
 
-const kerror = require('../../kerror');
-const { get } = require('../../util/safeObject');
+const kerror = require("../../kerror");
+const { get } = require("../../util/safeObject");
 
-const assertionError = kerror.wrap('api', 'assert');
+const assertionError = kerror.wrap("api", "assert");
 
 // Base class for all controllers
 class BaseController {
-  constructor () {
+  constructor() {
     this.__actions = new Set();
   }
 
-  get _actions () {
+  get _actions() {
     return this.__actions;
   }
 
-  _addAction (name, fn) {
+  _addAction(name, fn) {
     this.__actions.add(name);
     this[name] = fn;
   }
@@ -51,13 +51,13 @@ class BaseController {
    * @param  {string} name
    * @returns {boolean}
    */
-  _isAction (name) {
+  _isAction(name) {
     return this.__actions.has(name);
   }
 }
 
 class NativeController extends BaseController {
-  constructor (actions = []) {
+  constructor(actions = []) {
     super();
 
     this.ask = global.kuzzle.ask.bind(global.kuzzle);
@@ -72,38 +72,37 @@ class NativeController extends BaseController {
    *
    * @returns {Promise}
    */
-  init () {
+  init() {
     return Bluebird.resolve();
   }
 
-  async translateKoncorde (koncordeFilters) {
+  async translateKoncorde(koncordeFilters) {
     if (Object.keys(koncordeFilters).length === 0) {
       return {};
     }
 
-    if (typeof koncordeFilters !== 'object') {
-      throw assertionError.get('invalid_type', 'body.query', 'object');
+    if (typeof koncordeFilters !== "object") {
+      throw assertionError.get("invalid_type", "body.query", "object");
     }
 
     try {
       global.kuzzle.koncorde.validate(koncordeFilters);
-    }
-    catch (error) {
-      throw assertionError.getFrom(error, 'koncorde_dsl_error', error.message);
+    } catch (error) {
+      throw assertionError.getFrom(error, "koncorde_dsl_error", error.message);
     }
 
     try {
-      return await this.ask('core:storage:public:translate', koncordeFilters);
-    }
-    catch (error) {
-      if (! error.keyword) {
+      return await this.ask("core:storage:public:translate", koncordeFilters);
+    } catch (error) {
+      if (!error.keyword) {
         throw error;
       }
 
       throw assertionError.get(
-        'koncorde_restricted_keyword',
+        "koncorde_restricted_keyword",
         error.keyword.type,
-        error.keyword.name);
+        error.keyword.name
+      );
     }
   }
 
@@ -113,11 +112,11 @@ class NativeController extends BaseController {
    * @param {Request} request
    * @param  {...any} paths
    */
-  assertBodyHasNotAttributes (request, ...paths) {
+  assertBodyHasNotAttributes(request, ...paths) {
     if (request.input.body !== null) {
       for (const path of paths) {
         if (get(request.input.body, path)) {
-          throw assertionError.get('forbidden_argument', `body.${path}`);
+          throw assertionError.get("forbidden_argument", `body.${path}`);
         }
       }
     }
@@ -129,9 +128,9 @@ class NativeController extends BaseController {
    * @todo move this method in some kind of "Security" class
    * @param {String} strategy
    */
-  assertIsStrategyRegistered (strategy) {
-    if (! global.kuzzle.pluginsManager.listStrategies().includes(strategy)) {
-      throw kerror.get('security', 'credentials', 'unknown_strategy', strategy);
+  assertIsStrategyRegistered(strategy) {
+    if (!global.kuzzle.pluginsManager.listStrategies().includes(strategy)) {
+      throw kerror.get("security", "credentials", "unknown_strategy", strategy);
     }
   }
 
@@ -140,36 +139,63 @@ class NativeController extends BaseController {
    * - missing properties
    * - invalid types
    * - unauthorized values
-   * 
+   *
    * @param {Array<{index:string, collections?: string[]}>} targets Array of targets
    * @param {*} options
    */
-  assertTargetsAreValid (targets, { allowEmptyCollections } = {}) {
+  assertTargetsAreValid(targets, { allowEmptyCollections } = {}) {
     for (let i = 0; i < targets.length; i++) {
       const target = targets[i];
 
-      if (! target.index) {
-        throw kerror.get('api', 'assert', 'missing_argument', `targets[${i}].index`);
+      if (!target.index) {
+        throw kerror.get(
+          "api",
+          "assert",
+          "missing_argument",
+          `targets[${i}].index`
+        );
       }
       if (this._hasMultiTargets(target.index)) {
-        throw kerror.get('services', 'storage', 'invalid_target_format', `targets[${i}].index`, target.index);
+        throw kerror.get(
+          "services",
+          "storage",
+          "invalid_target_format",
+          `targets[${i}].index`,
+          target.index
+        );
       }
 
-      if (! allowEmptyCollections && ! target.collections) {
-        throw kerror.get('api', 'assert', 'missing_argument', `targets[${i}].collections`);
+      if (!allowEmptyCollections && !target.collections) {
+        throw kerror.get(
+          "api",
+          "assert",
+          "missing_argument",
+          `targets[${i}].collections`
+        );
       }
 
-      if (target.collections && ! Array.isArray(target.collections)) {
-        throw kerror.get('api', 'assert', 'invalid_type', `targets[${i}].collections`, 'array');
+      if (target.collections && !Array.isArray(target.collections)) {
+        throw kerror.get(
+          "api",
+          "assert",
+          "invalid_type",
+          `targets[${i}].collections`,
+          "array"
+        );
       }
 
-      if (! allowEmptyCollections && target.collections.length === 0) {
-        throw kerror.get('api', 'assert', 'empty_argument', `targets[${i}].collections`);
+      if (!allowEmptyCollections && target.collections.length === 0) {
+        throw kerror.get(
+          "api",
+          "assert",
+          "empty_argument",
+          `targets[${i}].collections`
+        );
       }
 
-      if (allowEmptyCollections
-        && (! target.collections
-          || target.collections.length === 0)
+      if (
+        allowEmptyCollections &&
+        (!target.collections || target.collections.length === 0)
       ) {
         continue;
       }
@@ -177,19 +203,31 @@ class NativeController extends BaseController {
       for (let j = 0; j < target.collections.length; j++) {
         const collection = target.collections[j];
 
-        if (typeof collection !== 'string') {
-          throw kerror.get('api', 'assert', 'invalid_type', `targets[${i}].collections[${j}]`, 'string');
+        if (typeof collection !== "string") {
+          throw kerror.get(
+            "api",
+            "assert",
+            "invalid_type",
+            `targets[${i}].collections[${j}]`,
+            "string"
+          );
         }
 
         if (this._hasMultiTargets(collection)) {
-          throw kerror.get('services', 'storage', 'invalid_target_format', `targets[${i}].collections[${j}]`, collection);
+          throw kerror.get(
+            "services",
+            "storage",
+            "invalid_target_format",
+            `targets[${i}].collections[${j}]`,
+            collection
+          );
         }
       }
     }
   }
 
-  _hasMultiTargets (str) {
-    return [',', '*', '+'].some(chr => str.includes(chr)) || str === '_all';
+  _hasMultiTargets(str) {
+    return [",", "*", "+"].some((chr) => str.includes(chr)) || str === "_all";
   }
 
   /**
@@ -198,11 +236,11 @@ class NativeController extends BaseController {
    * @param {Number} asked
    * @throws
    */
-  assertNotExceedMaxFetch (asked) {
+  assertNotExceedMaxFetch(asked) {
     const limit = global.kuzzle.config.limits.documentsFetchCount;
 
     if (asked > limit) {
-      throw kerror.get('services', 'storage', 'get_limit_exceeded');
+      throw kerror.get("services", "storage", "get_limit_exceeded");
     }
   }
 
@@ -212,11 +250,11 @@ class NativeController extends BaseController {
    * @param {Number} asked
    * @throws
    */
-  assertNotExceedMaxWrite (asked) {
+  assertNotExceedMaxWrite(asked) {
     const limit = global.kuzzle.config.limits.documentsWriteCount;
 
     if (asked > limit) {
-      throw kerror.get('services', 'storage', 'write_limit_exceeded');
+      throw kerror.get("services", "storage", "write_limit_exceeded");
     }
   }
 }

package/lib/api/controllers/bulkController.js

@@ -19,24 +19,18 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { NativeController } = require('./baseController');
-const actionEnum = require('../../core/realtime/actionEnum');
-const kerror = require('../../kerror');
+const { NativeController } = require("./baseController");
+const actionEnum = require("../../core/realtime/actionEnum");
+const kerror = require("../../kerror");
 
 /**
  * @class BulkController
  */
 class BulkController extends NativeController {
-  constructor () {
-    super([
-      'import',
-      'write',
-      'mWrite',
-      'deleteByQuery',
-      'updateByQuery',
-    ]);
+  constructor() {
+    super(["import", "write", "mWrite", "deleteByQuery", "updateByQuery"]);
   }
 
   /**
@@ -45,109 +39,126 @@ class BulkController extends NativeController {
    * @param {Request} request
    * @returns {Promise}
    */
-  async import (request) {
+  async import(request) {
     const userId = request.getKuid();
     const { index, collection } = request.getIndexAndCollection();
-    const strict = request.getBoolean('strict');
+    const strict = request.getBoolean("strict");
     const refresh = request.getRefresh();
-    const bulkData = request.getBodyArray('bulkData');
+    const bulkData = request.getBodyArray("bulkData");
     const options = {
       refresh,
-      userId
+      userId,
     };
 
     const { items, errors } = await this.ask(
-      'core:storage:public:document:bulk',
+      "core:storage:public:document:bulk",
       index,
       collection,
       bulkData,
-      options);
+      options
+    );
 
     if (strict && errors.length) {
-      throw kerror.get('api', 'process', 'incomplete_multiple_request', 'import', errors);
+      throw kerror.get(
+        "api",
+        "process",
+        "incomplete_multiple_request",
+        "import",
+        errors
+      );
     }
 
     // @todo next major release: if (successes.length === 0) then throw (no matter strict value)
 
     return {
       errors,
-      successes: items
+      successes: items,
     };
   }
 
   /**
    * Write a document without adding metadata or performing data validation.
    */
-  async write (request) {
+  async write(request) {
     const { index, collection } = request.getIndexAndCollection();
-    const id = request.getId({ ifMissing: 'ignore' });
+    const id = request.getId({ ifMissing: "ignore" });
     const content = request.getBody();
     const refresh = request.getRefresh();
-    const notify = request.getBoolean('notify');
+    const notify = request.getBoolean("notify");
 
     const result = await this.ask(
-      'core:storage:public:document:createOrReplace',
+      "core:storage:public:document:createOrReplace",
       index,
       collection,
       id,
       content,
-      { injectKuzzleMeta: false, refresh });
+      { injectKuzzleMeta: false, refresh }
+    );
 
     if (notify) {
       await this.ask(
-        'core:realtime:document:notify',
+        "core:realtime:document:notify",
         request,
         actionEnum.WRITE,
-        result);
+        result
+      );
     }
 
     return {
       _id: result._id,
       _source: result._source,
-      _version: result._version
+      _version: result._version,
     };
   }
 
   /**
    * Write several documents without adding metadata or performing data validation.
    */
-  async mWrite (request) {
+  async mWrite(request) {
     const { index, collection } = request.getIndexAndCollection();
-    const documents = request.getBodyArray('documents');
-    const strict = request.getBoolean('strict');
+    const documents = request.getBodyArray("documents");
+    const strict = request.getBoolean("strict");
     const refresh = request.getRefresh();
-    const notify = request.getBoolean('notify');
+    const notify = request.getBoolean("notify");
 
     const { items, errors } = await this.ask(
-      'core:storage:public:document:mCreateOrReplace',
+      "core:storage:public:document:mCreateOrReplace",
       index,
       collection,
       documents,
-      { injectKuzzleMeta: false, limits: false, refresh });
+      { injectKuzzleMeta: false, limits: false, refresh }
+    );
 
     if (strict && errors.length) {
-      throw kerror.get('api', 'process', 'incomplete_multiple_request', 'write', errors);
+      throw kerror.get(
+        "api",
+        "process",
+        "incomplete_multiple_request",
+        "write",
+        errors
+      );
     }
 
     // @todo next major release: if (successes.length === 0) then throw (no matter strict value)
 
     if (notify) {
       await global.kuzzle.ask(
-        'core:realtime:document:mNotify',
+        "core:realtime:document:mNotify",
         request,
         actionEnum.WRITE,
-        items);
+        items
+      );
     }
 
-    const successes = items.map(item => ({
+    const successes = items.map((item) => ({
       _id: item._id,
       _source: item._source,
-      _version: item._version
+      _version: item._version,
     }));
 
     return {
       errors,
-      successes
+      successes,
     };
   }
 
@@ -157,17 +168,18 @@ class BulkController extends NativeController {
    *  - fetching deleted documents
    *  - triggering realtime notifications
    */
-  async deleteByQuery (request) {
+  async deleteByQuery(request) {
     const { index, collection } = request.getIndexAndCollection();
-    const query = request.getBodyObject('query');
+    const query = request.getBodyObject("query");
     const refresh = request.getRefresh();
 
     const { deleted } = await this.ask(
-      'core:storage:public:document:deleteByQuery',
+      "core:storage:public:document:deleteByQuery",
       index,
       collection,
       query,
-      { fetch: false, refresh, size: -1 });
+      { fetch: false, refresh, size: -1 }
+    );
 
     return { deleted };
   }
@@ -178,19 +190,20 @@ class BulkController extends NativeController {
    *  - Injecting Kuzzle metadata
    *  - Triggering realtime notifications
    */
-  async updateByQuery (request) {
+  async updateByQuery(request) {
     const { index, collection } = request.getIndexAndCollection();
-    const query = request.getBodyObject('query');
-    const changes = request.getBodyObject('changes');
+    const query = request.getBodyObject("query");
+    const changes = request.getBodyObject("changes");
     const refresh = request.getRefresh();
 
     return this.ask(
-      'core:storage:public:bulk:updateByQuery',
+      "core:storage:public:bulk:updateByQuery",
       index,
       collection,
       query,
       changes,
-      { refresh });
+      { refresh }
+    );
   }
 }
 

package/lib/api/controllers/clusterController.js

@@ -19,19 +19,17 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { NativeController } = require('./baseController');
+const { NativeController } = require("./baseController");
 
 class ClusterController extends NativeController {
-  constructor () {
-    super([
-      'status',
-    ]);
+  constructor() {
+    super(["status"]);
   }
 
-  async status () {
-    return global.kuzzle.ask('cluster:status:get');
+  async status() {
+    return global.kuzzle.ask("cluster:status:get");
   }
 }