@opra/common 0.33.13 → 1.0.0-alpha.1

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

@@ -1,322 +0,0 @@
-import { validator } from 'valgen';
-import { cloneObject, isConstructor, resolveThunk, ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { DATATYPE_METADATA } from '../constants.js';
-import { AnyType, ApproxDatetimeType, ApproxDateType, Base64Type, BigintType, BooleanType, DatetimeType, DateType, EmailType, IntegerType, NullType, NumberType, ObjectIdType, ObjectType, StringType, TimeType, UrlType, UuidType } from '../data-type/builtin/index.js';
-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 { MixinType } from '../data-type/mixin-type.js';
-import { SimpleType } from '../data-type/simple-type.js';
-import { TypeDocument } from '../type-document.js';
-/**
- * @class TypeDocumentFactory
- */
-export class TypeDocumentFactory {
-    constructor() {
-        this.typeQueue = new ResponsiveMap();
-        this.circularRefs = new Map();
-        this.curPath = [];
-        this.cache = new Map();
-    }
-    /**
-     * Creates ApiDocument instance from given schema object
-     */
-    static async createDocument(init) {
-        const factory = new TypeDocumentFactory();
-        const document = factory.document = new TypeDocument();
-        await factory.initDocument(init);
-        return document;
-    }
-    /**
-     * Downloads schema from the given URL and creates the document instance   * @param url
-     */
-    static async createDocumentFromUrl(url) {
-        const factory = new TypeDocumentFactory();
-        const document = factory.document = new TypeDocument();
-        await factory.initDocumentFromUrl(url);
-        return document;
-    }
-    async initDocument(init) {
-        init.version = init.version || OpraSchema.SpecVersion;
-        this.document.url = init.url;
-        if (init.info)
-            Object.assign(this.document.info, init.info);
-        if (!init?.noBuiltinTypes) {
-            const builtinDocument = await this.createBuiltinTypeDocument();
-            this.document.references.set('opra', builtinDocument);
-        }
-        if (init.references)
-            await this.addReferences(init.references);
-        if (init.types) {
-            this.curPath.push('Types->');
-            // Add type sources into typeQueue
-            if (Array.isArray(init.types)) {
-                let i = 0;
-                for (const thunk of init.types) {
-                    const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk) || thunk[DATATYPE_METADATA];
-                    if (!(metadata && metadata.name))
-                        throw new TypeError(`Metadata information not found at types[${i++}] "${String(thunk)}"`);
-                    this.typeQueue.set(metadata.name, thunk);
-                }
-            }
-            else
-                for (const [name, schema] of Object.entries(init.types)) {
-                    this.typeQueue.set(name, { ...schema, name });
-                }
-            // Create type instances
-            for (const thunk of this.typeQueue.values()) {
-                await this.importDataType(thunk);
-            }
-            this.document.types.sort();
-            this.curPath.pop();
-        }
-        this.document.invalidate();
-        return this.document;
-    }
-    async initDocumentFromUrl(url) {
-        const resp = await fetch(url, { method: 'GET' });
-        const init = await resp.json();
-        if (!init)
-            throw new TypeError(`Invalid response returned from url: ${url}`);
-        return await this.initDocument({ ...init, url });
-    }
-    async createBuiltinTypeDocument() {
-        const init = {
-            version: OpraSchema.SpecVersion,
-            url: 'https://oprajs.com/spec/v1.0',
-            info: {
-                version: OpraSchema.SpecVersion,
-                title: 'Opra built-in types',
-                license: {
-                    url: 'https://github.com/oprajs/opra/blob/main/LICENSE',
-                    name: 'MIT'
-                }
-            },
-            types: [AnyType, Base64Type, BigintType, BooleanType,
-                DateType, EmailType, IntegerType, NullType, NumberType, ObjectIdType,
-                ObjectType, ApproxDateType, ApproxDatetimeType,
-                StringType, DatetimeType, TimeType, UrlType, UuidType
-            ]
-        };
-        const factory = new TypeDocumentFactory();
-        factory.document = new TypeDocument();
-        return await factory.initDocument({ ...init, noBuiltinTypes: true });
-    }
-    async addReferences(references) {
-        const { document } = this;
-        let ns;
-        let r;
-        for ([ns, r] of Object.entries(references)) {
-            r = await r;
-            if (typeof r === 'string') {
-                document.references.set(ns, await this.initDocumentFromUrl(r));
-            }
-            else if (r instanceof TypeDocument)
-                document.references.set(ns, r);
-            else if (typeof r === 'object') {
-                document.references.set(ns, await this.initDocument(r));
-            }
-            else
-                throw new TypeError(`Invalid document reference (${ns}) in schema`);
-        }
-    }
-    async importDataType(thunk) {
-        thunk = await resolveThunk(thunk);
-        let name = '';
-        // let schema: OpraSchema.DataType | undefined;
-        let ctor;
-        if (typeof thunk === 'string') {
-            name = thunk;
-            thunk = this.typeQueue.get(name);
-        }
-        let initArguments;
-        if (typeof thunk === 'function') {
-            const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk);
-            if (!metadata) {
-                // Check if is an internal type class like String, Number etc
-                const dataType = this.document.getDataType(thunk, true);
-                if (dataType)
-                    return dataType;
-                throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
-            }
-            name = metadata.embedded ? undefined : metadata.name;
-            initArguments = cloneObject(metadata);
-            ctor = thunk;
-        }
-        else if (typeof thunk === 'object') {
-            if (OpraSchema.isDataType(thunk)) {
-                name = thunk.name;
-                ctor = thunk.ctor || ctor;
-                initArguments = cloneObject(thunk);
-            }
-            else {
-                // It should be an enum object
-                const metadata = thunk[DATATYPE_METADATA];
-                if (!metadata)
-                    throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(thunk).substring(0, 20)}...`);
-                name = metadata.embedded ? undefined : metadata.name;
-                initArguments = cloneObject(metadata);
-                initArguments.enumObject = thunk;
-            }
-        }
-        ctor = ctor ?? (initArguments && (isConstructor(initArguments.ctor)) ? initArguments.ctor : undefined);
-        if (name) {
-            if (this.circularRefs.has(name.toLowerCase()))
-                throw new TypeError('Circular reference detected');
-            const dataType = this.document.getDataType(name, true);
-            if (dataType)
-                return dataType;
-            this.curPath.push('/' + name);
-            this.circularRefs.set(name, 1);
-        }
-        if (ctor) {
-            if (this.circularRefs.has(ctor))
-                throw new TypeError('Circular reference detected');
-            const dataType = this.document.getDataType(ctor, true);
-            if (dataType)
-                return dataType;
-            this.circularRefs.set(ctor, 1);
-        }
-        try {
-            if (!initArguments)
-                throw new TypeError(`No DataType schema determined`);
-            // Create an empty DataType instance and add in to document.
-            // This will help us for circular dependent data types
-            const instance = this.createDataTypeInstance(initArguments.kind, name);
-            if (name)
-                this.document.types.set(name, instance);
-            await this.prepareDataTypeInitArguments(initArguments, ctor);
-            if (initArguments.kind === 'ComplexType') {
-                if (typeof initArguments.additionalFields === 'function')
-                    initArguments.additionalFields = await this.importDataType(initArguments.additionalFields);
-                ComplexType.apply(instance, [this.document, initArguments]);
-            }
-            else if (initArguments.kind === 'SimpleType')
-                SimpleType.apply(instance, [this.document, initArguments]);
-            else if (initArguments.kind === 'EnumType')
-                EnumType.apply(instance, [this.document, initArguments]);
-            else if (initArguments.kind === 'MappedType')
-                MappedType.apply(instance, [this.document, initArguments]);
-            else if (initArguments.kind === 'MixinType')
-                MixinType.apply(instance, [this.document, initArguments]);
-            else
-                throw new TypeError(`Invalid data type schema: ${String(initArguments)}`);
-            return instance;
-        }
-        finally {
-            if (name) {
-                this.curPath.pop();
-                this.circularRefs.delete(name.toLowerCase());
-            }
-            if (ctor)
-                this.circularRefs.delete(ctor);
-        }
-    }
-    async prepareDataTypeInitArguments(schema, ctor) {
-        const initArguments = schema;
-        // Import extending class first
-        if (initArguments.kind === 'SimpleType' || initArguments.kind === 'ComplexType' ||
-            initArguments.kind === 'EnumType') {
-            if (ctor) {
-                const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-                const baseMeta = Reflect.getMetadata(DATATYPE_METADATA, baseClass);
-                if (baseMeta) {
-                    initArguments.base = await this.importDataType(baseClass);
-                }
-            }
-            else if (initArguments.base) {
-                initArguments.base = await this.importDataType(initArguments.base);
-            }
-        }
-        if (initArguments.kind === 'SimpleType' && ctor) {
-            if (typeof ctor.prototype.decode === 'function')
-                initArguments.decoder = initArguments.name
-                    ? validator(initArguments.name, ctor.prototype.decode) : validator(ctor.prototype.decode);
-            if (typeof ctor.prototype.encode === 'function')
-                initArguments.decoder = initArguments.name
-                    ? validator(initArguments.name, ctor.prototype.encode) : validator(ctor.prototype.encode);
-            return;
-        }
-        if (initArguments.kind === 'ComplexType') {
-            initArguments.ctor = ctor;
-            if (initArguments.fields) {
-                const srcFields = initArguments.fields;
-                const trgFields = initArguments.fields = {};
-                for (const [fieldName, o] of Object.entries(srcFields)) {
-                    try {
-                        this.curPath.push('.' + fieldName);
-                        const srcMeta = typeof o === 'string' ? { type: o } : o;
-                        const fieldInit = trgFields[fieldName] = {
-                            ...srcMeta,
-                            name: fieldName
-                        };
-                        if (srcMeta.enum) {
-                            const enumObject = srcMeta.enum;
-                            delete srcMeta.enum;
-                            if (enumObject[DATATYPE_METADATA]) {
-                                fieldInit.type = await this.importDataType(enumObject);
-                            }
-                            else {
-                                const enumMeta = EnumType(enumObject, { name: '' });
-                                fieldInit.type = await this.importDataType({ ...enumMeta, kind: 'EnumType', base: undefined });
-                            }
-                        }
-                        else {
-                            if (srcMeta.isArray && !srcMeta.type)
-                                throw new TypeError(`"type" must be defined explicitly for array properties`);
-                            fieldInit.type = await this.importDataType(srcMeta.type || srcMeta.designType || 'any');
-                        }
-                        this.curPath.pop();
-                    }
-                    catch (e) {
-                        e.message = `Error in resource "${initArguments.name}.${fieldName}". ` + e.message;
-                        throw e;
-                    }
-                }
-            }
-        }
-        if (initArguments.kind === 'MappedType') {
-            const dataType = await this.importDataType(initArguments.base);
-            // istanbul ignore next
-            if (!(dataType instanceof ComplexType))
-                throw new TypeError('MappedType.type property must address to a ComplexType');
-            initArguments.base = dataType;
-        }
-        if (initArguments.kind === 'MixinType') {
-            const oldTypes = initArguments.types;
-            initArguments.types = [];
-            for (const type of oldTypes)
-                initArguments.types.push(await this.importDataType(type));
-        }
-        return initArguments;
-    }
-    createDataTypeInstance(kind, name) {
-        const dataType = {
-            document: this.document,
-            kind,
-            name
-        };
-        switch (kind) {
-            case OpraSchema.ComplexType.Kind:
-                Object.setPrototypeOf(dataType, ComplexType.prototype);
-                break;
-            case OpraSchema.EnumType.Kind:
-                Object.setPrototypeOf(dataType, EnumType.prototype);
-                break;
-            case OpraSchema.MappedType.Kind:
-                Object.setPrototypeOf(dataType, MappedType.prototype);
-                break;
-            case OpraSchema.SimpleType.Kind:
-                Object.setPrototypeOf(dataType, SimpleType.prototype);
-                break;
-            case OpraSchema.MixinType.Kind:
-                Object.setPrototypeOf(dataType, MixinType.prototype);
-                break;
-            default:
-                throw new TypeError(`Unknown DataType kind (${kind})`);
-        }
-        return dataType;
-    }
-}
-TypeDocumentFactory.designTypeMap = new Map();

package/esm/document/resource/action-decorator.js

@@ -1,29 +0,0 @@
-import { RESOURCE_METADATA } from '../constants.js';
-export function createActionDecorator(options, bannedProperties, list) {
-    const decorator = ((target, propertyKey) => {
-        if (typeof propertyKey === 'string' && bannedProperties.includes(propertyKey))
-            throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
-        const resourceMetadata = (Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {});
-        resourceMetadata.actions = resourceMetadata.actions || {};
-        const actionMeta = { ...options };
-        resourceMetadata.actions[propertyKey] = actionMeta;
-        for (const fn of list)
-            fn(actionMeta);
-        Reflect.defineMetadata(RESOURCE_METADATA, resourceMetadata, target.constructor);
-    });
-    decorator.Parameter = (name, arg0) => {
-        const parameterOptions = typeof arg0 === 'string' || typeof arg0 === 'function' ? { type: arg0 } : { ...arg0 };
-        list.push((operationMeta) => {
-            operationMeta.parameters = operationMeta.parameters || {};
-            operationMeta.parameters[name] = { ...parameterOptions };
-        });
-        return decorator;
-    };
-    decorator.Returns = (t) => {
-        list.push((actionMetadata) => {
-            actionMetadata.returnType = t;
-        });
-        return decorator;
-    };
-    return decorator;
-}

package/esm/document/resource/action.js

@@ -1,30 +0,0 @@
-import { isAny } from 'valgen';
-import { DataType } from '../data-type/data-type.js';
-import { Endpoint } from './endpoint.js';
-/**
- *
- * @class Action
- */
-export class Action extends Endpoint {
-    constructor(resource, name, init) {
-        super(resource, name, init);
-        this.resource = resource;
-        this.name = name;
-        this.kind = 'action';
-        this.encodeReturning = isAny;
-        if (init.returnType)
-            this.returnType = init.returnType instanceof DataType
-                ? init.returnType : this.resource.document.getDataType(init.returnType);
-        this.returnMime = init.returnMime;
-    }
-    exportSchema(options) {
-        const schema = super.exportSchema(options);
-        if (this.returnType)
-            schema.returnType = this.returnType.isEmbedded
-                ? this.returnType.exportSchema(options)
-                : this.returnType.name;
-        if (this.returnMime)
-            schema.returnMime = this.returnMime;
-        return schema;
-    }
-}

package/esm/document/resource/collection-class.js

@@ -1,253 +0,0 @@
-import { vg } from 'valgen';
-import { BadRequestError } from '../../exception/index.js';
-import { OpraFilter } from '../../filter/index.js';
-import { translate } from '../../i18n/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { SORT_FIELD_PATTERN } from '../constants.js';
-import { SimpleType } from '../data-type/simple-type.js';
-import { CrudResource } from './crud-resource.js';
-export class CollectionClass extends CrudResource {
-    constructor(parent, init) {
-        super(parent, init);
-        this.kind = OpraSchema.Collection.Kind;
-        const dataType = this.type = init.type;
-        // Validate key fields
-        this.primaryKey = init.primaryKey
-            ? (Array.isArray(init.primaryKey) ? init.primaryKey : [init.primaryKey])
-            : [];
-        if (!this.primaryKey.length)
-            throw new TypeError(`You must provide primaryKey for Collection resource ("${this.name}")`);
-        this.primaryKey.forEach(f => {
-            const field = dataType.getField(f);
-            if (!(field?.type instanceof SimpleType))
-                throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${field.type.kind}`);
-        });
-        // ------------------
-        let endpoint = this.operations.get('create');
-        if (endpoint) {
-            // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
-            endpoint.defineParameter('pick', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.defineParameter('omit', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.decodeInput = this.type.generateCodec('decode', {
-                partial: false,
-                pick: endpoint.options.inputPickFields,
-                omit: endpoint.options.inputOmitFields,
-                operation: 'write',
-                overwriteFields: endpoint.inputOverwriteFields
-            });
-            endpoint.returnType = this.type;
-            endpoint.encodeReturning = endpoint.returnType.generateCodec('encode', {
-                partial: true,
-                pick: endpoint.options.outputPickFields,
-                omit: endpoint.options.outputOmitFields,
-                operation: 'read',
-                overwriteFields: endpoint.outputOverwriteFields
-            });
-        }
-        // ------------------
-        endpoint = this.operations.get('deleteMany');
-        if (endpoint) {
-            // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true});
-            endpoint.defineParameter('filter', { type: 'string', isBuiltin: true });
-        }
-        // ------------------
-        endpoint = this.operations.get('get');
-        if (endpoint) {
-            // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
-            endpoint.defineParameter('pick', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.defineParameter('omit', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.returnType = this.type;
-            endpoint.encodeReturning = endpoint.returnType.generateCodec('encode', {
-                partial: true,
-                pick: endpoint.options.outputPickFields,
-                omit: endpoint.options.outputOmitFields,
-                operation: 'read',
-                overwriteFields: endpoint.outputOverwriteFields
-            });
-        }
-        // ------------------
-        endpoint = this.operations.get('findMany');
-        if (endpoint) {
-            // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
-            endpoint.defineParameter('pick', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.defineParameter('omit', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.defineParameter('sort', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.defineParameter('filter', { type: 'string', isBuiltin: true });
-            endpoint.defineParameter('limit', { type: 'integer', isBuiltin: true });
-            endpoint.defineParameter('skip', { type: 'integer', isBuiltin: true });
-            endpoint.defineParameter('distinct', { type: 'boolean', isBuiltin: true });
-            endpoint.defineParameter('count', { type: 'boolean', isBuiltin: true });
-            endpoint.returnType = this.type;
-            endpoint.encodeReturning = vg.isArray(this.type.generateCodec('encode', {
-                partial: true,
-                pick: endpoint.options.outputPickFields,
-                omit: endpoint.options.outputOmitFields,
-                operation: 'read',
-                overwriteFields: endpoint.outputOverwriteFields
-            }));
-        }
-        // ------------------
-        endpoint = this.operations.get('update');
-        if (endpoint) {
-            // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
-            endpoint.defineParameter('pick', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.defineParameter('omit', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
-            endpoint.decodeInput = this.type.generateCodec('decode', {
-                partial: true,
-                pick: endpoint.options.inputPickFields,
-                omit: endpoint.options.inputOmitFields,
-                operation: 'write',
-                overwriteFields: endpoint.inputOverwriteFields
-            });
-            endpoint.returnType = this.type;
-            endpoint.encodeReturning = endpoint.returnType.generateCodec('encode', {
-                partial: true,
-                pick: endpoint.options.outputPickFields,
-                omit: endpoint.options.outputOmitFields,
-                operation: 'read',
-                overwriteFields: endpoint.outputOverwriteFields
-            });
-        }
-        // ------------------
-        endpoint = this.operations.get('updateMany');
-        if (endpoint) {
-            // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
-            endpoint.defineParameter('filter', { type: 'string', isBuiltin: true });
-            endpoint.decodeInput = this.type.generateCodec('decode', {
-                partial: true,
-                pick: endpoint.options.inputPickFields,
-                omit: endpoint.options.inputOmitFields,
-                operation: 'write',
-                overwriteFields: endpoint.inputOverwriteFields
-            });
-        }
-    }
-    exportSchema(options) {
-        return {
-            ...super.exportSchema(options),
-            type: this.type.name || 'object',
-            ...{
-                primaryKey: this.primaryKey
-            }
-        };
-    }
-    parseKeyValue(value) {
-        if (!this.primaryKey?.length)
-            return;
-        const dataType = this.type;
-        if (this.primaryKey.length > 1) {
-            // Build primary key/value mapped object
-            const obj = Array.isArray(value)
-                ? this.primaryKey.reduce((o, k, i) => {
-                    o[k] = value[i];
-                    return obj;
-                }, {})
-                : value;
-            // decode values
-            for (const [k, v] of Object.entries(obj)) {
-                const el = dataType.getField(k);
-                if (el.type instanceof SimpleType) {
-                    try {
-                        obj[k] = el.type.decode(v, { coerce: true });
-                    }
-                    catch (e) {
-                        e.message = `The key value for field "${el.name}" is not valid. ` + e.message;
-                    }
-                }
-                if (obj[k] == null)
-                    throw new TypeError(`You must provide value of primary field(s) (${k})`);
-            }
-        }
-        else {
-            const primaryKey = this.primaryKey[0];
-            if (typeof value === 'object')
-                value = value[primaryKey];
-            const el = dataType.getField(primaryKey);
-            let result;
-            if (value != null && el.type instanceof SimpleType) {
-                try {
-                    result = el.type.decode(value, { coerce: true });
-                }
-                catch (e) {
-                    e.message = `The key value is not valid. ` + e.message;
-                }
-            }
-            if (result == null)
-                throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);
-            return result;
-        }
-    }
-    normalizeFieldNames(fields, allowSortSigns) {
-        return this.type.normalizeFieldNames(fields, allowSortSigns);
-    }
-    normalizeSortFields(fields) {
-        const normalized = this.type.normalizeFieldNames(fields, true);
-        if (!normalized)
-            return;
-        const findManyOp = this.getOperation('findMany');
-        const sortFields = findManyOp && findManyOp.options.sortFields;
-        (Array.isArray(normalized) ? normalized : [normalized]).forEach(field => {
-            const m = SORT_FIELD_PATTERN.exec(field);
-            if (m && !sortFields?.find(x => x === m[2]))
-                throw new BadRequestError({
-                    message: translate('error:UNACCEPTED_SORT_FIELD', { field }),
-                });
-        });
-        return normalized;
-    }
-    normalizeFilter(filter) {
-        if (!filter)
-            return;
-        const ast = typeof filter === 'string' ? OpraFilter.parse(filter) : filter;
-        if (ast instanceof OpraFilter.ComparisonExpression) {
-            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.getOperation('findMany');
-            const fieldLower = ast.left.value.toLowerCase();
-            const filterDef = (findManyOp && findManyOp.options.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 endpoint accepted for given field
-            if (filterDef.operators && !filterDef.operators.includes(ast.op))
-                throw new BadRequestError({
-                    message: translate('error:UNACCEPTED_FILTER_OPERATION', { field: ast.left.value }),
-                });
-            this.normalizeFilter(ast.right);
-            return ast;
-        }
-        if (ast instanceof OpraFilter.LogicalExpression) {
-            ast.items.forEach(item => this.normalizeFilter(item));
-            return ast;
-        }
-        if (ast instanceof OpraFilter.ArithmeticExpression) {
-            ast.items.forEach(item => this.normalizeFilter(item.expression));
-            return ast;
-        }
-        if (ast instanceof OpraFilter.ArrayExpression) {
-            ast.items.forEach(item => this.normalizeFilter(item));
-            return ast;
-        }
-        if (ast instanceof OpraFilter.ParenthesizedExpression) {
-            this.normalizeFilter(ast.expression);
-            return ast;
-        }
-        if (ast instanceof OpraFilter.QualifiedIdentifier) {
-            const normalizedFieldPath = this.type.normalizeFieldNames(ast.value)?.join('.');
-            ast.field = this.type.getField(normalizedFieldPath);
-            ast.dataType = ast.field?.type || this.document.getDataType('any');
-            ast.value = normalizedFieldPath;
-            return ast;
-        }
-        return ast;
-    }
-}