kuzzle 2.27.1 → 2.27.3

package/lib/kerror/codes/index.js

@@ -49,57 +49,57 @@ function checkErrors(subdomain, domain, options) {
   for (const [name, error] of Object.entries(subdomain.errors)) {
     assert(
       has(error, "code"),
-      `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+      `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`,
     );
     assert(
       Number.isInteger(error.code),
-      `Error configuration file : Field 'code' must be an integer (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+      `Error configuration file : Field 'code' must be an integer (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`,
     );
     assert(
       error.code > 0x0000 && error.code <= 0xffff,
-      `Error configuration file : Field 'code' must be between 1 and 65535 (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+      `Error configuration file : Field 'code' must be between 1 and 65535 (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`,
     );
     assert(
       !codes.has(error.code),
-      `Error configuration file : code ${error.code} for error '${name}' is not unique (domain: ${domain.code}, subdomain: ${subdomain.code}).`
+      `Error configuration file : code ${error.code} for error '${name}' is not unique (domain: ${domain.code}, subdomain: ${subdomain.code}).`,
     );
 
     codes.add(error.code);
 
     assert(
       has(error, "message"),
-      `Error configuration file : Missing required 'message' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+      `Error configuration file : Missing required 'message' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`,
     );
     assert(
       typeof error.message === "string" && error.message.length > 0,
-      `Error configuration file : Field 'message' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+      `Error configuration file : Field 'message' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`,
     );
 
     assert(
       has(error, "class"),
-      `Error configuration file : Missing required 'class' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+      `Error configuration file : Missing required 'class' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`,
     );
     assert(
       typeof error.class === "string",
-      `Error configuration file : Field 'class' must be a string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+      `Error configuration file : Field 'class' must be a string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`,
     );
     assert(
       has(errors, error.class),
-      `Error configuration file : Field 'class' must target a known KuzzleError object (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}), '${name.class}' does not exist.`
+      `Error configuration file : Field 'class' must target a known KuzzleError object (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}), '${name.class}' does not exist.`,
     );
 
     // plugin errors aren't required to have descriptions
     if (!options.plugin) {
       assert(
         typeof error.description === "string" && error.description.length > 0,
-        `Error configuration file : Field 'description' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+        `Error configuration file : Field 'description' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`,
       );
     }
 
     if (error.deprecated !== undefined && error.deprecated !== null) {
       assert(
         typeof error.deprecated === "string" && error.deprecated.length > 0,
-        `Error configuration file : Field 'deprecated' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`
+        `Error configuration file : Field 'deprecated' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`,
       );
     }
   }
@@ -115,7 +115,7 @@ function checkSubdomains(domain, options) {
     if (!options.plugin) {
       assert(
         has(subdomain, "code"),
-        `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomainName}).`
+        `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomainName}).`,
       );
     } else if (!has(subdomain, "code")) {
       subdomain.code = 0;
@@ -123,15 +123,15 @@ function checkSubdomains(domain, options) {
 
     assert(
       Number.isInteger(subdomain.code),
-      `Error configuration file : Field 'code' must be an integer (domain: ${domain.code}, subdomain: ${subdomainName}).`
+      `Error configuration file : Field 'code' must be an integer (domain: ${domain.code}, subdomain: ${subdomainName}).`,
     );
     assert(
       subdomain.code >= 0x00 && subdomain.code <= 0xff,
-      `Error configuration file : Field 'code' must be between 0 and 255 (domain: ${domain.code}, subdomain: ${subdomainName}).`
+      `Error configuration file : Field 'code' must be between 0 and 255 (domain: ${domain.code}, subdomain: ${subdomainName}).`,
     );
     assert(
       !subdomainCodes.has(subdomain.code),
-      `Error configuration file : code ${subdomain.code} for subdomain '${subdomainName}' is not unique (domain: ${domain.code}).`
+      `Error configuration file : code ${subdomain.code} for subdomain '${subdomainName}' is not unique (domain: ${domain.code}).`,
     );
 
     // We don't allow duplicates, except for defaulted plugin subdomain codes
@@ -141,11 +141,11 @@ function checkSubdomains(domain, options) {
 
     assert(
       has(subdomain, "errors"),
-      `Error configuration file : Missing required 'errors' field (domain: ${domain.code}, subdomain: ${subdomainName}).`
+      `Error configuration file : Missing required 'errors' field (domain: ${domain.code}, subdomain: ${subdomainName}).`,
     );
     assert(
       isPlainObject(subdomain.errors),
-      `Error configuration file : Field 'errors' must be an object (domain: ${domain.code}, subdomain: ${subdomainName}).`
+      `Error configuration file : Field 'errors' must be an object (domain: ${domain.code}, subdomain: ${subdomainName}).`,
     );
 
     checkErrors(subdomain, domain, options);
@@ -160,30 +160,30 @@ function checkDomains(errorCodesFiles, options = { plugin: false }) {
 
     assert(
       has(domain, "code"),
-      `Error configuration file : Missing required 'code' field. (domain: '${domainName}').`
+      `Error configuration file : Missing required 'code' field. (domain: '${domainName}').`,
     );
     assert(
       Number.isInteger(domain.code),
-      `Error configuration file : Field 'code' must be an integer. (domain: '${domainName}').`
+      `Error configuration file : Field 'code' must be an integer. (domain: '${domainName}').`,
     );
     assert(
       domain.code >= 0x00 && domain.code <= 0xff,
-      `Error configuration file : Field 'code' must be between 0 and 255. (domain: '${domainName}').`
+      `Error configuration file : Field 'code' must be between 0 and 255. (domain: '${domainName}').`,
     );
     assert(
       !domainCodes.has(domain.code),
-      `Error configuration file : code ${domain.code} for domain ${domainName} is not unique.`
+      `Error configuration file : code ${domain.code} for domain ${domainName} is not unique.`,
     );
 
     domainCodes.add(domain.code);
 
     assert(
       has(domain, "subDomains"),
-      `Error configuration file : Missing required 'subDomains' field. (domain: '${domainName}').`
+      `Error configuration file : Missing required 'subDomains' field. (domain: '${domainName}').`,
     );
     assert(
       isPlainObject(domain.subDomains),
-      `Error configuration file : Field 'subDomains' must be an object. (domain: '${domainName}').`
+      `Error configuration file : Field 'subDomains' must be an object. (domain: '${domainName}').`,
     );
 
     checkSubdomains(domain, options);

package/lib/kuzzle/dumpGenerator.js

@@ -56,7 +56,7 @@ class DumpGenerator {
       moment()
         .format(global.kuzzle.config.dump.dateFormat)
         .concat(`-${suffix}`)
-        .substring(0, 200)
+        .substring(0, 200),
     );
 
     global.kuzzle.log.info("=".repeat(79));
@@ -83,8 +83,8 @@ class DumpGenerator {
           version: require("../../package.json").version,
         },
         null,
-        " "
-      ).concat("\n")
+        " ",
+      ).concat("\n"),
     );
 
     // dump plugins configuration
@@ -94,8 +94,8 @@ class DumpGenerator {
       JSON.stringify(
         global.kuzzle.pluginsManager.getPluginsDescription(),
         null,
-        " "
-      ).concat("\n")
+        " ",
+      ).concat("\n"),
     );
 
     // dump Node.js configuration
@@ -112,8 +112,8 @@ class DumpGenerator {
           versions: process.versions,
         },
         null,
-        " "
-      ).concat("\n")
+        " ",
+      ).concat("\n"),
     );
 
     // dump os configuration
@@ -133,8 +133,8 @@ class DumpGenerator {
           uptime: os.uptime(),
         },
         null,
-        " "
-      ).concat("\n")
+        " ",
+      ).concat("\n"),
     );
 
     // core-dump
@@ -159,11 +159,11 @@ class DumpGenerator {
                 fs.unlinkSync(corefiles[0]);
               } catch (e) {
                 global.kuzzle.log.warn(
-                  `> unable to clean up core file ${corefiles[0]}`
+                  `> unable to clean up core file ${corefiles[0]}`,
                 );
               }
               resolve();
-            })
+            }),
         );
       } else {
         global.kuzzle.log.warn("> could not generate dump");
@@ -179,17 +179,17 @@ class DumpGenerator {
     // dumping Kuzzle's stats
     global.kuzzle.log.info("> dumping kuzzle's stats");
     const statistics = await global.kuzzle.statistics.getAllStats(
-      new Request({ action: "getAllStats", controller: "statistics" })
+      new Request({ action: "getAllStats", controller: "statistics" }),
     );
 
     fs.writeFileSync(
       path.join(dumpPath, "statistics.json"),
-      JSON.stringify(statistics.hits, null, " ").concat("\n")
+      JSON.stringify(statistics.hits, null, " ").concat("\n"),
     );
 
     global.kuzzle.log.info("Done.");
     global.kuzzle.log.info(
-      "[ℹ] You can send the folder to the kuzzle core team at support@kuzzle.io"
+      "[ℹ] You can send the folder to the kuzzle core team at support@kuzzle.io",
     );
     global.kuzzle.log.info("=".repeat(79));
 
@@ -204,7 +204,7 @@ class DumpGenerator {
     try {
       fs.accessSync(
         dumpPath,
-        fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK
+        fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK,
       );
     } catch (e) {
       return;
@@ -234,7 +234,7 @@ class DumpGenerator {
     for (let i = 0; i < dumps.length - config.history.coredump; i++) {
       const corefiles = this._listFilesMatching(
         path.normalize(dumps[i].path),
-        "core"
+        "core",
       );
 
       if (corefiles[0]) {
@@ -249,7 +249,7 @@ class DumpGenerator {
       .filter(
         (entry) =>
           fs.lstatSync(`${directory}/${entry}`).isFile() &&
-          entry.startsWith(start)
+          entry.startsWith(start),
       )
       .map((file) => path.join(directory, file));
   }

package/lib/kuzzle/event/kuzzleEventEmitter.js

@@ -81,7 +81,7 @@ class KuzzleEventEmitter extends EventEmitter {
   onPipe(event, fn) {
     assert(
       typeof fn === "function",
-      `Cannot listen to pipe event ${event}: "${fn}" is not a function`
+      `Cannot listen to pipe event ${event}: "${fn}" is not a function`,
     );
 
     if (!this.corePipes.has(event)) {
@@ -101,11 +101,11 @@ class KuzzleEventEmitter extends EventEmitter {
   onAsk(event, fn) {
     assert(
       typeof fn === "function",
-      `Cannot listen to ask event "${event}": "${fn}" is not a function`
+      `Cannot listen to ask event "${event}": "${fn}" is not a function`,
     );
     assert(
       !this.coreAnswerers.has(event),
-      `Cannot add a listener to the ask event "${event}": event has already an answerer`
+      `Cannot add a listener to the ask event "${event}": event has already an answerer`,
     );
 
     this.coreAnswerers.set(event, fn);
@@ -121,11 +121,11 @@ class KuzzleEventEmitter extends EventEmitter {
   onCall(event, fn) {
     assert(
       typeof fn === "function",
-      `Cannot register callback for event "${event}": "${fn}" is not a function`
+      `Cannot register callback for event "${event}": "${fn}" is not a function`,
     );
     assert(
       !this.coreSyncedAnswerers.has(event),
-      `Cannot register callback for event "${event}": a callback has already been registered`
+      `Cannot register callback for event "${event}": a callback has already been registered`,
     );
 
     this.coreSyncedAnswerers.set(event, fn);
@@ -222,7 +222,7 @@ class KuzzleEventEmitter extends EventEmitter {
         "core",
         "fatal",
         "assertion_failed",
-        `the requested ask event '${event}' doesn't have an answerer`
+        `the requested ask event '${event}' doesn't have an answerer`,
       );
     }
 
@@ -232,7 +232,7 @@ class KuzzleEventEmitter extends EventEmitter {
       super.emit(ev, {
         args: payload,
         response,
-      })
+      }),
     );
 
     return response;
@@ -251,7 +251,7 @@ class KuzzleEventEmitter extends EventEmitter {
         "core",
         "fatal",
         "assertion_failed",
-        `the requested callback event '${event}' doesn't have an answerer`
+        `the requested callback event '${event}' doesn't have an answerer`,
       );
     }
 
@@ -261,7 +261,7 @@ class KuzzleEventEmitter extends EventEmitter {
       super.emit(ev, {
         args: payload,
         response,
-      })
+      }),
     );
 
     return response;

package/lib/kuzzle/event/pipeRunner.js

@@ -83,11 +83,11 @@ class PipeRunner {
   constructor(concurrent, bufferSize) {
     assert(
       typeof concurrent === "number" && concurrent > 0,
-      "Cannot instantiate pipes executor: invalid maxConcurrentPipes parameter value"
+      "Cannot instantiate pipes executor: invalid maxConcurrentPipes parameter value",
     );
     assert(
       typeof bufferSize === "number" && bufferSize > 0,
-      "Cannot instantiate pipes executor: invalid pipesBufferSize parameter value"
+      "Cannot instantiate pipes executor: invalid pipesBufferSize parameter value",
     );
 
     this.maxConcurrent = concurrent;

package/lib/kuzzle/internalIndexHandler.js

@@ -81,7 +81,7 @@ class InternalIndexHandler extends Store {
   constructor() {
     super(
       global.kuzzle.config.services.storageEngine.internalIndex.name,
-      scopeEnum.PRIVATE
+      scopeEnum.PRIVATE,
     );
 
     this.timeout =
@@ -121,7 +121,7 @@ class InternalIndexHandler extends Store {
         { timestamp: Date.now() },
         {
           id: this._BOOTSTRAP_DONE_ID,
-        }
+        },
       );
     } catch (error) {
       if (error instanceof Bluebird.TimeoutError) {
@@ -129,7 +129,7 @@ class InternalIndexHandler extends Store {
           "services",
           "storage",
           "bootstrap_timeout",
-          "internalIndex"
+          "internalIndex",
         );
       }
 
@@ -158,7 +158,7 @@ class InternalIndexHandler extends Store {
       { version: dataModelVersion },
       {
         id: this._DATAMODEL_VERSION_ID,
-      }
+      },
     );
   }
 
@@ -172,7 +172,7 @@ class InternalIndexHandler extends Store {
         return this.createOrReplace("roles", roleId, content, {
           refresh: "wait_for",
         });
-      }
+      },
     );
 
     await Bluebird.map(
@@ -181,7 +181,7 @@ class InternalIndexHandler extends Store {
         return this.createOrReplace("profiles", profileId, content, {
           refresh: "wait_for",
         });
-      }
+      },
     );
   }
 
@@ -194,7 +194,7 @@ class InternalIndexHandler extends Store {
         const validationId = `${index}#${collectionName}`;
 
         promises.push(
-          this.createOrReplace("validations", validationId, validation)
+          this.createOrReplace("validations", validationId, validation),
         );
       }
     }
@@ -218,7 +218,7 @@ class InternalIndexHandler extends Store {
       { seed },
       {
         id: this._JWT_SECRET_ID,
-      }
+      },
     );
   }
 }

package/lib/kuzzle/log.js

@@ -58,12 +58,12 @@ class Logger {
 
           global.kuzzle.emit(
             `log:${method}`,
-            `[${global.kuzzle.id}] ${this.failsafeModeString}[${request.id}] ${message}`
+            `[${global.kuzzle.id}] ${this.failsafeModeString}[${request.id}] ${message}`,
           );
         } else {
           global.kuzzle.emit(
             `log:${method}`,
-            `[${global.kuzzle.id}] ${this.failsafeModeString}${message}`
+            `[${global.kuzzle.id}] ${this.failsafeModeString}${message}`,
           );
         }
       };

package/lib/kuzzle/vault.js

@@ -35,7 +35,7 @@ function load(vaultKey, secretsFile) {
   // Using KaaF kuzzle is an npm package and is located under node_modules folder
   // We need to get back to root folder of the project to get the secret file
   const defaultEncryptedSecretsFile = __dirname.endsWith(
-    "/node_modules/kuzzle/lib/kuzzle"
+    "/node_modules/kuzzle/lib/kuzzle",
   )
     ? path.resolve(`${__dirname}/../../../../config/secrets.enc.json`)
     : path.resolve(`${__dirname}/../../config/secrets.enc.json`);
@@ -59,7 +59,7 @@ function load(vaultKey, secretsFile) {
   if (!_.isEmpty(process.env.KUZZLE_SECRETS_FILE) || !_.isEmpty(secretsFile)) {
     assert(
       fileExists,
-      `A secret file has been provided but Kuzzle cannot find it at "${encryptedSecretsFile}".`
+      `A secret file has been provided but Kuzzle cannot find it at "${encryptedSecretsFile}".`,
     );
   }
 
@@ -67,14 +67,14 @@ function load(vaultKey, secretsFile) {
   // but no vault key has been provided
   assert(
     !(fileExists && _.isEmpty(key)),
-    "A secret file has been provided but Kuzzle cannot find the Vault key. Aborting."
+    "A secret file has been provided but Kuzzle cannot find the Vault key. Aborting.",
   );
 
   // Abort if a vault key has been provided
   // but no secrets file can be loaded (default or custom)
   assert(
     !(!_.isEmpty(key) && !fileExists),
-    `A Vault key is present but Kuzzle cannot find the secret file at "${encryptedSecretsFile}". Aborting.`
+    `A Vault key is present but Kuzzle cannot find the secret file at "${encryptedSecretsFile}". Aborting.`,
   );
 
   const vault = new Vault(key);

package/lib/model/security/role.js

@@ -115,7 +115,9 @@ class Role {
         if (Object.keys(this.controllers).length === 0) {
             throw assertionError.get("empty_argument", `${this._id}.controllers`);
         }
-        Object.entries(this.controllers).forEach((entry) => this.validateControllerRights(...entry));
+        for (const entry of Object.entries(this.controllers)) {
+            this.validateControllerRights(...entry);
+        }
     }
     /**
      * @param {String} index

package/lib/model/security/user.js

@@ -74,7 +74,9 @@ class User {
         const profiles = await this.getProfiles();
         const results = await Promise.all(profiles.map((p) => p.getRights()));
         const rights = {};
-        results.forEach((right) => lodash_1.default.assignWith(rights, right, rights_1.default.merge));
+        for (const right of results) {
+            lodash_1.default.assignWith(rights, right, rights_1.default.merge);
+        }
         return rights;
     }
     /**

package/lib/model/storage/apiKey.js

@@ -38,7 +38,7 @@ class ApiKey extends BaseModel {
     const token = await global.kuzzle.ask(
       "core:security:token:get",
       this.userId,
-      this.token
+      this.token,
     );
 
     if (token) {
@@ -93,7 +93,7 @@ class ApiKey extends BaseModel {
     user,
     expiresIn,
     description,
-    { creatorId = null, apiKeyId = null, refresh, bypassMaxTTL = false } = {}
+    { creatorId = null, apiKeyId = null, refresh, bypassMaxTTL = false } = {},
   ) {
     const token = await global.kuzzle.ask("core:security:token:create", user, {
       bypassMaxTTL,
@@ -111,7 +111,7 @@ class ApiKey extends BaseModel {
         ttl: token.ttl,
         userId: user._id,
       },
-      apiKeyId || fingerprint
+      apiKeyId || fingerprint,
     );
 
     await apiKey.save({ refresh, userId: creatorId });

package/lib/model/storage/baseModel.js

@@ -78,7 +78,7 @@ class BaseModel {
       const { _id, _source } = await global.kuzzle.internalIndex.create(
         this.constructor.collection,
         this._source,
-        { id: this._id, refresh, userId }
+        { id: this._id, refresh, userId },
       );
 
       this._id = _id;
@@ -89,7 +89,7 @@ class BaseModel {
         this.constructor.collection,
         this._id,
         this._source,
-        { refresh, userId }
+        { refresh, userId },
       );
     }
   }
@@ -110,7 +110,7 @@ class BaseModel {
     await global.kuzzle.internalIndex.delete(
       this.constructor.collection,
       this._id,
-      { refresh }
+      { refresh },
     );
 
     await this._afterDelete();
@@ -190,13 +190,13 @@ class BaseModel {
   static async deleteByQuery(query, { refresh } = {}) {
     const { documents } = await global.kuzzle.internalIndex.deleteByQuery(
       this.collection,
-      query
+      query,
     );
 
     await Bluebird.map(
       documents,
       (document) => this._instantiateFromDb(document)._afterDelete(),
-      { concurrency: 10 }
+      { concurrency: 10 },
     ); // limits the load on storage services
 
     if (refresh) {
@@ -216,7 +216,7 @@ class BaseModel {
     const resp = await global.kuzzle.internalIndex.search(
       this.collection,
       searchBody,
-      options
+      options,
     );
 
     return resp.hits.map((hit) => this._instantiateFromDb(hit));
@@ -237,7 +237,7 @@ class BaseModel {
     return global.kuzzle.internalIndex.mExecute(
       this.collection,
       query,
-      callback
+      callback,
     );
   }
 

package/lib/service/cache/redis.js

@@ -77,7 +77,7 @@ class Redis extends Service {
     this.client.on("error", (error) => {
       if (this.connected) {
         global.kuzzle.log.error(
-          `Redis service seem to be down, see original error for more info:\n${error.message}`
+          `Redis service seem to be down, see original error for more info:\n${error.message}`,
         );
       }
       this.connected = false;
@@ -93,7 +93,7 @@ class Redis extends Service {
       this.client.once("ready", async () => {
         await this.client.client(
           "SETNAME",
-          `${this.adapterName}/${global.kuzzle.id}`
+          `${this.adapterName}/${global.kuzzle.id}`,
         );
         resolve();
       });
@@ -128,7 +128,7 @@ class Redis extends Service {
       await this.client.ping();
     } catch (error) {
       global.kuzzle.log.error(
-        `Failed to PING Redis to keep connection alive:\n${error.message}`
+        `Failed to PING Redis to keep connection alive:\n${error.message}`,
       );
     }
   }