@opra/common 1.0.0-alpha.1 → 1.0.0-alpha.2

package/esm/document/http/decorators/http-controller.decorator.js

@@ -1,112 +0,0 @@
-import omit from 'lodash.omit';
-import merge from 'putil-merge';
-import { OpraSchema } from '../../../schema/index.js';
-import { HTTP_CONTROLLER_METADATA } from '../../constants.js';
-const CLASS_NAME_PATTERN = /^(.*)(Collection|Singleton|Resource|Controller)$/;
-export function HttpControllerDecoratorFactory(options) {
-    const decoratorChain = [];
-    /**
-     *
-     */
-    const decorator = function (target) {
-        let name = options?.name;
-        if (!name)
-            name = CLASS_NAME_PATTERN.exec(target.name)?.[1] || target.name;
-        const metadata = {};
-        const baseMetadata = Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, Object.getPrototypeOf(target));
-        if (baseMetadata)
-            merge(metadata, baseMetadata, { deep: true });
-        const oldMetadata = Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target);
-        if (oldMetadata)
-            merge(metadata, oldMetadata, { deep: true });
-        merge(metadata, {
-            kind: OpraSchema.HttpController.Kind,
-            name,
-            path: name,
-            ...omit(options, ['kind', 'name', 'instance', 'endpoints', 'key']),
-        }, { deep: true });
-        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, metadata, target);
-        for (const fn of decoratorChain)
-            fn(metadata);
-        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, metadata, target);
-    };
-    /**
-     *
-     */
-    decorator.Cookie = (name, arg1) => {
-        decoratorChain.push((meta) => {
-            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
-                ? {
-                    name,
-                    location: 'cookie',
-                    type: arg1,
-                }
-                : { ...arg1, name, location: 'cookie' };
-            meta.parameters = meta.parameters || [];
-            meta.parameters.push(paramMeta);
-        });
-        return decorator;
-    };
-    /**
-     *
-     */
-    decorator.Header = (name, arg1) => {
-        decoratorChain.push((meta) => {
-            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
-                ? {
-                    name,
-                    location: 'header',
-                    type: arg1,
-                }
-                : { ...arg1, name, location: 'header' };
-            meta.parameters = meta.parameters || [];
-            meta.parameters.push(paramMeta);
-        });
-        return decorator;
-    };
-    /**
-     *
-     */
-    decorator.QueryParam = (name, arg1) => {
-        decoratorChain.push((meta) => {
-            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
-                ? {
-                    name,
-                    location: 'query',
-                    type: arg1,
-                }
-                : { ...arg1, name, location: 'query' };
-            meta.parameters = meta.parameters || [];
-            meta.parameters.push(paramMeta);
-        });
-        return decorator;
-    };
-    /**
-     *
-     */
-    decorator.PathParam = (name, arg1) => {
-        decoratorChain.push((meta) => {
-            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
-                ? {
-                    name,
-                    location: 'path',
-                    type: arg1,
-                }
-                : { ...arg1, name, location: 'path' };
-            meta.parameters = meta.parameters || [];
-            meta.parameters.push(paramMeta);
-        });
-        return decorator;
-    };
-    /**
-     *
-     */
-    decorator.UseType = (...type) => {
-        decoratorChain.push((meta) => {
-            meta.types = meta.types || [];
-            meta.types.push(...type);
-        });
-        return decorator;
-    };
-    return decorator;
-}

package/esm/document/http/decorators/http-operation-entity.decorator.js

@@ -1,459 +0,0 @@
-import { FilterRules } from '../../../filter/filter-rules.js';
-import { omitUndefined } from '../../../helpers/index.js';
-import { HttpStatusCode, MimeTypes } from '../../../http/index.js';
-import { DATATYPE_METADATA } from '../../constants.js';
-import { FieldPathType, FilterType } from '../../data-type/extended-types/index.js';
-import { IntegerType } from '../../data-type/primitive-types/index.js';
-import { HttpOperation } from '../http-operation.js';
-import { HttpOperationDecoratorFactory } from './http-operation.decorator.js';
-/** Implementation **/
-HttpOperation.Entity = {};
-/**
- * HttpOperation.Entity.Create
- */
-HttpOperation.Entity.Create = function (arg0, arg1) {
-    let args;
-    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
-        args = arg0;
-    }
-    else
-        args = { ...arg1, type: arg0 };
-    /** Initialize the decorator and the chain */
-    const decoratorChain = [];
-    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
-        method: 'POST',
-        composition: 'Entity.Create',
-        requestBody: {
-            immediateFetch: true,
-            ...args.requestBody,
-            required: true,
-        },
-    }));
-    decorator
-        .QueryParam('projection', {
-        description: 'Determines fields projection',
-        type: new FieldPathType({
-            dataType: args.type,
-            allowSigns: 'each',
-        }),
-        isArray: true,
-        arraySeparator: ',',
-    })
-        .RequestContent(args.requestBody?.type || args.type)
-        .Response(HttpStatusCode.CREATED, {
-        description: 'Operation is successful. Returns OperationResult with "payload" field that contains the created resource.',
-        contentType: MimeTypes.opra_response_json,
-        type: args.type,
-        partial: 'deep',
-    })
-        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
-        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
-        contentType: MimeTypes.opra_response_json,
-    });
-    if (typeof args.type === 'function')
-        decorator.UseType(args.type);
-    decoratorChain.push((operationMeta) => {
-        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
-        compositionOptions.type = getDataTypeName(args.type);
-    });
-    return decorator;
-};
-/**
- * HttpOperation.Entity.Delete
- */
-HttpOperation.Entity.Delete = function (arg0, arg1) {
-    let args;
-    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
-        args = arg0;
-    }
-    else
-        args = { ...arg1, type: arg0 };
-    /** Initialize the decorator and the chain */
-    const decoratorChain = [];
-    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
-        method: 'DELETE',
-        composition: 'Entity.Delete',
-    }));
-    decorator
-        .Response(HttpStatusCode.OK, {
-        description: 'Operation is successful. Returns OperationResult with "affected" field.',
-        contentType: MimeTypes.opra_response_json,
-    })
-        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
-        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
-        contentType: MimeTypes.opra_response_json,
-    });
-    if (typeof args.type === 'function')
-        decorator.UseType(args.type);
-    /**
-     *
-     */
-    decorator.KeyParam = (name, prmOptions) => {
-        decorator.PathParam(name, prmOptions);
-        decoratorChain.push((meta) => {
-            meta.path = (meta.path || '') + '@:' + name;
-            meta.compositionOptions = meta.compositionOptions || {};
-            meta.compositionOptions.keyParameter = name;
-        });
-        return decorator;
-    };
-    decoratorChain.push((operationMeta) => {
-        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
-        compositionOptions.type = getDataTypeName(args.type);
-    });
-    return decorator;
-};
-/**
- * HttpOperation.Entity.DeleteMany
- */
-HttpOperation.Entity.DeleteMany = function (arg0, arg1) {
-    let args;
-    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
-        args = arg0;
-    }
-    else
-        args = { ...arg1, type: arg0 };
-    /** Initialize the decorator and the chain */
-    const decoratorChain = [];
-    const filterRules = new FilterRules();
-    const filterType = new FilterType({ dataType: args.type });
-    filterType.rules = {};
-    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
-        method: 'DELETE',
-        composition: 'Entity.DeleteMany',
-    }));
-    decorator
-        .Response(HttpStatusCode.OK, {
-        description: 'Operation is successful. Returns OperationResult with "affected" field.',
-        contentType: MimeTypes.opra_response_json,
-    })
-        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
-        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
-        contentType: MimeTypes.opra_response_json,
-    })
-        .QueryParam('filter', {
-        type: filterType,
-        description: 'Determines filter fields',
-    });
-    if (typeof args.type === 'function')
-        decorator.UseType(args.type);
-    decoratorChain.push((operationMeta) => {
-        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
-        compositionOptions.type = getDataTypeName(args.type);
-    });
-    decorator.Filter = (field, operators, description) => {
-        decoratorChain.push(() => {
-            filterRules.set(field, { operators, description });
-            filterType.rules = filterRules.toJSON();
-        });
-        return decorator;
-    };
-    return decorator;
-};
-/**
- * HttpOperation.Entity.FindMany
- */
-HttpOperation.Entity.FindMany = function (arg0, arg1) {
-    let args;
-    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
-        args = arg0;
-    }
-    else
-        args = { ...arg1, type: arg0 };
-    /** Initialize the decorator and the chain */
-    const decoratorChain = [];
-    const filterRules = new FilterRules();
-    const filterType = new FilterType({ dataType: args.type });
-    filterType.rules = {};
-    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
-        method: 'GET',
-        composition: 'Entity.FindMany',
-    }));
-    decorator
-        .Response(HttpStatusCode.OK, {
-        description: 'Operation is successful. Returns OperationResult with "payload" field that contains list of resources.',
-        contentType: MimeTypes.opra_response_json,
-        type: args.type,
-        partial: 'deep',
-        isArray: true,
-    })
-        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
-        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
-        contentType: MimeTypes.opra_response_json,
-    })
-        .QueryParam('limit', {
-        description: 'Determines number of returning instances',
-        type: new IntegerType({ minValue: 1 }),
-    })
-        .QueryParam('skip', {
-        description: 'Determines number of returning instances',
-        type: new IntegerType({ minValue: 1 }),
-    })
-        .QueryParam('count', {
-        description: 'Counts all matching instances if enabled',
-        type: Boolean,
-    })
-        .QueryParam('projection', {
-        description: 'Determines fields projection',
-        type: new FieldPathType({
-            dataType: args.type,
-            allowSigns: 'each',
-        }),
-        isArray: true,
-        arraySeparator: ',',
-    })
-        .QueryParam('filter', {
-        type: filterType,
-        description: 'Determines filter fields',
-    })
-        .QueryParam('sort', {
-        description: 'Determines sort fields',
-        type: new FieldPathType({
-            dataType: args.type,
-            allowSigns: 'first',
-        }),
-        isArray: true,
-        arraySeparator: ',',
-    });
-    if (typeof args.type === 'function')
-        decorator.UseType(args.type);
-    decoratorChain.push((operationMeta) => {
-        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
-        compositionOptions.type = getDataTypeName(args.type);
-    });
-    decorator.DefaultSort = (...fields) => {
-        decoratorChain.push((operationMeta) => {
-            const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
-            compositionOptions.defaultSort = fields;
-        });
-        return decorator;
-    };
-    decorator.SortFields = (...fields) => {
-        decoratorChain.push((operationMeta) => {
-            const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
-            compositionOptions.sortFields = fields;
-        });
-        return decorator;
-    };
-    decorator.Filter = (field, operators, description) => {
-        decoratorChain.push(() => {
-            filterRules.set(field, { operators, description });
-            filterType.rules = filterRules.toJSON();
-        });
-        return decorator;
-    };
-    return decorator;
-};
-/**
- * HttpOperation.Entity.Get
- */
-HttpOperation.Entity.Get = function (arg0, arg1) {
-    let args;
-    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
-        args = arg0;
-    }
-    else
-        args = { ...arg1, type: arg0 };
-    /** Initialize the decorator and the chain */
-    const decoratorChain = [];
-    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
-        method: 'GET',
-        composition: 'Entity.Get',
-    }));
-    decorator
-        .QueryParam('projection', {
-        description: 'Determines fields projection',
-        type: new FieldPathType({
-            dataType: args.type,
-            allowSigns: 'each',
-        }),
-        isArray: true,
-        arraySeparator: ',',
-    })
-        .Response(HttpStatusCode.OK, {
-        description: 'Operation is successful. Returns OperationResult with "payload" field that contains the resource asked for.',
-        contentType: MimeTypes.opra_response_json,
-        type: args.type,
-        partial: 'deep',
-    })
-        .Response(HttpStatusCode.NO_CONTENT, {
-        description: 'Operation is successful but no resource found',
-    })
-        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
-        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
-        contentType: MimeTypes.opra_response_json,
-    });
-    if (typeof args.type === 'function')
-        decorator.UseType(args.type);
-    /**
-     *
-     */
-    decorator.KeyParam = (name, prmOptions) => {
-        decorator.PathParam(name, prmOptions);
-        decoratorChain.push((meta) => {
-            meta.path = (meta.path || '') + '@:' + name;
-            meta.compositionOptions = meta.compositionOptions || {};
-            meta.compositionOptions.keyParameter = name;
-        });
-        return decorator;
-    };
-    decoratorChain.push((operationMeta) => {
-        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
-        compositionOptions.type = getDataTypeName(args.type);
-    });
-    return decorator;
-};
-/**
- * HttpOperation.Entity.UpdateMany
- */
-HttpOperation.Entity.UpdateMany = function (arg0, arg1) {
-    let args;
-    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
-        args = arg0;
-    }
-    else
-        args = { ...arg1, type: arg0 };
-    /** Initialize the decorator and the chain */
-    const decoratorChain = [];
-    const filterType = new FilterType({ dataType: args.type });
-    filterType.rules = {};
-    const filterRules = new FilterRules();
-    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
-        method: 'PATCH',
-        composition: 'Entity.UpdateMany',
-        requestBody: {
-            immediateFetch: true,
-            partial: 'deep',
-            ...args.requestBody,
-            required: true,
-        },
-    }));
-    decorator.RequestContent(args.requestBody?.type || args.type);
-    if (typeof args.type === 'function')
-        decorator.UseType(args.type);
-    decorator
-        .Response(HttpStatusCode.OK, {
-        description: 'Operation is successful. Returns OperationResult with "affected" field.',
-        contentType: MimeTypes.opra_response_json,
-    })
-        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
-        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
-        contentType: MimeTypes.opra_response_json,
-    })
-        .QueryParam('filter', {
-        type: filterType,
-        description: 'Determines filter fields',
-    });
-    decoratorChain.push((operationMeta) => {
-        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
-        compositionOptions.type = getDataTypeName(args.type);
-    });
-    decorator.Filter = (field, operators, description) => {
-        decoratorChain.push(() => {
-            filterRules.set(field, { operators, description });
-            filterType.rules = filterRules.toJSON();
-        });
-        return decorator;
-    };
-    return decorator;
-};
-/**
- * HttpOperation.Entity.Update
- */
-HttpOperation.Entity.Update = function (arg0, arg1) {
-    let args;
-    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
-        args = arg0;
-    }
-    else
-        args = { ...arg1, type: arg0 };
-    /** Initialize the decorator and the chain */
-    const decoratorChain = [];
-    const filterRules = new FilterRules();
-    const filterType = new FilterType({ dataType: args.type });
-    filterType.rules = {};
-    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
-        method: 'PATCH',
-        composition: 'Entity.Update',
-        requestBody: {
-            partial: 'deep',
-            ...args.requestBody,
-            required: true,
-        },
-    }));
-    decorator
-        .QueryParam('projection', {
-        description: 'Determines fields projection',
-        type: new FieldPathType({
-            dataType: args.type,
-            allowSigns: 'each',
-        }),
-        isArray: true,
-        arraySeparator: ',',
-    })
-        .QueryParam('filter', {
-        type: filterType,
-        description: 'Determines filter fields',
-    })
-        .RequestContent(args.requestBody?.type || args.type)
-        .Response(HttpStatusCode.OK, {
-        description: 'Operation is successful. Returns OperationResult with "payload" field that contains updated resource.',
-        contentType: MimeTypes.opra_response_json,
-        type: args.type,
-        partial: 'deep',
-    })
-        .Response(HttpStatusCode.NO_CONTENT, {
-        description: 'Operation is successful but no resource found',
-    })
-        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
-        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
-        contentType: MimeTypes.opra_response_json,
-    });
-    if (typeof args.type === 'function')
-        decorator.UseType(args.type);
-    /**
-     *
-     */
-    decorator.KeyParam = (name, prmOptions) => {
-        decorator.PathParam(name, prmOptions);
-        decoratorChain.push((meta) => {
-            meta.path = (meta.path || '') + '@:' + name;
-            meta.compositionOptions = meta.compositionOptions || {};
-            meta.compositionOptions.keyParameter = name;
-        });
-        return decorator;
-    };
-    decoratorChain.push((operationMeta) => {
-        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
-        compositionOptions.type = getDataTypeName(args.type);
-    });
-    decorator.Filter = (field, operators, description) => {
-        decoratorChain.push(() => {
-            filterRules.set(field, { operators, description });
-            filterType.rules = filterRules.toJSON();
-        });
-        return decorator;
-    };
-    return decorator;
-};
-/**
- *
- * @param typ
- */
-function getDataTypeName(typ) {
-    if (typeof typ === 'string')
-        return typ;
-    const metadata = Reflect.getMetadata(DATATYPE_METADATA, typ);
-    if (!metadata)
-        throw new TypeError(`Type (${typ}) is not decorated with any datatype decorators`);
-    if (metadata?.name)
-        return metadata.name;
-    throw new TypeError(`You should provide named data type but embedded one found`);
-}