kuzzle 2.16.11 → 2.17.2

package/lib/core/backend/backendController.js

@@ -19,16 +19,32 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackendController = void 0;
 const inflector_1 = require("../../util/inflector");
-const kerror_1 = __importDefault(require("../../kerror"));
+const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
-const assertionError = kerror_1.default.wrap('plugin', 'assert');
-const runtimeError = kerror_1.default.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap('plugin', 'assert');
+const runtimeError = kerror.wrap('plugin', 'runtime');
 class BackendController extends index_1.ApplicationManager {
     /**
      * Registers a new controller.

package/lib/core/backend/backendErrors.d.ts

@@ -0,0 +1,58 @@
+import { KuzzleError } from '../../kerror/errors';
+import { ApplicationManager, Backend } from './index';
+import { CustomErrorDefinition } from '../../types';
+export declare class BackendErrors extends ApplicationManager {
+    private domains;
+    private subDomains;
+    constructor(application: Backend);
+    /**
+     * Register a new standard KuzzleError
+     *
+     * @param subDomain Subdomain name
+     * @param name Standard error name
+     * @param definition Standard error definition
+     *
+     * @example
+     * ```
+     * app.errors.register('api', 'custom', {
+     *   class: 'BadRequestError',
+     *   description: 'This is a custom error from API subdomain',
+     *   message: 'Custom API error: %s',
+     * });
+     * ```
+     */
+    register(subDomain: string, name: string, definition: CustomErrorDefinition): void;
+    /**
+     * Get a standardized KuzzleError
+     *
+     * @param subDomain Subdomain name
+     * @param name Standard error name
+     * @param placeholders Other placeholder arguments
+     *
+     * @example throw app.errors.get('api', 'custom', 'Tbilisi');
+     *
+     * @returns Standardized KuzzleError
+     */
+    get(subDomain: string, name: string, ...placeholders: any[]): KuzzleError;
+    /**
+     * Get a standardized KuzzleError from an existing error to keep the stacktrace
+     *
+     * @param source Original error
+     * @param subDomain Subdomain name
+     * @param name Standard error name
+     * @param placeholders Other placeholder arguments
+     *
+     * @returns Standardized KuzzleError
+     */
+    getFrom(source: Error, subDomain: string, name: string, ...placeholders: any[]): KuzzleError;
+    /**
+     * Wrap an error manager on the subDomain
+     *
+     * @param subDomain Subdomain to wrap to
+     */
+    wrap(subDomain: string): {
+        get: (error: any, ...placeholders: any[]) => KuzzleError;
+        getFrom: (source: any, error: any, ...placeholders: any[]) => KuzzleError;
+        reject: (error: any, ...placeholders: any[]) => Promise<any>;
+    };
+}

package/lib/core/backend/backendErrors.js

@@ -0,0 +1,121 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2020 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendErrors = void 0;
+const kerror = __importStar(require("../../kerror"));
+const index_1 = require("./index");
+class BackendErrors extends index_1.ApplicationManager {
+    constructor(application) {
+        super(application);
+        this.domains = {
+            app: {
+                code: 9,
+                subdomains: {},
+            }
+        };
+        this.subDomains = 0;
+    }
+    /**
+     * Register a new standard KuzzleError
+     *
+     * @param subDomain Subdomain name
+     * @param name Standard error name
+     * @param definition Standard error definition
+     *
+     * @example
+     * ```
+     * app.errors.register('api', 'custom', {
+     *   class: 'BadRequestError',
+     *   description: 'This is a custom error from API subdomain',
+     *   message: 'Custom API error: %s',
+     * });
+     * ```
+     */
+    register(subDomain, name, definition) {
+        if (!this.domains.app.subdomains[subDomain]) {
+            this.domains.app.subdomains[subDomain] = {
+                code: this.subDomains++,
+                errors: {},
+            };
+        }
+        this.domains.app.subdomains[subDomain].errors[name] = {
+            code: Object.keys(this.domains.app.subdomains[subDomain].errors).length,
+            ...definition,
+        };
+    }
+    /**
+     * Get a standardized KuzzleError
+     *
+     * @param subDomain Subdomain name
+     * @param name Standard error name
+     * @param placeholders Other placeholder arguments
+     *
+     * @example throw app.errors.get('api', 'custom', 'Tbilisi');
+     *
+     * @returns Standardized KuzzleError
+     */
+    get(subDomain, name, ...placeholders) {
+        return kerror.rawGet(this.domains, 'app', subDomain, name, ...placeholders);
+    }
+    /**
+     * Get a standardized KuzzleError from an existing error to keep the stacktrace
+     *
+     * @param source Original error
+     * @param subDomain Subdomain name
+     * @param name Standard error name
+     * @param placeholders Other placeholder arguments
+     *
+     * @returns Standardized KuzzleError
+     */
+    getFrom(source, subDomain, name, ...placeholders) {
+        return kerror.rawGetFrom(this.domains, source, 'app', subDomain, name, ...placeholders);
+    }
+    /**
+     * Wrap an error manager on the subDomain
+     *
+     * @param subDomain Subdomain to wrap to
+     */
+    wrap(subDomain) {
+        return kerror.rawWrap(this.domains, 'app', subDomain);
+    }
+}
+exports.BackendErrors = BackendErrors;
+//# sourceMappingURL=backendErrors.js.map

package/lib/core/backend/backendHook.js

@@ -19,15 +19,31 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackendHook = void 0;
-const kerror_1 = __importDefault(require("../../kerror"));
+const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
-const assertionError = kerror_1.default.wrap('plugin', 'assert');
-const runtimeError = kerror_1.default.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap('plugin', 'assert');
+const runtimeError = kerror.wrap('plugin', 'runtime');
 class BackendHook extends index_1.ApplicationManager {
     /**
      * Registers a new hook on an event

package/lib/core/backend/backendImport.js

@@ -19,16 +19,32 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackendImport = void 0;
-const kerror_1 = __importDefault(require("../../kerror"));
+const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
 const safeObject_1 = require("../../../lib/util/safeObject");
-const assertionError = kerror_1.default.wrap('validation', 'assert');
-const runtimeError = kerror_1.default.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap('validation', 'assert');
+const runtimeError = kerror.wrap('plugin', 'runtime');
 class BackendImport extends index_1.ApplicationManager {
     /**
      * Import mappings.

package/lib/core/backend/backendOpenApi.d.ts

@@ -0,0 +1,9 @@
+import { ApplicationManager, Backend } from './index';
+import { OpenApiDefinition } from '../../types';
+export declare class BackendOpenApi extends ApplicationManager {
+    /**
+     * Application Open API definition
+     */
+    definition: Partial<OpenApiDefinition>;
+    constructor(application: Backend);
+}

package/lib/core/backend/backendOpenApi.js

@@ -0,0 +1,69 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2020 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendOpenApi = void 0;
+const index_1 = require("./index");
+class BackendOpenApi extends index_1.ApplicationManager {
+    constructor(application) {
+        super(application);
+        /* eslint-disable sort-keys */
+        this.definition = {
+            openapi: '3.0.0',
+            info: {
+                title: `${application.name} API`,
+                description: `${application.name} HTTP API definition`,
+                contact: {
+                    name: 'Kuzzle team',
+                    url: 'https://kuzzle.io',
+                    email: 'support@kuzzle.io',
+                    discord: 'http://join.discord.kuzzle.io'
+                },
+                license: {
+                    name: 'Apache 2',
+                    url: 'http://opensource.org/licenses/apache2.0'
+                },
+                version: application.version
+            },
+            externalDocs: {
+                description: 'Kuzzle API Documentation',
+                url: 'https://docs.kuzzle.io/core/2/api/'
+            },
+            servers: [
+                {
+                    url: 'https://{baseUrl}:{port}',
+                    description: `${application.name} Base Url`,
+                    variables: {
+                        baseUrl: { default: 'localhost' },
+                        port: { default: 7512 },
+                    }
+                }
+            ],
+            tags: [],
+            schemes: ['https', 'http'],
+            paths: {},
+            components: {}
+        };
+        /* eslint-enable sort-keys */
+    }
+}
+exports.BackendOpenApi = BackendOpenApi;
+//# sourceMappingURL=backendOpenApi.js.map

package/lib/core/backend/backendPipe.js

@@ -19,15 +19,31 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackendPipe = void 0;
-const kerror_1 = __importDefault(require("../../kerror"));
+const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
-const assertionError = kerror_1.default.wrap('plugin', 'assert');
-const runtimeError = kerror_1.default.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap('plugin', 'assert');
+const runtimeError = kerror.wrap('plugin', 'runtime');
 class BackendPipe extends index_1.ApplicationManager {
     /**
      * Registers a new pipe on an event

package/lib/core/backend/backendPlugin.js

@@ -19,17 +19,36 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+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.BackendPlugin = void 0;
 const inflector_1 = require("../../util/inflector");
-const kerror_1 = __importDefault(require("../../kerror"));
+const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
 const didYouMean_1 = __importDefault(require("../../util/didYouMean"));
-const assertionError = kerror_1.default.wrap('plugin', 'assert');
-const runtimeError = kerror_1.default.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap('plugin', 'assert');
+const runtimeError = kerror.wrap('plugin', 'runtime');
 class BackendPlugin extends index_1.ApplicationManager {
     /**
      * Uses a plugin in this application.

package/lib/core/backend/backendVault.js

@@ -19,15 +19,34 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+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.BackendVault = void 0;
 const vault_1 = __importDefault(require("../../kuzzle/vault"));
-const kerror_1 = __importDefault(require("../../kerror"));
+const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
-const runtimeError = kerror_1.default.wrap('plugin', 'runtime');
+const runtimeError = kerror.wrap('plugin', 'runtime');
 class BackendVault extends index_1.ApplicationManager {
     constructor() {
         super(...arguments);

package/lib/core/backend/index.d.ts

@@ -9,4 +9,6 @@ export * from './backendPipe';
 export * from './backendPlugin';
 export * from './backendStorage';
 export * from './backendVault';
+export * from './backendOpenApi';
 export * from './internalLogger';
+export * from './backendErrors';

package/lib/core/backend/index.js

@@ -21,5 +21,7 @@ __exportStar(require("./backendPipe"), exports);
 __exportStar(require("./backendPlugin"), exports);
 __exportStar(require("./backendStorage"), exports);
 __exportStar(require("./backendVault"), exports);
+__exportStar(require("./backendOpenApi"), exports);
 __exportStar(require("./internalLogger"), exports);
+__exportStar(require("./backendErrors"), exports);
 //# sourceMappingURL=index.js.map

package/lib/core/network/accessLogger.js

@@ -54,15 +54,15 @@ class AccessLogger {
     const config = global.kuzzle.config.server;
 
     for (const out of config.logs.transports) {
-      if (out.transport && !ALLOWED_TRANSPORTS.includes(out.transport)) {
+      if (out.transport && ! ALLOWED_TRANSPORTS.includes(out.transport)) {
         global.kuzzle.log.error(`Failed to initialize logger transport "${out.transport}": unsupported transport. Skipped.`);
       }
       else {
-        this.isActive = this.isActive || !out.silent;
+        this.isActive = this.isActive || ! out.silent;
       }
     }
 
-    if (!this.isActive) {
+    if (! this.isActive) {
       return;
     }
 
@@ -78,7 +78,7 @@ class AccessLogger {
   }
 
   log (connection, request, extra) {
-    if (!this.isActive) {
+    if (! this.isActive) {
       return;
     }
 
@@ -212,7 +212,7 @@ class AccessLoggerWorker {
       }
     }
 
-    this.logger = winston.createLogger({transports});
+    this.logger = winston.createLogger({ transports });
   }
 
   /**
@@ -325,7 +325,7 @@ class AccessLoggerWorker {
   }
 }
 
-if (!isMainThread) {
+if (! isMainThread) {
   // Needed for instantiating a serialized KuzzleRequest object
   global.kuzzle = { id: workerData.kuzzleId };
 

package/lib/core/network/clientConnection.js

@@ -36,7 +36,7 @@ class ClientConnection {
     this.protocol = protocol;
     this.headers = {};
 
-    if (!Array.isArray(ips)) {
+    if (! Array.isArray(ips)) {
       throw new TypeError(`Expected ips to be an Array, got ${typeof ips}`);
     }
     this.ips = ips;

package/lib/core/network/entryPoint.js

@@ -99,7 +99,7 @@ class EntryPoint {
   async startListening () {
     // We need to verify the port ourselves, to make sure Node.js won't open
     // a named pipe if the provided port number is a string
-    if (!Number.isInteger(this.config.port)) {
+    if (! Number.isInteger(this.config.port)) {
       throw networkError.get('invalid_port', this.config.port);
     }
 
@@ -140,7 +140,7 @@ class EntryPoint {
 
     const client = this._clients.get(connectionId);
 
-    if (!client || !client.protocol) {
+    if (! client || ! client.protocol) {
       return;
     }
 
@@ -160,7 +160,7 @@ class EntryPoint {
 
     const client = this._clients.get(connectionId);
 
-    if (!client || !client.protocol) {
+    if (! client || ! client.protocol) {
       return;
     }
 
@@ -248,7 +248,7 @@ class EntryPoint {
     global.kuzzle.funnel.execute(request, (error, result) => {
       const _res = result || request;
 
-      if (error && !_res.error) {
+      if (error && ! _res.error) {
         _res.setError(error);
       }
 
@@ -327,7 +327,7 @@ class EntryPoint {
 
     const client = this._clients.get(data.connectionId);
 
-    if (!client || !client.protocol) {
+    if (! client || ! client.protocol) {
       return;
     }
 

package/lib/core/network/httpRouter/index.js

@@ -142,7 +142,7 @@ class Router {
   route (message, cb) {
     debug('Routing HTTP message: %a', message);
 
-    if (!has(this.routes, message.method)) {
+    if (! has(this.routes, message.method)) {
       this.routeUnhandledHttpMethod(message, cb);
       return;
     }
@@ -165,8 +165,8 @@ class Router {
     }
     catch (err) {
       let request;
-      if (!routeHandler || !routeHandler._request) {
-        request = new Request({requestId: message.requestId}, {});
+      if (! routeHandler || ! routeHandler._request) {
+        request = new Request({ requestId: message.requestId }, {});
         // Set Headers if not present
         request.response.setHeaders(this.defaultHeaders, true);
 
@@ -190,7 +190,7 @@ class Router {
    * @param  {HttpMessage} message
    * @param {function} cb
    */
-  routeUnhandledHttpMethod(message, cb) {
+  routeUnhandledHttpMethod (message, cb) {
     const
       requestContext = global.kuzzle.router.connections.get(message.connection.id),
       request = new Request(
@@ -253,7 +253,7 @@ function applyACAOHeader (message, request) {
 function attach (path, handler, target) {
   const sanitized = path[path.length - 1] === '/' ? path.slice(0, -1) : path;
 
-  if (!attachParts(sanitized.split('/'), handler, target)) {
+  if (! attachParts(sanitized.split('/'), handler, target)) {
     throw kerror.get('duplicate_url', sanitized);
   }
 }