kuzzle 2.19.2 → 2.19.3

package/lib/kuzzle/internalIndexHandler.js

@@ -19,55 +19,55 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const crypto = require('crypto');
+const crypto = require("crypto");
 
-const Bluebird = require('bluebird');
+const Bluebird = require("bluebird");
 
-const debug = require('../util/debug')('kuzzle:bootstrap:internalIndex');
-const Store = require('../core/shared/store');
-const { Mutex } = require('../util/mutex');
-const scopeEnum = require('../core/storage/storeScopeEnum');
-const kerror = require('../kerror');
+const debug = require("../util/debug")("kuzzle:bootstrap:internalIndex");
+const Store = require("../core/shared/store");
+const { Mutex } = require("../util/mutex");
+const scopeEnum = require("../core/storage/storeScopeEnum");
+const kerror = require("../kerror");
 
 const securitiesBootstrap = {
   profiles: {
     admin: {
-      policies: [ { roleId: 'admin' } ],
+      policies: [{ roleId: "admin" }],
       rateLimit: 0,
     },
     anonymous: {
-      policies: [ { roleId: 'anonymous' } ],
+      policies: [{ roleId: "anonymous" }],
     },
     default: {
-      policies: [ { roleId: 'default' } ],
-    }
+      policies: [{ roleId: "default" }],
+    },
   },
   roles: {
     admin: {
       controllers: {
-        '*': {
+        "*": {
           actions: {
-            '*': true,
+            "*": true,
           },
         },
       },
     },
     anonymous: {
       controllers: {
-        '*': {
+        "*": {
           actions: {
-            '*': true,
+            "*": true,
           },
         },
       },
     },
     default: {
       controllers: {
-        '*': {
+        "*": {
           actions: {
-            '*': true,
+            "*": true,
           },
         },
       },
@@ -75,30 +75,32 @@ const securitiesBootstrap = {
   },
 };
 
-const dataModelVersion = '2.0.0';
+const dataModelVersion = "2.0.0";
 
 class InternalIndexHandler extends Store {
-  constructor () {
+  constructor() {
     super(
       global.kuzzle.config.services.storageEngine.internalIndex.name,
-      scopeEnum.PRIVATE);
+      scopeEnum.PRIVATE
+    );
 
-    this.timeout = global.kuzzle.config.services.internalIndex.bootstrapLockTimeout;
+    this.timeout =
+      global.kuzzle.config.services.internalIndex.bootstrapLockTimeout;
     this.config = global.kuzzle.config.services.storageEngine.internalIndex;
 
     // IDs for config documents
     this._BOOTSTRAP_DONE_ID = `${this.index}.done`;
-    this._DATAMODEL_VERSION_ID = 'internalIndex.dataModelVersion';
-    this._JWT_SECRET_ID = 'security.jwt.secret';
+    this._DATAMODEL_VERSION_ID = "internalIndex.dataModelVersion";
+    this._JWT_SECRET_ID = "security.jwt.secret";
   }
 
   /**
    * @returns {Promise}
    */
-  async init () {
+  async init() {
     await super.init(this.config.collections);
 
-    const mutex = new Mutex('InternalIndexBootstrap', {
+    const mutex = new Mutex("InternalIndexBootstrap", {
       timeout: -1,
       ttl: 30000,
     });
@@ -106,7 +108,7 @@ class InternalIndexHandler extends Store {
     await mutex.lock();
 
     try {
-      const bootstrapped = await this.exists('config', this._BOOTSTRAP_DONE_ID);
+      const bootstrapped = await this.exists("config", this._BOOTSTRAP_DONE_ID);
 
       if (bootstrapped) {
         return;
@@ -114,18 +116,25 @@ class InternalIndexHandler extends Store {
 
       await Bluebird.resolve(this._bootstrapSequence()).timeout(this.timeout);
 
-      await this.create('config', { timestamp: Date.now() }, {
-        id: this._BOOTSTRAP_DONE_ID,
-      });
-    }
-    catch (error) {
+      await this.create(
+        "config",
+        { timestamp: Date.now() },
+        {
+          id: this._BOOTSTRAP_DONE_ID,
+        }
+      );
+    } catch (error) {
       if (error instanceof Bluebird.TimeoutError) {
-        throw kerror.get('services', 'storage', 'bootstrap_timeout', 'internalIndex');
+        throw kerror.get(
+          "services",
+          "storage",
+          "bootstrap_timeout",
+          "internalIndex"
+        );
       }
 
       throw error;
-    }
-    finally {
+    } finally {
       await mutex.unlock();
     }
   }
@@ -133,44 +142,50 @@ class InternalIndexHandler extends Store {
   /**
    * @override
    */
-  async _bootstrapSequence () {
-    debug('Bootstrapping security structure');
+  async _bootstrapSequence() {
+    debug("Bootstrapping security structure");
     await this.createInitialSecurities();
 
-    debug('Bootstrapping document validation structure');
+    debug("Bootstrapping document validation structure");
     await this.createInitialValidations();
 
-    debug('Bootstrapping JWT secret');
+    debug("Bootstrapping JWT secret");
     await this._persistSecret();
 
     // Create datamodel version
-    await this.create('config', { version: dataModelVersion }, {
-      id: this._DATAMODEL_VERSION_ID,
-    });
+    await this.create(
+      "config",
+      { version: dataModelVersion },
+      {
+        id: this._DATAMODEL_VERSION_ID,
+      }
+    );
   }
 
   /**
    * Creates initial roles and profiles as specified in Kuzzle configuration
    */
-  async createInitialSecurities () {
+  async createInitialSecurities() {
     await Bluebird.map(
       Object.entries(securitiesBootstrap.roles),
       ([roleId, content]) => {
-        return this.createOrReplace('roles', roleId, content, {
-          refresh: 'wait_for',
+        return this.createOrReplace("roles", roleId, content, {
+          refresh: "wait_for",
         });
-      });
+      }
+    );
 
     await Bluebird.map(
       Object.entries(securitiesBootstrap.profiles),
       ([profileId, content]) => {
-        return this.createOrReplace('profiles', profileId, content, {
-          refresh: 'wait_for',
+        return this.createOrReplace("profiles", profileId, content, {
+          refresh: "wait_for",
         });
-      });
+      }
+    );
   }
 
-  async createInitialValidations () {
+  async createInitialValidations() {
     const initialValidations = global.kuzzle.config.validation;
     const promises = [];
 
@@ -179,26 +194,32 @@ class InternalIndexHandler extends Store {
         const validationId = `${index}#${collectionName}`;
 
         promises.push(
-          this.createOrReplace('validations', validationId, validation));
+          this.createOrReplace("validations", validationId, validation)
+        );
       }
     }
 
     await Bluebird.all(promises);
   }
 
-  async getSecret () {
-    const response = await this.get('config', this._JWT_SECRET_ID);
+  async getSecret() {
+    const response = await this.get("config", this._JWT_SECRET_ID);
 
     return response._source.seed;
   }
 
-  async _persistSecret () {
-    const seed = global.kuzzle.config.security.jwt.secret
-      || crypto.randomBytes(512).toString('hex');
+  async _persistSecret() {
+    const seed =
+      global.kuzzle.config.security.jwt.secret ||
+      crypto.randomBytes(512).toString("hex");
 
-    await this.create('config', { seed }, {
-      id: this._JWT_SECRET_ID,
-    });
+    await this.create(
+      "config",
+      { seed },
+      {
+        id: this._JWT_SECRET_ID,
+      }
+    );
   }
 }