@opra/common 0.22.0 → 0.23.1

package/esm/document/data-type/complex-type.js

@@ -1,8 +1,8 @@
 import 'reflect-metadata';
 import omit from 'lodash.omit';
 import merge from 'putil-merge';
-import * as vg from 'valgen';
 import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
+import { translate } from '../../i18n/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY, TYPENAME_PATTERN } from '../constants.js';
 import { ApiField } from './api-field.js';
@@ -15,7 +15,7 @@ class ComplexTypeClass extends DataType {
         super(document, init);
         this.kind = OpraSchema.ComplexType.Kind;
         const own = this.own = {};
-        own.ctor = init?.ctor;
+        own.ctor = init?.ctor || init?.base?.ctor;
         own.abstract = init?.abstract;
         own.additionalFields = init?.additionalFields;
         own.fields = new ResponsiveMap();
@@ -28,8 +28,6 @@ class ComplexTypeClass extends DataType {
         if (this.base) {
             if (this.additionalFields == null)
                 this.additionalFields = this.base.additionalFields;
-            if (own.ctor == null && this.base instanceof ComplexType)
-                this.ctor = this.base.ctor;
             if (this.base.fields)
                 for (const [k, el] of this.base.fields.entries()) {
                     const newEl = new ApiField(this, el);
@@ -65,7 +63,7 @@ class ComplexTypeClass extends DataType {
         else
             field = this.fields.get(nameOrPath);
         if (!field)
-            throw new Error(`Unknown field "${nameOrPath}"`);
+            throw new Error(translate('error:UNKNOWN_FIELD', { field: nameOrPath }));
         return field;
     }
     iteratePath(path, silent) {
@@ -99,7 +97,7 @@ class ComplexTypeClass extends DataType {
                         if (dataType && !dataType.additionalFields) {
                             if (silent)
                                 return { done: true, value: [] };
-                            throw new Error(`Unknown or Invalid field (${curPath})`);
+                            throw new Error(translate('error:UNKNOWN_FIELD', { field: curPath }));
                         }
                     }
                 }
@@ -111,13 +109,15 @@ class ComplexTypeClass extends DataType {
         };
     }
     normalizeFieldPath(fieldPaths) {
-        if (Array.isArray(fieldPaths))
-            return fieldPaths.map((s) => this.normalizeFieldPath(s));
-        let curPath = '';
-        for (const [, , p] of this.iteratePath(fieldPaths)) {
-            curPath = p;
-        }
-        return curPath;
+        const array = (Array.isArray(fieldPaths) ? fieldPaths : [fieldPaths])
+            .map(s => {
+            let curPath = '';
+            for (const [, , p] of this.iteratePath(s)) {
+                curPath = p;
+            }
+            return curPath;
+        }).flat();
+        return array.length ? array : undefined;
     }
     exportSchema() {
         const out = super.exportSchema();
@@ -147,52 +147,6 @@ class ComplexTypeClass extends DataType {
         }
         return false;
     }
-    decode(v) {
-        return this._getDecoder()(v, { coerce: true });
-    }
-    encode(v) {
-        return this._getEncoder()(v, { coerce: true });
-    }
-    validate(v) {
-        return this._getEncoder()(v);
-    }
-    _getDecoder() {
-        if (this._decoder)
-            return this._decoder;
-        const schema = {};
-        for (const f of this.fields.values()) {
-            let t = f.type._getDecoder();
-            if (f.isArray)
-                t = vg.isArray(t);
-            schema[f.name] = f.required ? vg.required(t) : vg.optional(t);
-        }
-        this._decoder = vg.isObject(schema, {
-            ctor: this.ctor,
-            additionalFields: this.additionalFields ?? 'ignore',
-            name: this.name,
-            caseInSensitive: true,
-        });
-        return this._decoder;
-    }
-    _getEncoder() {
-        if (this._encoder)
-            return this._encoder;
-        const schema = {};
-        for (const f of this.fields.values()) {
-            let t = f.type._getEncoder();
-            if (f.isArray)
-                t = vg.isArray(t);
-            schema[f.name] = t;
-        }
-        this._encoder = vg.isObject(schema, {
-            ctor: this.ctor,
-            additionalFields: this.additionalFields,
-            name: this.name,
-            caseInSensitive: true,
-            detectCircular: true
-        });
-        return this._encoder;
-    }
 }
 /**
  * @class ComplexType

package/esm/document/data-type/data-type.js

@@ -8,15 +8,6 @@ export class DataType {
         this.description = init?.description;
         this.isAnonymous = !this.name;
     }
-    decode(v) {
-        return this._getDecoder()(v, { coerce: true });
-    }
-    encode(v) {
-        return this._getEncoder()(v, { coerce: true });
-    }
-    validate(v) {
-        return this._getEncoder()(v);
-    }
     exportSchema() {
         return omitUndefined({
             kind: this.kind,

package/esm/document/data-type/enum-type.js

@@ -15,6 +15,8 @@ class EnumTypeClass extends DataType {
         this.ownMeanings = init.meanings || {};
         this.values = { ...this.base?.values, ...this.ownValues };
         this.meanings = { ...this.base?.meanings, ...this.ownMeanings };
+        this.decode = vg.isEnum(Object.values(this.values));
+        this.encode = vg.isEnum(Object.values(this.values));
     }
     exportSchema() {
         const out = DataType.prototype.exportSchema.call(this);
@@ -26,14 +28,6 @@ class EnumTypeClass extends DataType {
         }));
         return out;
     }
-    _getDecoder() {
-        if (!this._decoder)
-            this._decoder = vg.isEnum(Object.values(this.values), { enumName: this.name });
-        return this._decoder;
-    }
-    _getEncoder() {
-        return this._getDecoder();
-    }
 }
 /**
  * @class EnumType

package/esm/document/data-type/mapped-type.js

@@ -1,6 +1,5 @@
 import 'reflect-metadata';
 import merge from 'putil-merge';
-import * as vg from 'valgen';
 import { inheritPropertyInitializers, mergePrototype, omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY } from '../constants.js';
@@ -33,41 +32,6 @@ class MappedTypeClass extends DataType {
         }));
         return out;
     }
-    _getDecoder() {
-        if (this._decoder)
-            return this._decoder;
-        const schema = {};
-        for (const f of this.fields.values()) {
-            let t = f.type.getDecoder();
-            if (f.isArray)
-                t = vg.isArray(t);
-            schema[f.name] = t;
-        }
-        this._decoder = vg.isObject(schema, {
-            additionalFields: this.additionalFields,
-            name: this.name,
-            caseInSensitive: true
-        });
-        return this._decoder;
-    }
-    _getEncoder() {
-        if (this._encoder)
-            return this._encoder;
-        const schema = {};
-        for (const f of this.fields.values()) {
-            let t = f.type.getEncoder();
-            if (f.isArray)
-                t = vg.isArray(t);
-            schema[f.name] = t;
-        }
-        this._encoder = vg.isObject(schema, {
-            additionalFields: this.additionalFields,
-            name: this.name,
-            caseInSensitive: true,
-            detectCircular: true
-        });
-        return this._encoder;
-    }
 }
 /**
  * @class MappedType

package/esm/document/data-type/simple-type.js

@@ -13,14 +13,8 @@ class SimpleTypeClass extends DataType {
         super(document, init);
         this.kind = OpraSchema.SimpleType.Kind;
         this.base = init.base;
-        this._decoder = init.decoder || init.base?._decoder || vg.isAny();
-        this._encoder = init.encoder || init.base?._encoder || vg.isAny();
-    }
-    _getDecoder() {
-        return this._decoder;
-    }
-    _getEncoder() {
-        return this._encoder;
+        this.decode = init.decoder || init.base?.decode || vg.isAny();
+        this.encode = init.encoder || init.base?.encode || vg.isAny();
     }
     exportSchema() {
         // noinspection UnnecessaryLocalVariableJS

package/esm/document/data-type/union-type.js

@@ -1,6 +1,5 @@
 import 'reflect-metadata';
 import merge from 'putil-merge';
-import * as vg from 'valgen';
 import { inheritPropertyInitializers, mergePrototype, omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY } from '../constants.js';
@@ -20,7 +19,7 @@ class UnionTypeClass extends DataType {
                     `${OpraSchema.UnionType.Kind} of ${OpraSchema.MappedType.Kind} types.`);
             own.types.push(base);
             if (base.additionalFields)
-                this.additionalFields = true;
+                this.additionalFields = base.additionalFields;
             this.fields.setAll(base.fields);
         }
         this.types = [...own.types];
@@ -32,41 +31,6 @@ class UnionTypeClass extends DataType {
         }));
         return out;
     }
-    _getDecoder() {
-        if (this._decoder)
-            return this._decoder;
-        const schema = {};
-        for (const f of this.fields.values()) {
-            let t = f.type.getDecoder();
-            if (f.isArray)
-                t = vg.isArray(t);
-            schema[f.name] = t;
-        }
-        this._decoder = vg.isObject(schema, {
-            additionalFields: this.additionalFields,
-            name: this.name,
-            caseInSensitive: true
-        });
-        return this._decoder;
-    }
-    _getEncoder() {
-        if (this._encoder)
-            return this._encoder;
-        const schema = {};
-        for (const f of this.fields.values()) {
-            let t = f.type.getEncoder();
-            if (f.isArray)
-                t = vg.isArray(t);
-            schema[f.name] = t;
-        }
-        this._encoder = vg.isObject(schema, {
-            additionalFields: this.additionalFields,
-            name: this.name,
-            caseInSensitive: true,
-            detectCircular: true
-        });
-        return this._encoder;
-    }
 }
 /**
  * @class UnionType

package/esm/document/index.js

@@ -13,3 +13,5 @@ export * from './resource/resource.js';
 export * from './resource/collection.js';
 export * from './resource/singleton.js';
 export * from './resource/storage.js';
+export * from './interfaces/collection-resource.interface.js';
+export * from './interfaces/singleton-resource.interface.js';

package/esm/document/resource/collection.js

@@ -1,5 +1,6 @@
 import omit from 'lodash.omit';
 import merge from 'putil-merge';
+import * as vg from 'valgen';
 import { BadRequestError } from '../../exception/index.js';
 import { OpraFilter } from '../../filter/index.js';
 import { omitUndefined } from '../../helpers/index.js';
@@ -7,15 +8,18 @@ import { translate } from '../../i18n/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY } from '../constants.js';
 import { SimpleType } from '../data-type/simple-type.js';
+import { generateCodec } from '../utils/generate-codec.js';
 import { Resource } from './resource.js';
-const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__'; // todo, put this in nextjs package wia augmentation
 const NAME_PATTERN = /^(.*)(Resource|Collection)$/;
 class CollectionClass extends Resource {
     constructor(document, init) {
         super(document, init);
+        this._decoders = {};
+        this._encoders = {};
         this.kind = OpraSchema.Collection.Kind;
         this.controller = init.controller;
-        const operations = this.operations = init.operations || {};
+        this.operations = { ...init.operations };
         const dataType = this.type = init.type;
         // Validate key fields
         this.primaryKey = init.primaryKey
@@ -28,19 +32,6 @@ class CollectionClass extends Resource {
             if (!(field?.type instanceof SimpleType))
                 throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${field.type.kind}`);
         });
-        if (this.controller) {
-            const instance = typeof this.controller == 'function'
-                ? new this.controller()
-                : this.controller;
-            for (const operation of Object.values(operations)) {
-                if (!operation.handler && operation.handlerName) {
-                    const fn = instance[operation.handlerName];
-                    if (!fn)
-                        throw new TypeError(`No such operation handler (${operation.handlerName}) found`);
-                    operation.handler = fn.bind(instance);
-                }
-            }
-        }
     }
     exportSchema() {
         const out = Resource.prototype.exportSchema.call(this);
@@ -66,7 +57,8 @@ class CollectionClass extends Resource {
             // decode values
             for (const [k, v] of Object.entries(obj)) {
                 const el = dataType.getField(k);
-                obj[k] = el.type.decode(v);
+                if (el.type instanceof SimpleType)
+                    obj[k] = el.type.decode(v);
                 if (obj[k] == null)
                     throw new TypeError(`You must provide value of primary field(s) (${k})`);
             }
@@ -76,7 +68,9 @@ class CollectionClass extends Resource {
             if (typeof value === 'object')
                 value = value[primaryKey];
             const el = dataType.getField(primaryKey);
-            const result = el.type.decode(value);
+            let result;
+            if (el.type instanceof SimpleType)
+                result = el.type.decode(value);
             if (result == null)
                 throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);
             return result;
@@ -87,12 +81,14 @@ class CollectionClass extends Resource {
     }
     normalizeSortFields(fields) {
         const normalized = this.type.normalizeFieldPath(fields);
-        const findManyEndpoint = this.operations.findMany;
-        const sortFields = findManyEndpoint && findManyEndpoint.sortFields;
+        if (!normalized)
+            return;
+        const findManyOp = this.operations.findMany;
+        const sortFields = findManyOp && findManyOp.sortFields;
         (Array.isArray(normalized) ? normalized : [normalized]).forEach(field => {
             if (!sortFields?.find(x => x === field))
                 throw new BadRequestError({
-                    message: translate('error:UNACCEPTED_SORT_FIELD', { field }, `Field '${field}' is not available for sort operation`),
+                    message: translate('error:UNACCEPTED_SORT_FIELD', { field }),
                 });
         });
         return normalized;
@@ -105,27 +101,75 @@ class CollectionClass extends Resource {
             this.normalizeFilter(ast.left);
             if (!(ast.left instanceof OpraFilter.QualifiedIdentifier && ast.left.field))
                 throw new TypeError(`Invalid filter query. Left side should be a data field.`);
+            // Check if filtering accepted for given field
+            const findManyOp = this.operations.findMany;
+            const fieldLower = ast.left.value.toLowerCase();
+            const filterDef = (findManyOp && findManyOp.filters || [])
+                .find(f => f.field.toLowerCase() === fieldLower);
+            if (!filterDef) {
+                throw new BadRequestError({
+                    message: translate('error:UNACCEPTED_FILTER_FIELD', { field: ast.left.value }),
+                });
+            }
+            // Check if filtering operation accepted for given field
+            if (!filterDef.operators?.includes(ast.op))
+                throw new BadRequestError({
+                    message: translate('error:UNACCEPTED_FILTER_OPERATION', { field: ast.left.value }),
+                });
             this.normalizeFilter(ast.right);
+            return ast;
         }
-        else if (ast instanceof OpraFilter.LogicalExpression) {
+        if (ast instanceof OpraFilter.LogicalExpression) {
             ast.items.forEach(item => this.normalizeFilter(item));
+            return ast;
         }
-        else if (ast instanceof OpraFilter.ArithmeticExpression) {
+        if (ast instanceof OpraFilter.ArithmeticExpression) {
             ast.items.forEach(item => this.normalizeFilter(item.expression));
+            return ast;
         }
-        else if (ast instanceof OpraFilter.ArrayExpression) {
+        if (ast instanceof OpraFilter.ArrayExpression) {
             ast.items.forEach(item => this.normalizeFilter(item));
+            return ast;
         }
-        else if (ast instanceof OpraFilter.ParenthesizedExpression) {
+        if (ast instanceof OpraFilter.ParenthesizedExpression) {
             this.normalizeFilter(ast.expression);
+            return ast;
         }
-        else if (ast instanceof OpraFilter.QualifiedIdentifier) {
-            ast.field = this.type.findField(ast.value);
+        if (ast instanceof OpraFilter.QualifiedIdentifier) {
+            const normalizedFieldPath = this.type.normalizeFieldPath(ast.value)?.join('.');
+            ast.field = this.type.getField(normalizedFieldPath);
             ast.dataType = ast.field?.type || this.document.getDataType('any');
-            ast.value = this.type.normalizeFieldPath(ast.value);
+            ast.value = normalizedFieldPath;
+            return ast;
         }
         return ast;
     }
+    getDecoder(operation) {
+        let decoder = this._decoders[operation];
+        if (decoder)
+            return decoder;
+        const options = {
+            partial: operation !== 'create'
+        };
+        if (operation !== 'create')
+            options.omit = [...this.primaryKey];
+        decoder = generateCodec(this.type, 'decode', options);
+        this._decoders[operation] = decoder;
+        return decoder;
+    }
+    getEncoder(operation) {
+        let encoder = this._encoders[operation];
+        if (encoder)
+            return encoder;
+        const options = {
+            partial: true
+        };
+        encoder = generateCodec(this.type, 'encode', options);
+        if (operation === 'findMany')
+            return vg.isArray(encoder);
+        this._encoders[operation] = encoder;
+        return encoder;
+    }
 }
 /**
  *
@@ -163,13 +207,12 @@ export const Collection = function (...args) {
 Collection.prototype = CollectionClass.prototype;
 function createOperationDecorator(operation) {
     return (options) => ((target, propertyKey) => {
-        const metadata = {
-            ...options,
-            handlerName: propertyKey
-        };
+        if (propertyKey !== operation)
+            throw new TypeError(`Name of the handler name should be '${operation}'`);
+        const operationMeta = { ...options };
         const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
         resourceMetadata.operations = resourceMetadata.operations || {};
-        resourceMetadata.operations[operation] = metadata;
+        resourceMetadata.operations[operation] = operationMeta;
         Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
     });
 }

package/esm/document/resource/singleton.js

@@ -3,29 +3,19 @@ import merge from 'putil-merge';
 import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY } from '../constants.js';
+import { generateCodec } from '../utils/generate-codec.js';
 import { Resource } from './resource.js';
-const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__'; // todo, put this in nextjs package wia augmentation
 const NAME_PATTERN = /^(.*)(Resource|Singleton)$/;
 class SingletonClass extends Resource {
     constructor(document, init) {
         super(document, init);
+        this._decoders = {};
+        this._encoders = {};
         this.kind = OpraSchema.Singleton.Kind;
         this.controller = init.controller;
-        const operations = this.operations = init.operations || {};
+        this.operations = { ...init.operations };
         this.type = init.type;
-        if (this.controller) {
-            const instance = typeof this.controller == 'function'
-                ? new this.controller()
-                : this.controller;
-            for (const operation of Object.values(operations)) {
-                if (!operation.handler && operation.handlerName) {
-                    const fn = instance[operation.handlerName];
-                    if (!fn)
-                        throw new TypeError(`No such operation handler (${operation.handlerName}) found`);
-                    operation.handler = fn.bind(instance);
-                }
-            }
-        }
     }
     exportSchema() {
         const out = Resource.prototype.exportSchema.call(this);
@@ -38,6 +28,28 @@ class SingletonClass extends Resource {
     normalizeFieldPath(path) {
         return this.type.normalizeFieldPath(path);
     }
+    getDecoder(operation) {
+        let decoder = this._decoders[operation];
+        if (decoder)
+            return decoder;
+        const options = {
+            partial: operation !== 'create'
+        };
+        decoder = generateCodec(this.type, 'decode', options);
+        this._decoders[operation] = decoder;
+        return decoder;
+    }
+    getEncoder(operation) {
+        let encoder = this._encoders[operation];
+        if (encoder)
+            return encoder;
+        const options = {
+            partial: true
+        };
+        encoder = generateCodec(this.type, 'encode', options);
+        this._encoders[operation] = encoder;
+        return encoder;
+    }
 }
 export const Singleton = function (...args) {
     // ClassDecorator
@@ -68,13 +80,12 @@ export const Singleton = function (...args) {
 Singleton.prototype = SingletonClass.prototype;
 function createOperationDecorator(operation) {
     return (options) => ((target, propertyKey) => {
-        const metadata = {
-            ...options,
-            handlerName: propertyKey
-        };
+        if (propertyKey !== operation)
+            throw new TypeError(`Name of the handler name should be '${operation}'`);
+        const operationMeta = { ...options };
         const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
         resourceMetadata.operations = resourceMetadata.operations || {};
-        resourceMetadata.operations[operation] = metadata;
+        resourceMetadata.operations[operation] = operationMeta;
         Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
     });
 }

package/esm/document/resource/storage.js

@@ -11,20 +11,7 @@ class StorageClass extends Resource {
         super(document, init);
         this.kind = OpraSchema.Storage.Kind;
         this.controller = init.controller;
-        const operations = this.operations = init.operations || {};
-        if (this.controller) {
-            const instance = typeof this.controller == 'function'
-                ? new this.controller()
-                : this.controller;
-            for (const operation of Object.values(operations)) {
-                if (!operation.handler && operation.handlerName) {
-                    const fn = instance[operation.handlerName];
-                    if (!fn)
-                        throw new TypeError(`No such operation handler (${operation.handlerName}) found`);
-                    operation.handler = fn.bind(instance);
-                }
-            }
-        }
+        this.operations = { ...init.operations };
     }
     exportSchema() {
         const out = Resource.prototype.exportSchema.call(this);
@@ -62,16 +49,15 @@ export const Storage = function (...args) {
 Storage.prototype = StorageClass.prototype;
 function createOperationDecorator(operation) {
     return (options) => ((target, propertyKey) => {
-        const metadata = {
-            ...options,
-            handlerName: propertyKey
-        };
+        if (propertyKey !== operation)
+            throw new TypeError(`Name of the handler name should be '${operation}'`);
+        const operationMeta = { ...options };
         const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
         resourceMetadata.operations = resourceMetadata.operations || {};
-        resourceMetadata.operations[operation] = metadata;
+        resourceMetadata.operations[operation] = operationMeta;
         Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
     });
 }
 Storage.Delete = createOperationDecorator('delete');
 Storage.Get = createOperationDecorator('get');
-Storage.Put = createOperationDecorator('put');
+Storage.Post = createOperationDecorator('post');

package/esm/document/utils/generate-codec.js

@@ -0,0 +1,33 @@
+import * as vg from 'valgen';
+import { ComplexType } from '../data-type/complex-type.js';
+import { EnumType } from '../data-type/enum-type.js';
+import { MappedType } from '../data-type/mapped-type.js';
+import { SimpleType } from '../data-type/simple-type.js';
+import { UnionType } from '../data-type/union-type.js';
+export function generateCodec(type, codec, options) {
+    return _generateDecoder(type, codec, options);
+}
+export function _generateDecoder(type, codec, options) {
+    const schema = {};
+    for (const f of type.fields.values()) {
+        let fn;
+        if (f.type instanceof SimpleType || f.type instanceof EnumType) {
+            fn = f.type[codec];
+        }
+        else if (f.type instanceof ComplexType || f.type instanceof MappedType || f.type instanceof UnionType) {
+            fn = _generateDecoder(f.type, codec, options);
+        }
+        /* istanbul ignore next */
+        if (!fn)
+            throw new TypeError(`Can't generate codec for (${f.type})`);
+        if (f.isArray)
+            fn = vg.isArray(fn);
+        schema[f.name] = !options.partial && f.required ? vg.required(fn) : vg.optional(fn);
+    }
+    return vg.isObject(schema, {
+        ctor: type.ctor,
+        additionalFields: type.additionalFields ?? false,
+        name: type.name,
+        caseInSensitive: true,
+    });
+}

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

@@ -10,10 +10,9 @@ export class BadRequestError extends OpraException {
         super(...arguments);
         this.status = 400;
     }
-    setIssue(issue) {
-        super.setIssue({
+    init(issue) {
+        super.init({
             message: translate('error:BAD_REQUEST', 'Bad request'),
-            severity: 'error',
             code: 'BAD_REQUEST',
             ...issue
         });

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

@@ -9,10 +9,9 @@ export class FailedDependencyError extends OpraException {
         super(...arguments);
         this.status = 424;
     }
-    setIssue(issue) {
-        super.setIssue({
+    init(issue) {
+        super.init({
             message: translate('error:FAILED_DEPENDENCY', 'The request failed due to failure of a previous request'),
-            severity: 'error',
             code: 'FAILED_DEPENDENCY',
             ...issue
         });