kuzzle 2.17.3 → 2.17.4

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/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle",
-  "version": "2.17.3",
+  "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.3",
+  "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"