kuzzle 2.17.1 → 2.17.4

package/lib/api/controllers/serverController.js

@@ -314,7 +314,6 @@ class ServerController extends NativeController {
     request.response.configure({
       format: 'raw',
       headers: { 'Content-Type': `application/${format}` },
-      status: 200,
     });
 
     return format === 'json' ? definition : jsonToYaml.stringify(definition);

package/lib/api/funnel.js

@@ -896,6 +896,10 @@ class Funnel {
   _isOriginAuthorized (origin) {
     const httpConfig = global.kuzzle.config.http;
 
+    if (! origin) {
+      return true;
+    }
+
     if (global.kuzzle.config.internal.allowAllOrigins) {
       return true;
     }

package/lib/api/request/requestResponse.js

@@ -251,7 +251,12 @@ class RequestResponse {
         if (options.headers) {
             this.setHeaders(options.headers);
         }
-        this.status = options.status || 200;
+        if (options.status) {
+            this.status = options.status;
+        }
+        else if (this.status === 102) {
+            this.status = 200;
+        }
         switch (options.format) {
             case 'raw':
                 this.raw = true;

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

@@ -3,54 +3,57 @@ 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 domain Domain name
      * @param subDomain Subdomain name
      * @param name Standard error name
      * @param definition Standard error definition
      *
      * @example
      * ```
-     * app.errors.register('api', 'custom', {
+     * app.errors.register('app', '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;
+    register(domain: string, subDomain: string, name: string, definition: CustomErrorDefinition): void;
     /**
      * Get a standardized KuzzleError
      *
+     * @param domain Domain name
      * @param subDomain Subdomain name
      * @param name Standard error name
      * @param placeholders Other placeholder arguments
      *
-     * @example throw app.errors.get('api', 'custom', 'Tbilisi');
+     * @example throw app.errors.get('app', 'api', 'custom', 'Tbilisi');
      *
      * @returns Standardized KuzzleError
      */
-    get(subDomain: string, name: string, ...placeholders: any[]): KuzzleError;
+    get(domain: string, subDomain: string, name: string, ...placeholders: any[]): KuzzleError;
     /**
      * Get a standardized KuzzleError from an existing error to keep the stacktrace
      *
      * @param source Original error
+     * @param domain Domain name
      * @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;
+    getFrom(source: Error, domain: string, subDomain: string, name: string, ...placeholders: any[]): KuzzleError;
     /**
-     * Wrap an error manager on the subDomain
+     * Wrap an error manager on the domain and subDomain
      *
+     * @param domain Domain name
      * @param subDomain Subdomain to wrap to
      */
-    wrap(subDomain: string): {
+    wrap(domain: string, 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

@@ -45,76 +45,80 @@ const index_1 = require("./index");
 class BackendErrors extends index_1.ApplicationManager {
     constructor(application) {
         super(application);
-        this.domains = {
-            app: {
-                code: 9,
-                subdomains: {},
-            }
-        };
-        this.subDomains = 0;
+        this.domains = {};
     }
     /**
      * Register a new standard KuzzleError
      *
+     * @param domain Domain name
      * @param subDomain Subdomain name
      * @param name Standard error name
      * @param definition Standard error definition
      *
      * @example
      * ```
-     * app.errors.register('api', 'custom', {
+     * app.errors.register('app', '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++,
+    register(domain, subDomain, name, definition) {
+        if (!this.domains[domain]) {
+            this.domains[domain] = {
+                code: Object.keys(this.domains).length,
+                subDomains: {},
+            };
+        }
+        if (!this.domains[domain].subDomains[subDomain]) {
+            this.domains[domain].subDomains[subDomain] = {
+                code: Object.keys(this.domains[domain].subDomains).length,
                 errors: {},
             };
         }
-        this.domains.app.subdomains[subDomain].errors[name] = {
-            code: Object.keys(this.domains.app.subdomains[subDomain].errors).length,
+        this.domains[domain].subDomains[subDomain].errors[name] = {
+            code: Object.keys(this.domains[domain].subDomains[subDomain].errors).length,
             ...definition,
         };
     }
     /**
      * Get a standardized KuzzleError
      *
+     * @param domain Domain name
      * @param subDomain Subdomain name
      * @param name Standard error name
      * @param placeholders Other placeholder arguments
      *
-     * @example throw app.errors.get('api', 'custom', 'Tbilisi');
+     * @example throw app.errors.get('app', 'api', 'custom', 'Tbilisi');
      *
      * @returns Standardized KuzzleError
      */
-    get(subDomain, name, ...placeholders) {
-        return kerror.rawGet(this.domains, 'app', subDomain, name, ...placeholders);
+    get(domain, subDomain, name, ...placeholders) {
+        return kerror.rawGet(this.domains, domain, subDomain, name, ...placeholders);
     }
     /**
      * Get a standardized KuzzleError from an existing error to keep the stacktrace
      *
      * @param source Original error
+     * @param domain Domain name
      * @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);
+    getFrom(source, domain, subDomain, name, ...placeholders) {
+        return kerror.rawGetFrom(this.domains, source, domain, subDomain, name, ...placeholders);
     }
     /**
-     * Wrap an error manager on the subDomain
+     * Wrap an error manager on the domain and subDomain
      *
+     * @param domain Domain name
      * @param subDomain Subdomain to wrap to
      */
-    wrap(subDomain) {
-        return kerror.rawWrap(this.domains, 'app', subDomain);
+    wrap(domain, subDomain) {
+        return kerror.rawWrap(this.domains, domain, subDomain);
     }
 }
 exports.BackendErrors = BackendErrors;

package/lib/core/network/protocols/httpMessage.js

@@ -33,7 +33,6 @@ class HttpMessage {
     this.connection = connection;
     this._content = null;
     this.ips = connection.ips;
-    this.requestId = connection.id;
     this.query = request.getQuery();
     this.path = request.getUrl();
 
@@ -51,6 +50,8 @@ class HttpMessage {
     this.headers = {};
 
     request.forEach((name, value) => (this.headers[name] = value));
+
+    this.requestId = this.headers['x-kuzzle-request-id'] || connection.id;
   }
 
   set content (value) {

package/lib/core/network/protocols/httpwsProtocol.js

@@ -88,6 +88,7 @@ const HTTP_HEADER_TRANSFER_ENCODING = Buffer.from('Transfer-Encoding');
 const CHUNKED = Buffer.from('chunked');
 const WILDCARD = Buffer.from('*');
 const ORIGIN = Buffer.from('Origin');
+const X_KUZZLE_REQUEST_ID = Buffer.from('X-Kuzzle-Request-Id');
 const CLOSE = Buffer.from('close');
 const CHARSET_REGEX = /charset=([\w-]+)/i;
 
@@ -258,6 +259,7 @@ class HttpWsProtocol extends Protocol {
     res.upgrade(
       {
         cookie: req.getHeader('cookie'),
+        origin: req.getHeader('origin'),
       },
       req.getHeader('sec-websocket-key'),
       req.getHeader('sec-websocket-protocol'),
@@ -268,7 +270,14 @@ class HttpWsProtocol extends Protocol {
 
   wsOnOpenHandler (socket) {
     const ip = Buffer.from(socket.getRemoteAddressAsText()).toString();
-    const connection = new ClientConnection(this.name, [ip], { cookie: socket.cookie });
+    const connection = new ClientConnection(
+      this.name,
+      [ip],
+      {
+        cookie: socket.cookie,
+        origin: socket.origin
+      }
+    );
 
     this.entryPoint.newConnection(connection);
     this.connectionBySocket.set(socket, connection);
@@ -634,15 +643,16 @@ class HttpWsProtocol extends Protocol {
   }
 
   /**
-   * 
-   * @param {uWS.HttpRequest} request 
-   * @param {uWS.HttpResponse} response 
-   * @param {HttpMessage} message 
+   *
+   * @param {uWS.HttpRequest} request
+   * @param {uWS.HttpResponse} response
+   * @param {HttpMessage} message
    */
   httpWriteRequestHeaders (request, response, message) {
     response.writeStatus(Buffer.from(request.response.status.toString()));
-    
+
     response.writeHeader(HTTP_HEADER_CONNECTION, CLOSE);
+    response.writeHeader(X_KUZZLE_REQUEST_ID, message.requestId);
 
     for (const header of this.httpConfig.headers) {
       // If header is missing, add the default one

package/lib/kerror/codes/0-core.json

@@ -1,6 +1,6 @@
 {
   "code": 0,
-  "subdomains": {
+  "subDomains": {
     "fatal": {
       "code": 0,
       "errors": {

package/lib/kerror/codes/1-services.json

@@ -1,6 +1,6 @@
 {
   "code": 1,
-  "subdomains": {
+  "subDomains": {
     "storage": {
       "code": 1,
       "errors": {

package/lib/kerror/codes/2-api.json

@@ -1,6 +1,6 @@
 {
   "code": 2,
-  "subdomains": {
+  "subDomains": {
     "assert": {
       "code": 1,
       "errors": {

package/lib/kerror/codes/3-network.json

@@ -1,6 +1,6 @@
 {
   "code": 3,
-  "subdomains": {
+  "subDomains": {
     "http": {
       "code": 1,
       "errors": {

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

@@ -1,6 +1,6 @@
 {
   "code": 4,
-  "subdomains": {
+  "subDomains": {
     "assert": {
       "code": 1,
       "errors" : {

package/lib/kerror/codes/5-validation.json

@@ -1,6 +1,6 @@
 {
   "code": 5,
-  "subdomains": {
+  "subDomains": {
     "assert": {
       "code": 1,
       "errors": {

package/lib/kerror/codes/6-protocol.json

@@ -1,6 +1,6 @@
 {
   "code": 6,
-  "subdomains": {
+  "subDomains": {
     "runtime": {
       "code": 1,
       "errors": {

package/lib/kerror/codes/7-security.json

@@ -1,6 +1,6 @@
 {
   "code": 7,
-  "subdomains": {
+  "subDomains": {
     "token": {
       "code": 1,
       "errors": {

package/lib/kerror/codes/8-cluster.json

@@ -1,6 +1,6 @@
 {
   "code": 8,
-  "subdomains": {
+  "subDomains": {
     "fatal": {
       "code": 0,
       "errors": {

package/lib/kerror/codes/index.js

@@ -97,8 +97,8 @@ function checkErrors (subdomain, domain, options) {
 function checkSubdomains (domain, options) {
   const subdomainCodes = new Set();
 
-  for (const subdomainName of Object.keys(domain.subdomains)) {
-    const subdomain = domain.subdomains[subdomainName];
+  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) {
@@ -158,11 +158,11 @@ function checkDomains (errorCodesFiles, options = { plugin: false }) {
     domainCodes.add(domain.code);
 
     assert(
-      has(domain, 'subdomains'),
-      `Error configuration file : Missing required 'subdomains' field. (domain: '${domainName}').`);
+      has(domain, 'subDomains'),
+      `Error configuration file : Missing required 'subDomains' field. (domain: '${domainName}').`);
     assert(
-      isPlainObject(domain.subdomains),
-      `Error configuration file : Field 'subdomains' must be an object. (domain: '${domainName}').`);
+      isPlainObject(domain.subDomains),
+      `Error configuration file : Field 'subDomains' must be an object. (domain: '${domainName}').`);
 
     checkSubdomains(domain, options);
   }
@@ -170,7 +170,7 @@ function checkDomains (errorCodesFiles, options = { plugin: false }) {
 
 function loadPluginsErrors (pluginManifest, pluginCode) {
   // @todo this should be in its own, independant domain
-  domains.plugin.subdomains[pluginManifest.name] = {
+  domains.plugin.subDomains[pluginManifest.name] = {
     code: pluginCode,
     errors: pluginManifest.errors
   };

package/lib/kerror/index.d.ts

@@ -4,7 +4,7 @@ import { ErrorDomains } from '../types';
 /**
  * Construct and return the corresponding error
  *
- * @param  domains - Domains object with subdomains and error names
+ * @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')
@@ -15,7 +15,7 @@ export declare function rawGet(domains: ErrorDomains, domain: string, subdomain:
 /**
  * Returns a promise rejected with the corresponding error
  *
- * @param  domains - Domains object with subdomains and error names
+ * @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')
@@ -26,7 +26,7 @@ export declare function rawReject(domains: ErrorDomains, domain: string, subdoma
  * 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  domains - Domains object with subDomains and error names
  * @param  source - Original error
  * @param  domain - Domain (eg: 'external')
  * @param  subdomain - Subdomain (eg: 'elasticsearch')

package/lib/kerror/index.js

@@ -63,7 +63,7 @@ function _getCurrentFileName() {
 /**
  * Construct and return the corresponding error
  *
- * @param  domains - Domains object with subdomains and error names
+ * @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')
@@ -76,7 +76,7 @@ function rawGet(domains, domain, subdomain, error, ...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}`);
+    const kuzzleError = lodash_1.default.get(domains, `${domain}.subDomains.${subdomain}.errors.${error}`);
     if (!kuzzleError) {
         return get('core', 'fatal', 'unexpected_error', `${domain}.${subdomain}.${error}`);
     }
@@ -87,12 +87,16 @@ function rawGet(domains, domain, subdomain, error, ...placeholders) {
     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;
+        | 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 if (kuzzleError.class === 'KuzzleError') {
+        const status = kuzzleError.status || 500;
+        kerror = new errors.KuzzleError(message, status, id, code);
+    }
     else {
         kerror = new errors[kuzzleError.class](message, id, code);
     }
@@ -136,7 +140,7 @@ function cleanStackTrace(error) {
 /**
  * Returns a promise rejected with the corresponding error
  *
- * @param  domains - Domains object with subdomains and error names
+ * @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')
@@ -150,7 +154,7 @@ exports.rawReject = rawReject;
  * 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  domains - Domains object with subDomains and error names
  * @param  source - Original error
  * @param  domain - Domain (eg: 'external')
  * @param  subdomain - Subdomain (eg: 'elasticsearch')

package/lib/types/errors/ErrorDefinition.d.ts

@@ -24,4 +24,10 @@ export declare type CustomErrorDefinition = {
      * Error class
      */
     class: ErrorClassNames;
+    /**
+     * Custom HTTP status.
+     *
+     * Only available for generic KuzzleError.
+     */
+    status?: number;
 };

package/lib/types/errors/ErrorDomains.d.ts

@@ -1,11 +1,11 @@
 import { ErrorDefinition } from './ErrorDefinition';
 /**
- * Represents the domains, subdomains and error names with associated definitions
+ * Represents the domains, subDomains and error names with associated definitions
  */
 export declare type ErrorDomains = {
     [domain: string]: {
         code: number;
-        subdomains?: {
+        subDomains?: {
             [subDomain: string]: {
                 code: number;
                 errors: {

package/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle",
-  "version": "2.17.1",
+  "version": "2.17.4",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kuzzle",
   "author": "The Kuzzle Team <support@kuzzle.io>",
-  "version": "2.17.1",
+  "version": "2.17.4",
   "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
   "bin": {
     "kuzzle": "bin/start-kuzzle-server"