kuzzle 2.19.2 → 2.19.3

package/lib/core/shared/repository.js

@@ -19,12 +19,12 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Bluebird = require('bluebird');
+const Bluebird = require("bluebird");
 
-const cacheDbEnum = require('../cache/cacheDbEnum');
-const kerror = require('../../kerror');
+const cacheDbEnum = require("../cache/cacheDbEnum");
+const kerror = require("../../kerror");
 
 /**
  * @class Repository
@@ -41,7 +41,7 @@ class Repository {
    * @param {{cache: cacheDbEnum, store: Store}} [options]
    * @constructor
    */
-  constructor ({ cache = cacheDbEnum.INTERNAL, store = null } = {}) {
+  constructor({ cache = cacheDbEnum.INTERNAL, store = null } = {}) {
     this.ttl = global.kuzzle.config.repositories.common.cacheTTL;
     this.collection = null;
     this.ObjectConstructor = null;
@@ -54,15 +54,14 @@ class Repository {
    * @param {string} id
    * @returns {Promise} resolves on a new ObjectConstructor()
    */
-  async loadOneFromDatabase (id) {
+  async loadOneFromDatabase(id) {
     let response;
 
     try {
       response = await this.store.get(this.collection, id);
-    }
-    catch (error) {
+    } catch (error) {
       if (error.status === 404) {
-        throw kerror.get('services', 'storage', 'not_found', id);
+        throw kerror.get("services", "storage", "not_found", id);
       }
 
       throw error;
@@ -73,8 +72,7 @@ class Repository {
 
       if (response._source) {
         Object.assign(dto, response._source, { _id: response._id });
-      }
-      else {
+      } else {
         Object.assign(dto, response);
       }
 
@@ -89,16 +87,16 @@ class Repository {
    * @param {string[]|object[]} _ids
    * @returns {Promise<object>}
    */
-  async loadMultiFromDatabase (ids) {
+  async loadMultiFromDatabase(ids) {
     const { items } = await this.store.mGet(this.collection, ids);
 
     if (items.length === 0) {
       return [];
     }
 
-    return Bluebird.map(
-      items,
-      doc => this.fromDTO(Object.assign({}, doc._source, { _id: doc._id })));
+    return Bluebird.map(items, (doc) =>
+      this.fromDTO(Object.assign({}, doc._source, { _id: doc._id }))
+    );
   }
 
   /**
@@ -108,8 +106,12 @@ class Repository {
    * @param {object} [options] - optional search arguments (from, size, scroll)
    * @returns {Promise}
    */
-  async search (searchBody, options = {}) {
-    const response = await this.store.search(this.collection, searchBody, options);
+  async search(searchBody, options = {}) {
+    const response = await this.store.search(
+      this.collection,
+      searchBody,
+      options
+    );
 
     return this._formatSearchResults(response);
   }
@@ -119,7 +121,7 @@ class Repository {
    * @param {string} scrollId
    * @param {string} [ttl]
    */
-  async scroll (scrollId, ttl) {
+  async scroll(scrollId, ttl) {
     const response = await this.store.scroll(scrollId, ttl);
 
     return this._formatSearchResults(response);
@@ -137,7 +139,7 @@ class Repository {
    * @param {object} [options] - Optional options.
    * @returns {Promise}
    */
-  async loadFromCache (id, options = {}) {
+  async loadFromCache(id, options = {}) {
     const key = options.key || this.getCacheKey(id);
     let response;
 
@@ -149,9 +151,8 @@ class Repository {
       }
 
       return await this.fromDTO(Object.assign({}, JSON.parse(response)));
-    }
-    catch (err) {
-      throw kerror.get('services', 'cache', 'read_failed', err.message);
+    } catch (err) {
+      throw kerror.get("services", "cache", "read_failed", err.message);
     }
   }
 
@@ -172,7 +173,7 @@ class Repository {
    * @param {object} [options] - Optional options.
    * @returns {Promise}
    */
-  async load (id, options = {}) {
+  async load(id, options = {}) {
     if (this.cacheDb === cacheDbEnum.NONE) {
       return this.loadOneFromDatabase(id);
     }
@@ -205,21 +206,23 @@ class Repository {
    * @param {object} [options] - The persistence options
    * @returns {Promise}
    */
-  persistToDatabase (object, options = {}) {
-    const method = options.method || 'createOrReplace';
+  persistToDatabase(object, options = {}) {
+    const method = options.method || "createOrReplace";
 
-    if (method === 'create') {
+    if (method === "create") {
       return this.store.create(
         this.collection,
         this.serializeToDatabase(object),
-        { ...options, id: object._id });
+        { ...options, id: object._id }
+      );
     }
 
     return this.store[method](
       this.collection,
       object._id,
       this.serializeToDatabase(object),
-      options);
+      options
+    );
   }
 
   /**
@@ -231,7 +234,7 @@ class Repository {
    * @param {object} [options] - optional options for the current operation
    * @returns {Promise}
    */
-  delete (object, options = {}) {
+  delete(object, options = {}) {
     const promises = [];
 
     if (this.cacheDb !== cacheDbEnum.NONE) {
@@ -251,7 +254,7 @@ class Repository {
    * @param {string} id
    * @param {object} [options]
    */
-  deleteFromDatabase (id, options = {}) {
+  deleteFromDatabase(id, options = {}) {
     return this.store.delete(this.collection, id, options);
   }
 
@@ -267,13 +270,13 @@ class Repository {
    * @param {object} [options] - Optional options for the current operation
    * @returns {Promise}
    */
-  async persistToCache (object, options = {}) {
+  async persistToCache(object, options = {}) {
     const key = options.key || this.getCacheKey(object._id);
     const value = JSON.stringify(this.serializeToCache(object));
     const ttl = options.ttl !== undefined ? options.ttl : this.ttl;
 
     await global.kuzzle.ask(`core:cache:${this.cacheDb}:store`, key, value, {
-      ttl
+      ttl,
     });
 
     return object;
@@ -288,7 +291,7 @@ class Repository {
    * @param {object} [options] - optional options for the current operation
    * @returns {Promise}
    */
-  deleteFromCache (id, options = {}) {
+  deleteFromCache(id, options = {}) {
     const key = options.key || this.getCacheKey(id);
 
     return global.kuzzle.ask(`core:cache:${this.cacheDb}:del`, key);
@@ -299,19 +302,17 @@ class Repository {
    * @param {object} [options] - optional options for the current operation
    * @returns {Promise}
    */
-  refreshCacheTTL (object, options = {}) {
+  refreshCacheTTL(object, options = {}) {
     const key = options.key || this.getCacheKey(object._id);
     let ttl;
 
     if (options.ttl !== undefined) {
       ttl = options.ttl;
-    }
-    else if (object.ttl !== undefined) {
+    } else if (object.ttl !== undefined) {
       // if a TTL has been defined at the entry creation, we should
       // use it
       ttl = object.ttl;
-    }
-    else {
+    } else {
       ttl = this.ttl;
     }
 
@@ -327,7 +328,7 @@ class Repository {
    * @param {object} [options] - optional options for the current operation
    * @returns {*}
    */
-  expireFromCache (object, options = {}) {
+  expireFromCache(object, options = {}) {
     const key = options.key || this.getCacheKey(object._id);
     return global.kuzzle.ask(`core:cache:${this.cacheDb}:expire`, key, -1);
   }
@@ -338,7 +339,7 @@ class Repository {
    * @param {object} object - The object to serialize
    * @returns {object}
    */
-  serializeToCache (object) {
+  serializeToCache(object) {
     return this.toDTO(object);
   }
 
@@ -348,7 +349,7 @@ class Repository {
    * @param {object} object - The object to serialize
    * @returns {object}
    */
-  serializeToDatabase (object) {
+  serializeToDatabase(object) {
     const dto = this.toDTO(object);
     delete dto._id;
     return dto;
@@ -357,7 +358,7 @@ class Repository {
   /**
    * @param {string} id
    */
-  getCacheKey (id) {
+  getCacheKey(id) {
     return `repos/${this.index}/${this.collection}/${id}`;
   }
 
@@ -365,7 +366,7 @@ class Repository {
    * @param {object} dto
    * @returns {Promise<ObjectConstructor>}
    */
-  async fromDTO (dto) {
+  async fromDTO(dto) {
     const o = new this.ObjectConstructor();
     Object.assign(o, dto);
 
@@ -376,7 +377,7 @@ class Repository {
    * @param {ObjectConstructor} o
    * @returns {object}
    */
-  toDTO (o) {
+  toDTO(o) {
     return Object.assign({}, o);
   }
 
@@ -387,7 +388,7 @@ class Repository {
    * @param {object} part
    * @returns {Promise<integer>} total deleted objects
    */
-  async truncate (options) {
+  async truncate(options) {
     // Allows safe overrides, as _truncate is called recursively
     return this._truncate(options);
   }
@@ -396,16 +397,19 @@ class Repository {
    * Do not override this: this function calls itself.
    * @private
    */
-  async _truncate (options, part = null) {
+  async _truncate(options, part = null) {
     if (part === null) {
-      const objects = await this.search({}, { refresh: options.refresh, scroll: '5s', size: 100 });
+      const objects = await this.search(
+        {},
+        { refresh: options.refresh, scroll: "5s", size: 100 }
+      );
       const deleted = await this._truncatePart(objects, options);
 
       if (objects.hits.length < objects.total) {
         const total = await this._truncate(options, {
           fetched: objects.hits.length,
           scrollId: objects.scrollId,
-          total: objects.total
+          total: objects.total,
         });
 
         return deleted + total;
@@ -414,7 +418,7 @@ class Repository {
       return deleted;
     }
 
-    const objects = await this.scroll(part.scrollId, '5s');
+    const objects = await this.scroll(part.scrollId, "5s");
     const deleted = await this._truncatePart(objects, options);
 
     part.fetched += objects.hits.length;
@@ -435,26 +439,24 @@ class Repository {
    * @returns {Promise<integer>} count of deleted objects
    * @private
    */
-  async _truncatePart (objects, options) {
-    return Bluebird
-      .map(objects.hits, async object => {
-        // profile and role repositories have protected objects, we can't delete
-        // them
-        const protectedObjects = ['profiles', 'roles']
-          .indexOf(this.collection) !== -1
-          ? ['admin', 'default', 'anonymous']
+  async _truncatePart(objects, options) {
+    return Bluebird.map(objects.hits, async (object) => {
+      // profile and role repositories have protected objects, we can't delete
+      // them
+      const protectedObjects =
+        ["profiles", "roles"].indexOf(this.collection) !== -1
+          ? ["admin", "default", "anonymous"]
           : [];
 
-        if (protectedObjects.indexOf(object._id) !== -1) {
-          return 0;
-        }
+      if (protectedObjects.indexOf(object._id) !== -1) {
+        return 0;
+      }
 
-        const loaded = await this.load(object._id);
-        await this.delete(loaded, options);
+      const loaded = await this.load(object._id);
+      await this.delete(loaded, options);
 
-        return 1;
-      })
-      .reduce((total, deleted) => total + deleted, 0);
+      return 1;
+    }).reduce((total, deleted) => total + deleted, 0);
   }
 
   /**
@@ -463,7 +465,7 @@ class Repository {
    * @returns {Promise<object>}
    * @private
    */
-  async _formatSearchResults (raw) {
+  async _formatSearchResults(raw) {
     const result = {
       aggregations: raw.aggregations,
       hits: [],
@@ -472,7 +474,7 @@ class Repository {
     };
 
     if (raw.hits && raw.hits.length > 0) {
-      result.hits = await Bluebird.map(raw.hits, doc => {
+      result.hits = await Bluebird.map(raw.hits, (doc) => {
         return this.fromDTO(Object.assign({}, doc._source, { _id: doc._id }));
       });
     }

package/lib/core/shared/sdk/embeddedSdk.d.ts

@@ -1,5 +1,5 @@
-import { RealtimeController, Notification, JSONObject, ScopeOption, UserOption, Kuzzle, RequestPayload } from 'kuzzle-sdk';
-import { ResponsePayload } from '../../../types';
+import { RealtimeController, Notification, JSONObject, ScopeOption, UserOption, Kuzzle, RequestPayload } from "kuzzle-sdk";
+import { ResponsePayload } from "../../../types";
 interface EmbeddedRealtime extends RealtimeController {
     /**
      * Subscribes by providing a set of filters: messages, document changes

package/lib/core/shared/sdk/embeddedSdk.js

@@ -53,30 +53,30 @@ const funnelProtocol_1 = require("./funnelProtocol");
 const safeObject_1 = require("../../../util/safeObject");
 const kerror = __importStar(require("../../../kerror"));
 const impersonatedSdk_1 = __importDefault(require("./impersonatedSdk"));
-const contextError = kerror.wrap('plugin', 'context');
+const contextError = kerror.wrap("plugin", "context");
 const forbiddenEmbeddedActions = {
-    'auth': new Set([
-        'checkRights',
-        'createApiKey',
-        'createMyCredentials',
-        'credentialsExist',
-        'deleteApiKey',
-        'getCurrentUser',
-        'getMyCredentials',
-        'getMyRights',
-        'getStrategies',
-        'logout',
-        'refreshToken',
-        'searchApiKeys',
-        'updateMyCredentials',
-        'updateSelf',
-        'validateMyCredentials',
+    auth: new Set([
+        "checkRights",
+        "createApiKey",
+        "createMyCredentials",
+        "credentialsExist",
+        "deleteApiKey",
+        "getCurrentUser",
+        "getMyCredentials",
+        "getMyRights",
+        "getStrategies",
+        "logout",
+        "refreshToken",
+        "searchApiKeys",
+        "updateMyCredentials",
+        "updateSelf",
+        "validateMyCredentials",
     ]),
 };
 const warnEmbeddedActions = {
-    'auth': {
-        'login': 'EmbeddedSDK.login is deprecated, use user impersonation instead',
-    }
+    auth: {
+        login: "EmbeddedSDK.login is deprecated, use user impersonation instead",
+    },
 };
 /**
  * Kuzzle embedded SDK to make API calls inside applications or plugins.
@@ -93,8 +93,8 @@ class EmbeddedSDK extends kuzzle_sdk_1.Kuzzle {
      * @param options - Optional sdk arguments
      */
     as(user, options = { checkRights: false }) {
-        if (!(0, safeObject_1.isPlainObject)(user) || typeof user._id !== 'string') {
-            throw contextError.get('invalid_user');
+        if (!(0, safeObject_1.isPlainObject)(user) || typeof user._id !== "string") {
+            throw contextError.get("invalid_user");
         }
         return new impersonatedSdk_1.default(user._id, options);
     }
@@ -109,18 +109,22 @@ class EmbeddedSDK extends kuzzle_sdk_1.Kuzzle {
      */
     query(request, options = {}) {
         // By default, do not propagate realtime notification accross cluster nodes
-        if ((0, safeObject_1.isPlainObject)(request)
-            && request.controller === 'realtime'
-            && request.action === 'subscribe') {
-            request.propagate = options.propagate === undefined || options.propagate === null
-                ? false
-                : options.propagate;
+        if ((0, safeObject_1.isPlainObject)(request) &&
+            request.controller === "realtime" &&
+            request.action === "subscribe") {
+            request.propagate =
+                options.propagate === undefined || options.propagate === null
+                    ? false
+                    : options.propagate;
         }
-        if (forbiddenEmbeddedActions[request.controller] !== undefined
-            && forbiddenEmbeddedActions[request.controller].has(request.action)) {
-            throw kerror.get('api', 'process', 'forbidden_embedded_sdk_action', request.controller, request.action, ', use user impersonation or security controller instead');
+        if (forbiddenEmbeddedActions[request.controller] !== undefined &&
+            forbiddenEmbeddedActions[request.controller].has(request.action)) {
+            throw kerror.get("api", "process", "forbidden_embedded_sdk_action", request.controller, request.action, ", use user impersonation or security controller instead");
         }
-        const warning = lodash_1.default.get(warnEmbeddedActions, [request.controller, request.action]);
+        const warning = lodash_1.default.get(warnEmbeddedActions, [
+            request.controller,
+            request.action,
+        ]);
         if (warning) {
             global.kuzzle.log.warn(warning);
         }

package/lib/core/shared/sdk/funnelProtocol.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleEventEmitter, RequestPayload } from 'kuzzle-sdk';
+import { KuzzleEventEmitter, RequestPayload } from "kuzzle-sdk";
 export declare class FunnelProtocol extends KuzzleEventEmitter {
     private id;
     private connectionId;

package/lib/core/shared/sdk/funnelProtocol.js

@@ -50,13 +50,13 @@ const kerror = __importStar(require("../../../kerror"));
 class FunnelProtocol extends kuzzle_sdk_1.KuzzleEventEmitter {
     constructor() {
         super();
-        this.id = 'funnel';
+        this.id = "funnel";
         this.connectionId = null;
         /**
          * Realtime notifications are sent by the InternalProtocol
          * through the internal event system.
          */
-        global.kuzzle.on('core:network:internal:message', message => {
+        global.kuzzle.on("core:network:internal:message", (message) => {
             // Send the notifications to the SDK for the internal Room mechanism
             this.emit(message.room, message);
         });
@@ -69,28 +69,28 @@ class FunnelProtocol extends kuzzle_sdk_1.KuzzleEventEmitter {
      */
     async query(request) {
         if (!this.connectionId) {
-            this.connectionId = await global.kuzzle.ask('core:network:internal:connectionId:get');
+            this.connectionId = await global.kuzzle.ask("core:network:internal:connectionId:get");
         }
         const requestOptions = {
             connection: {
                 id: this.connectionId,
-                protocol: this.id
+                protocol: this.id,
             },
             user: null,
         };
         // Validate and use the provided request.kuid
         if (request.__kuid__) {
-            if (typeof request.__kuid__ !== 'string') {
-                throw kerror.get('plugin', 'context', 'invalid_user');
+            if (typeof request.__kuid__ !== "string") {
+                throw kerror.get("plugin", "context", "invalid_user");
             }
             // Get the user and store it in this context to prevent any possible race conditions
-            requestOptions.user = await global.kuzzle.ask('core:security:user:get', request.__kuid__);
+            requestOptions.user = await global.kuzzle.ask("core:security:user:get", request.__kuid__);
         }
         const kuzzleRequest = new request_1.Request(request, requestOptions);
-        if (requestOptions.user
-            && request.__checkRights__
-            && !await requestOptions.user.isActionAllowed(kuzzleRequest)) {
-            throw kerror.get('security', 'rights', 'forbidden', kuzzleRequest.input.controller, kuzzleRequest.input.action, requestOptions.user._id);
+        if (requestOptions.user &&
+            request.__checkRights__ &&
+            !(await requestOptions.user.isActionAllowed(kuzzleRequest))) {
+            throw kerror.get("security", "rights", "forbidden", kuzzleRequest.input.controller, kuzzleRequest.input.action, requestOptions.user._id);
         }
         const result = await global.kuzzle.funnel.executePluginRequest(kuzzleRequest);
         return { result };

package/lib/core/shared/sdk/impersonatedSdk.js

@@ -19,24 +19,24 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const nativeControllers = require('../../../api/controllers');
+const nativeControllers = require("../../../api/controllers");
 
 class ImpersonatedSDK {
-  constructor (kuid, options = {}) {
+  constructor(kuid, options = {}) {
     this.kuid = kuid;
     this.checkRights = options.checkRights || false;
 
     for (const controller of Object.keys(nativeControllers)) {
       // @todo in the future, native controller names should be normalized to sdk naming
       const controllerName = controller
-        .replace('Controller', '')
-        .replace('MemoryStorage', 'ms')
+        .replace("Controller", "")
+        .replace("MemoryStorage", "ms")
         .toLowerCase();
       const controllerProxy = `${controllerName}Proxy`;
 
-      if (! global.app.sdk[controllerName]) {
+      if (!global.app.sdk[controllerName]) {
         continue;
       }
 
@@ -44,8 +44,7 @@ class ImpersonatedSDK {
       Reflect.defineProperty(this, controllerName, {
         get: () => {
           // If the requested controller has not yet been proxied
-          if (! this[controllerProxy]) {
-
+          if (!this[controllerProxy]) {
             // Create a proxy object to inject our local 'query' behaviour
             // in the underlying base 'sdk' action methods so we can send
             // impersonation configuration (kuid & checkRights) to the funnel
@@ -58,31 +57,33 @@ class ImpersonatedSDK {
 
                     // Call the 'ImpersonatedSdk.query' method instead
                     return this.query(request, opts);
-                  }
+                  },
                 };
 
                 // Make sure we bring any local methods into our new custom context
-                Object.getOwnPropertyNames(Object.getPrototypeOf(global.app.sdk[controllerName]))
-                  .forEach((localMethod) => {
-                    if (! ['constructor', 'query'].includes(localMethod)) {
-                      customContext[localMethod] = controllerInstance[localMethod];
-                    }
-                  });
+                Object.getOwnPropertyNames(
+                  Object.getPrototypeOf(global.app.sdk[controllerName])
+                ).forEach((localMethod) => {
+                  if (!["constructor", "query"].includes(localMethod)) {
+                    customContext[localMethod] =
+                      controllerInstance[localMethod];
+                  }
+                });
 
                 // Return the original SDK action method AND also bind our merged custom context
                 // containing our 'query' method and any original local methods
                 return controllerInstance[actionName].bind(customContext);
-              }
+              },
             });
           }
 
           return this[controllerProxy];
-        }
+        },
       });
     }
   }
 
-  query (request, options = {}) {
+  query(request, options = {}) {
     request.__kuid__ = this.kuid;
     request.__checkRights__ = this.checkRights;