@opra/core 0.0.8 → 0.0.9

package/cjs/implementation/{execution-context.js → query-context.js}

@@ -1,41 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionResponse = exports.ExecutionRequest = exports.ExecutionContext = void 0;
+exports.QueryResponse = exports.QueryContext = void 0;
 const url_1 = require("@opra/url");
 const headers_js_1 = require("../utils/headers.js");
-class ExecutionContext {
-    type;
+class QueryContext {
     service;
-    request;
-    response;
-    adapterContext;
-    userContext;
-    continueOnError;
-    constructor(args) {
-        Object.assign(this, args);
-    }
-    switchToHttp() {
-        if (this.type !== 'http')
-            throw new Error(`You can't access http context within an ${this.type} context`);
-        return this.adapterContext;
-    }
-}
-exports.ExecutionContext = ExecutionContext;
-class ExecutionRequest {
+    executionContext;
     query;
     params;
     headers;
     parentValue;
     resultPath;
+    response;
+    userContext;
+    continueOnError;
     constructor(args) {
         Object.assign(this, args);
+        this.response = new QueryResponse();
         this.params = this.params || new url_1.OpraURLSearchParams();
         this.headers = this.headers || headers_js_1.Headers.create();
         this.resultPath = this.resultPath || '';
     }
+    get type() {
+        return this.executionContext.getType();
+    }
+    switchToHttp() {
+        if (this.type !== 'http')
+            throw new Error(`You can't access http context within an ${this.type} context`);
+        return this.executionContext;
+    }
 }
-exports.ExecutionRequest = ExecutionRequest;
-class ExecutionResponse {
+exports.QueryContext = QueryContext;
+class QueryResponse {
     headers = headers_js_1.Headers.create();
     errors = [];
     status;
@@ -46,4 +42,4 @@ class ExecutionResponse {
             Object.assign(this, args);
     }
 }
-exports.ExecutionResponse = ExecutionResponse;
+exports.QueryResponse = QueryResponse;

package/cjs/implementation/resource/entity-resource-handler.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityResourceHandler = void 0;
 const tslib_1 = require("tslib");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const execution_query_interface_js_1 = require("../../interfaces/execution-query.interface.js");
+const query_interface_js_1 = require("../../interfaces/query.interface.js");
 const entity_type_js_1 = require("../data-type/entity-type.js");
 const resource_handler_js_1 = require("./resource-handler.js");
-var isSearchQuery = execution_query_interface_js_1.ExecutionQuery.isSearchQuery;
+var isSearchQuery = query_interface_js_1.OpraQuery.isSearchQuery;
+const index_js_1 = require("../../exception/index.js");
 class EntityResourceHandler extends resource_handler_js_1.ResourceHandler {
     service;
     dataType;
@@ -22,7 +23,7 @@ class EntityResourceHandler extends resource_handler_js_1.ResourceHandler {
             throw new TypeError(`You should provide an EntityType for EntityResourceController`);
     }
     async execute(ctx) {
-        const { query } = ctx.request;
+        const { query } = ctx;
         if (isSearchQuery(query)) {
             const promises = [];
             let search;
@@ -61,16 +62,19 @@ class EntityResourceHandler extends resource_handler_js_1.ResourceHandler {
                 if (typeof result === 'object')
                     affectedRecords = result.affectedRows || result.affectedRecords;
                 return { affectedRecords };
-            default:
-                result = Array.isArray(result) ? result[0] : result;
-                if (result && ctx.request.resultPath) {
-                    const pathArray = ctx.request.resultPath.split('.');
-                    for (const property of pathArray) {
-                        result = result && typeof result === 'object' && result[property];
-                    }
-                }
-                return result;
         }
+        result = Array.isArray(result) ? result[0] : result;
+        if (!result)
+            throw new index_js_1.UnprocessableEntityError();
+        if (ctx.resultPath) {
+            const pathArray = ctx.resultPath.split('.');
+            for (const property of pathArray) {
+                result = result && typeof result === 'object' && result[property];
+            }
+        }
+        if (fnName === 'create')
+            ctx.response.status = 201;
+        return result;
     }
 }
 exports.EntityResourceHandler = EntityResourceHandler;

package/cjs/implementation/resource/resource-handler.js

@@ -17,7 +17,7 @@ class ResourceHandler {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
     }
     async prepare(ctx) {
-        const { query } = ctx.request;
+        const { query } = ctx;
         const fn = this._args['pre_' + query.queryType];
         if (fn && typeof fn === 'function') {
             await fn(ctx);

package/cjs/implementation/schema-generator.js

@@ -6,6 +6,7 @@ const schema_1 = require("@opra/schema");
 const constants_js_1 = require("../constants.js");
 const class_utils_js_1 = require("../utils/class-utils.js");
 const internal_data_types_js_1 = require("../utils/internal-data-types.js");
+var isDataType = schema_1.OpraSchema.isDataType;
 const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
 class SchemaGenerator {
     _dataTypes = {};
@@ -14,24 +15,16 @@ class SchemaGenerator {
         //
     }
     async addDataType(thunk) {
-        let schema;
         thunk = (0, types_1.isPromise)(thunk) ? await thunk : thunk;
-        if (typeof thunk === 'function' && !(0, class_utils_js_1.isConstructor)(thunk))
-            thunk = await thunk();
-        if (!(0, class_utils_js_1.isConstructor)(thunk) || schema_1.OpraSchema.isDataType(thunk))
-            throw new TypeError(`Function must return a type class or type schema`);
-        if ((0, class_utils_js_1.isConstructor)(thunk)) {
+        if (typeof thunk === 'function') {
+            if (!(0, class_utils_js_1.isConstructor)(thunk))
+                return this.addDataType(await thunk());
+            if (internal_data_types_js_1.builtinClassMap.has(thunk))
+                return this.addDataType(internal_data_types_js_1.builtinClassMap.get(thunk));
             const ctor = thunk;
             const metadata = Reflect.getOwnMetadata(schema_1.DATATYPE_METADATA, ctor);
             if (!metadata)
                 throw new TypeError(`Class "${ctor}" has no type metadata`);
-            schema = this._dataTypes[metadata.name];
-            if (schema) {
-                if (schema.kind !== metadata.kind ||
-                    (schema_1.OpraSchema.isComplexType(schema) && schema.ctor !== ctor))
-                    throw new Error(`An other instance of "${schema.name}" data type previously defined`);
-                return schema;
-            }
             // Add base data type
             let base;
             let baseCtor = Object.getPrototypeOf(ctor);
@@ -42,49 +35,43 @@ class SchemaGenerator {
                 const baseSchema = await this.addDataType(baseCtor);
                 base = baseSchema.name;
             }
-            if (schema_1.OpraSchema.isComplexType(metadata) || schema_1.OpraSchema.isEntityType(metadata)) {
-                schema = {
-                    ...metadata,
-                    ctor,
-                    base
-                };
-                const properties = Reflect.getMetadata(schema_1.DATATYPE_PROPERTIES, ctor.prototype);
-                if (properties) {
-                    for (const [k, p] of Object.entries(properties)) {
-                        let type;
-                        if ((0, class_utils_js_1.isConstructor)(p.type) && internal_data_types_js_1.builtinClassMap.has(p.type))
-                            type = internal_data_types_js_1.builtinClassMap.get(p.type);
-                        else if (typeof p.type === 'function' || typeof p.type === 'object') {
-                            const t = await this.addDataType(p.type);
-                            type = t.name;
-                        }
-                        else
-                            type = p.type || 'string';
-                        if (internal_data_types_js_1.internalDataTypes.has(type) && !this._dataTypes[type])
-                            this._dataTypes[type] = internal_data_types_js_1.internalDataTypes.get(type.toLowerCase());
-                        schema.properties = schema.properties || {};
-                        schema.properties[k] = { ...p, type };
+            const schema = {
+                ...metadata,
+                ctor,
+                base
+            };
+            const properties = Reflect.getMetadata(schema_1.DATATYPE_PROPERTIES, ctor.prototype);
+            if (properties) {
+                for (const [k, p] of Object.entries(properties)) {
+                    let type = p.type || 'string';
+                    if (typeof type !== 'string') {
+                        const propSchema = await this.addDataType(type);
+                        type = propSchema.name;
                     }
+                    else {
+                        if (internal_data_types_js_1.internalDataTypes.has(type))
+                            await this.addDataType(internal_data_types_js_1.internalDataTypes.get(type));
+                    }
+                    schema.properties = schema.properties || {};
+                    schema.properties[k] = { ...p, type };
                 }
             }
-            else if (schema_1.OpraSchema.isSimpleType(metadata)) {
-                if (!internal_data_types_js_1.primitiveDataTypeNames.includes(metadata.type))
-                    throw new Error(`"type" of SimpleType schema must be one of enumerated value (${internal_data_types_js_1.primitiveDataTypeNames})`);
-                schema = {
-                    ...metadata
-                };
-            }
-            else
-                /* istanbul ignore next */
-                throw new TypeError(`Invalid metadata`);
+            return this.addDataType(schema);
         }
-        else if (schema_1.OpraSchema.isDataType(thunk)) {
-            schema = thunk;
-        }
-        else
+        if (!isDataType(thunk))
             throw new TypeError(`Invalid data type schema`);
-        this._dataTypes[schema.name] = schema;
-        return schema;
+        // Check if datatype previously added
+        const currentSchema = this._dataTypes[thunk.name];
+        if (currentSchema) {
+            if (!(currentSchema.kind === thunk.kind && currentSchema.ctor && currentSchema.ctor === thunk.ctor))
+                throw new Error(`An other instance of "${currentSchema.name}" data type previously defined`);
+            return currentSchema;
+        }
+        if (schema_1.OpraSchema.isSimpleType(thunk) && !internal_data_types_js_1.primitiveDataTypeNames.includes(thunk.type))
+            throw new Error(`"type" of SimpleType schema must be one of enumerated value (${internal_data_types_js_1.primitiveDataTypeNames})`);
+        return this._dataTypes[thunk.name] = {
+            ...thunk
+        };
     }
     async addResource(instance) {
         if ((0, class_utils_js_1.isConstructor)(instance))

package/cjs/index.js

@@ -7,11 +7,10 @@ tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./enums/index.js"), exports);
 tslib_1.__exportStar(require("./exception/index.js"), exports);
 tslib_1.__exportStar(require("./decorators/entity-resource.decorator.js"), exports);
-tslib_1.__exportStar(require("./interfaces/http-context.interface.js"), exports);
-tslib_1.__exportStar(require("./interfaces/execution-query.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/execution-context.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/query.interface.js"), exports);
 tslib_1.__exportStar(require("./interfaces/resource-container.interface.js"), exports);
-tslib_1.__exportStar(require("./interfaces/user-context.interface.js"), exports);
-tslib_1.__exportStar(require("./implementation/execution-context.js"), exports);
+tslib_1.__exportStar(require("./implementation/query-context.js"), exports);
 tslib_1.__exportStar(require("./implementation/opra-document.js"), exports);
 tslib_1.__exportStar(require("./implementation/opra-service.js"), exports);
 tslib_1.__exportStar(require("./implementation/schema-generator.js"), exports);

package/cjs/interfaces/{execution-query.interface.js → query.interface.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionQuery = void 0;
+exports.OpraQuery = void 0;
 const tslib_1 = require("tslib");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const complex_type_js_1 = require("../implementation/data-type/complex-type.js");
 const string_path_to_object_tree_js_1 = require("../utils/string-path-to-object-tree.js");
-var ExecutionQuery;
-(function (ExecutionQuery) {
+var OpraQuery;
+(function (OpraQuery) {
     function forCreate(resource, values, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -24,7 +24,7 @@ var ExecutionQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forCreate = forCreate;
+    OpraQuery.forCreate = forCreate;
     function forGet(resource, key, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -43,7 +43,7 @@ var ExecutionQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forGet = forGet;
+    OpraQuery.forGet = forGet;
     function forSearch(resource, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -62,7 +62,7 @@ var ExecutionQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forSearch = forSearch;
+    OpraQuery.forSearch = forSearch;
     function forGetProperty(property, options) {
         const out = {
             queryType: 'get',
@@ -73,7 +73,7 @@ var ExecutionQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forGetProperty = forGetProperty;
+    OpraQuery.forGetProperty = forGetProperty;
     function forUpdate(resource, keyValue, values, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -93,7 +93,7 @@ var ExecutionQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forUpdate = forUpdate;
+    OpraQuery.forUpdate = forUpdate;
     function forUpdateMany(resource, values, options) {
         const out = {
             queryType: 'updateMany',
@@ -105,7 +105,7 @@ var ExecutionQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forUpdateMany = forUpdateMany;
+    OpraQuery.forUpdateMany = forUpdateMany;
     function forDelete(resource, key) {
         checkKeyFields(resource, key);
         return {
@@ -116,7 +116,7 @@ var ExecutionQuery;
             keyValue: key
         };
     }
-    ExecutionQuery.forDelete = forDelete;
+    OpraQuery.forDelete = forDelete;
     function forDeleteMany(resource, options) {
         const out = {
             queryType: 'deleteMany',
@@ -127,24 +127,24 @@ var ExecutionQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forDeleteMany = forDeleteMany;
+    OpraQuery.forDeleteMany = forDeleteMany;
     function isCreateQuery(q) {
         return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'create';
     }
-    ExecutionQuery.isCreateQuery = isCreateQuery;
+    OpraQuery.isCreateQuery = isCreateQuery;
     function isSearchQuery(q) {
         return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'search';
     }
-    ExecutionQuery.isSearchQuery = isSearchQuery;
+    OpraQuery.isSearchQuery = isSearchQuery;
     function isReadQuery(q) {
         return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'read';
     }
-    ExecutionQuery.isReadQuery = isReadQuery;
+    OpraQuery.isReadQuery = isReadQuery;
     function isDeleteQuery(q) {
         return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'delete';
     }
-    ExecutionQuery.isDeleteQuery = isDeleteQuery;
-})(ExecutionQuery = exports.ExecutionQuery || (exports.ExecutionQuery = {}));
+    OpraQuery.isDeleteQuery = isDeleteQuery;
+})(OpraQuery = exports.OpraQuery || (exports.OpraQuery = {}));
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function checkKeyFields(resource, key) {
     if (!resource.dataType.primaryKey)

package/cjs/utils/internal-data-types.js

@@ -1,44 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.internalDataTypes = exports.primitiveDataTypeNames = exports.builtinClassMap = void 0;
+exports.internalDataTypes = exports.builtinClassMap = exports.primitiveDataTypeNames = void 0;
+exports.primitiveDataTypeNames = ['boolean', 'number', 'string', 'null'];
 exports.builtinClassMap = new Map();
-exports.builtinClassMap.set(Boolean, 'boolean');
-exports.builtinClassMap.set(Number, 'number');
-exports.builtinClassMap.set(String, 'string');
-exports.builtinClassMap.set(Buffer, 'buffer');
-exports.primitiveDataTypeNames = ['boolean', 'number', 'integer', 'string'];
 exports.internalDataTypes = new Map();
 const internalDataTypeArray = [
     {
         kind: 'SimpleType',
         name: 'boolean',
         type: 'boolean',
-        description: 'Simple true/false value'
+        description: 'Simple true/false value',
+        ctor: Boolean
+    },
+    {
+        kind: 'SimpleType',
+        name: 'string',
+        type: 'string',
+        description: 'A sequence of characters',
+        ctor: String
     },
     {
         kind: 'SimpleType',
         name: 'number',
         type: 'number',
-        description: 'Both Integer as well as Floating-Point numbers'
+        description: 'Both Integer as well as Floating-Point numbers',
+        ctor: Number
     },
     {
         kind: 'SimpleType',
-        name: 'string',
-        type: 'string',
-        description: 'A sequence of characters'
+        name: 'integer',
+        type: 'number',
+        base: 'number',
+        description: 'Integer number',
+        ctor: Number
     },
     {
         kind: 'ComplexType',
         name: 'object',
         description: 'Object type with additional properties',
-        additionalProperties: true
+        additionalProperties: true,
+        ctor: Object
     },
     {
         kind: 'SimpleType',
-        name: 'integer',
-        type: 'number',
-        base: 'number',
-        description: 'Integer number'
+        name: 'date',
+        type: 'string',
+        description: 'Date',
+        format: 'date',
+        ctor: Date
+    },
+    {
+        kind: 'SimpleType',
+        name: 'date-time',
+        type: 'string',
+        description: 'Date time value',
+        format: 'date-time',
+        ctor: Date
+    },
+    {
+        kind: 'SimpleType',
+        name: 'time',
+        type: 'string',
+        description: 'Time value',
+        format: 'time',
+        ctor: String
+    },
+    {
+        kind: 'SimpleType',
+        name: 'buffer',
+        type: 'string',
+        description: 'Buffer value',
+        format: 'base64',
+        ctor: Buffer
     }
 ];
-internalDataTypeArray.forEach(sch => exports.internalDataTypes.set(sch.name, sch));
+internalDataTypeArray.forEach(sch => {
+    exports.internalDataTypes.set(sch.name, sch);
+    if (sch.ctor && !exports.builtinClassMap.has(sch.ctor))
+        exports.builtinClassMap.set(sch.ctor, sch);
+});

package/esm/exception/api-exception.d.ts

@@ -31,9 +31,10 @@ export declare class ApiException extends Error {
     response: ErrorResponse;
     status: number;
     cause?: Error;
-    constructor(response: string | ErrorResponse | Error, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
     setStatus(status: number | HttpStatus): this;
     protected _initName(): void;
-    protected _initResponse(init: string | ErrorResponse | Error): void;
+    protected _initErrorInstance(init: Error): void;
+    protected _initResponse(response?: Partial<ErrorResponse>): void;
     static wrap(response: string | ErrorResponse | Error): ApiException;
 }

package/esm/exception/api-exception.js

@@ -10,52 +10,49 @@ export class ApiException extends Error {
     constructor(response, cause) {
         super('');
         this._initName();
+        this.status = HttpStatus.INTERNAL_SERVER_ERROR;
+        cause = cause || (response instanceof Error ? response : undefined);
         if (cause)
             Object.defineProperty(this, 'cause', { enumerable: false, configurable: true, writable: true, value: cause });
-        else if (response instanceof Error)
-            Object.defineProperty(this, 'cause', { enumerable: false, configurable: true, writable: true, value: response });
-        this.status = HttpStatus.INTERNAL_SERVER_ERROR;
-        this._initResponse(response);
-    }
-    setStatus(status) {
-        this.status = status;
-        return this;
-    }
-    _initName() {
-        this.name = this.constructor.name;
-    }
-    _initResponse(init) {
-        if (init && typeof init === 'object') {
-            const x = init;
-            if (typeof x.status === 'number')
-                this.setStatus(x.status);
-            else if (typeof x.getStatus === 'function')
-                this.setStatus(x.getStatus());
-        }
-        if (typeof init === 'object') {
-            const x = init;
-            this.response = {
-                message: x.message || x.details || ('' + init),
-            };
-            if (!(init instanceof Error))
-                Object.assign(this.response, init);
-        }
-        else {
-            this.response = {
-                message: '' + init,
-            };
-        }
         if (this.cause instanceof Error && this.cause.stack) {
             if (ApiException.stackAsDiagnostics)
                 this.response.diagnostics = this.cause.stack.split('\n');
             this.stack = this.cause.stack;
         }
+        if (response instanceof Error)
+            this._initErrorInstance(response);
+        else if (typeof response === 'string')
+            this._initResponse({ message: response });
+        else
+            this._initResponse(response);
         if (!this.response.severity)
             if (this.status >= 500)
                 this.response.severity = 'fatal';
             else
                 this.response.severity = 'error';
     }
+    setStatus(status) {
+        this.status = status;
+        return this;
+    }
+    _initName() {
+        this.name = this.constructor.name;
+    }
+    _initErrorInstance(init) {
+        this._initResponse({
+            message: init.message
+        });
+        if (typeof init.status === 'number')
+            this.setStatus(init.status);
+        else if (typeof init.getStatus === 'function')
+            this.setStatus(init.getStatus());
+    }
+    _initResponse(response) {
+        this.response = {
+            message: 'Unknown error',
+            ...response
+        };
+    }
     static wrap(response) {
         if (response instanceof ApiException)
             return response;

package/esm/exception/errors/bad-request.error.d.ts

@@ -5,5 +5,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
  */
 export declare class BadRequestError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/errors/bad-request.error.js

@@ -8,12 +8,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class BadRequestError extends ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = HttpStatus.BAD_REQUEST;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: translate('error:BAD_REQUEST', 'Bad request'),
             severity: 'error',
             code: 'BAD_REQUEST',
             ...response
-        }, cause);
-        this.status = HttpStatus.BAD_REQUEST;
+        });
     }
 }

package/esm/exception/errors/failed-dependency.error.d.ts

@@ -4,5 +4,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * The request failed due to failure of a previous request.
  */
 export declare class FailedDependencyError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/errors/failed-dependency.error.js

@@ -7,12 +7,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class FailedDependencyError extends ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = HttpStatus.FAILED_DEPENDENCY;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: translate('error:FAILED_DEPENDENCY', 'The request failed due to failure of a previous request.'),
             severity: 'error',
             code: 'FAILED_DEPENDENCY',
             ...response
-        }, cause);
-        this.status = HttpStatus.FAILED_DEPENDENCY;
+        });
     }
 }

package/esm/exception/errors/forbidden.error.d.ts

@@ -6,5 +6,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * the client's identity is known to the server.
  */
 export declare class ForbiddenError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/errors/forbidden.error.js

@@ -9,12 +9,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class ForbiddenError extends ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = HttpStatus.FORBIDDEN;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: translate('error:FORBIDDEN', 'Forbidden'),
             severity: 'error',
             code: 'FORBIDDEN',
             ...response
-        }, cause);
-        this.status = HttpStatus.FORBIDDEN;
+        });
     }
 }