@opra/common 1.7.4 → 1.9.0

package/cjs/filter/antlr/OpraFilterVisitor.js

@@ -1,5 +1,5 @@
 "use strict";
-// Generated from ./src/filter/antlr/OpraFilter.g4 by ANTLR 4.12.0
+// Generated from ./src/filter/antlr/OpraFilter.g4 by ANTLR 4.13.2
 Object.defineProperty(exports, "__esModule", { value: true });
 const antlr4_1 = require("@browsery/antlr4");
 /**

package/cjs/filter/ast/index.js

@@ -13,6 +13,7 @@ tslib_1.__exportStar(require("./expressions/negative-expression.js"), exports);
 tslib_1.__exportStar(require("./expressions/parenthesized-expression.js"), exports);
 tslib_1.__exportStar(require("./terms/boolean-literal.js"), exports);
 tslib_1.__exportStar(require("./terms/date-literal.js"), exports);
+tslib_1.__exportStar(require("./terms/date-time-literal.js"), exports);
 tslib_1.__exportStar(require("./terms/null-literal.js"), exports);
 tslib_1.__exportStar(require("./terms/number-literal.js"), exports);
 tslib_1.__exportStar(require("./terms/qualified-identifier.js"), exports);

package/cjs/filter/ast/terms/date-time-literal.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTimeLiteral = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+const errors_js_1 = require("../../errors.js");
+const utils_js_1 = require("../../utils.js");
+const literal_js_1 = require("../abstract/literal.js");
+const NullDate = new Date(0);
+class DateTimeLiteral extends literal_js_1.Literal {
+    constructor(value) {
+        super('');
+        if (value instanceof Date) {
+            this.value = value.toISOString();
+            return;
+        }
+        // noinspection SuspiciousTypeOfGuard
+        if (typeof value === 'string' && (0, putil_varhelpers_1.toDateDef)(value, NullDate) !== NullDate) {
+            this.value = value;
+            return;
+        }
+        throw new errors_js_1.FilterValidationError(`Invalid date-time value "${value}"`);
+    }
+    toString() {
+        return (0, utils_js_1.quoteFilterString)(this.value);
+    }
+}
+exports.DateTimeLiteral = DateTimeLiteral;

package/cjs/filter/build.js

@@ -104,7 +104,9 @@ function $arithmetic(n) {
     return exp;
 }
 function comparisonExpression(op, left, right) {
-    const lex = wrapEntryValue(left);
+    const lex = typeof left === 'string'
+        ? new index_js_1.QualifiedIdentifier(left)
+        : wrapEntryValue(left);
     const rex = wrapEntryValue(right);
     return new index_js_1.ComparisonExpression({ op, left: lex, right: rex });
 }

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/cjs/filter/filter-tree-visitor.js

@@ -85,7 +85,7 @@ class FilterTreeVisitor extends antlr4_1.ParseTreeVisitor {
         return new index_js_1.DateLiteral((0, utils_js_1.unquoteFilterString)(ctx.getText()));
     }
     visitDateTimeLiteral(ctx) {
-        return new index_js_1.DateLiteral((0, utils_js_1.unquoteFilterString)(ctx.getText()));
+        return new index_js_1.DateTimeLiteral((0, utils_js_1.unquoteFilterString)(ctx.getText()));
     }
     visitTimeLiteral(ctx) {
         return new index_js_1.TimeLiteral((0, utils_js_1.unquoteFilterString)(ctx.getText()));

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

@@ -33,6 +33,7 @@ export const ApiField = function (...args) {
     _this.type = initArgs.type || owner.node.getDataType('any');
     _this.description = initArgs.description;
     _this.isArray = initArgs.isArray;
+    _this.isNestedEntity = initArgs.isNestedEntity;
     _this.default = initArgs.default;
     _this.fixed = initArgs.fixed;
     _this.required = initArgs.required;
@@ -93,6 +94,7 @@ class ApiFieldClass extends DocumentElement {
             type: typeName ? typeName : this.type?.toJSON(options),
             description: this.description,
             isArray: this.isArray || undefined,
+            isNestedEntity: this.isNestedEntity || undefined,
             default: this.default,
             fixed: this.fixed,
             required: this.required || undefined,

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/api-field-decorator.js

@@ -37,6 +37,7 @@ export function ApiFieldDecoratorFactory(options) {
                 scopePattern: Array.isArray(scopes) ? scopes : [scopes],
                 type: undefined,
                 isArray: undefined,
+                isNestedEntity: undefined,
             }));
         });
         return decorator;

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;
+};