kuzzle 2.16.11 → 2.17.2

package/lib/kerror/codes/4-plugin.json

@@ -93,6 +93,12 @@
           "code": 15,
           "message": "Plugin \"%s\" not found.%s",
           "class": "NotFoundError"
+        },
+        "invalid_openapi_schema": {
+          "description": "OpenAPI specification is invalid",
+          "code": 16,
+          "message": "Invalid OpenAPI specification: \"%s\"",
+          "class": "PluginImplementationError"
         }
       }
     },

package/lib/kerror/codes/index.js

@@ -43,7 +43,7 @@ const domains = {
  *  @param {object} - error config file domain
  */
 
-function checkErrors(subdomain, domain, options) {
+function checkErrors (subdomain, domain, options) {
   const codes = new Set();
 
   for (const [name, error] of Object.entries(subdomain.errors)) {
@@ -57,7 +57,7 @@ function checkErrors(subdomain, domain, options) {
       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}).`);
     assert(
-      !codes.has(error.code),
+      ! codes.has(error.code),
       `Error configuration file : code ${error.code} for error '${name}' is not unique (domain: ${domain.code}, subdomain: ${subdomain.code}).`);
 
     codes.add(error.code);
@@ -80,7 +80,7 @@ function checkErrors(subdomain, domain, options) {
       `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) {
+    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}).`);
@@ -94,19 +94,19 @@ function checkErrors(subdomain, domain, options) {
   }
 }
 
-function checkSubdomains(domain, options) {
+function checkSubdomains (domain, options) {
   const subdomainCodes = new Set();
 
   for (const subdomainName of Object.keys(domain.subdomains)) {
     const subdomain = domain.subdomains[subdomainName];
 
     // Subdomain code for plugins is not required and is automatically set to 0
-    if (!options.plugin) {
+    if (! options.plugin) {
       assert(
         has(subdomain, 'code'),
         `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomainName}).`);
     }
-    else if (!has(subdomain, 'code')) {
+    else if (! has(subdomain, 'code')) {
       subdomain.code = 0;
     }
 
@@ -117,11 +117,11 @@ function checkSubdomains(domain, options) {
       subdomain.code >= 0x00 && subdomain.code <= 0xFF,
       `Error configuration file : Field 'code' must be between 0 and 255 (domain: ${domain.code}, subdomain: ${subdomainName}).`);
     assert(
-      !subdomainCodes.has(subdomain.code),
+      ! subdomainCodes.has(subdomain.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
-    if (!options.plugin || subdomain.code > 0) {
+    if (! options.plugin || subdomain.code > 0) {
       subdomainCodes.add(subdomain.code);
     }
 
@@ -136,7 +136,7 @@ function checkSubdomains(domain, options) {
   }
 }
 
-function checkDomains(errorCodesFiles, options = {plugin: false}) {
+function checkDomains (errorCodesFiles, options = { plugin: false }) {
   const domainCodes = new Set();
 
   for (const domainName of Object.keys(errorCodesFiles)) {
@@ -152,7 +152,7 @@ function checkDomains(errorCodesFiles, options = {plugin: false}) {
       domain.code >= 0x00 && domain.code <= 0xFF,
       `Error configuration file : Field 'code' must be between 0 and 255. (domain: '${domainName}').`);
     assert(
-      !domainCodes.has(domain.code),
+      ! domainCodes.has(domain.code),
       `Error configuration file : code ${domain.code} for domain ${domainName} is not unique.`);
 
     domainCodes.add(domain.code);
@@ -168,7 +168,7 @@ function checkDomains(errorCodesFiles, options = {plugin: false}) {
   }
 }
 
-function loadPluginsErrors(pluginManifest, pluginCode) {
+function loadPluginsErrors (pluginManifest, pluginCode) {
   // @todo this should be in its own, independant domain
   domains.plugin.subdomains[pluginManifest.name] = {
     code: pluginCode,

package/lib/kerror/errors/multipleErrorsError.d.ts

@@ -2,6 +2,6 @@ import { KuzzleError } from './kuzzleError';
 export declare class MultipleErrorsError extends KuzzleError {
     errors: Array<KuzzleError>;
     count: number;
-    constructor(message: string, body?: Array<KuzzleError>, id?: string, code?: number);
+    constructor(message: string, errors?: KuzzleError[], id?: string, code?: number);
     toJSON(): import("kuzzle-sdk").JSONObject;
 }

package/lib/kerror/errors/multipleErrorsError.js

@@ -23,10 +23,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultipleErrorsError = void 0;
 const kuzzleError_1 = require("./kuzzleError");
 class MultipleErrorsError extends kuzzleError_1.KuzzleError {
-    constructor(message, body = [], id, code) {
+    constructor(message, errors = [], id, code) {
         super(message, 400, id, code);
-        this.errors = body;
-        this.count = body.length;
+        this.errors = errors;
+        this.count = errors.length;
     }
     toJSON() {
         const serialized = super.toJSON();

package/lib/kerror/index.d.ts

@@ -0,0 +1,82 @@
+import * as errors from './errors';
+import { KuzzleError } from './errors';
+import { ErrorDomains } from '../types';
+/**
+ * Construct and return the corresponding error
+ *
+ * @param  domains - Domains object with subdomains and error names
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
+ * @param  options - Last param can be additional options { message }
+ */
+export declare function rawGet(domains: ErrorDomains, domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
+/**
+ * Returns a promise rejected with the corresponding error
+ *
+ * @param  domains - Domains object with subdomains and error names
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
+ */
+export declare function rawReject(domains: ErrorDomains, domain: string, subdomain: string, error: string, ...placeholders: any[]): Promise<any>;
+/**
+ * Construct and return the corresponding error, with its stack
+ * trace derivated from a provided source error
+ *
+ * @param  domains - Domains object with subdomains and error names
+ * @param  source - Original error
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
+ */
+export declare function rawGetFrom(domains: ErrorDomains, source: Error, domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
+/**
+ * Wrap error functions with the provided domain and subdomain.
+ */
+export declare function rawWrap(domains: ErrorDomains, domain: string, subdomain: string): {
+    get: (error: any, ...placeholders: any[]) => errors.KuzzleError;
+    getFrom: (source: any, error: any, ...placeholders: any[]) => errors.KuzzleError;
+    reject: (error: any, ...placeholders: any[]) => Promise<any>;
+};
+/**
+ * Construct and return the corresponding error
+ *
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
+ * @param  options - Last param can be additional options { message }
+ */
+export declare function get(domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
+/**
+ * Returns a promise rejected with the corresponding error
+ *
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
+ */
+export declare function reject(domain: string, subdomain: string, error: string, ...placeholders: any[]): Promise<any>;
+/**
+ * Construct and return the corresponding error, with its stack
+ * trace derivated from a provided source error
+ *
+ * @param  source - Original error
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
+ */
+export declare function getFrom(source: Error, domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
+/**
+ * Wrap error functions with the provided domain and subdomain.
+ */
+export declare function wrap(domain: string, subdomain: string): {
+    get: (error: any, ...placeholders: any[]) => errors.KuzzleError;
+    getFrom: (source: any, error: any, ...placeholders: any[]) => errors.KuzzleError;
+    reject: (error: any, ...placeholders: any[]) => Promise<any>;
+};

package/lib/kerror/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,83 +19,89 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-'use strict';
-
-const { format } = require('util');
-
-const Bluebird = require('bluebird');
-const _ = require('lodash');
-
-const { domains } = require('./codes');
-const errors = require('./errors');
-const { hilightUserCode } = require('../util/stackTrace');
-
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrap = exports.getFrom = exports.reject = exports.get = exports.rawWrap = exports.rawGetFrom = exports.rawReject = exports.rawGet = void 0;
+const util_1 = require("util");
+const lodash_1 = __importDefault(require("lodash"));
+const codes_1 = require("./codes");
+const errors = __importStar(require("./errors"));
+const stackTrace_1 = require("../util/stackTrace");
 /**
  * Gets this file name in the exact same format than the one printed in the
  * stacktraces (used to clean kerror lines from stacktraces)
  */
 let _currentFileName = null;
-function _getCurrentFileName () {
-  if (_currentFileName !== null) {
+function _getCurrentFileName() {
+    if (_currentFileName !== null) {
+        return _currentFileName;
+    }
+    _currentFileName = module.filename.substr(process.cwd().length + 1);
     return _currentFileName;
-  }
-
-  _currentFileName = module.filename.substr(process.cwd().length + 1);
-
-  return _currentFileName;
 }
-
 /**
  * Construct and return the corresponding error
  *
- * @param  {string} domain - Domain (eg: 'external')
- * @param  {string} subdomain - Subdomain (eg: 'elasticsearch')
- * @param  {string} error - Error name: (eg: 'index_not_found')
- * @param  {...any} placeholders - Placeholders value to inject in error message
- * @param  {object} options - Last param can be additional options { message }
+ * @param  domains - Domains object with subdomains and error names
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
+ * @param  options - Last param can be additional options { message }
  */
-function get (domain, subdomain, error, ...placeholders) {
-  let options = {};
-
-  // extract options object from the placeholders
-  if (_.isPlainObject(placeholders[placeholders.length - 1])) {
-    options = placeholders.pop();
-  }
-
-  const kuzzleError = _.get(domains, `${domain}.subdomains.${subdomain}.errors.${error}`);
-
-  if (! kuzzleError) {
-    return get('core', 'fatal', 'unexpected_error', `${domain}.${subdomain}.${error}`);
-  }
-
-  let body = null;
-
-  if (kuzzleError.class === 'PartialError' || kuzzleError.class === 'MultipleErrorsError') {
-    body = placeholders.splice(-1)[0];
-  }
-
-  const message = options.message || format(kuzzleError.message, ...placeholders);
-  const id = `${domain}.${subdomain}.${error}`;
-  const code = domains[domain].code << 24
-    | domains[domain].subdomains[subdomain].code << 16
-    | domains[domain].subdomains[subdomain].errors[error].code;
-
-  let kerror;
-  if (kuzzleError.class === 'PartialError' || kuzzleError.class === 'MultipleErrorsError') {
-    kerror = new errors[kuzzleError.class](message, body, id, code);
-  }
-  else {
-    kerror = new errors[kuzzleError.class](message, id, code);
-  }
-
-  if (error.name !== 'InternalError') {
-    cleanStackTrace(kerror);
-  }
-
-  return kerror;
+function rawGet(domains, domain, subdomain, error, ...placeholders) {
+    let options = {};
+    // extract options object from the placeholders
+    if (lodash_1.default.isPlainObject(placeholders[placeholders.length - 1])) {
+        options = placeholders.pop();
+    }
+    const kuzzleError = lodash_1.default.get(domains, `${domain}.subdomains.${subdomain}.errors.${error}`);
+    if (!kuzzleError) {
+        return get('core', 'fatal', 'unexpected_error', `${domain}.${subdomain}.${error}`);
+    }
+    let body = null;
+    if (kuzzleError.class === 'PartialError' || kuzzleError.class === 'MultipleErrorsError') {
+        body = placeholders.splice(-1)[0];
+    }
+    const message = options.message || (0, util_1.format)(kuzzleError.message, ...placeholders);
+    const id = `${domain}.${subdomain}.${error}`;
+    const code = domains[domain].code << 24
+        | domains[domain].subdomains[subdomain].code << 16
+        | domains[domain].subdomains[subdomain].errors[error].code;
+    let kerror;
+    if (kuzzleError.class === 'PartialError' || kuzzleError.class === 'MultipleErrorsError') {
+        kerror = new errors[kuzzleError.class](message, body, id, code);
+    }
+    else {
+        kerror = new errors[kuzzleError.class](message, id, code);
+    }
+    if (kuzzleError.class !== 'InternalError') {
+        cleanStackTrace(kerror);
+    }
+    return kerror;
 }
-
+exports.rawGet = rawGet;
 /**
  * Removes the first lines of the stacktrace because they are related
  * to internal mechanisms.
@@ -106,98 +113,124 @@ function get (domain, subdomain, error, ...placeholders) {
  *  // Line that triggered the error =>
  *  at ControllerManager.add (kuzzle/lib/core/backend/backend.ts:226:34)
  */
-
-function cleanStackTrace (error) {
-  // Keep the original error message
-  const messageLength = error.message.split('\n').length;
-  const currentFileName = _getCurrentFileName();
-
-  // we keep the new error instantiation line ("new ...Error (") on purpose:
-  // this will allow us to replace it without inserting a new line in the array,
-  // saving us from building a new array
-  const newStack = error.stack.split('\n')
-    .filter((line, index) => {
-      if (index < messageLength) {
-        return true;
-      }
-
-      // filter all lines related to the kerror object
-      return !line.includes(currentFileName);
+function cleanStackTrace(error) {
+    // Keep the original error message
+    const messageLength = error.message.split('\n').length;
+    const currentFileName = _getCurrentFileName();
+    // we keep the new error instantiation line ("new ...Error (") on purpose:
+    // this will allow us to replace it without inserting a new line in the array,
+    // saving us from building a new array
+    const newStack = error.stack.split('\n')
+        .filter((line, index) => {
+        if (index < messageLength) {
+            return true;
+        }
+        // filter all lines related to the kerror object
+        return !line.includes(currentFileName);
     })
-    .map(hilightUserCode);
-
-  // insert a deletion message in place of the new error instantiation line
-  newStack[messageLength] = '      [...Kuzzle internal calls deleted...]';
-
-  error.stack = newStack.join('\n');
+        .map(stackTrace_1.hilightUserCode);
+    // insert a deletion message in place of the new error instantiation line
+    newStack[messageLength] = '      [...Kuzzle internal calls deleted...]';
+    error.stack = newStack.join('\n');
 }
-
 /**
  * Returns a promise rejected with the corresponding error
  *
- * @param  {string} domain - Domain (eg: 'external')
- * @param  {string} subdomain - Subdomain (eg: 'elasticsearch')
- * @param  {string} error - Error name: (eg: 'index_not_found')
- * @param  {...any} placeholders - Placeholders value to inject in error message
+ * @param  domains - Domains object with subdomains and error names
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
  */
-function reject (domain, subdomain, error, ...placeholders) {
-  return Bluebird.reject(get(domain, subdomain, error, ...placeholders));
+function rawReject(domains, domain, subdomain, error, ...placeholders) {
+    return Promise.reject(rawGet(domains, domain, subdomain, error, ...placeholders));
 }
-
+exports.rawReject = rawReject;
 /**
  * Construct and return the corresponding error, with its stack
  * trace derivated from a provided source error
  *
- * @param  {Error}  source
- * @param  {string} domain - Domain (eg: 'external')
- * @param  {string} subdomain - Subdomain (eg: 'elasticsearch')
- * @param  {string} error - Error name: (eg: 'index_not_found')
- * @param  {...any} placeholders - Placeholders value to inject in error message
+ * @param  domains - Domains object with subdomains and error names
+ * @param  source - Original error
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
  */
-function getFrom (source, domain, subdomain, error, ...placeholders) {
-  const derivedError = get(domain, subdomain, error, ...placeholders);
-
-  // If a stacktrace is present, we need to modify the first line because it
-  // still contains the original error message
-  if (derivedError.stack && derivedError.stack.length) {
-    const stackArray = source.stack.split('\n');
-    stackArray.shift();
-    derivedError.stack = [
-      `${derivedError.constructor.name}: ${derivedError.message}`,
-      ...stackArray
-    ].join('\n');
-  }
-
-  return derivedError;
+function rawGetFrom(domains, source, domain, subdomain, error, ...placeholders) {
+    const derivedError = rawGet(domains, domain, subdomain, error, ...placeholders);
+    // If a stacktrace is present, we need to modify the first line because it
+    // still contains the original error message
+    if (derivedError.stack && derivedError.stack.length) {
+        const stackArray = source.stack.split('\n');
+        stackArray.shift();
+        derivedError.stack = [
+            `${derivedError.constructor.name}: ${derivedError.message}`,
+            ...stackArray
+        ].join('\n');
+    }
+    return derivedError;
 }
-
+exports.rawGetFrom = rawGetFrom;
 /**
  * Wrap error functions with the provided domain and subdomain.
  */
-function wrap (domain, subdomain) {
-  return {
-    get: (error, ...placeholders) => get(
-      domain,
-      subdomain,
-      error,
-      ...placeholders),
-    getFrom: (source, error, ...placeholders) => getFrom(
-      source,
-      domain,
-      subdomain,
-      error,
-      ...placeholders),
-    reject: (error, ...placeholders) => reject(
-      domain,
-      subdomain,
-      error,
-      ...placeholders),
-  };
+function rawWrap(domains, domain, subdomain) {
+    return {
+        get: (error, ...placeholders) => rawGet(domains, domain, subdomain, error, ...placeholders),
+        getFrom: (source, error, ...placeholders) => rawGetFrom(domains, source, domain, subdomain, error, ...placeholders),
+        reject: (error, ...placeholders) => rawReject(domains, domain, subdomain, error, ...placeholders),
+    };
 }
-
-module.exports = {
-  get,
-  getFrom,
-  reject,
-  wrap,
-};
+exports.rawWrap = rawWrap;
+/**
+ * Construct and return the corresponding error
+ *
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
+ * @param  options - Last param can be additional options { message }
+ */
+function get(domain, subdomain, error, ...placeholders) {
+    return rawGet(codes_1.domains, domain, subdomain, error, ...placeholders);
+}
+exports.get = get;
+/**
+ * Returns a promise rejected with the corresponding error
+ *
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
+ */
+function reject(domain, subdomain, error, ...placeholders) {
+    return rawReject(codes_1.domains, domain, subdomain, error, ...placeholders);
+}
+exports.reject = reject;
+/**
+ * Construct and return the corresponding error, with its stack
+ * trace derivated from a provided source error
+ *
+ * @param  source - Original error
+ * @param  domain - Domain (eg: 'external')
+ * @param  subdomain - Subdomain (eg: 'elasticsearch')
+ * @param  error - Error name: (eg: 'index_not_found')
+ * @param  placeholders - Placeholders value to inject in error message
+ */
+function getFrom(source, domain, subdomain, error, ...placeholders) {
+    return rawGetFrom(codes_1.domains, source, domain, subdomain, error, ...placeholders);
+}
+exports.getFrom = getFrom;
+/**
+ * Wrap error functions with the provided domain and subdomain.
+ */
+function wrap(domain, subdomain) {
+    return {
+        get: (error, ...placeholders) => get(domain, subdomain, error, ...placeholders),
+        getFrom: (source, error, ...placeholders) => getFrom(source, domain, subdomain, error, ...placeholders),
+        reject: (error, ...placeholders) => reject(domain, subdomain, error, ...placeholders),
+    };
+}
+exports.wrap = wrap;
+//# sourceMappingURL=index.js.map

package/lib/kuzzle/dumpGenerator.js

@@ -175,7 +175,7 @@ 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'),
@@ -197,14 +197,14 @@ class DumpGenerator {
     try {
       fs.accessSync(dumpPath, fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);
     }
-    catch(e) {
+    catch (e) {
       return;
     }
 
     const dumps = fs.readdirSync(dumpPath)
       .map(file => {
         const filepath = `${dumpPath}/${file}`;
-        return {path: filepath, stat: fs.statSync(filepath)};
+        return { path: filepath, stat: fs.statSync(filepath) };
       })
       .filter(prop => prop.stat.isDirectory())
       .sort((a, b) => {

package/lib/kuzzle/event/kuzzleEventEmitter.js

@@ -80,7 +80,7 @@ class KuzzleEventEmitter extends EventEmitter {
   onPipe (event, fn) {
     assert(typeof fn === 'function', `Cannot listen to pipe event ${event}: "${fn}" is not a function`);
 
-    if (!this.corePipes.has(event)) {
+    if (! this.corePipes.has(event)) {
       this.corePipes.set(event, []);
     }
 
@@ -96,7 +96,7 @@ class KuzzleEventEmitter extends EventEmitter {
    */
   onAsk (event, fn) {
     assert(typeof fn === '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`);
+    assert(! this.coreAnswerers.has(event), `Cannot add a listener to the ask event "${event}": event has already an answerer`);
 
     this.coreAnswerers.set(event, fn);
   }
@@ -143,7 +143,7 @@ class KuzzleEventEmitter extends EventEmitter {
     let callback = null;
 
     // safe: a pipe's payload can never contain functions
-    if (payload.length > 0 && typeof payload[payload.length-1] === 'function') {
+    if (payload.length > 0 && typeof payload[payload.length - 1] === 'function') {
       callback = payload.pop();
     }
 
@@ -185,7 +185,7 @@ class KuzzleEventEmitter extends EventEmitter {
 
     const fn = this.coreAnswerers.get(event);
 
-    if (!fn) {
+    if (! fn) {
       throw kerror.get('core', 'fatal', 'assertion_failed', `the requested ask event '${event}' doesn't have an answerer`);
     }
 

package/lib/kuzzle/event/pipeRunner.js

@@ -40,7 +40,7 @@ const kerror = require('../../kerror').wrap('plugin', 'runtime');
 function waterfallCallback (error, result) {
   this.instance.running--;
 
-  if (!this.instance.buffer.isEmpty()) {
+  if (! this.instance.buffer.isEmpty()) {
     setImmediate(this.instance._boundRunNext);
   }