@opra/common 0.14.0 → 0.16.0

package/cjs/document/factory/import-resource-class.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCollectionSchema = exports.extractSingletonSchema = exports.importResourceClass = void 0;
+require("reflect-metadata");
+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 importResourceClass(thunk) {
+    const { document, resourceQueue, cache } = this;
+    const controller = await (0, index_js_1.resolveThunk)(thunk);
+    const cached = cache.get(controller);
+    if (cached)
+        return cached;
+    const ctor = typeof thunk === 'function' ? thunk : Object.getPrototypeOf(thunk).constructor;
+    let metadata = Reflect.getMetadata(constants_js_1.METADATA_KEY, ctor);
+    if (!metadata && index_js_2.OpraSchema.isResource(metadata))
+        throw new TypeError(`Class "${ctor.name}" doesn't have a valid Resource metadata`);
+    // const controller = typeof thunk === 'function' ? new ctor() : thunk;
+    // Clone metadata to prevent changing its contents
+    metadata = (0, index_js_1.cloneObject)(metadata);
+    const schema = (0, index_js_1.cloneObject)(metadata);
+    schema.controller = controller;
+    cache.set(thunk, schema);
+    if (index_js_2.OpraSchema.isSingleton(schema) || index_js_2.OpraSchema.isCollection(schema)) {
+        if (!document.getDataType(metadata.type, true) && (typeof metadata.type === 'function')) {
+            await this.importTypeClass(metadata.type);
+            await this.processTypes();
+            const dataTypeCtor = await (0, index_js_1.resolveClass)(metadata.type);
+            const dataType = document.getComplexType(dataTypeCtor);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            schema.type = dataType.name;
+        }
+        // Check if data type exists
+        document.getComplexType(schema.type);
+    }
+    if (index_js_2.OpraSchema.isSingleton(schema))
+        await this.extractSingletonSchema(schema, ctor, metadata, controller);
+    if (index_js_2.OpraSchema.isCollection(schema))
+        await this.extractCollectionSchema(schema, ctor, metadata, controller);
+    resourceQueue.set(metadata.name, schema);
+}
+exports.importResourceClass = importResourceClass;
+async function extractSingletonSchema(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+target, ctor, metadata, controller) {
+    // Do nothing. This method is used by external modules for extending the factory
+}
+exports.extractSingletonSchema = extractSingletonSchema;
+async function extractCollectionSchema(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+target, ctor, metadata, controller) {
+    // Do nothing. This method is used by external modules for extending the factory
+}
+exports.extractCollectionSchema = extractCollectionSchema;

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

@@ -0,0 +1,137 @@
+"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) {
+    const { document, typeQueue, cache } = this;
+    const thunk = await (0, index_js_1.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))) {
+        // If thunk is a Type class
+        if ((0, index_js_1.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 result = name || schema;
+    if (name) {
+        if (this.document.types.has(name) || typeQueue.has(name))
+            throw new TypeError(`Type "${name}" already imported`);
+        cache.set(thunk, result);
+        typeQueue.set(name, schema);
+    }
+    // If thunk is a DataType class
+    if ((0, index_js_1.isConstructor)(thunk)) {
+        const ctor = thunk;
+        if (index_js_2.OpraSchema.isSimpleType(schema))
+            await this.extractSimpleTypeSchema(schema, ctor, metadata);
+        else if (index_js_2.OpraSchema.isComplexType(schema))
+            await this.extractComplexTypeSchema(schema, ctor, metadata);
+        else if (index_js_2.OpraSchema.isMappedType(schema))
+            await this.extractMappedTypeSchema(schema, ctor, metadata);
+        else if (index_js_2.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 (index_js_2.OpraSchema.isEnumType(schema)) {
+        let baseType;
+        if (metadata.base && Reflect.hasMetadata(constants_js_1.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)}...`);
+}
+exports.importTypeClass = importTypeClass;
+// noinspection JSUnusedLocalSymbols
+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))
+        target.base = await this.importTypeClass(baseClass);
+    target.codec = Object.create(ctor.prototype);
+}
+exports.extractSimpleTypeSchema = extractSimpleTypeSchema;
+async function extractComplexTypeSchema(target, ctor, metadata) {
+    const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
+    if (Reflect.hasMetadata(constants_js_1.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);
+                // Check enum again. External packages may modify enum value
+                if (elemMeta.enum)
+                    elemSchema.type = await this.importTypeClass(elemMeta.enum);
+                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;
+            }
+        }
+    }
+}
+exports.extractComplexTypeSchema = extractComplexTypeSchema;
+async function extractMappedTypeSchema(target, ctor, metadata) {
+    target.type = await this.importTypeClass(metadata.type);
+}
+exports.extractMappedTypeSchema = extractMappedTypeSchema;
+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(
+// 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(
+// 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/cjs/document/factory/index.js

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

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

@@ -0,0 +1,55 @@
+"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() {
+    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 (index_js_1.OpraSchema.isCollection(schema)) {
+                const resource = await this.createCollection(name, schema);
+                document.resources.set(name, resource);
+                continue;
+            }
+            if (index_js_1.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)}...`);
+    }
+}
+exports.processResourceQueue = processResourceQueue;
+async function createCollection(name, schema) {
+    const { document } = this;
+    const dataType = document.getComplexType(schema.type);
+    const initArgs = {
+        ...schema,
+        name,
+        type: dataType
+    };
+    return new collection_js_1.Collection(document, initArgs);
+}
+exports.createCollection = createCollection;
+async function createSingleton(name, schema) {
+    const { document } = this;
+    const dataType = document.getComplexType(schema.type);
+    const initArgs = {
+        ...schema,
+        name,
+        type: dataType
+    };
+    return new singleton_js_1.Singleton(document, initArgs);
+}
+exports.createSingleton = createSingleton;

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

@@ -0,0 +1,191 @@
+"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() {
+    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();
+}
+exports.processTypes = processTypes;
+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);
+            break;
+        case index_js_1.OpraSchema.EnumType.Kind:
+            Object.setPrototypeOf(dataType, enum_type_js_1.EnumType.prototype);
+            break;
+        case index_js_1.OpraSchema.MappedType.Kind:
+            Object.setPrototypeOf(dataType, mapped_type_js_1.MappedType.prototype);
+            break;
+        case index_js_1.OpraSchema.SimpleType.Kind:
+            Object.setPrototypeOf(dataType, simple_type_js_1.SimpleType.prototype);
+            break;
+        case index_js_1.OpraSchema.UnionType.Kind:
+            Object.setPrototypeOf(dataType, union_type_js_1.UnionType.prototype);
+            break;
+        default:
+            throw new TypeError(`Unknown DataType kind (${kind})`);
+    }
+    return dataType;
+}
+exports.createDataTypeInstance = createDataTypeInstance;
+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 ((index_js_1.OpraSchema.isSimpleType(schema) || index_js_1.OpraSchema.isComplexType(schema) || index_js_1.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)) {
+            const initArgs = {
+                ...schema,
+                name,
+                base
+            };
+            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
+            if (name)
+                curPath.push(name);
+            simple_type_js_1.SimpleType.apply(dataType, [document, initArgs]);
+            if (name)
+                curPath.pop();
+            return dataType;
+        }
+        // **** Init ComplexType ****
+        if (index_js_1.OpraSchema.isComplexType(schema)) {
+            const initArgs = {
+                ...schema,
+                name,
+                base
+            };
+            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
+            if (name)
+                curPath.push(name);
+            complex_type_js_1.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 (index_js_1.OpraSchema.isEnumType(schema)) {
+            const initArgs = {
+                ...schema,
+                name,
+                base
+            };
+            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
+            if (name)
+                curPath.push(name);
+            enum_type_js_1.EnumType.apply(dataType, [document, initArgs]);
+            if (name)
+                curPath.pop();
+            return dataType;
+        }
+        // **** Init UnionType ****
+        if (index_js_1.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);
+            union_type_js_1.UnionType.apply(dataType, [document, initArgs]);
+            if (name)
+                curPath.pop();
+            return dataType;
+        }
+        // **** Init MappedType ****
+        if (index_js_1.OpraSchema.isMappedType(schema)) {
+            const dt = this.addDataType(schema.type);
+            if (!(dt instanceof complex_type_js_1.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);
+            mapped_type_js_1.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)}...`);
+}
+exports.addDataType = addDataType;

package/cjs/document/index.js

@@ -0,0 +1,17 @@
+"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);

package/cjs/document/resource/collection.js

@@ -0,0 +1,185 @@
+"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");
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NAME_PATTERN = /^(.*)(Resource|Collection)$/;
+/**
+ *
+ */
+exports.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));
+            if (baseMetadata) {
+                (0, putil_merge_1.default)(metadata, baseMetadata, { deep: true });
+            }
+            metadata.kind = index_js_5.OpraSchema.Collection.Kind;
+            metadata.name = name;
+            metadata.type = type;
+            // Merge with previous metadata object
+            const m = Reflect.getMetadata(constants_js_1.METADATA_KEY, target);
+            if (m && metadata !== m)
+                Object.assign(metadata, (0, lodash_omit_1.default)(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);
+            /* Define Injectable metadata for NestJS support*/
+            Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
+        };
+    }
+    // Constructor
+    const [document, init] = args;
+    // call super()
+    resource_js_1.Resource.apply(this, [document, init]);
+};
+const proto = {
+    _construct(init) {
+        // call super()
+        resource_js_1.Resource.prototype._construct.call(this, init);
+        const _this = this;
+        _this.kind = index_js_5.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 simple_type_js_1.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_js_1.Resource.prototype.exportSchema.call(this);
+        Object.assign(out, (0, index_js_3.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 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`),
+                });
+        });
+        return normalized;
+    },
+    normalizeFilterFields(ast) {
+        if (ast instanceof index_js_2.ComparisonExpression) {
+            this.normalizeFilterFields(ast.left);
+        }
+        else if (ast instanceof index_js_2.LogicalExpression) {
+            ast.items.forEach(item => this.normalizeFilterFields(item));
+        }
+        else if (ast instanceof index_js_2.ArithmeticExpression) {
+            ast.items.forEach(item => this.normalizeFilterFields(item.expression));
+        }
+        else if (ast instanceof index_js_2.ArrayExpression) {
+            ast.items.forEach(item => this.normalizeFilterFields(item));
+        }
+        else if (ast instanceof index_js_2.ParenthesesExpression) {
+            this.normalizeFilterFields(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];
+        }
+        return ast;
+    }
+};
+Object.assign(exports.Collection.prototype, proto);
+Object.setPrototypeOf(exports.Collection.prototype, resource_js_1.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) || {});
+        resourceMetadata.operations = resourceMetadata.operations || {};
+        resourceMetadata.operations[operation] = metadata;
+        Reflect.defineMetadata(constants_js_1.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');