@opra/common 0.16.2 → 0.17.0

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

@@ -1,29 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFieldSchema = exports.extractEnumTypeSchema = exports.extractUnionTypeSchema = exports.extractMappedTypeSchema = exports.extractComplexTypeSchema = exports.extractSimpleTypeSchema = exports.importTypeClass = void 0;
-const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../schema/index.js");
-const constants_js_1 = require("../constants.js");
-async function importTypeClass(typeThunk) {
+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 (0, index_js_1.resolveThunk)(typeThunk);
+    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(constants_js_1.METADATA_KEY, thunk);
-    if (!(metadata && index_js_2.OpraSchema.isDataType(metadata))) {
+    const metadata = Reflect.getMetadata(METADATA_KEY, thunk);
+    if (!(metadata && OpraSchema.isDataType(metadata))) {
         // If thunk is a Type class
-        if ((0, index_js_1.isConstructor)(thunk))
+        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 = (0, index_js_1.cloneObject)(metadata);
+    const schema = cloneObject(metadata);
     const result = name || schema;
     if (name) {
         if (this.document.types.has(name) || typeQueue.has(name))
@@ -32,15 +29,15 @@ async function importTypeClass(typeThunk) {
         typeQueue.set(name, schema);
     }
     // If thunk is a DataType class
-    if ((0, index_js_1.isConstructor)(thunk)) {
+    if (isConstructor(thunk)) {
         const ctor = thunk;
-        if (index_js_2.OpraSchema.isSimpleType(schema))
+        if (OpraSchema.isSimpleType(schema))
             await this.extractSimpleTypeSchema(schema, ctor, metadata);
-        else if (index_js_2.OpraSchema.isComplexType(schema))
+        else if (OpraSchema.isComplexType(schema))
             await this.extractComplexTypeSchema(schema, ctor, metadata);
-        else if (index_js_2.OpraSchema.isMappedType(schema))
+        else if (OpraSchema.isMappedType(schema))
             await this.extractMappedTypeSchema(schema, ctor, metadata);
-        else if (index_js_2.OpraSchema.isUnionType(schema))
+        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`);
@@ -48,9 +45,9 @@ async function importTypeClass(typeThunk) {
     }
     // If thunk is a EnumType object
     const enumObject = thunk;
-    if (index_js_2.OpraSchema.isEnumType(schema)) {
+    if (OpraSchema.isEnumType(schema)) {
         let baseType;
-        if (metadata.base && Reflect.hasMetadata(constants_js_1.METADATA_KEY, metadata.base)) {
+        if (metadata.base && Reflect.hasMetadata(METADATA_KEY, metadata.base)) {
             baseType = await this.importTypeClass(metadata.base);
         }
         schema.base = baseType;
@@ -59,20 +56,18 @@ async function importTypeClass(typeThunk) {
     }
     throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(enumObject).substring(0, 20)}...`);
 }
-exports.importTypeClass = importTypeClass;
 // noinspection JSUnusedLocalSymbols
-async function extractSimpleTypeSchema(target, ctor, 
+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(constants_js_1.METADATA_KEY, baseClass))
+    if (Reflect.hasMetadata(METADATA_KEY, baseClass))
         target.base = await this.importTypeClass(baseClass);
     target.codec = Object.create(ctor.prototype);
 }
-exports.extractSimpleTypeSchema = extractSimpleTypeSchema;
-async function extractComplexTypeSchema(target, ctor, metadata) {
+export async function extractComplexTypeSchema(target, ctor, metadata) {
     const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-    if (Reflect.hasMetadata(constants_js_1.METADATA_KEY, baseClass))
+    if (Reflect.hasMetadata(METADATA_KEY, baseClass))
         target.base = await this.importTypeClass(baseClass);
     target.ctor = ctor;
     // Fields
@@ -109,29 +104,24 @@ async function extractComplexTypeSchema(target, ctor, metadata) {
         }
     }
 }
-exports.extractComplexTypeSchema = extractComplexTypeSchema;
-async function extractMappedTypeSchema(target, ctor, metadata) {
+export async function extractMappedTypeSchema(target, ctor, metadata) {
     target.type = await this.importTypeClass(metadata.type);
 }
-exports.extractMappedTypeSchema = extractMappedTypeSchema;
-async function extractUnionTypeSchema(target, ctor, metadata) {
+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));
 }
-exports.extractUnionTypeSchema = extractUnionTypeSchema;
 // noinspection JSUnusedLocalSymbols
-async function extractEnumTypeSchema(
+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
 }
-exports.extractEnumTypeSchema = extractEnumTypeSchema;
 // noinspection JSUnusedLocalSymbols
-async function extractFieldSchema(
+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
 }
-exports.extractFieldSchema = extractFieldSchema;

package/esm/document/factory/index.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./factory.js"), exports);
+export * from './factory.js';

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

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSingleton = exports.createCollection = exports.processResourceQueue = void 0;
-const index_js_1 = require("../../schema/index.js");
-const collection_js_1 = require("../resource/collection.js");
-const singleton_js_1 = require("../resource/singleton.js");
-async function processResourceQueue() {
+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) {
@@ -12,12 +9,12 @@ async function processResourceQueue() {
         if (!schema)
             continue;
         try {
-            if (index_js_1.OpraSchema.isCollection(schema)) {
+            if (OpraSchema.isCollection(schema)) {
                 const resource = await this.createCollection(name, schema);
                 document.resources.set(name, resource);
                 continue;
             }
-            if (index_js_1.OpraSchema.isSingleton(schema)) {
+            if (OpraSchema.isSingleton(schema)) {
                 const resource = await this.createSingleton(name, schema);
                 document.resources.set(name, resource);
                 continue;
@@ -30,8 +27,7 @@ async function processResourceQueue() {
         throw new TypeError(`Invalid Resource schema: ${JSON.stringify(schema).substring(0, 20)}...`);
     }
 }
-exports.processResourceQueue = processResourceQueue;
-async function createCollection(name, schema) {
+export async function createCollection(name, schema) {
     const { document } = this;
     const dataType = document.getComplexType(schema.type);
     const initArgs = {
@@ -39,10 +35,9 @@ async function createCollection(name, schema) {
         name,
         type: dataType
     };
-    return new collection_js_1.Collection(document, initArgs);
+    return new Collection(document, initArgs);
 }
-exports.createCollection = createCollection;
-async function createSingleton(name, schema) {
+export async function createSingleton(name, schema) {
     const { document } = this;
     const dataType = document.getComplexType(schema.type);
     const initArgs = {
@@ -50,6 +45,5 @@ async function createSingleton(name, schema) {
         name,
         type: dataType
     };
-    return new singleton_js_1.Singleton(document, initArgs);
+    return new Singleton(document, initArgs);
 }
-exports.createSingleton = createSingleton;

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

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addDataType = exports.createDataTypeInstance = exports.processTypes = void 0;
-const index_js_1 = require("../../schema/index.js");
-const complex_type_js_1 = require("../data-type/complex-type.js");
-const enum_type_js_1 = require("../data-type/enum-type.js");
-const mapped_type_js_1 = require("../data-type/mapped-type.js");
-const simple_type_js_1 = require("../data-type/simple-type.js");
-const union_type_js_1 = require("../data-type/union-type.js");
-async function processTypes() {
+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()) {
@@ -23,36 +20,34 @@ async function processTypes() {
     }
     document.invalidate();
 }
-exports.processTypes = processTypes;
-function createDataTypeInstance(kind, name) {
+export function createDataTypeInstance(kind, name) {
     const dataType = {
         document: this.document,
         kind,
         name
     };
     switch (kind) {
-        case index_js_1.OpraSchema.ComplexType.Kind:
-            Object.setPrototypeOf(dataType, complex_type_js_1.ComplexType.prototype);
+        case OpraSchema.ComplexType.Kind:
+            Object.setPrototypeOf(dataType, ComplexType.prototype);
             break;
-        case index_js_1.OpraSchema.EnumType.Kind:
-            Object.setPrototypeOf(dataType, enum_type_js_1.EnumType.prototype);
+        case OpraSchema.EnumType.Kind:
+            Object.setPrototypeOf(dataType, EnumType.prototype);
             break;
-        case index_js_1.OpraSchema.MappedType.Kind:
-            Object.setPrototypeOf(dataType, mapped_type_js_1.MappedType.prototype);
+        case OpraSchema.MappedType.Kind:
+            Object.setPrototypeOf(dataType, MappedType.prototype);
             break;
-        case index_js_1.OpraSchema.SimpleType.Kind:
-            Object.setPrototypeOf(dataType, simple_type_js_1.SimpleType.prototype);
+        case OpraSchema.SimpleType.Kind:
+            Object.setPrototypeOf(dataType, SimpleType.prototype);
             break;
-        case index_js_1.OpraSchema.UnionType.Kind:
-            Object.setPrototypeOf(dataType, union_type_js_1.UnionType.prototype);
+        case OpraSchema.UnionType.Kind:
+            Object.setPrototypeOf(dataType, UnionType.prototype);
             break;
         default:
             throw new TypeError(`Unknown DataType kind (${kind})`);
     }
     return dataType;
 }
-exports.createDataTypeInstance = createDataTypeInstance;
-function addDataType(schemaOrName) {
+export function addDataType(schemaOrName) {
     const { document, typeQueue, circularRefs, curPath } = this;
     const name = typeof schemaOrName === 'string' ? schemaOrName : undefined;
     let schema;
@@ -74,13 +69,13 @@ function addDataType(schemaOrName) {
     try {
         // Init base
         let base;
-        if ((index_js_1.OpraSchema.isSimpleType(schema) || index_js_1.OpraSchema.isComplexType(schema) || index_js_1.OpraSchema.isEnumType(schema)) && schema.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 (index_js_1.OpraSchema.isSimpleType(schema)) {
+        if (OpraSchema.isSimpleType(schema)) {
             const initArgs = {
                 ...schema,
                 name,
@@ -89,13 +84,13 @@ function addDataType(schemaOrName) {
             dataType = dataType || this.createDataTypeInstance(schema.kind, name);
             if (name)
                 curPath.push(name);
-            simple_type_js_1.SimpleType.apply(dataType, [document, initArgs]);
+            SimpleType.apply(dataType, [document, initArgs]);
             if (name)
                 curPath.pop();
             return dataType;
         }
         // **** Init ComplexType ****
-        if (index_js_1.OpraSchema.isComplexType(schema)) {
+        if (OpraSchema.isComplexType(schema)) {
             const initArgs = {
                 ...schema,
                 name,
@@ -104,7 +99,7 @@ function addDataType(schemaOrName) {
             dataType = dataType || this.createDataTypeInstance(schema.kind, name);
             if (name)
                 curPath.push(name);
-            complex_type_js_1.ComplexType.apply(dataType, [document, initArgs]);
+            ComplexType.apply(dataType, [document, initArgs]);
             if (name)
                 typeQueue.delete(name);
             // process fields
@@ -126,7 +121,7 @@ function addDataType(schemaOrName) {
             return dataType;
         }
         // **** Init EnumType ****
-        if (index_js_1.OpraSchema.isEnumType(schema)) {
+        if (OpraSchema.isEnumType(schema)) {
             const initArgs = {
                 ...schema,
                 name,
@@ -135,13 +130,13 @@ function addDataType(schemaOrName) {
             dataType = dataType || this.createDataTypeInstance(schema.kind, name);
             if (name)
                 curPath.push(name);
-            enum_type_js_1.EnumType.apply(dataType, [document, initArgs]);
+            EnumType.apply(dataType, [document, initArgs]);
             if (name)
                 curPath.pop();
             return dataType;
         }
         // **** Init UnionType ****
-        if (index_js_1.OpraSchema.isUnionType(schema)) {
+        if (OpraSchema.isUnionType(schema)) {
             const unionTypes = schema.types.map(t => this.addDataType(t));
             const initArgs = {
                 ...schema,
@@ -151,15 +146,15 @@ function addDataType(schemaOrName) {
             dataType = dataType || this.createDataTypeInstance(schema.kind, name);
             if (name)
                 curPath.push(name);
-            union_type_js_1.UnionType.apply(dataType, [document, initArgs]);
+            UnionType.apply(dataType, [document, initArgs]);
             if (name)
                 curPath.pop();
             return dataType;
         }
         // **** Init MappedType ****
-        if (index_js_1.OpraSchema.isMappedType(schema)) {
+        if (OpraSchema.isMappedType(schema)) {
             const dt = this.addDataType(schema.type);
-            if (!(dt instanceof complex_type_js_1.ComplexType))
+            if (!(dt instanceof ComplexType))
                 throw new TypeError(`MappedType requires a ComplexType`);
             const initArgs = {
                 ...schema,
@@ -169,7 +164,7 @@ function addDataType(schemaOrName) {
             dataType = dataType || this.createDataTypeInstance(schema.kind, name);
             if (name)
                 curPath.push(name);
-            mapped_type_js_1.MappedType.apply(dataType, [document, initArgs]);
+            MappedType.apply(dataType, [document, initArgs]);
             if (name)
                 curPath.pop();
             return dataType;
@@ -188,4 +183,3 @@ function addDataType(schemaOrName) {
     }
     throw new TypeError(`Invalid DataType schema: ${JSON.stringify(schema).substring(0, 20)}...`);
 }
-exports.addDataType = addDataType;

package/esm/document/index.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-require("reflect-metadata");
-tslib_1.__exportStar(require("./constants.js"), exports);
-tslib_1.__exportStar(require("./api-document.js"), exports);
-tslib_1.__exportStar(require("./factory/index.js"), exports);
-tslib_1.__exportStar(require("./data-type/data-type.js"), exports);
-tslib_1.__exportStar(require("./data-type/complex-type.js"), exports);
-tslib_1.__exportStar(require("./data-type/api-field.js"), exports);
-tslib_1.__exportStar(require("./data-type/enum-type.js"), exports);
-tslib_1.__exportStar(require("./data-type/mapped-type.js"), exports);
-tslib_1.__exportStar(require("./data-type/simple-type.js"), exports);
-tslib_1.__exportStar(require("./data-type/union-type.js"), exports);
-tslib_1.__exportStar(require("./resource/resource.js"), exports);
-tslib_1.__exportStar(require("./resource/collection.js"), exports);
-tslib_1.__exportStar(require("./resource/singleton.js"), exports);
+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.js

@@ -1,44 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Collection = void 0;
-const tslib_1 = require("tslib");
-const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
-const index_js_1 = require("../../exception/index.js");
-const index_js_2 = require("../../filter/index.js");
-const index_js_3 = require("../../helpers/index.js");
-const index_js_4 = require("../../i18n/index.js");
-const index_js_5 = require("../../schema/index.js");
-const constants_js_1 = require("../constants.js");
-const simple_type_js_1 = require("../data-type/simple-type.js");
-const resource_js_1 = require("./resource.js");
+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)$/;
 /**
  *
  */
-exports.Collection = function (...args) {
+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(constants_js_1.METADATA_KEY, target) || {};
-            const baseMetadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, Object.getPrototypeOf(target));
+            const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
+            const baseMetadata = Reflect.getOwnMetadata(METADATA_KEY, Object.getPrototypeOf(target));
             if (baseMetadata) {
-                (0, putil_merge_1.default)(metadata, baseMetadata, { deep: true });
+                merge(metadata, baseMetadata, { deep: true });
             }
-            metadata.kind = index_js_5.OpraSchema.Collection.Kind;
+            metadata.kind = OpraSchema.Collection.Kind;
             metadata.name = name;
             metadata.type = type;
             // Merge with previous metadata object
-            const m = Reflect.getMetadata(constants_js_1.METADATA_KEY, target);
+            const m = Reflect.getMetadata(METADATA_KEY, target);
             if (m && metadata !== m)
-                Object.assign(metadata, (0, lodash_omit_1.default)(m), Object.keys(metadata));
+                Object.assign(metadata, omit(m), Object.keys(metadata));
             // Merge options
             if (options)
-                Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'name', 'type', 'controller']));
-            Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, target);
+                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);
         };
@@ -46,14 +42,14 @@ exports.Collection = function (...args) {
     // Constructor
     const [document, init] = args;
     // call super()
-    resource_js_1.Resource.apply(this, [document, init]);
+    Resource.apply(this, [document, init]);
 };
 const proto = {
     _construct(init) {
         // call super()
-        resource_js_1.Resource.prototype._construct.call(this, init);
+        Resource.prototype._construct.call(this, init);
         const _this = this;
-        _this.kind = index_js_5.OpraSchema.Collection.Kind;
+        _this.kind = OpraSchema.Collection.Kind;
         _this.controller = init.controller;
         const operations = _this.operations = init.operations || {};
         const dataType = _this.type = init.type;
@@ -64,9 +60,9 @@ const proto = {
         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 simple_type_js_1.SimpleType))
-                throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${el.type.kind}`);
+            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}`);
         });
         if (_this.controller) {
             const instance = typeof _this.controller == 'function'
@@ -83,8 +79,8 @@ const proto = {
         }
     },
     exportSchema() {
-        const out = resource_js_1.Resource.prototype.exportSchema.call(this);
-        Object.assign(out, (0, index_js_3.omitUndefined)({
+        const out = Resource.prototype.exportSchema.call(this);
+        Object.assign(out, omitUndefined({
             type: this.type.name,
             operations: this.operations,
             primaryKey: this.primaryKey
@@ -122,64 +118,63 @@ const proto = {
             return result;
         }
     },
-    normalizeFieldNames(fields) {
-        return this.type.normalizeFieldNames(fields);
+    normalizeFieldPath(path) {
+        return this.type.normalizeFieldPath(path);
     },
     normalizeSortFields(fields) {
-        const normalized = this.normalizeFieldNames(fields);
-        if (!normalized)
-            return;
+        const normalized = this.type.normalizeFieldPath(fields);
         const findManyEndpoint = this.operations.findMany;
         const sortFields = findManyEndpoint && findManyEndpoint.sortFields;
         normalized.forEach(field => {
             if (!sortFields?.find(x => x === field))
-                throw new index_js_1.BadRequestError({
-                    message: (0, index_js_4.translate)('error:UNACCEPTED_SORT_FIELD', { field }, `Field '${field}' is not available for sort operation`),
+                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 index_js_2.ComparisonExpression) {
-            this.normalizeFilterFields(ast.left);
+    normalizeFilter(ast) {
+        if (ast instanceof ComparisonExpression) {
+            this.normalizeFilter(ast.left);
         }
-        else if (ast instanceof index_js_2.LogicalExpression) {
-            ast.items.forEach(item => this.normalizeFilterFields(item));
+        else if (ast instanceof LogicalExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item));
         }
-        else if (ast instanceof index_js_2.ArithmeticExpression) {
-            ast.items.forEach(item => this.normalizeFilterFields(item.expression));
+        else if (ast instanceof ArithmeticExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item.expression));
         }
-        else if (ast instanceof index_js_2.ArrayExpression) {
-            ast.items.forEach(item => this.normalizeFilterFields(item));
+        else if (ast instanceof ArrayExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item));
         }
-        else if (ast instanceof index_js_2.ParenthesesExpression) {
-            this.normalizeFilterFields(ast.expression);
+        else if (ast instanceof ParenthesesExpression) {
+            this.normalizeFilter(ast.expression);
         }
-        else if (ast instanceof index_js_2.QualifiedIdentifier) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            ast.value = this.normalizeFieldNames([ast.value])[0];
+        else if (ast instanceof QualifiedIdentifier) {
+            ast.field = this.type.findField(ast.value);
+            ast.dataType = ast.field?.type || this.document.getDataType('any');
+            ast.value = this.type.normalizeFieldPath(ast.value);
         }
         return ast;
     }
 };
-Object.assign(exports.Collection.prototype, proto);
-Object.setPrototypeOf(exports.Collection.prototype, resource_js_1.Resource.prototype);
+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(constants_js_1.METADATA_KEY, target.constructor) || {});
+        const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
         resourceMetadata.operations = resourceMetadata.operations || {};
         resourceMetadata.operations[operation] = metadata;
-        Reflect.defineMetadata(constants_js_1.METADATA_KEY, resourceMetadata, target.constructor);
+        Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
     });
 }
-exports.Collection.Create = createOperationDecorator('create');
-exports.Collection.Delete = createOperationDecorator('delete');
-exports.Collection.DeleteMany = createOperationDecorator('deleteMany');
-exports.Collection.Get = createOperationDecorator('get');
-exports.Collection.FindMany = createOperationDecorator('findMany');
-exports.Collection.Update = createOperationDecorator('update');
-exports.Collection.UpdateMany = createOperationDecorator('updateMany');
+Collection.Create = createOperationDecorator('create');
+Collection.Delete = createOperationDecorator('delete');
+Collection.DeleteMany = createOperationDecorator('deleteMany');
+Collection.Get = createOperationDecorator('get');
+Collection.FindMany = createOperationDecorator('findMany');
+Collection.Update = createOperationDecorator('update');
+Collection.UpdateMany = createOperationDecorator('updateMany');

package/esm/document/resource/resource.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Resource = void 0;
-const object_utils_js_1 = require("../../helpers/object-utils.js");
-const inspect_util_js_1 = require("../utils/inspect.util.js");
-exports.Resource = function (document, init) {
-    if (!(this instanceof exports.Resource)) {
+import { omitUndefined } from '../../helpers/object-utils.js';
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
+export const Resource = function (document, init) {
+    if (!(this instanceof Resource)) {
         throw new TypeError(`Class constructor must be called with "new" keyword`);
         // noinspection UnreachableCodeJS
         return;
@@ -22,7 +19,7 @@ const proto = {
         // Do nothing
     },
     exportSchema() {
-        return (0, object_utils_js_1.omitUndefined)({
+        return omitUndefined({
             kind: this.kind,
             description: this.description
         });
@@ -30,9 +27,9 @@ const proto = {
     toString() {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || '#anonymous'}]`;
     },
-    [inspect_util_js_1.nodeInspectCustom]() {
-        return `[${inspect_util_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + inspect_util_js_1.colorReset}` +
-            ` ${inspect_util_js_1.colorFgMagenta + this.name + inspect_util_js_1.colorReset}]`;
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
+            ` ${colorFgMagenta + this.name + colorReset}]`;
     }
 };
-Object.assign(exports.Resource.prototype, proto);
+Object.assign(Resource.prototype, proto);