@opra/common 1.8.0 → 1.9.1

package/cjs/filter/filter-rules.js

@@ -44,7 +44,6 @@ class FilterRules {
                 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 rule = this._rules.get(ast.left.value);
             if (!rule) {
                 throw new index_js_1.OpraException({
@@ -70,6 +69,8 @@ class FilterRules {
                     },
                 });
             }
+            if (rule.prepare)
+                ast.prepare = rule.prepare;
             this.normalizeFilterAst(ast.right, stack, currentType);
             stack.pop();
             return ast;

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

@@ -105,8 +105,8 @@ function EnumTypeFactory(enumSource, ...args) {
     const metadata = {
         kind: OpraSchema.EnumType.Kind,
         attributes,
-        base: options.base,
-        name: options.name,
+        base: options?.base,
+        name: options?.name,
         description: options?.description,
     };
     Object.defineProperty(enumSource, DATATYPE_METADATA, {

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

@@ -0,0 +1,56 @@
+import { HttpStatusCode, MimeTypes } from '../../enums/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { FieldPathType } from '../data-type/extended-types/index.js';
+import { HttpOperation } from '../http/http-operation.js';
+import { HttpOperationDecoratorFactory } from './http-operation.decorator.js';
+import { getDataTypeName } from './http-operation-entity.decorator.js';
+/**
+ *
+ */
+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;
+};

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

@@ -0,0 +1,39 @@
+import { HttpStatusCode, MimeTypes } from '../../enums/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { HttpOperation } from '../http/http-operation.js';
+import { HttpOperationDecoratorFactory } from './http-operation.decorator.js';
+import { createFilterDecorator, getDataTypeName, } from './http-operation-entity.decorator.js';
+/**
+ * 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 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,
+    });
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions =
+            operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    decorator.Filter = createFilterDecorator(decorator, decoratorChain, args.type);
+    return decorator;
+};

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

@@ -0,0 +1,39 @@
+import { HttpStatusCode, MimeTypes } from '../../enums/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { HttpOperation } from '../http/http-operation.js';
+import { HttpOperationDecoratorFactory } from './http-operation.decorator.js';
+import { createKeyParamDecorator, getDataTypeName, } from './http-operation-entity.decorator.js';
+/**
+ * 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,
+    });
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions =
+            operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    decorator.KeyParam = createKeyParamDecorator(decorator, decoratorChain);
+    return decorator;
+};

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

@@ -0,0 +1,83 @@
+import { HttpStatusCode, MimeTypes } from '../../enums/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { FieldPathType } from '../data-type/extended-types/index.js';
+import { IntegerType } from '../data-type/primitive-types/index.js';
+import { HttpOperation } from '../http/http-operation.js';
+import { HttpOperationDecoratorFactory } from './http-operation.decorator.js';
+import { createFilterDecorator, createSortFieldsDecorator, getDataTypeName, } from './http-operation-entity.decorator.js';
+/**
+ * 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 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: ',',
+    });
+    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.Filter = createFilterDecorator(decorator, decoratorChain, args.type);
+    /**
+     *
+     */
+    decorator.DefaultSort = (...fields) => {
+        decoratorChain.push((operationMeta) => {
+            const compositionOptions = (operationMeta.compositionOptions =
+                operationMeta.compositionOptions || {});
+            compositionOptions.defaultSort = fields;
+        });
+        return decorator;
+    };
+    decorator.SortFields = createSortFieldsDecorator(decorator, decoratorChain);
+    return decorator;
+};

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

@@ -0,0 +1,54 @@
+import { HttpStatusCode, MimeTypes } from '../../enums/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { FieldPathType } from '../data-type/extended-types/index.js';
+import { HttpOperation } from '../http/http-operation.js';
+import { HttpOperationDecoratorFactory } from './http-operation.decorator.js';
+import { createKeyParamDecorator, getDataTypeName, } from './http-operation-entity.decorator.js';
+/**
+ * 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,
+    });
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions =
+            operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    decorator.KeyParam = createKeyParamDecorator(decorator, decoratorChain);
+    return decorator;
+};

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

@@ -0,0 +1,54 @@
+import { HttpStatusCode, MimeTypes } from '../../enums/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { FieldPathType } from '../data-type/extended-types/index.js';
+import { HttpOperation } from '../http/http-operation.js';
+import { HttpOperationDecoratorFactory } from './http-operation.decorator.js';
+import { createKeyParamDecorator, getDataTypeName, } from './http-operation-entity.decorator.js';
+/**
+ * HttpOperation.Entity.Replace
+ */
+HttpOperation.Entity.Replace = 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.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,
+    });
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions =
+            operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    decorator.KeyParam = createKeyParamDecorator(decorator, decoratorChain);
+    return decorator;
+};

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

@@ -0,0 +1,48 @@
+import { HttpStatusCode, MimeTypes } from '../../enums/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { HttpOperation } from '../http/http-operation.js';
+import { HttpOperationDecoratorFactory } from './http-operation.decorator.js';
+import { createFilterDecorator, getDataTypeName, } from './http-operation-entity.decorator.js';
+/**
+ * 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 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,
+    });
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions =
+            operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    decorator.Filter = createFilterDecorator(decorator, decoratorChain, args.type);
+    return decorator;
+};

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

@@ -0,0 +1,64 @@
+import { HttpStatusCode, MimeTypes } from '../../enums/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { FieldPathType } from '../data-type/extended-types/index.js';
+import { HttpOperation } from '../http/http-operation.js';
+import { HttpOperationDecoratorFactory } from './http-operation.decorator.js';
+import { createFilterDecorator, createKeyParamDecorator, getDataTypeName, } from './http-operation-entity.decorator.js';
+/**
+ * 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 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: ',',
+    })
+        .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,
+    });
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions =
+            operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    decorator.KeyParam = createKeyParamDecorator(decorator, decoratorChain);
+    decorator.Filter = createFilterDecorator(decorator, decoratorChain, args.type);
+    return decorator;
+};