@opra/common 0.28.0 → 0.29.0

package/cjs/document/resource/endpoint.js

@@ -12,6 +12,7 @@ class Endpoint {
     constructor(resource, name, init) {
         this.resource = resource;
         this.name = name;
+        this.options = {};
         Object.assign(this, init);
         this.parameters = new index_js_1.ResponsiveMap();
         if (init.parameters) {
@@ -38,12 +39,19 @@ class Endpoint {
         const schema = (0, index_js_1.omitUndefined)({
             description: this.description
         });
+        if (Object.keys(this.options).length)
+            schema.options = { ...this.options };
         if (this.parameters.size) {
-            schema.parameters = {};
+            let i = 0;
+            const parameters = {};
             for (const [name, param] of this.parameters.entries()) {
-                if (!param.isBuiltin)
-                    schema.parameters[name] = param.exportSchema(options);
+                if (!param.isBuiltin) {
+                    parameters[name] = param.exportSchema(options);
+                    i++;
+                }
             }
+            if (i)
+                schema.parameters = parameters;
         }
         return schema;
     }

package/cjs/document/resource/singleton-class.js

@@ -16,14 +16,18 @@ class SingletonClass extends crud_resource_js_1.CrudResource {
             endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
             endpoint.decodeInput = this.type.generateCodec('decode', {
                 partial: true,
-                pick: endpoint.inputPickFields,
-                omit: endpoint.inputOmitFields,
+                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.outputPickFields,
-                omit: endpoint.outputOmitFields,
+                pick: endpoint.options.outputPickFields,
+                omit: endpoint.options.outputOmitFields,
+                operation: 'read',
+                overwriteFields: endpoint.outputOverwriteFields
             });
         }
         // ------------------
@@ -35,8 +39,10 @@ class SingletonClass extends crud_resource_js_1.CrudResource {
             endpoint.returnType = this.type;
             endpoint.encodeReturning = endpoint.returnType.generateCodec('encode', {
                 partial: true,
-                pick: endpoint.outputPickFields,
-                omit: endpoint.outputOmitFields,
+                pick: endpoint.options.outputPickFields,
+                omit: endpoint.options.outputOmitFields,
+                operation: 'read',
+                overwriteFields: endpoint.outputOverwriteFields
             });
         }
         // ------------------
@@ -46,14 +52,18 @@ class SingletonClass extends crud_resource_js_1.CrudResource {
             endpoint.defineParameter('omit', { type: 'string', isArray: true, isBuiltin: true });
             endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
             endpoint.decodeInput = this.type.generateCodec('decode', {
-                pick: endpoint.inputPickFields,
-                omit: endpoint.inputOmitFields,
+                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.outputPickFields,
-                omit: endpoint.outputOmitFields,
+                pick: endpoint.options.outputPickFields,
+                omit: endpoint.options.outputOmitFields,
+                operation: 'read',
+                overwriteFields: endpoint.outputOverwriteFields
             });
         }
     }

package/cjs/document/resource/storage-decorator.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageDecorator = void 0;
 const index_js_1 = require("../../schema/index.js");
 const action_decorator_js_1 = require("./action-decorator.js");
-const operation_decorator_js_1 = require("./operation-decorator.js");
+const crud_operation_decorator_js_1 = require("./crud-operation-decorator.js");
 const resource_decorator_js_1 = require("./resource-decorator.js");
 const operationProperties = ['delete', 'get', 'post'];
 function StorageDecorator(options) {
@@ -25,39 +25,39 @@ Object.assign(StorageDecorator, resource_decorator_js_1.ResourceDecorator);
     StorageDecorator.Action = Action;
     function Delete(options) {
         const list = [];
-        return (0, operation_decorator_js_1.createOperationDecorator)('delete', options, list);
+        return (0, crud_operation_decorator_js_1.createOperationDecorator)('delete', options, list);
     }
     StorageDecorator.Delete = Delete;
     function Get(options) {
         const list = [];
-        return (0, operation_decorator_js_1.createOperationDecorator)('get', options, list);
+        return (0, crud_operation_decorator_js_1.createOperationDecorator)('get', options, list);
     }
     StorageDecorator.Get = Get;
     function Post(options) {
         const list = [];
-        const decorator = (0, operation_decorator_js_1.createOperationDecorator)('post', options, list);
+        const decorator = (0, crud_operation_decorator_js_1.createOperationDecorator)('post', options, list);
         decorator.MaxFields = (amount) => {
-            list.push(operationMeta => operationMeta.maxFields = amount);
+            list.push(operationMeta => operationMeta.options.maxFields = amount);
             return decorator;
         };
         decorator.MaxFieldSize = (amount) => {
-            list.push(operationMeta => operationMeta.maxFieldsSize = amount);
+            list.push(operationMeta => operationMeta.options.maxFieldsSize = amount);
             return decorator;
         };
         decorator.MaxFiles = (amount) => {
-            list.push(operationMeta => operationMeta.maxFiles = amount);
+            list.push(operationMeta => operationMeta.options.maxFiles = amount);
             return decorator;
         };
         decorator.MaxFileSize = (sizeInBytes) => {
-            list.push(operationMeta => operationMeta.maxFileSize = sizeInBytes);
+            list.push(operationMeta => operationMeta.options.maxFileSize = sizeInBytes);
             return decorator;
         };
         decorator.MaxTotalFileSize = (sizeInBytes) => {
-            list.push(operationMeta => operationMeta.maxTotalFileSize = sizeInBytes);
+            list.push(operationMeta => operationMeta.options.maxTotalFileSize = sizeInBytes);
             return decorator;
         };
         decorator.MinFileSize = (sizeInBytes) => {
-            list.push(operationMeta => operationMeta.minFileSize = sizeInBytes);
+            list.push(operationMeta => operationMeta.options.minFileSize = sizeInBytes);
             return decorator;
         };
         return decorator;

package/esm/document/data-type/complex-type-class.js

@@ -11,6 +11,7 @@ export class ComplexTypeClass extends DataType {
     constructor(document, init) {
         super(document, init);
         this.kind = OpraSchema.ComplexType.Kind;
+        this.fields = new ResponsiveMap();
         const own = this.own = {};
         own.ctor = init.ctor;
         if (init.base) {
@@ -29,7 +30,6 @@ export class ComplexTypeClass extends DataType {
             this.additionalFields = true;
         else if (this.base?.additionalFields === 'error' && !this.additionalFields)
             this.additionalFields = 'error';
-        this.fields = new ResponsiveMap();
         if (this.base) {
             if (this.base.fields)
                 for (const [k, el] of this.base.fields.entries()) {
@@ -130,7 +130,11 @@ export class ComplexTypeClass extends DataType {
             base: this.base ?
                 (this.base.name ? this.base.name : this.base.exportSchema(options)) : undefined,
             abstract: this.abstract,
-            additionalFields: this.own.additionalFields
+            additionalFields: this.own.additionalFields instanceof DataType
+                ? (this.own.additionalFields.name
+                    ? this.own.additionalFields.name
+                    : this.own.additionalFields.exportSchema(options))
+                : this.own.additionalFields
         }));
         if (this.own.fields.size) {
             const fields = out.fields = {};
@@ -154,9 +158,12 @@ export class ComplexTypeClass extends DataType {
     }
     generateCodec(codec, options) {
         const schema = this._generateCodecSchema(codec, options);
+        const additionalFields = this.additionalFields instanceof DataType
+            ? this.additionalFields.generateCodec(codec, options)
+            : this.additionalFields;
         return vg.isObject(schema, {
             ctor: this.ctor,
-            additionalFields: this.additionalFields ?? false,
+            additionalFields,
             name: this.name,
             caseInSensitive: !options?.caseSensitive
         });
@@ -165,20 +172,36 @@ export class ComplexTypeClass extends DataType {
         const schema = {};
         const pickOption = (options?.pick || []).map(x => x.toLowerCase());
         const omitOption = (options?.omit || []).map(x => x.toLowerCase());
-        for (const f of this.fields.values()) {
-            const nameLower = f.name.toLowerCase();
-            if (omitOption.find(x => x === nameLower))
+        const dedupedFieldNames = (options?.overwriteFields
+            ? Array.from(new Set([...this.fields.keys(), ...options?.overwriteFields.keys()]))
+            : Array.from(this.fields.keys())).map(x => x.toLocaleString());
+        for (const nameLower of dedupedFieldNames) {
+            const overwriteField = options?.overwriteFields?.get(nameLower);
+            const field = this.fields.get(nameLower);
+            /* istanbul ignore next */
+            if (!(field || overwriteField))
                 continue;
-            if (pickOption.length && !pickOption.find(x => x === nameLower || x.startsWith(nameLower + '.')))
+            if (!overwriteField &&
+                (omitOption.find(x => x === nameLower) ||
+                    (pickOption.length && !pickOption.find(x => x === nameLower || x.startsWith(nameLower + '.')))))
                 continue;
+            let f;
+            if (overwriteField) {
+                f = { ...overwriteField };
+                Object.setPrototypeOf(f, field || ApiField.prototype);
+            }
+            else
+                f = field;
             schema[f.name] = f.generateCodec(codec, {
                 ...options,
-                pick: pickOption
-                    .filter(x => x.startsWith(nameLower + '.'))
-                    .map(x => x.substring(x.indexOf('.') + 1)),
-                omit: omitOption
-                    .filter(x => x.startsWith(nameLower + '.'))
-                    .map(x => x.substring(x.indexOf('.') + 1)),
+                pick: overwriteField ? [] :
+                    pickOption
+                        .filter(x => x.startsWith(nameLower + '.'))
+                        .map(x => x.substring(x.indexOf('.') + 1)),
+                omit: overwriteField ? [] :
+                    omitOption
+                        .filter(x => x.startsWith(nameLower + '.'))
+                        .map(x => x.substring(x.indexOf('.') + 1)),
             });
         }
         return schema;

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

@@ -11,6 +11,8 @@ export class FieldClass {
         this.default = init.default;
         this.fixed = init.fixed;
         this.required = init.required;
+        this.readonly = init.readonly;
+        this.writeonly = init.writeonly;
         this.exclusive = init.exclusive;
         this.deprecated = init.deprecated;
         this.examples = init.examples;
@@ -23,22 +25,18 @@ export class FieldClass {
             default: this.default,
             fixed: this.fixed,
             required: this.required,
+            readonly: this.readonly,
+            writeonly: this.writeonly,
             exclusive: this.exclusive,
             deprecated: this.deprecated,
             examples: this.examples
         });
     }
-    getDecoder() {
-        if (!this._decoder)
-            this._decoder = this.generateCodec('decode');
-        return this._decoder;
-    }
-    getEncoder() {
-        if (!this._encoder)
-            this._encoder = this.generateCodec('encode');
-        return this._encoder;
-    }
     generateCodec(codec, options) {
+        if (options?.operation === 'read' && this.writeonly)
+            return vg.isUndefined();
+        if (options?.operation === 'write' && this.readonly)
+            return vg.isUndefined();
         let fn = this.type.generateCodec(codec, options);
         if (this.isArray)
             fn = vg.isArray(fn);

package/esm/document/factory/api-document-factory.js

@@ -159,9 +159,9 @@ export class ApiDocumentFactory extends TypeDocumentFactory {
                 return;
             const output = {};
             for (const [kA, oA] of Object.entries(source)) {
-                let parameters;
+                const o = output[kA] = { ...oA };
                 if (oA.parameters) {
-                    parameters = {};
+                    const parameters = o.parameters = {};
                     for (const [kP, oP] of Object.entries(oA.parameters)) {
                         if (oP.enum) {
                             oP.type = EnumType(oP.enum, { name: kP + 'Enum' });
@@ -172,7 +172,30 @@ export class ApiDocumentFactory extends TypeDocumentFactory {
                         };
                     }
                 }
-                output[kA] = { ...oA, parameters };
+                if (oA.options?.inputOverwriteFields) {
+                    const inputOverwriteFields = {};
+                    for (const [kP, oP] of Object.entries(oA.options.inputOverwriteFields)) {
+                        if (oP.enum) {
+                            oP.type = EnumType(oP.enum, { name: kP + 'Enum' });
+                        }
+                        inputOverwriteFields[kP] = { ...oP, };
+                        if (oP.type)
+                            inputOverwriteFields[kP].type = await this.importDataType(oP.type);
+                    }
+                    o.options.inputOverwriteFields = inputOverwriteFields;
+                }
+                if (oA.options?.outputOverwriteFields) {
+                    const outputOverwriteFields = {};
+                    for (const [kP, oP] of Object.entries(oA.options.outputOverwriteFields)) {
+                        if (oP.enum) {
+                            oP.type = EnumType(oP.enum, { name: kP + 'Enum' });
+                        }
+                        outputOverwriteFields[kP] = { ...oP };
+                        if (oP.type)
+                            outputOverwriteFields[kP].type = await this.importDataType(oP.type);
+                    }
+                    o.options.outputOverwriteFields = outputOverwriteFields;
+                }
             }
             return output;
         };

package/esm/document/factory/type-document-factory.js

@@ -139,7 +139,7 @@ export class TypeDocumentFactory {
                     return dataType;
                 throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
             }
-            name = metadata.name;
+            name = metadata.anonymous ? undefined : metadata.name;
             initArguments = cloneObject(metadata);
             ctor = thunk;
         }
@@ -154,7 +154,7 @@ export class TypeDocumentFactory {
                 const metadata = thunk[DATATYPE_METADATA];
                 if (!metadata)
                     throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(thunk).substring(0, 20)}...`);
-                name = metadata.name;
+                name = metadata.anonymous ? undefined : metadata.name;
                 initArguments = cloneObject(metadata);
                 initArguments.enumObject = thunk;
             }
@@ -186,8 +186,11 @@ export class TypeDocumentFactory {
             if (name)
                 this.document.types.set(name, instance);
             await this.prepareDataTypeInitArguments(initArguments, ctor);
-            if (initArguments.kind === 'ComplexType')
+            if (initArguments.kind === 'ComplexType') {
+                if (typeof initArguments.additionalFields === 'function')
+                    initArguments.additionalFields = await this.importDataType(initArguments.additionalFields);
                 ComplexType.apply(instance, [this.document, initArguments]);
+            }
             else if (initArguments.kind === 'SimpleType')
                 SimpleType.apply(instance, [this.document, initArguments]);
             else if (initArguments.kind === 'EnumType')

package/esm/document/index.js

@@ -16,7 +16,7 @@ export * from './resource/collection.js';
 export * from './resource/container.js';
 export * from './resource/crud-resource.js';
 export * from './resource/endpoint.js';
-export * from './resource/operation.js';
+export * from './resource/crud-operation.js';
 export * from './resource/parameter.js';
 export * from './resource/resource.js';
 export * from './resource/singleton.js';

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

@@ -30,14 +30,18 @@ export class CollectionClass extends CrudResource {
             endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
             endpoint.decodeInput = this.type.generateCodec('decode', {
                 partial: true,
-                pick: endpoint.inputPickFields,
-                omit: endpoint.inputOmitFields,
+                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.outputPickFields,
-                omit: endpoint.outputOmitFields,
+                pick: endpoint.options.outputPickFields,
+                omit: endpoint.options.outputOmitFields,
+                operation: 'read',
+                overwriteFields: endpoint.outputOverwriteFields
             });
         }
         // ------------------
@@ -56,8 +60,10 @@ export class CollectionClass extends CrudResource {
             endpoint.returnType = this.type;
             endpoint.encodeReturning = endpoint.returnType.generateCodec('encode', {
                 partial: true,
-                pick: endpoint.outputPickFields,
-                omit: endpoint.outputOmitFields,
+                pick: endpoint.options.outputPickFields,
+                omit: endpoint.options.outputOmitFields,
+                operation: 'read',
+                overwriteFields: endpoint.outputOverwriteFields
             });
         }
         // ------------------
@@ -76,8 +82,10 @@ export class CollectionClass extends CrudResource {
             endpoint.returnType = this.type;
             endpoint.encodeReturning = vg.isArray(this.type.generateCodec('encode', {
                 partial: true,
-                pick: endpoint.outputPickFields,
-                omit: endpoint.outputOmitFields,
+                pick: endpoint.options.outputPickFields,
+                omit: endpoint.options.outputOmitFields,
+                operation: 'read',
+                overwriteFields: endpoint.outputOverwriteFields
             }));
         }
         // ------------------
@@ -88,14 +96,18 @@ export class CollectionClass extends CrudResource {
             endpoint.defineParameter('omit', { type: 'string', isArray: true, isBuiltin: true });
             endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
             endpoint.decodeInput = this.type.generateCodec('decode', {
-                pick: endpoint.inputPickFields,
-                omit: endpoint.inputOmitFields,
+                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.outputPickFields,
-                omit: endpoint.outputOmitFields,
+                pick: endpoint.options.outputPickFields,
+                omit: endpoint.options.outputOmitFields,
+                operation: 'read',
+                overwriteFields: endpoint.outputOverwriteFields
             });
         }
         // ------------------
@@ -104,14 +116,13 @@ export class CollectionClass extends CrudResource {
             // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
             endpoint.defineParameter('filter', { type: 'string', isBuiltin: true });
             endpoint.decodeInput = this.type.generateCodec('decode', {
-                pick: endpoint.inputPickFields,
-                omit: endpoint.inputOmitFields,
+                pick: endpoint.options.inputPickFields,
+                omit: endpoint.options.inputOmitFields,
+                operation: 'write',
+                overwriteFields: endpoint.inputOverwriteFields
             });
         }
     }
-    getOperation(name) {
-        return super.getOperation(name);
-    }
     exportSchema(options) {
         return {
             ...super.exportSchema(options),
@@ -163,7 +174,7 @@ export class CollectionClass extends CrudResource {
         if (!normalized)
             return;
         const findManyOp = this.getOperation('findMany');
-        const sortFields = findManyOp && findManyOp.sortFields;
+        const sortFields = findManyOp && findManyOp.options.sortFields;
         (Array.isArray(normalized) ? normalized : [normalized]).forEach(field => {
             if (!sortFields?.find(x => x === field))
                 throw new BadRequestError({
@@ -183,7 +194,7 @@ export class CollectionClass extends CrudResource {
             // Check if filtering accepted for given field
             const findManyOp = this.getOperation('findMany');
             const fieldLower = ast.left.value.toLowerCase();
-            const filterDef = (findManyOp && findManyOp.filters || [])
+            const filterDef = (findManyOp && findManyOp.options.filters || [])
                 .find(f => f.field.toLowerCase() === fieldLower);
             if (!filterDef) {
                 throw new BadRequestError({
@@ -191,7 +202,7 @@ export class CollectionClass extends CrudResource {
                 });
             }
             // Check if filtering endpoint accepted for given field
-            if (!filterDef.operators?.includes(ast.op))
+            if (filterDef.operators && !filterDef.operators.includes(ast.op))
                 throw new BadRequestError({
                     message: translate('error:UNACCEPTED_FILTER_OPERATION', { field: ast.left.value }),
                 });