@opra/common 0.23.2 → 0.24.0

package/cjs/document/constants.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TYPENAME_PATTERN = exports.NAMESPACE_PATTERN = exports.METADATA_KEY = void 0;
-exports.METADATA_KEY = Symbol.for('opra.metadata');
+exports.TYPENAME_PATTERN = exports.NAMESPACE_PATTERN = exports.DECORATOR = exports.SOURCE_METADATA = exports.DATATYPE_METADATA = void 0;
+exports.DATATYPE_METADATA = Symbol('DATATYPE_METADATA');
+exports.SOURCE_METADATA = Symbol('SOURCE_METADATA');
+exports.DECORATOR = Symbol('DECORATOR');
 exports.NAMESPACE_PATTERN = /([A-Z$_]\w+)(?::.+)?/i;
 exports.TYPENAME_PATTERN = /^(.*)Type(\d*)$/;

package/cjs/document/data-type/api-field.js

@@ -15,7 +15,7 @@ exports.ApiField = function (...args) {
         return function (target, propertyKey) {
             if (typeof propertyKey !== 'string')
                 throw new TypeError(`Symbol properties can't be used as a field`);
-            const metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target.constructor) || {};
+            const metadata = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, target.constructor) || {};
             metadata.kind = index_js_2.OpraSchema.ComplexType.Kind;
             metadata.fields = metadata.fields || {};
             const designType = Reflect.getMetadata('design:type', target, propertyKey);
@@ -39,13 +39,13 @@ exports.ApiField = function (...args) {
                     elemMeta.enum = enumObj;
                 }
                 else {
-                    const m = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, options?.enum);
+                    const m = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, options?.enum);
                     if (!index_js_2.OpraSchema.isEnumType(m))
                         throw new TypeError(`Invalid "enum" value. Did you forget to set metadata using EnumType() method?`);
                     elemMeta.enum = options.enum;
                 }
             }
-            Reflect.defineMetadata(constants_js_1.METADATA_KEY, (0, index_js_1.omitUndefined)(metadata), target.constructor);
+            Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, (0, index_js_1.omitUndefined)(metadata), target.constructor);
         };
     }
     // Constructor

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

@@ -166,10 +166,10 @@ exports.ComplexType = function (...args) {
     const [options] = args;
     return function (target) {
         const name = options?.name || target.name.match(constants_js_1.TYPENAME_PATTERN)?.[1] || target.name;
-        let metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target);
+        let metadata = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, target);
         if (!metadata) {
             metadata = {};
-            Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, target);
+            Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, target);
         }
         metadata.kind = index_js_3.OpraSchema.ComplexType.Kind;
         metadata.name = name;

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

@@ -44,20 +44,20 @@ exports.EnumType = function (...args) {
         return;
     }
     // Injector
-    const [source, options] = args;
-    const values = Array.isArray(source)
-        ? source.reduce((obj, v) => {
+    const [enumSource, options] = args;
+    const values = Array.isArray(enumSource)
+        ? enumSource.reduce((obj, v) => {
             obj[v] = v;
             return obj;
         }, {})
-        : source;
+        : enumSource;
     const metadata = {
         kind: index_js_2.OpraSchema.EnumType.Kind,
         values
     };
     if (options)
         Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'values']));
-    Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, source);
+    Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, enumSource);
     return values;
 };
 exports.EnumType.prototype = EnumTypeClass.prototype;

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

@@ -48,30 +48,30 @@ exports.MappedType = function (...args) {
         return;
     }
     // MappedType helper
-    const [source, options] = args;
+    const [mappedSource, options] = args;
     const isInheritedPredicate = getIsInheritedPredicateFn(options.pick, options.omit);
     class MappedClass {
         constructor() {
-            (0, index_js_1.inheritPropertyInitializers)(this, source, isInheritedPredicate);
+            (0, index_js_1.inheritPropertyInitializers)(this, mappedSource, isInheritedPredicate);
         }
     }
-    (0, index_js_1.mergePrototype)(MappedClass.prototype, source.prototype);
+    (0, index_js_1.mergePrototype)(MappedClass.prototype, mappedSource.prototype);
     // const mappedTypeMetadata: MappedType.TypeMapping[] = [];
-    const m = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, source);
+    const m = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, mappedSource);
     if (!m)
-        throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
+        throw new TypeError(`Class "${mappedSource}" doesn't have datatype metadata information`);
     if (!(m.kind === index_js_2.OpraSchema.ComplexType.Kind))
-        throw new TypeError(`Class "${source}" is not a ${index_js_2.OpraSchema.ComplexType.Kind}`);
+        throw new TypeError(`Class "${mappedSource}" is not a ${index_js_2.OpraSchema.ComplexType.Kind}`);
     const metadata = {
         kind: 'MappedType',
-        type: source
+        type: mappedSource
     };
     if (options.pick)
         metadata.pick = options.pick;
     if (options.omit)
         metadata.omit = options.omit;
-    Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, MappedClass);
-    exports.MappedType._applyMixin(MappedClass, source, {
+    Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, MappedClass);
+    exports.MappedType._applyMixin(MappedClass, mappedSource, {
         ...options,
         isInheritedPredicate
     });

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

@@ -45,12 +45,12 @@ exports.SimpleType = function (...args) {
     return function (target) {
         let name = options?.name || target.name.match(constants_js_1.TYPENAME_PATTERN)?.[1] || target.name;
         name = name.charAt(0).toLowerCase() + name.substring(1);
-        const metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target) || {};
+        const metadata = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, target) || {};
         metadata.kind = index_js_1.OpraSchema.SimpleType.Kind;
         metadata.name = name;
         if (options)
             Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'name']));
-        Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, target);
+        Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, target);
     };
 };
 exports.SimpleType.prototype = SimpleTypeClass.prototype;

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

@@ -63,9 +63,9 @@ exports.UnionType = function (...args) {
         kind: index_js_2.OpraSchema.UnionType.Kind,
         types: []
     };
-    Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, UnionClass);
+    Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, UnionClass);
     for (const c of clasRefs) {
-        const itemMeta = Reflect.getMetadata(constants_js_1.METADATA_KEY, c);
+        const itemMeta = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, c);
         if (!(itemMeta && (itemMeta.kind === index_js_2.OpraSchema.ComplexType.Kind || itemMeta.kind === index_js_2.OpraSchema.UnionType.Kind ||
             itemMeta.kind === index_js_2.OpraSchema.MappedType.Kind)))
             throw new TypeError(`Class "${c.name}" is not a ${index_js_2.OpraSchema.ComplexType.Kind}, ${index_js_2.OpraSchema.UnionType.Kind} or ${index_js_2.OpraSchema.MappedType.Kind}`);

package/cjs/document/factory/create-document.js

@@ -30,11 +30,11 @@ async function createDocument(init, options) {
         this.curPath.push('resources');
         if (Array.isArray(init.resources)) {
             for (const res of init.resources)
-                await this.importResourceClass(res);
+                await this.importSourceClass(res);
         }
         else
-            this.resourceQueue.setAll(init.resources);
-        await this.processResourceQueue();
+            this.sourceQueue.setAll(init.resources);
+        await this.processSourceQueue();
         this.curPath.pop();
     }
     this.document.types.sort();

package/cjs/document/factory/factory.js

@@ -17,7 +17,7 @@ class DocumentFactory {
     constructor() {
         this.document = new api_document_js_1.ApiDocument();
         this.typeQueue = new index_js_1.ResponsiveMap();
-        this.resourceQueue = new index_js_1.ResponsiveMap();
+        this.sourceQueue = new index_js_1.ResponsiveMap();
         this.circularRefs = new index_js_1.ResponsiveMap();
         this.curPath = [];
         this.cache = new Map();
@@ -56,11 +56,11 @@ DocumentFactory.designTypeMap = new Map();
     _a.prototype.processTypes = process_types_js_1.processTypes;
     _a.prototype.createDataTypeInstance = process_types_js_1.createDataTypeInstance;
     _a.prototype.addDataType = process_types_js_1.addDataType;
-    _a.prototype.importResourceClass = import_resource_class_js_1.importResourceClass;
+    _a.prototype.importSourceClass = import_resource_class_js_1.importResourceClass;
     _a.prototype.extractSingletonSchema = import_resource_class_js_1.extractSingletonSchema;
     _a.prototype.extractCollectionSchema = import_resource_class_js_1.extractCollectionSchema;
-    _a.prototype.processResourceQueue = process_resources_js_1.processResourceQueue;
-    _a.prototype.createCollectionResource = process_resources_js_1.createCollectionResource;
-    _a.prototype.createSingletonResource = process_resources_js_1.createSingletonResource;
-    _a.prototype.createFileResource = process_resources_js_1.createFileResource;
+    _a.prototype.processSourceQueue = process_resources_js_1.processSourceQueue;
+    _a.prototype.createCollectionSource = process_resources_js_1.createCollectionResource;
+    _a.prototype.createSingletonSource = process_resources_js_1.createSingletonResource;
+    _a.prototype.createFileSource = process_resources_js_1.createStorageResource;
 })();

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

@@ -6,14 +6,14 @@ 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 { document, sourceQueue, 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))
+    let metadata = Reflect.getMetadata(constants_js_1.SOURCE_METADATA, ctor);
+    if (!metadata && index_js_2.OpraSchema.isSource(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
@@ -37,7 +37,7 @@ async function importResourceClass(thunk) {
         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);
+    sourceQueue.set(metadata.name, schema);
 }
 exports.importResourceClass = importResourceClass;
 async function extractSingletonSchema(

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

@@ -14,7 +14,7 @@ async function importTypeClass(typeThunk) {
     const dt = document.getDataType(thunk, true);
     if (dt && dt.name)
         return dt.name;
-    const metadata = Reflect.getMetadata(constants_js_1.METADATA_KEY, thunk);
+    const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, thunk);
     if (!(metadata && index_js_2.OpraSchema.isDataType(metadata))) {
         // If thunk is a Type class
         if ((0, index_js_1.isConstructor)(thunk))
@@ -51,7 +51,7 @@ async function importTypeClass(typeThunk) {
     const enumObject = thunk;
     if (index_js_2.OpraSchema.isEnumType(schema)) {
         let baseType;
-        if (metadata.base && Reflect.hasMetadata(constants_js_1.METADATA_KEY, metadata.base)) {
+        if (metadata.base && Reflect.hasMetadata(constants_js_1.DATATYPE_METADATA, metadata.base)) {
             baseType = await this.importTypeClass(metadata.base);
         }
         schema.base = baseType;
@@ -66,7 +66,7 @@ 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(constants_js_1.DATATYPE_METADATA, baseClass))
         target.base = await this.importTypeClass(baseClass);
     if (typeof ctor.prototype.decode === 'function')
         target.decoder = (0, valgen_1.validator)(metadata.name, ctor.prototype.decode);
@@ -76,7 +76,7 @@ metadata) {
 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))
+    if (Reflect.hasMetadata(constants_js_1.DATATYPE_METADATA, baseClass))
         target.base = await this.importTypeClass(baseClass);
     target.ctor = target.ctor || ctor;
     // Fields

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

@@ -1,30 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFileResource = exports.createSingletonResource = exports.createCollectionResource = exports.processResourceQueue = void 0;
+exports.createStorageResource = exports.createSingletonResource = exports.createCollectionResource = exports.processSourceQueue = 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");
 const storage_js_1 = require("../resource/storage.js");
-async function processResourceQueue() {
-    const { document, resourceQueue } = this;
-    const resourceNames = Array.from(resourceQueue.keys());
-    for (const name of resourceNames) {
-        const schema = resourceQueue.get(name);
+async function processSourceQueue() {
+    const { document, sourceQueue } = this;
+    const sourceNames = Array.from(sourceQueue.keys());
+    for (const name of sourceNames) {
+        const schema = sourceQueue.get(name);
         if (!schema)
             continue;
         try {
             if (index_js_1.OpraSchema.isCollection(schema)) {
-                const resource = await this.createCollectionResource(name, schema);
+                const resource = await this.createCollectionSource(name, schema);
                 document.resources.set(name, resource);
                 continue;
             }
             if (index_js_1.OpraSchema.isSingleton(schema)) {
-                const resource = await this.createSingletonResource(name, schema);
+                const resource = await this.createSingletonSource(name, schema);
                 document.resources.set(name, resource);
                 continue;
             }
             if (index_js_1.OpraSchema.isStorage(schema)) {
-                const resource = await this.createFileResource(name, schema);
+                const resource = await this.createFileSource(name, schema);
                 document.resources.set(name, resource);
                 continue;
             }
@@ -36,7 +36,7 @@ async function processResourceQueue() {
         throw new TypeError(`Invalid Resource schema: ${JSON.stringify(schema).substring(0, 20)}...`);
     }
 }
-exports.processResourceQueue = processResourceQueue;
+exports.processSourceQueue = processSourceQueue;
 async function createCollectionResource(name, schema) {
     const { document } = this;
     const dataType = document.getComplexType(schema.type);
@@ -59,7 +59,7 @@ async function createSingletonResource(name, schema) {
     return new singleton_js_1.Singleton(document, initArgs);
 }
 exports.createSingletonResource = createSingletonResource;
-async function createFileResource(name, schema) {
+async function createStorageResource(name, schema) {
     const { document } = this;
     const initArgs = {
         ...schema,
@@ -67,4 +67,4 @@ async function createFileResource(name, schema) {
     };
     return new storage_js_1.Storage(document, initArgs);
 }
-exports.createFileResource = createFileResource;
+exports.createStorageResource = createStorageResource;

package/cjs/document/index.js

@@ -16,5 +16,6 @@ tslib_1.__exportStar(require("./resource/resource.js"), exports);
 tslib_1.__exportStar(require("./resource/collection.js"), exports);
 tslib_1.__exportStar(require("./resource/singleton.js"), exports);
 tslib_1.__exportStar(require("./resource/storage.js"), exports);
-tslib_1.__exportStar(require("./interfaces/collection-resource.interface.js"), exports);
-tslib_1.__exportStar(require("./interfaces/singleton-resource.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/collection.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/singleton.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/storage.interface.js"), exports);

package/cjs/document/resource/action.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Action = void 0;
+class Action {
+    exportSchema() {
+        return {};
+    }
+}
+exports.Action = Action;

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

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionClass = void 0;
+const tslib_1 = require("tslib");
+const vg = tslib_1.__importStar(require("valgen"));
+const index_js_1 = require("../../exception/index.js");
+const index_js_2 = require("../../filter/index.js");
+const object_utils_js_1 = require("../../helpers/object-utils.js");
+const index_js_3 = require("../../i18n/index.js");
+const index_js_4 = require("../../schema/index.js");
+const simple_type_js_1 = require("../data-type/simple-type.js");
+const generate_codec_js_1 = require("../utils/generate-codec.js");
+const resource_js_1 = require("./resource.js");
+class CollectionClass extends resource_js_1.Resource {
+    constructor(document, init) {
+        super(document, init);
+        this._decoders = {};
+        this._encoders = {};
+        this.kind = index_js_4.OpraSchema.Collection.Kind;
+        this.controller = init.controller;
+        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 field = dataType.getField(f);
+            if (!(field?.type instanceof simple_type_js_1.SimpleType))
+                throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${field.type.kind}`);
+        });
+    }
+    exportSchema() {
+        return {
+            ...super.exportSchema(),
+            ...(0, object_utils_js_1.omitUndefined)({
+                type: this.type.name || 'object',
+                operations: this.operations,
+                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 simple_type_js_1.SimpleType)
+                    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);
+            let result;
+            if (el.type instanceof simple_type_js_1.SimpleType)
+                result = el.type.decode(value);
+            if (result == null)
+                throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);
+            return result;
+        }
+    }
+    normalizeFieldPath(path) {
+        return this.type.normalizeFieldPath(path);
+    }
+    normalizeSortFields(fields) {
+        const normalized = this.type.normalizeFieldPath(fields);
+        if (!normalized)
+            return;
+        const findManyOp = this.operations.findMany;
+        const sortFields = findManyOp && findManyOp.sortFields;
+        (Array.isArray(normalized) ? normalized : [normalized]).forEach(field => {
+            if (!sortFields?.find(x => x === field))
+                throw new index_js_1.BadRequestError({
+                    message: (0, index_js_3.translate)('error:UNACCEPTED_SORT_FIELD', { field }),
+                });
+        });
+        return normalized;
+    }
+    normalizeFilter(filter) {
+        if (!filter)
+            return;
+        const ast = typeof filter === 'string' ? index_js_2.OpraFilter.parse(filter) : filter;
+        if (ast instanceof index_js_2.OpraFilter.ComparisonExpression) {
+            this.normalizeFilter(ast.left);
+            if (!(ast.left instanceof index_js_2.OpraFilter.QualifiedIdentifier && ast.left.field))
+                throw new TypeError(`Invalid filter query. Left side should be a data field.`);
+            // Check if filtering accepted for given field
+            const findManyOp = this.operations.findMany;
+            const fieldLower = ast.left.value.toLowerCase();
+            const filterDef = (findManyOp && findManyOp.filters || [])
+                .find(f => f.field.toLowerCase() === fieldLower);
+            if (!filterDef) {
+                throw new index_js_1.BadRequestError({
+                    message: (0, index_js_3.translate)('error:UNACCEPTED_FILTER_FIELD', { field: ast.left.value }),
+                });
+            }
+            // Check if filtering endpoint accepted for given field
+            if (!filterDef.operators?.includes(ast.op))
+                throw new index_js_1.BadRequestError({
+                    message: (0, index_js_3.translate)('error:UNACCEPTED_FILTER_OPERATION', { field: ast.left.value }),
+                });
+            this.normalizeFilter(ast.right);
+            return ast;
+        }
+        if (ast instanceof index_js_2.OpraFilter.LogicalExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item));
+            return ast;
+        }
+        if (ast instanceof index_js_2.OpraFilter.ArithmeticExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item.expression));
+            return ast;
+        }
+        if (ast instanceof index_js_2.OpraFilter.ArrayExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item));
+            return ast;
+        }
+        if (ast instanceof index_js_2.OpraFilter.ParenthesizedExpression) {
+            this.normalizeFilter(ast.expression);
+            return ast;
+        }
+        if (ast instanceof index_js_2.OpraFilter.QualifiedIdentifier) {
+            const normalizedFieldPath = this.type.normalizeFieldPath(ast.value)?.join('.');
+            ast.field = this.type.getField(normalizedFieldPath);
+            ast.dataType = ast.field?.type || this.document.getDataType('any');
+            ast.value = normalizedFieldPath;
+            return ast;
+        }
+        return ast;
+    }
+    getDecoder(endpoint) {
+        let decoder = this._decoders[endpoint];
+        if (decoder)
+            return decoder;
+        const options = {
+            partial: endpoint !== 'create'
+        };
+        if (endpoint !== 'create')
+            options.omit = [...this.primaryKey];
+        decoder = (0, generate_codec_js_1.generateCodec)(this.type, 'decode', options);
+        this._decoders[endpoint] = decoder;
+        return decoder;
+    }
+    getEncoder(endpoint) {
+        let encoder = this._encoders[endpoint];
+        if (encoder)
+            return encoder;
+        const options = {
+            partial: true
+        };
+        encoder = (0, generate_codec_js_1.generateCodec)(this.type, 'encode', options);
+        if (endpoint === 'findMany')
+            return vg.isArray(encoder);
+        this._encoders[endpoint] = encoder;
+        return encoder;
+    }
+}
+exports.CollectionClass = CollectionClass;

package/cjs/document/resource/collection-decorator.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionDecorator = 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("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const resource_decorator_js_1 = require("./resource-decorator.js");
+const NAME_PATTERN = /^(.*)(Resource|Collection|Controller)$/;
+const operationProperties = ['create', 'delete', 'deleteMany', 'get', 'findMany', 'update', 'updateMany'];
+function CollectionDecorator(type, options) {
+    return function (target) {
+        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+        const metadata = Reflect.getOwnMetadata(constants_js_1.SOURCE_METADATA, target) || {};
+        const baseMetadata = Reflect.getOwnMetadata(constants_js_1.SOURCE_METADATA, Object.getPrototypeOf(target));
+        if (baseMetadata) {
+            (0, putil_merge_1.default)(metadata, baseMetadata, { deep: true });
+        }
+        metadata.kind = index_js_1.OpraSchema.Collection.Kind;
+        metadata.name = name;
+        metadata.type = type;
+        // Merge with previous metadata object
+        const m = Reflect.getMetadata(constants_js_1.SOURCE_METADATA, 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.SOURCE_METADATA, metadata, target);
+    };
+}
+exports.CollectionDecorator = CollectionDecorator;
+Object.assign(CollectionDecorator, resource_decorator_js_1.ResourceDecorator);
+CollectionDecorator.Create = createOperationDecorator('create');
+CollectionDecorator.Delete = createOperationDecorator('delete');
+CollectionDecorator.DeleteMany = createOperationDecorator('deleteMany');
+CollectionDecorator.Get = createOperationDecorator('get');
+CollectionDecorator.FindMany = createOperationDecorator('findMany');
+CollectionDecorator.Update = createOperationDecorator('update');
+CollectionDecorator.UpdateMany = createOperationDecorator('updateMany');
+CollectionDecorator.Action = function (options) {
+    const oldDecorator = resource_decorator_js_1.ResourceDecorator.Action(options);
+    return (target, propertyKey) => {
+        if (typeof propertyKey === 'string' && operationProperties.includes(propertyKey))
+            throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
+        return oldDecorator(target, propertyKey);
+    };
+};
+function createOperationDecorator(operation) {
+    return (options) => ((target, propertyKey) => {
+        if (propertyKey !== operation)
+            throw new TypeError(`Name of the handler name should be '${operation}'`);
+        const operationMeta = { ...options };
+        const sourceMetadata = (Reflect.getOwnMetadata(constants_js_1.SOURCE_METADATA, target.constructor) || {});
+        sourceMetadata.operations = sourceMetadata.operations || {};
+        sourceMetadata.operations[operation] = operationMeta;
+        Reflect.defineMetadata(constants_js_1.SOURCE_METADATA, sourceMetadata, target.constructor);
+    });
+}