@opra/common 1.7.4 → 1.9.0

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

@@ -1,92 +1,30 @@
-import { HttpStatusCode, MimeTypes } from '../../enums/index.js';
 import { FilterRules } from '../../filter/filter-rules.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 { FIELD_PATH_PATTERN } from '../data-type/complex-type-base.js';
+import { EnumType } from '../data-type/enum-type.js';
+import { FilterType } from '../data-type/extended-types/index.js';
 import { HttpOperation } from '../http/http-operation.js';
-import { HttpOperationDecoratorFactory, } from './http-operation.decorator.js';
 /** Implementation **/
 HttpOperation.Entity = {};
 /**
- * HttpOperation.Entity.Create
+ *
+ * @param typ
  */
-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, {
-        method: 'POST',
-        ...args,
-        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,
-    });
-    decoratorChain.push((operationMeta) => {
-        const compositionOptions = (operationMeta.compositionOptions =
-            operationMeta.compositionOptions || {});
-        compositionOptions.type = getDataTypeName(args.type);
-    });
-    return decorator;
-};
+export 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`);
+}
 /**
- * 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, {
-        method: 'DELETE',
-        ...args,
-        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,
-    });
-    /**
-     *
-     */
-    decorator.KeyParam = (name, prmOptions) => {
+export function createKeyParamDecorator(decorator, decoratorChain) {
+    return (name, prmOptions) => {
         const paramMeta = typeof prmOptions === 'string' || typeof prmOptions === 'function'
             ? {
                 name,
@@ -108,468 +46,84 @@ HttpOperation.Entity.Delete = function (arg0, arg1) {
         });
         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, {
-        method: 'DELETE',
-        ...args,
-        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',
-    });
-    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, {
-        method: 'GET',
-        ...args,
-        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, maxValue: args.maxLimit }),
-    })
-        .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: ',',
-    });
-    decoratorChain.push((operationMeta) => {
-        const compositionOptions = (operationMeta.compositionOptions =
-            operationMeta.compositionOptions || {});
-        compositionOptions.type = getDataTypeName(args.type);
-        if (args.defaultLimit)
-            compositionOptions.defaultLimit = args.defaultLimit;
-        if (args.defaultProjection)
-            compositionOptions.defaultProjection = args.defaultProjection;
-        if (args.maxLimit)
-            compositionOptions.maxLimit = args.maxLimit;
-    });
-    decorator.DefaultSort = (...fields) => {
-        decoratorChain.push((operationMeta) => {
-            const compositionOptions = (operationMeta.compositionOptions =
-                operationMeta.compositionOptions || {});
-            compositionOptions.defaultSort = fields;
-        });
-        return decorator;
-    };
-    decorator.SortFields = (...fields) => {
+export function createSortFieldsDecorator(decorator, decoratorChain) {
+    return (...varargs) => {
+        const defObj = typeof varargs[0] === 'object'
+            ? varargs[0]
+            : varargs.reduce((acc, k) => {
+                const a = k.split(':');
+                acc[a[0]] = a[1] || a[0];
+                return acc;
+            }, {});
+        const fieldsMap = Object.keys(defObj).reduce((acc, k) => {
+            const m1 = FIELD_PATH_PATTERN.exec(k);
+            const m2 = FIELD_PATH_PATTERN.exec(defObj[k]);
+            if (m1 && m2) {
+                acc[m1[2]] = m2[2];
+            }
+            return acc;
+        }, {});
+        const prmEnum = Object.keys(defObj).reduce((acc, k) => {
+            const m = FIELD_PATH_PATTERN.exec(k);
+            if (m) {
+                if (m[1] != '-')
+                    acc[m[2]] = m[2];
+                if (m[1] != '+')
+                    acc['-' + m[2]] = '-' + m[2];
+            }
+            return acc;
+        }, {});
         decoratorChain.push((operationMeta) => {
             const compositionOptions = (operationMeta.compositionOptions =
                 operationMeta.compositionOptions || {});
-            compositionOptions.sortFields = fields;
+            compositionOptions.sortFields = fieldsMap;
         });
-        return decorator;
-    };
-    decorator.Filter = (field, operators, description) => {
-        decoratorChain.push(() => {
-            filterRules.set(field, { operators, description });
-            filterType.rules = filterRules.toJSON();
+        decorator.QueryParam('sort', {
+            description: 'Determines sort fields',
+            type: EnumType(prmEnum),
+            isArray: true,
+            arraySeparator: ',',
+            parser: (v) => v.map(x => {
+                const m = FIELD_PATH_PATTERN.exec(x);
+                return m ? (m[1] || '') + fieldsMap[m[2]] : x;
+            }),
         });
         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, {
-        method: 'GET',
-        ...args,
-        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,
-    });
-    /**
-     *
-     */
-    decorator.KeyParam = (name, prmOptions) => {
-        const paramMeta = typeof prmOptions === 'string' || typeof prmOptions === 'function'
-            ? {
-                name,
-                location: 'path',
-                type: prmOptions,
-                keyParam: true,
-            }
-            : {
-                ...prmOptions,
-                name,
-                location: 'path',
-                keyParam: true,
-            };
-        decorator.PathParam(name, paramMeta);
-        decoratorChain.push((meta) => {
-            if (!meta.path?.includes(':' + name))
-                meta.path = (meta.path || '') + '@:' + name;
-            meta.mergePath = true;
-        });
-        return decorator;
-    };
-    decoratorChain.push((operationMeta) => {
-        const compositionOptions = (operationMeta.compositionOptions =
-            operationMeta.compositionOptions || {});
-        compositionOptions.type = getDataTypeName(args.type);
-    });
-    return decorator;
-};
+}
 /**
- * HttpOperation.Entity.Replace
+ *
  */
-HttpOperation.Entity.Replace = function (arg0, arg1) {
-    let args;
-    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
-        args = arg0;
+export function createFilterDecorator(decorator, decoratorChain, dataType) {
+    let filterRules = Reflect.getMetadata('FilterRules', decorator);
+    if (!filterRules) {
+        filterRules = new FilterRules();
+        Reflect.defineMetadata('FilterRules', filterRules, decorator);
     }
-    else
-        args = { ...arg1, type: arg0 };
-    /** Initialize the decorator and the chain */
-    const decoratorChain = [];
-    const decorator = HttpOperationDecoratorFactory(decoratorChain, {
-        method: 'POST',
-        ...args,
-        composition: 'Entity.Replace',
-    });
-    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,
-    });
-    /**
-     *
-     */
-    decorator.KeyParam = (name, prmOptions) => {
-        const paramMeta = typeof prmOptions === 'string' || typeof prmOptions === 'function'
-            ? {
-                name,
-                location: 'path',
-                type: prmOptions,
-                keyParam: true,
-            }
-            : {
-                ...prmOptions,
-                name,
-                location: 'path',
-                keyParam: true,
-            };
-        decorator.PathParam(name, paramMeta);
-        decoratorChain.push((meta) => {
-            if (!meta.path?.includes(':' + name))
-                meta.path = (meta.path || '') + '@:' + name;
-            meta.mergePath = true;
-        });
-        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;
+    let filterType = Reflect.getMetadata('FilterType', decorator);
+    if (!filterType) {
+        filterType = new FilterType({ dataType });
+        filterType.rules = {};
+        Reflect.defineMetadata('FilterType', filterType, decorator);
     }
-    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, {
-        method: 'PATCH',
-        ...args,
-        composition: 'Entity.UpdateMany',
-        requestBody: {
-            immediateFetch: true,
-            partial: 'deep',
-            allowPatchOperators: true,
-            keepKeyFields: true,
-            ...args.requestBody,
-            required: true,
-        },
-    });
-    decorator
-        .RequestContent(args.requestBody?.type || args.type)
-        .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) => {
+    return (field, arg0) => {
+        const filterOptions = (Array.isArray(arg0)
+            ? { operators: arg0 }
+            : typeof arg0 === 'string'
+                ? { operators: [arg0] }
+                : arg0) || {};
         decoratorChain.push(() => {
-            filterRules.set(field, { operators, description });
+            filterRules.set(field, filterOptions);
             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, {
-        method: 'PATCH',
-        ...args,
-        composition: 'Entity.Update',
-        requestBody: {
-            partial: 'deep',
-            immediateFetch: true,
-            allowPatchOperators: true,
-            keepKeyFields: true,
-            ...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,
-    });
-    /**
-     *
-     */
-    decorator.KeyParam = (name, prmOptions) => {
-        const paramMeta = typeof prmOptions === 'string' || typeof prmOptions === 'function'
-            ? {
-                name,
-                location: 'path',
-                type: prmOptions,
-                keyParam: true,
-            }
-            : {
-                ...prmOptions,
-                name,
-                location: 'path',
-                keyParam: true,
-            };
-        decorator.PathParam(name, paramMeta);
-        decoratorChain.push((meta) => {
-            if (!meta.path?.includes(':' + name))
-                meta.path = (meta.path || '') + '@:' + name;
-            meta.mergePath = true;
+        decorator.QueryParam('filter', {
+            type: filterType,
+            description: 'Determines filter fields',
         });
         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`);
 }

package/esm/document/http/http-parameter.js

@@ -25,6 +25,7 @@ export const HttpParameter = function (owner, initArgs) {
         _this.required = true;
     _this.arraySeparator = initArgs.arraySeparator;
     _this.keyParam = initArgs.keyParam;
+    _this.parser = initArgs.parser;
 };
 /**
  * @class HttpParameter

package/esm/document/index.js

@@ -1,4 +1,13 @@
 import 'reflect-metadata';
+import './decorators/http-operation-entity.decorator.js';
+import './decorators/http-operation-entity-create.decorator.js';
+import './decorators/http-operation-entity-delete.decorator.js';
+import './decorators/http-operation-entity-delete-many.decorator.js';
+import './decorators/http-operation-entity-find-many.decorator.js';
+import './decorators/http-operation-entity-get.decorator.js';
+import './decorators/http-operation-entity-replace.decorator.js';
+import './decorators/http-operation-entity-update.decorator.js';
+import './decorators/http-operation-entity-update-many.decorator.js';
 import * as RpcControllerDecorator_ from './decorators/rpc-controller.decorator.js';
 import * as RpcOperationDecorator_ from './decorators/rpc-operation.decorator.js';
 import * as DataTypeFactory_ from './factory/data-type.factory.js';
@@ -24,7 +33,6 @@ export * from './data-type/pick-type.js';
 export * from './data-type/primitive-types/index.js';
 export * from './data-type/required-type.js';
 export * from './data-type/simple-type.js';
-export * from './decorators/http-operation-entity.decorator.js';
 export * from './factory/api-document.factory.js';
 export * from './http/http-api.js';
 export * from './http/http-controller.js';