@opra/common 0.14.0 → 0.15.0

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

@@ -0,0 +1,120 @@
+import { cloneObject, isConstructor, resolveThunk } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { METADATA_KEY } from '../constants.js';
+export async function importTypeClass(typeThunk) {
+    const { document, typeQueue, cache } = this;
+    const thunk = await resolveThunk(typeThunk);
+    const cached = cache.get(thunk);
+    if (cached)
+        return cached;
+    const dt = document.getDataType(thunk, true);
+    if (dt && dt.name)
+        return dt.name;
+    const metadata = Reflect.getMetadata(METADATA_KEY, thunk);
+    if (!(metadata && OpraSchema.isDataType(metadata))) {
+        // If thunk is a Type class
+        if (isConstructor(thunk))
+            throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
+        // If thunk is an Enum object
+        throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(thunk).substring(0, 20)}...`);
+    }
+    // Clone metadata to prevent changing its contents
+    const name = metadata.name;
+    const schema = cloneObject(metadata);
+    const result = name || schema;
+    if (name) {
+        cache.set(thunk, result);
+        typeQueue.set(name, schema);
+    }
+    // If thunk is a DataType class
+    if (isConstructor(thunk)) {
+        const ctor = thunk;
+        if (OpraSchema.isSimpleType(schema))
+            await this.extractSimpleTypeSchema(schema, ctor, metadata);
+        else if (OpraSchema.isComplexType(schema))
+            await this.extractComplexTypeSchema(schema, ctor, metadata);
+        else if (OpraSchema.isMappedType(schema))
+            await this.extractMappedTypeSchema(schema, ctor, metadata);
+        else if (OpraSchema.isUnionType(schema))
+            await this.extractUnionTypeSchema(schema, ctor, metadata);
+        else
+            throw new TypeError(`Class "${ctor.name}" doesn't have a valid DataType metadata`);
+        return result;
+    }
+    // If thunk is a EnumType object
+    const enumObject = thunk;
+    if (OpraSchema.isEnumType(schema)) {
+        let baseType;
+        if (metadata.base && Reflect.hasMetadata(METADATA_KEY, metadata.base)) {
+            baseType = await this.importTypeClass(metadata.base);
+        }
+        schema.base = baseType;
+        await this.extractEnumTypeSchema(schema, enumObject, metadata);
+        return result;
+    }
+    throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(enumObject).substring(0, 20)}...`);
+}
+export async function extractSimpleTypeSchema(target, ctor, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+metadata) {
+    const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
+    if (Reflect.hasMetadata(METADATA_KEY, baseClass))
+        target.base = await this.importTypeClass(baseClass);
+    target.codec = Object.create(ctor.prototype);
+}
+export async function extractComplexTypeSchema(target, ctor, metadata) {
+    const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
+    if (Reflect.hasMetadata(METADATA_KEY, baseClass))
+        target.base = await this.importTypeClass(baseClass);
+    target.ctor = ctor;
+    // Fields
+    if (metadata.fields) {
+        const fields = target.fields = {};
+        for (const [elemName, elemMeta] of Object.entries(metadata.fields)) {
+            try {
+                const t = await elemMeta.type;
+                const type = typeof t === 'function'
+                    ? await this.importTypeClass(t)
+                    : (t || '');
+                const elemSchema = fields[elemName] = {
+                    ...elemMeta,
+                    type
+                };
+                if (elemMeta.enum) {
+                    elemSchema.type = await this.importTypeClass(elemMeta.enum);
+                }
+                if (!elemSchema.type && elemMeta.designType)
+                    elemSchema.type = await this.importTypeClass(elemMeta.designType);
+                await this.extractFieldSchema(elemSchema, ctor, elemMeta, elemName);
+                if (typeof elemSchema.type === 'function')
+                    elemSchema.type = await this.importTypeClass(elemSchema.type);
+                if (elemSchema.isArray && !elemSchema.type)
+                    throw new TypeError(`"type" must be defined explicitly for array properties`);
+                elemSchema.type = elemSchema.type || 'any';
+            }
+            catch (e) {
+                e.message = `Error in class "${ctor.name}.${elemName}". ` + e.message;
+                throw e;
+            }
+        }
+    }
+}
+export async function extractMappedTypeSchema(target, ctor, metadata) {
+    target.type = await this.importTypeClass(metadata.type);
+}
+export async function extractUnionTypeSchema(target, ctor, metadata) {
+    const oldTypes = metadata.types;
+    target.types = [];
+    for (const type of oldTypes)
+        target.types.push(await this.importTypeClass(type));
+}
+export async function extractEnumTypeSchema(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+target, enumObject, metadata) {
+    // Do nothing. This method is used by external modules for extending the factory
+}
+export async function extractFieldSchema(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+target, ctor, metadata, name) {
+    // Do nothing. This method is used by external modules for extending the factory
+}

package/esm/document/factory/index.d.ts

@@ -0,0 +1 @@
+export * from './factory.js';

package/esm/document/factory/index.js

@@ -0,0 +1 @@
+export * from './factory.js';

package/esm/document/factory/process-resources.d.ts

@@ -0,0 +1,7 @@
+import { OpraSchema } from '../../schema/index.js';
+import { Collection } from '../resource/collection.js';
+import { Singleton } from '../resource/singleton.js';
+import type { DocumentFactory } from './factory.js';
+export declare function processResourceQueue(this: DocumentFactory): Promise<void>;
+export declare function createCollection(this: DocumentFactory, name: string, schema: OpraSchema.Collection): Promise<Collection>;
+export declare function createSingleton(this: DocumentFactory, name: string, schema: OpraSchema.Singleton): Promise<Singleton>;

package/esm/document/factory/process-resources.js

@@ -0,0 +1,49 @@
+import { OpraSchema } from '../../schema/index.js';
+import { Collection } from '../resource/collection.js';
+import { Singleton } from '../resource/singleton.js';
+export async function processResourceQueue() {
+    const { document, resourceQueue } = this;
+    const resourceNames = Array.from(resourceQueue.keys());
+    for (const name of resourceNames) {
+        const schema = resourceQueue.get(name);
+        if (!schema)
+            continue;
+        try {
+            if (OpraSchema.isCollection(schema)) {
+                const resource = await this.createCollection(name, schema);
+                document.resources.set(name, resource);
+                continue;
+            }
+            if (OpraSchema.isSingleton(schema)) {
+                const resource = await this.createSingleton(name, schema);
+                document.resources.set(name, resource);
+                continue;
+            }
+        }
+        catch (e) {
+            e.message = `Error in Resource schema (${name}): ` + e.message;
+            throw e;
+        }
+        throw new TypeError(`Invalid Resource schema: ${JSON.stringify(schema).substring(0, 20)}...`);
+    }
+}
+export async function createCollection(name, schema) {
+    const { document } = this;
+    const dataType = document.getComplexType(schema.type);
+    const initArgs = {
+        ...schema,
+        name,
+        type: dataType
+    };
+    return new Collection(document, initArgs);
+}
+export async function createSingleton(name, schema) {
+    const { document } = this;
+    const dataType = document.getComplexType(schema.type);
+    const initArgs = {
+        ...schema,
+        name,
+        type: dataType
+    };
+    return new Singleton(document, initArgs);
+}

package/esm/document/factory/process-types.d.ts

@@ -0,0 +1,6 @@
+import { OpraSchema } from '../../schema/index.js';
+import { DataType } from '../data-type/data-type.js';
+import type { DocumentFactory } from './factory.js';
+export declare function processTypes(this: DocumentFactory): Promise<void>;
+export declare function createDataTypeInstance(this: DocumentFactory, kind: OpraSchema.DataType.Kind, name?: string): DataType;
+export declare function addDataType(this: DocumentFactory, schemaOrName: OpraSchema.DataType | string): DataType;

package/esm/document/factory/process-types.js

@@ -0,0 +1,185 @@
+import { OpraSchema } from '../../schema/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 { SimpleType } from '../data-type/simple-type.js';
+import { UnionType } from '../data-type/union-type.js';
+export async function processTypes() {
+    const { document, typeQueue } = this;
+    // Create DataType instances
+    for (const [name, schema] of typeQueue.entries()) {
+        const dataType = this.createDataTypeInstance(schema.kind, name);
+        document.types.set(name, dataType);
+    }
+    // Process schemas
+    const typeNames = Array.from(typeQueue.keys());
+    for (const name of typeNames) {
+        if (!typeQueue.has(name))
+            continue;
+        this.addDataType(name);
+    }
+    document.invalidate();
+}
+export function 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.UnionType.Kind:
+            Object.setPrototypeOf(dataType, UnionType.prototype);
+            break;
+        default:
+            throw new TypeError(`Unknown DataType kind (${kind})`);
+    }
+    return dataType;
+}
+export function addDataType(schemaOrName) {
+    const { document, typeQueue, circularRefs, curPath } = this;
+    const name = typeof schemaOrName === 'string' ? schemaOrName : undefined;
+    let schema;
+    let dataType;
+    if (name) {
+        // Check if data type exists in document
+        dataType = document.getDataType(name);
+        // Get schema from stack, it is already done if not exist
+        schema = typeQueue.get(name);
+        if (!schema)
+            return dataType;
+        // Detect circular refs
+        if (circularRefs.has(name))
+            throw new TypeError(`Circular reference detected. ${[...Array.from(circularRefs.keys()), name].join('>')}`);
+        circularRefs.set(name, 1);
+    }
+    else
+        schema = schemaOrName;
+    try {
+        // Init base
+        let base;
+        if ((OpraSchema.isSimpleType(schema) || OpraSchema.isComplexType(schema) || OpraSchema.isEnumType(schema)) && schema.base) {
+            curPath.push(typeof schema.base === 'string' ? schema.base : '[base]');
+            base = this.addDataType(schema.base);
+            curPath.pop();
+        }
+        // **** Init SimpleType ****
+        if (OpraSchema.isSimpleType(schema)) {
+            const initArgs = {
+                ...schema,
+                name,
+                base
+            };
+            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
+            if (name)
+                curPath.push(name);
+            SimpleType.apply(dataType, [document, initArgs]);
+            if (name)
+                curPath.pop();
+            return dataType;
+        }
+        // **** Init ComplexType ****
+        if (OpraSchema.isComplexType(schema)) {
+            const initArgs = {
+                ...schema,
+                name,
+                base
+            };
+            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
+            if (name)
+                curPath.push(name);
+            ComplexType.apply(dataType, [document, initArgs]);
+            if (name)
+                typeQueue.delete(name);
+            // process fields
+            if (schema.fields) {
+                for (const [elemName, v] of Object.entries(schema.fields)) {
+                    const elemSchema = typeof v === 'object' ? v : { type: v };
+                    curPath.push(`${name}.${elemName}[type]`);
+                    const elemType = this.addDataType(elemSchema.type);
+                    dataType.addField({
+                        ...elemSchema,
+                        name: elemName,
+                        type: elemType
+                    });
+                    curPath.pop();
+                }
+            }
+            if (name)
+                curPath.pop();
+            return dataType;
+        }
+        // **** Init EnumType ****
+        if (OpraSchema.isEnumType(schema)) {
+            const initArgs = {
+                ...schema,
+                name,
+                base
+            };
+            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
+            if (name)
+                curPath.push(name);
+            EnumType.apply(dataType, [document, initArgs]);
+            if (name)
+                curPath.pop();
+            return dataType;
+        }
+        // **** Init UnionType ****
+        if (OpraSchema.isUnionType(schema)) {
+            const unionTypes = schema.types.map(t => this.addDataType(t));
+            const initArgs = {
+                ...schema,
+                name,
+                types: unionTypes
+            };
+            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
+            if (name)
+                curPath.push(name);
+            UnionType.apply(dataType, [document, initArgs]);
+            if (name)
+                curPath.pop();
+            return dataType;
+        }
+        // **** Init MappedType ****
+        if (OpraSchema.isMappedType(schema)) {
+            const dt = this.addDataType(schema.type);
+            if (!(dt instanceof ComplexType))
+                throw new TypeError(`MappedType requires a ComplexType`);
+            const initArgs = {
+                ...schema,
+                name,
+                type: dt
+            };
+            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
+            if (name)
+                curPath.push(name);
+            MappedType.apply(dataType, [document, initArgs]);
+            if (name)
+                curPath.pop();
+            return dataType;
+        }
+    }
+    catch (e) {
+        if (curPath.length)
+            e.message = `Error at ${curPath.join('/')}: ` + e.message;
+        throw e;
+    }
+    finally {
+        if (name) {
+            circularRefs.delete(name);
+            typeQueue.delete(name);
+        }
+    }
+    throw new TypeError(`Invalid DataType schema: ${JSON.stringify(schema).substring(0, 20)}...`);
+}

package/esm/document/index.d.ts

@@ -0,0 +1,14 @@
+import 'reflect-metadata';
+export * from './constants.js';
+export * from './api-document.js';
+export * from './factory/index.js';
+export * from './data-type/data-type.js';
+export * from './data-type/complex-type.js';
+export * from './data-type/api-field.js';
+export * from './data-type/enum-type.js';
+export * from './data-type/mapped-type.js';
+export * from './data-type/simple-type.js';
+export * from './data-type/union-type.js';
+export * from './resource/resource.js';
+export * from './resource/collection.js';
+export * from './resource/singleton.js';

package/esm/document/index.js

@@ -0,0 +1,14 @@
+import 'reflect-metadata';
+export * from './constants.js';
+export * from './api-document.js';
+export * from './factory/index.js';
+export * from './data-type/data-type.js';
+export * from './data-type/complex-type.js';
+export * from './data-type/api-field.js';
+export * from './data-type/enum-type.js';
+export * from './data-type/mapped-type.js';
+export * from './data-type/simple-type.js';
+export * from './data-type/union-type.js';
+export * from './resource/resource.js';
+export * from './resource/collection.js';
+export * from './resource/singleton.js';

package/esm/document/resource/collection.d.ts

@@ -0,0 +1,67 @@
+import { StrictOmit } from 'ts-gems';
+import { Expression } from '../../filter/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { TypeThunkAsync } from '../../types.js';
+import type { ApiDocument } from '../api-document.js';
+import type { ComplexType } from '../data-type/complex-type.js';
+import { Resource } from './resource.js';
+export declare namespace Collection {
+    export interface InitArguments extends Resource.InitArguments, Pick<OpraSchema.Collection, 'primaryKey'> {
+        type: ComplexType;
+        operations: Operations;
+    }
+    export interface DecoratorOptions extends Resource.DecoratorOptions, Partial<Pick<OpraSchema.Collection, 'primaryKey'>> {
+    }
+    export interface Metadata extends StrictOmit<OpraSchema.Collection, 'type'> {
+        name: string;
+        type: TypeThunkAsync | string;
+    }
+    interface Operation {
+        handlerName?: string;
+    }
+    export interface Operations {
+        create?: OpraSchema.Collection.CreateOperation & Operation;
+        delete?: OpraSchema.Collection.DeleteOperation & Operation;
+        deleteMany?: OpraSchema.Collection.DeleteManyOperation & Operation;
+        get?: OpraSchema.Collection.GetOperation & Operation;
+        update?: OpraSchema.Collection.UpdateOperation & Operation;
+        updateMany?: OpraSchema.Collection.UpdateManyOperation & Operation;
+        search?: OpraSchema.Collection.SearchOperation & Operation;
+    }
+    export type CreateOperationOptions = StrictOmit<OpraSchema.Collection.CreateOperation, 'handler'>;
+    export type DeleteOperationOptions = StrictOmit<OpraSchema.Collection.DeleteOperation, 'handler'>;
+    export type DeleteManyOperationOptions = StrictOmit<OpraSchema.Collection.DeleteManyOperation, 'handler'>;
+    export type GetOperationOptions = StrictOmit<OpraSchema.Collection.GetOperation, 'handler'>;
+    export type UpdateOperationOptions = StrictOmit<OpraSchema.Collection.UpdateOperation, 'handler'>;
+    export type UpdateManyOperationOptions = StrictOmit<OpraSchema.Collection.UpdateManyOperation, 'handler'>;
+    export type SearchOperationOptions = StrictOmit<OpraSchema.Collection.SearchOperation, 'handler'>;
+    export {};
+}
+export interface Collection extends StrictOmit<Resource, 'exportSchema' | '_construct'> {
+    readonly type: ComplexType;
+    readonly operations: Collection.Operations;
+    readonly controller?: object;
+    readonly primaryKey: string[];
+    exportSchema(): OpraSchema.Collection;
+    parseKeyValue(value: any): any;
+    normalizeFieldNames(fields: string[]): string[] | undefined;
+    normalizeSortFields(fields: string[]): string[] | undefined;
+    normalizeFilterFields(ast: Expression): Expression;
+    _construct(init: Collection.InitArguments): void;
+}
+export interface CollectionConstructor {
+    prototype: Collection;
+    new (document: ApiDocument, init: Collection.InitArguments): Collection;
+    (type: TypeThunkAsync | string, options?: Collection.DecoratorOptions): ClassDecorator;
+    CreateOperation: (options?: Collection.CreateOperationOptions) => PropertyDecorator;
+    GetOperation: (options?: Collection.GetOperationOptions) => PropertyDecorator;
+    DeleteOperation: (options?: Collection.DeleteOperationOptions) => PropertyDecorator;
+    UpdateOperation: (options?: Collection.UpdateOperationOptions) => PropertyDecorator;
+    SearchOperation: (options?: Collection.SearchOperationOptions) => PropertyDecorator;
+    UpdateManyOperation: (options?: Collection.UpdateManyOperationOptions) => PropertyDecorator;
+    DeleteManyOperation: (options?: Collection.DeleteManyOperationOptions) => PropertyDecorator;
+}
+/**
+ *
+ */
+export declare const Collection: CollectionConstructor;

package/esm/document/resource/collection.js

@@ -0,0 +1,181 @@
+import omit from 'lodash.omit';
+import merge from 'putil-merge';
+import { BadRequestError } from '../../exception/index.js';
+import { ArithmeticExpression, ArrayExpression, ComparisonExpression, LogicalExpression, ParenthesesExpression, QualifiedIdentifier } from '../../filter/index.js';
+import { omitUndefined } from '../../helpers/index.js';
+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 { Resource } from './resource.js';
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NAME_PATTERN = /^(.*)(Resource|Collection)$/;
+/**
+ *
+ */
+export const Collection = function (...args) {
+    // ClassDecorator
+    if (!this) {
+        const [type, options] = args;
+        return function (target) {
+            const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+            const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
+            const baseMetadata = Reflect.getOwnMetadata(METADATA_KEY, Object.getPrototypeOf(target));
+            if (baseMetadata) {
+                merge(metadata, baseMetadata, { deep: true });
+            }
+            metadata.kind = OpraSchema.Collection.Kind;
+            metadata.name = name;
+            metadata.type = type;
+            // Merge with previous metadata object
+            const m = Reflect.getMetadata(METADATA_KEY, target);
+            if (m && metadata !== m)
+                Object.assign(metadata, omit(m), Object.keys(metadata));
+            // Merge options
+            if (options)
+                Object.assign(metadata, omit(options, ['kind', 'name', 'type', 'controller']));
+            Reflect.defineMetadata(METADATA_KEY, metadata, target);
+            /* Define Injectable metadata for NestJS support*/
+            Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
+        };
+    }
+    // Constructor
+    const [document, init] = args;
+    // call super()
+    Resource.apply(this, [document, init]);
+};
+const proto = {
+    _construct(init) {
+        // call super()
+        Resource.prototype._construct.call(this, init);
+        const _this = this;
+        _this.kind = OpraSchema.Collection.Kind;
+        _this.controller = init.controller;
+        const operations = _this.operations = init.operations || {};
+        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 el = dataType.getField(f);
+            if (!(el.type instanceof SimpleType))
+                throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${el.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);
+        Object.assign(out, omitUndefined({
+            type: this.type.name,
+            operations: this.operations,
+            primaryKey: this.primaryKey
+        }));
+        return out;
+    },
+    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);
+                obj[k] = el.type.decode(v);
+                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);
+            const result = el.type.decode(value);
+            if (result == null)
+                throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);
+            return result;
+        }
+    },
+    normalizeFieldNames(fields) {
+        return this.type.normalizeFieldNames(fields);
+    },
+    normalizeSortFields(fields) {
+        const normalized = this.normalizeFieldNames(fields);
+        if (!normalized)
+            return;
+        const searchEndpoint = this.operations.search;
+        const sortFields = searchEndpoint && searchEndpoint.sortFields;
+        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`),
+                });
+        });
+        return normalized;
+    },
+    normalizeFilterFields(ast) {
+        if (ast instanceof ComparisonExpression) {
+            this.normalizeFilterFields(ast.left);
+        }
+        else if (ast instanceof LogicalExpression) {
+            ast.items.forEach(item => this.normalizeFilterFields(item));
+        }
+        else if (ast instanceof ArithmeticExpression) {
+            ast.items.forEach(item => this.normalizeFilterFields(item.expression));
+        }
+        else if (ast instanceof ArrayExpression) {
+            ast.items.forEach(item => this.normalizeFilterFields(item));
+        }
+        else if (ast instanceof ParenthesesExpression) {
+            this.normalizeFilterFields(ast.expression);
+        }
+        else if (ast instanceof QualifiedIdentifier) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            ast.value = this.normalizeFieldNames([ast.value])[0];
+        }
+        return ast;
+    }
+};
+Object.assign(Collection.prototype, proto);
+Object.setPrototypeOf(Collection.prototype, Resource.prototype);
+function createOperationDecorator(operation) {
+    return (options) => ((target, propertyKey) => {
+        const metadata = {
+            ...options,
+            handlerName: propertyKey
+        };
+        const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
+        resourceMetadata.operations = resourceMetadata.operations || {};
+        resourceMetadata.operations[operation] = metadata;
+        Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
+    });
+}
+Collection.CreateOperation = createOperationDecorator('create');
+Collection.GetOperation = createOperationDecorator('get');
+Collection.DeleteOperation = createOperationDecorator('delete');
+Collection.UpdateOperation = createOperationDecorator('update');
+Collection.SearchOperation = createOperationDecorator('search');
+Collection.UpdateManyOperation = createOperationDecorator('updateMany');
+Collection.DeleteManyOperation = createOperationDecorator('deleteMany');