kuzzle 2.19.2 → 2.19.3

package/lib/core/security/securityLoader.js

@@ -19,64 +19,67 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { isEmpty } = require('lodash');
-const Bluebird = require('bluebird');
+const { isEmpty } = require("lodash");
+const Bluebird = require("bluebird");
 
-const { Request } = require('../../api/request');
-const { assertIsObject } = require('../../util/requestAssertions');
-const kerror = require('../../kerror');
+const { Request } = require("../../api/request");
+const { assertIsObject } = require("../../util/requestAssertions");
+const kerror = require("../../kerror");
 
 /**
  * @class SecurityLoader
  */
 class SecurityLoader {
-  constructor () {
-  }
+  constructor() {}
 
-  async init () {
+  async init() {
     /**
      * Loads permissions into the app
      * @param {Object} permissions Object containing roles, profiles and users
      * @param {Object} opts - force, onExistingUsers (fail), onExistingUsersWarning (false), user (null)
      */
-    global.kuzzle.onAsk(
-      'core:security:load',
-      (json, opts) => this.load(json, opts));
+    global.kuzzle.onAsk("core:security:load", (json, opts) =>
+      this.load(json, opts)
+    );
   }
 
-  async load (permissions = {}, {
-    force,
-    onExistingUsers = 'fail',
-    onExistingUsersWarning = false,
-    refresh = 'false',
-    user = null,
-  } = {}) {
+  async load(
+    permissions = {},
+    {
+      force,
+      onExistingUsers = "fail",
+      onExistingUsersWarning = false,
+      refresh = "false",
+      user = null,
+    } = {}
+  ) {
     assertIsObject(permissions);
 
-    await this._create('createOrReplaceRole', permissions.roles, 'roles', {
+    await this._create("createOrReplaceRole", permissions.roles, "roles", {
       force,
       refresh,
       user,
     });
 
     await this._create(
-      'createOrReplaceProfile',
+      "createOrReplaceProfile",
       permissions.profiles,
-      'profiles',
-      { refresh, user });
+      "profiles",
+      { refresh, user }
+    );
 
     const usersToLoad = await this._getUsersToLoad(permissions.users, {
       onExistingUsers,
       warning: onExistingUsersWarning,
     });
 
-    await this._create('createUser', usersToLoad, 'users', { refresh, user });
+    await this._create("createUser", usersToLoad, "users", { refresh, user });
   }
 
-  async _create (action, objects, collection, { force, refresh, user } = {}) {
-    if (! objects) {
+  async _create(action, objects, collection, { force, refresh, user } = {}) {
+    if (!objects) {
       return;
     }
 
@@ -87,14 +90,17 @@ class SecurityLoader {
     for (const [_id, body] of Object.entries(objects)) {
       assertIsObject(body);
 
-      const request = new Request({
-        _id,
-        action,
-        body,
-        controller: 'security',
-        force,
-        refresh,
-      }, { user });
+      const request = new Request(
+        {
+          _id,
+          action,
+          body,
+          controller: "security",
+          force,
+          refresh,
+        },
+        { user }
+      );
 
       promises.push(global.kuzzle.funnel.processRequest(request));
     }
@@ -104,16 +110,16 @@ class SecurityLoader {
     await global.kuzzle.internalIndex.refreshCollection(collection);
   }
 
-  async _getUsersToLoad (users, { onExistingUsers, warning } = {}) {
+  async _getUsersToLoad(users, { onExistingUsers, warning } = {}) {
     if (isEmpty(users)) {
       return users;
     }
 
     const ids = Object.keys(users);
     const mGetUsers = new Request({
-      action: 'mGetUsers',
+      action: "mGetUsers",
       body: { ids },
-      controller: 'security'
+      controller: "security",
     });
 
     const { result } = await global.kuzzle.funnel.processRequest(mGetUsers);
@@ -124,44 +130,45 @@ class SecurityLoader {
       return users;
     }
 
-    if (onExistingUsers === 'fail') {
-      throw kerror.get('security', 'user', 'prevent_overwrite');
-    }
-    else if (onExistingUsers === 'skip') {
+    if (onExistingUsers === "fail") {
+      throw kerror.get("security", "user", "prevent_overwrite");
+    } else if (onExistingUsers === "skip") {
       if (warning) {
-        global.kuzzle.log.info(`Users skipped during import: ${existingUserIds}`);
+        global.kuzzle.log.info(
+          `Users skipped during import: ${existingUserIds}`
+        );
       }
-      return Object.entries(users)
-        .reduce((memo, [userId, content]) => {
-          if (! existingUserIds.includes(userId)) {
-            memo[userId] = content;
-          }
-
-          return memo;
-        }, {});
-    }
-    else if (onExistingUsers === 'overwrite') {
+      return Object.entries(users).reduce((memo, [userId, content]) => {
+        if (!existingUserIds.includes(userId)) {
+          memo[userId] = content;
+        }
+
+        return memo;
+      }, {});
+    } else if (onExistingUsers === "overwrite") {
       if (warning) {
-        global.kuzzle.log.info(`Users overwritten during import: ${existingUserIds}`);
+        global.kuzzle.log.info(
+          `Users overwritten during import: ${existingUserIds}`
+        );
       }
       const mDeleteUsers = new Request({
-        action: 'mDeleteUsers',
+        action: "mDeleteUsers",
         body: { ids: existingUserIds },
-        controller: 'security',
-        refresh: 'wait_for'
+        controller: "security",
+        refresh: "wait_for",
       });
 
       await global.kuzzle.funnel.processRequest(mDeleteUsers);
 
       return users;
-    }
-    else {
+    } else {
       throw kerror.get(
-        'api',
-        'assert',
-        'unexpected_argument',
-        'onExistingUsers',
-        ['skip', 'overwrite', 'fail']);
+        "api",
+        "assert",
+        "unexpected_argument",
+        "onExistingUsers",
+        ["skip", "overwrite", "fail"]
+      );
     }
   }
 }