@opra/common 0.33.12 → 1.0.0-alpha.1

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

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

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

@@ -1,207 +0,0 @@
-import { omitUndefined } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { createActionDecorator } from './action-decorator.js';
-import { createOperationDecorator } from './crud-operation-decorator.js';
-import { ResourceDecorator } from './resource-decorator.js';
-const operationProperties = ['create', 'delete', 'deleteMany', 'get', 'findMany', 'update', 'updateMany'];
-export function CollectionDecorator(type, options) {
-    return ResourceDecorator(OpraSchema.Collection.Kind, { ...options, type });
-}
-Object.assign(CollectionDecorator, ResourceDecorator);
-/*
- * Action PropertyDecorator
- */
-(function (CollectionDecorator) {
-    /**
-     * Action PropertyDecorator
-     */
-    function Action(options) {
-        const list = [];
-        return createActionDecorator(options, operationProperties, list);
-    }
-    CollectionDecorator.Action = Action;
-    function Create(options) {
-        const list = [];
-        const decorator = createOperationDecorator('create', options, list);
-        decorator.InputMaxContentSize = (sizeInBytes) => {
-            list.push(operationMeta => operationMeta.options.inputMaxContentSize = sizeInBytes);
-            return decorator;
-        };
-        decorator.InputPickFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.inputPickFields = fields);
-            return decorator;
-        };
-        decorator.InputOmitFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.inputOmitFields = fields);
-            return decorator;
-        };
-        decorator.InputOverwriteFields = (fields) => {
-            list.push(operationMeta => operationMeta.options.inputOverwriteFields = fields);
-            return decorator;
-        };
-        decorator.OutputPickFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.outputPickFields = fields);
-            return decorator;
-        };
-        decorator.OutputOmitFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.outputOmitFields = fields);
-            return decorator;
-        };
-        decorator.OutputOverwriteFields = (fields) => {
-            list.push(operationMeta => operationMeta.options.outputOverwriteFields = fields);
-            return decorator;
-        };
-        return decorator;
-    }
-    CollectionDecorator.Create = Create;
-    function Delete(options) {
-        const list = [];
-        return createOperationDecorator('delete', options, list);
-    }
-    CollectionDecorator.Delete = Delete;
-    function DeleteMany(options) {
-        const list = [];
-        const decorator = createOperationDecorator('deleteMany', options, list);
-        decorator.Filter = (field, operators, notes) => {
-            if (typeof operators === 'string')
-                operators = operators.split(/\s*[,| ]\s*/)
-                    .filter(s => s);
-            list.push(operationMeta => {
-                operationMeta.options.filters = operationMeta.options.filters || [];
-                operationMeta.options.filters.push(omitUndefined({ field, operators, notes }));
-            });
-            return decorator;
-        };
-        return decorator;
-    }
-    CollectionDecorator.DeleteMany = DeleteMany;
-    function Get(options) {
-        const list = [];
-        const decorator = createOperationDecorator('get', options, list);
-        decorator.OutputPickFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.outputPickFields = fields);
-            return decorator;
-        };
-        decorator.OutputOmitFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.outputOmitFields = fields);
-            return decorator;
-        };
-        decorator.OutputOverwriteFields = (fields) => {
-            list.push(operationMeta => operationMeta.options.outputOverwriteFields = fields);
-            return decorator;
-        };
-        return decorator;
-    }
-    CollectionDecorator.Get = Get;
-    function FindMany(options) {
-        const list = [];
-        const decorator = createOperationDecorator('findMany', options, list);
-        decorator.SortFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.sortFields = fields);
-            return decorator;
-        };
-        decorator.DefaultSort = (...fields) => {
-            list.push(operationMeta => operationMeta.options.defaultSort = fields);
-            return decorator;
-        };
-        decorator.Filter = (field, operators, notes) => {
-            if (typeof operators === 'string')
-                operators = operators.split(/\s*[,| ]\s*/);
-            list.push(operationMeta => {
-                operationMeta.options.filters = operationMeta.options.filters || [];
-                operationMeta.options.filters.push(omitUndefined({ field, operators, notes }));
-            });
-            return decorator;
-        };
-        decorator.OutputPickFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.outputPickFields = fields);
-            return decorator;
-        };
-        decorator.OutputOmitFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.outputOmitFields = fields);
-            return decorator;
-        };
-        decorator.OutputOverwriteFields = (fields) => {
-            list.push(operationMeta => operationMeta.options.outputOverwriteFields = fields);
-            return decorator;
-        };
-        return decorator;
-    }
-    CollectionDecorator.FindMany = FindMany;
-})(CollectionDecorator || (CollectionDecorator = {}));
-/*
- * Update PropertyDecorator
- */
-(function (CollectionDecorator) {
-    function Update(options) {
-        const list = [];
-        const decorator = createOperationDecorator('update', options, list);
-        decorator.InputMaxContentSize = (sizeInBytes) => {
-            list.push(operationMeta => operationMeta.options.inputMaxContentSize = sizeInBytes);
-            return decorator;
-        };
-        decorator.InputPickFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.inputPickFields = fields);
-            return decorator;
-        };
-        decorator.InputOmitFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.inputOmitFields = fields);
-            return decorator;
-        };
-        decorator.InputOverwriteFields = (fields) => {
-            list.push(operationMeta => operationMeta.options.inputOverwriteFields = fields);
-            return decorator;
-        };
-        decorator.OutputPickFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.outputPickFields = fields);
-            return decorator;
-        };
-        decorator.OutputOmitFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.outputOmitFields = fields);
-            return decorator;
-        };
-        decorator.OutputOverwriteFields = (fields) => {
-            list.push(operationMeta => operationMeta.options.outputOverwriteFields = fields);
-            return decorator;
-        };
-        return decorator;
-    }
-    CollectionDecorator.Update = Update;
-})(CollectionDecorator || (CollectionDecorator = {}));
-/*
- * UpdateMany PropertyDecorator
- */
-(function (CollectionDecorator) {
-    function UpdateMany(arg0) {
-        const list = [];
-        const options = typeof arg0 === 'string' ? { description: arg0 } : { ...arg0 };
-        const decorator = createOperationDecorator('updateMany', options, list);
-        decorator.InputMaxContentSize = (sizeInBytes) => {
-            list.push(operationMeta => operationMeta.options.inputMaxContentSize = sizeInBytes);
-            return decorator;
-        };
-        decorator.InputPickFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.inputPickFields = fields);
-            return decorator;
-        };
-        decorator.InputOmitFields = (...fields) => {
-            list.push(operationMeta => operationMeta.options.inputOmitFields = fields);
-            return decorator;
-        };
-        decorator.InputOverwriteFields = (fields) => {
-            list.push(operationMeta => operationMeta.options.inputOverwriteFields = fields);
-            return decorator;
-        };
-        decorator.Filter = (field, operators, notes) => {
-            if (typeof operators === 'string')
-                operators = operators.split(/\s*[,| ]\s*/);
-            list.push(operationMeta => {
-                operationMeta.options.filters = operationMeta.options.filters || [];
-                operationMeta.options.filters.push(omitUndefined({ field, operators, notes }));
-            });
-            return decorator;
-        };
-        return decorator;
-    }
-    CollectionDecorator.UpdateMany = UpdateMany;
-})(CollectionDecorator || (CollectionDecorator = {}));

package/esm/document/resource/collection.js

@@ -1,21 +0,0 @@
-import merge from 'putil-merge';
-import { DECORATOR } from '../constants.js';
-import { CollectionClass } from './collection-class.js';
-import { CollectionDecorator } from './collection-decorator.js';
-/**
- * @class Collection
- * @decorator Collection
- */
-export const Collection = function (...args) {
-    // ClassDecorator
-    if (!this) {
-        const [type, options] = args;
-        return Collection[DECORATOR].call(undefined, type, options);
-    }
-    // Constructor
-    const [parent, init] = args;
-    merge(this, new CollectionClass(parent, init), { descriptor: true });
-};
-Collection.prototype = CollectionClass.prototype;
-Object.assign(Collection, CollectionDecorator);
-Collection[DECORATOR] = CollectionDecorator;

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

@@ -1,80 +0,0 @@
-import { NotAcceptableError, ResourceNotAvailableError } from '../../exception/index.js';
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { Resource } from './resource.js';
-const PATH_PREFIX_PATTERN = /^(\/*)(.+)$/;
-export class ContainerClass extends Resource {
-    constructor(owner, init) {
-        super(owner instanceof ContainerClass ? owner.document : owner, init);
-        this.kind = OpraSchema.Container.Kind;
-        this.resources = new ResponsiveMap();
-        this.parent = owner instanceof ContainerClass ? owner : undefined;
-    }
-    exportSchema(options) {
-        const schema = super.exportSchema(options);
-        if (this.resources.size) {
-            const resources = schema.resources = {};
-            for (const [name, r] of this.resources.entries()) {
-                resources[name] = r.exportSchema(options);
-            }
-        }
-        return schema;
-    }
-    getResource(path, silent) {
-        let resource;
-        path = PATH_PREFIX_PATTERN.exec(path)?.[2] || path;
-        if (path.includes('/')) {
-            const arr = path.split('/');
-            let i;
-            const l = arr.length;
-            let container = this;
-            for (i = 0; i < l; i++) {
-                resource = container.resources.get(arr[i]);
-                if (resource instanceof ContainerClass)
-                    container = resource;
-                else
-                    break;
-            }
-            // If no resource found or walking through path not completed
-            if (!resource || i < l - 1)
-                resource = undefined;
-        }
-        else
-            resource = this.resources.get(path);
-        if (resource || silent)
-            return resource;
-        throw new ResourceNotAvailableError(path);
-    }
-    getContainer(path, silent) {
-        const t = this.getResource(path);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.Container.Kind)
-            return t;
-        throw new NotAcceptableError(`Resource type "${t.name}" is not a Container`);
-    }
-    getCollection(path, silent) {
-        const t = this.getResource(path);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.Collection.Kind)
-            return t;
-        throw new NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
-    }
-    getSingleton(path, silent) {
-        const t = this.getResource(path);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.Singleton.Kind)
-            return t;
-        throw new NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
-    }
-    getStorage(path, silent) {
-        const t = this.getResource(path);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.Storage.Kind)
-            return t;
-        throw new NotAcceptableError(`Resource type "${t.name}" is not a Storage`);
-    }
-}

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

@@ -1,20 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { createActionDecorator } from './action-decorator.js';
-import { ResourceDecorator } from './resource-decorator.js';
-export function ContainerDecorator(options) {
-    return ResourceDecorator(OpraSchema.Container.Kind, options);
-}
-Object.assign(ContainerDecorator, ResourceDecorator);
-/*
- * Action PropertyDecorator
- */
-(function (ContainerDecorator) {
-    /**
-     * Action PropertyDecorator
-     */
-    function Action(options) {
-        const list = [];
-        return createActionDecorator(options, [], list);
-    }
-    ContainerDecorator.Action = Action;
-})(ContainerDecorator || (ContainerDecorator = {}));

package/esm/document/resource/container.js

@@ -1,25 +0,0 @@
-import merge from 'putil-merge';
-import { DECORATOR } from '../constants.js';
-import { ContainerClass } from './container-class.js';
-import { ContainerDecorator } from './container-decorator.js';
-/**
- * @class Container
- * @decorator Container
- */
-export const Container = function (...args) {
-    // ClassDecorator
-    if (!this) {
-        const [options] = args;
-        return Container[DECORATOR].call(undefined, options);
-    }
-    // Constructor
-    const [parent, init] = args;
-    merge(this, new ContainerClass(parent, init), { descriptor: true });
-    if (init.resources) {
-        const container = this;
-        init.resources.forEach(r => container.resources.set(r.name, r));
-    }
-};
-Container.prototype = ContainerClass.prototype;
-Object.assign(Container, ContainerDecorator);
-Container[DECORATOR] = ContainerDecorator;

package/esm/document/resource/crud-operation-decorator.js

@@ -1,24 +0,0 @@
-import { RESOURCE_METADATA } from '../constants.js';
-export function createOperationDecorator(operation, init, list) {
-    const decorator = ((target, propertyKey) => {
-        if (propertyKey !== operation)
-            throw new TypeError(`Name of the handler name should be '${operation}'`);
-        const resourceMetadata = (Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {});
-        resourceMetadata.operations = resourceMetadata.operations || {};
-        const operationMeta = { ...init };
-        operationMeta.options = operationMeta.options || {};
-        resourceMetadata.operations[operation] = operationMeta;
-        for (const fn of list)
-            fn(operationMeta, target, propertyKey);
-        Reflect.defineMetadata(RESOURCE_METADATA, resourceMetadata, target.constructor);
-    });
-    decorator.Parameter = (name, arg0) => {
-        const parameterOptions = typeof arg0 === 'string' || typeof arg0 === 'function' ? { type: arg0 } : { ...arg0 };
-        list.push((operationMeta) => {
-            operationMeta.parameters = operationMeta.parameters || {};
-            operationMeta.parameters[name] = { ...parameterOptions };
-        });
-        return decorator;
-    };
-    return decorator;
-}

package/esm/document/resource/crud-operation.js

@@ -1,41 +0,0 @@
-import { vg } from 'valgen';
-import { DataType } from '../data-type/data-type.js';
-import { ApiField } from '../data-type/field.js';
-import { Endpoint } from './endpoint.js';
-/**
- *
- * @class CrudOperation
- */
-export class CrudOperation extends Endpoint {
-    constructor(resource, name, init) {
-        super(resource, name, init);
-        this.resource = resource;
-        this.name = name;
-        this.kind = 'operation';
-        this.decodeInput = vg.isAny();
-        this.encodeReturning = vg.isAny();
-        this.returnType = init.returnType instanceof DataType
-            ? init.returnType : this.resource.document.getDataType(init.returnType || 'any');
-        this.encodeReturning = this.returnType.generateCodec('encode', { operation: 'read', partial: true });
-        this.inputOverwriteFields = init.options?.inputOverwriteFields;
-        this.outputOverwriteFields = init.options?.outputOverwriteFields;
-    }
-    exportSchema(options) {
-        const schema = super.exportSchema(options);
-        if (this.inputOverwriteFields) {
-            const trg = schema.options.inputOverwriteFields = {};
-            Object.keys(this.inputOverwriteFields)
-                .forEach(([k, o]) => {
-                trg[k] = ApiField.prototype.exportSchema.call(o, options);
-            });
-        }
-        if (this.outputOverwriteFields) {
-            const trg = schema.options.outputOverwriteFields = {};
-            Object.keys(this.outputOverwriteFields)
-                .forEach(([k, o]) => {
-                trg[k] = ApiField.prototype.exportSchema.call(o, options);
-            });
-        }
-        return schema;
-    }
-}