@opra/common 1.0.0-alpha.3 → 1.0.0-alpha.5

package/cjs/document/factory/data-type.factory.js

@@ -7,6 +7,7 @@ const document_init_context_js_1 = require("../common/document-init-context.js")
 const constants_js_1 = require("../constants.js");
 const complex_type_js_1 = require("../data-type/complex-type.js");
 const complex_type_base_js_1 = require("../data-type/complex-type-base.js");
+const data_type_js_1 = require("../data-type/data-type.js");
 const enum_type_js_1 = require("../data-type/enum-type.js");
 const mapped_type_js_1 = require("../data-type/mapped-type.js");
 const mixin_type_js_1 = require("../data-type/mixin-type.js");
@@ -133,7 +134,7 @@ class DataTypeFactory {
         const { importQueue, initArgsMap } = context;
         // Check if data type already exist (maybe a builtin type or already imported)
         const dataType = owner.node.findDataType(thunk);
-        if (dataType)
+        if (dataType instanceof data_type_js_1.DataType)
             return dataType.name;
         let metadata;
         let ctor;
@@ -212,11 +213,15 @@ class DataTypeFactory {
             /** Mark "out" object as initializing. This will help us to detect circular dependencies */
             out[initializingSymbol] = true;
             try {
-                if (out.name && importQueue?.has(out.name)) {
-                    initArgsMap?.set(metadata.name, out);
+                if (out.name) {
+                    if (importQueue?.has(out.name)) {
+                        initArgsMap?.set(metadata.name, out);
+                        out._instance = { name: metadata.name };
+                        out[constants_js_1.kDataTypeMap] = owner.node[constants_js_1.kDataTypeMap];
+                    }
+                    else
+                        return context.addError(`Data Type (${out.name}) must be explicitly added to type list in the document scope`);
                 }
-                else if (out.name)
-                    return context.addError(`Data Type (${out.name}) must be explicitly added to type list in the document scope`);
                 switch (out.kind) {
                     case index_js_2.OpraSchema.ComplexType.Kind:
                         out.ctor = ctor;
@@ -332,6 +337,7 @@ class DataTypeFactory {
             initArgs.ctor = initArgs.ctor || baseArgs.ctor;
         });
         initArgs.properties = metadata.properties;
+        initArgs.nameMappings = metadata.nameMappings;
         if (!initArgs.properties && initArgs.ctor)
             initArgs.properties = new initArgs.ctor();
         if (metadata.attributes)
@@ -384,27 +390,40 @@ class DataTypeFactory {
         });
     }
     static _createDataType(context, owner, args) {
+        let dataType = owner.node.findDataType(typeof args === 'string' ? args : args.name || '');
+        if (dataType instanceof data_type_js_1.DataType)
+            return dataType;
         const initArgs = typeof args === 'string' ? context.initArgsMap?.get(args) : args;
-        switch (initArgs?.kind) {
-            case index_js_2.OpraSchema.ComplexType.Kind:
-                return this._createComplexType(context, owner, initArgs);
-            case index_js_2.OpraSchema.EnumType.Kind:
-                return this._createEnumType(context, owner, initArgs);
-            case index_js_2.OpraSchema.MappedType.Kind:
-                return this._createMappedType(context, owner, initArgs);
-            case index_js_2.OpraSchema.MixinType.Kind:
-                return this._createMixinType(context, owner, initArgs);
-            case index_js_2.OpraSchema.SimpleType.Kind:
-                return this._createSimpleType(context, owner, initArgs);
+        if (initArgs) {
+            const dataTypeMap = initArgs[constants_js_1.kDataTypeMap];
+            if (!dataTypeMap)
+                delete initArgs._instance;
+            dataType = initArgs._instance;
+            if (dataType?.name && dataTypeMap) {
+                dataTypeMap.set(dataType.name, dataType);
+            }
+            switch (initArgs?.kind) {
+                case index_js_2.OpraSchema.ComplexType.Kind:
+                    return this._createComplexType(context, owner, initArgs);
+                case index_js_2.OpraSchema.EnumType.Kind:
+                    return this._createEnumType(context, owner, initArgs);
+                case index_js_2.OpraSchema.MappedType.Kind:
+                    return this._createMappedType(context, owner, initArgs);
+                case index_js_2.OpraSchema.MixinType.Kind:
+                    return this._createMixinType(context, owner, initArgs);
+                case index_js_2.OpraSchema.SimpleType.Kind:
+                    return this._createSimpleType(context, owner, initArgs);
+            }
         }
         context.addError(`Unknown data type (${String(args)})`);
     }
     static _createComplexType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, complex_type_js_1.ComplexType.prototype);
         const initArgs = (0, index_js_1.cloneObject)(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) ||
-                    this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
         /** Set additionalFields */
@@ -413,14 +432,7 @@ class DataTypeFactory {
                 if (typeof args.additionalFields === 'boolean' || Array.isArray(args.additionalFields))
                     initArgs.additionalFields = args.additionalFields;
                 else {
-                    if (typeof args.additionalFields === 'string') {
-                        initArgs.additionalFields =
-                            owner.node.findDataType(args.additionalFields) ||
-                                this._createDataType(context, owner, args.additionalFields);
-                    }
-                    else {
-                        initArgs.additionalFields = this._createDataType(context, owner, args.additionalFields);
-                    }
+                    initArgs.additionalFields = this._createDataType(context, owner, args.additionalFields);
                 }
             });
         }
@@ -430,7 +442,7 @@ class DataTypeFactory {
             context.enter('.fields', () => {
                 for (const [k, v] of Object.entries(args.fields)) {
                     context.enter(`[${k}]`, () => {
-                        const type = owner.node.findDataType(v.type) || this._createDataType(context, owner, v.type);
+                        const type = this._createDataType(context, owner, v.type);
                         if (type)
                             initArgs.fields[k] = {
                                 ...v,
@@ -441,29 +453,37 @@ class DataTypeFactory {
                 }
             });
         }
-        return new complex_type_js_1.ComplexType(owner, initArgs);
+        complex_type_js_1.ComplexType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createEnumType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, enum_type_js_1.EnumType.prototype);
         const initArgs = (0, index_js_1.cloneObject)(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) ||
-                    this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
         initArgs.attributes = args.attributes;
-        return new enum_type_js_1.EnumType(owner, initArgs);
+        enum_type_js_1.EnumType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createMappedType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, mapped_type_js_1.MappedType.prototype);
         const initArgs = (0, index_js_1.cloneObject)(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) || this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
-        return new mapped_type_js_1.MappedType(owner, initArgs);
+        mapped_type_js_1.MappedType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createMixinType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, mixin_type_js_1.MixinType.prototype);
         const initArgs = (0, index_js_1.cloneObject)(args);
         if (args.types) {
             context.enter('.types', () => {
@@ -471,7 +491,7 @@ class DataTypeFactory {
                 let i = 0;
                 for (const t of args.types) {
                     context.enter(`[${i++}]`, () => {
-                        const base = owner.node.findDataType(t) || this._createDataType(context, owner, t);
+                        const base = this._createDataType(context, owner, t);
                         if (!(base instanceof complex_type_base_js_1.ComplexTypeBase))
                             throw new TypeError(`"${base?.kind}" can't be set as base for a "${initArgs.kind}"`);
                         initArgs.types.push(base);
@@ -479,17 +499,20 @@ class DataTypeFactory {
                 }
             });
         }
-        return new mixin_type_js_1.MixinType(owner, initArgs);
+        mixin_type_js_1.MixinType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createSimpleType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, simple_type_js_1.SimpleType.prototype);
         const initArgs = (0, index_js_1.cloneObject)(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) ||
-                    this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
-        return new simple_type_js_1.SimpleType(owner, initArgs);
+        simple_type_js_1.SimpleType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
 }
 exports.DataTypeFactory = DataTypeFactory;

package/cjs/document/http/http-api.js

@@ -31,8 +31,8 @@ class HttpApi extends api_base_js_1.ApiBase {
             url: this.url,
             controllers: {},
         };
-        for (const [name, v] of this.controllers.entries()) {
-            out.controllers[name] = v.toJSON();
+        for (const v of this.controllers.values()) {
+            out.controllers[v.name] = v.toJSON();
         }
         return out;
     }

package/cjs/document/http/http-controller.js

@@ -109,20 +109,20 @@ class HttpControllerClass extends document_element_js_1.DocumentElement {
         });
         if (this.operations.size) {
             out.operations = {};
-            for (const [name, v] of this.operations.entries()) {
-                out.operations[name] = v.toJSON();
+            for (const v of this.operations.values()) {
+                out.operations[v.name] = v.toJSON();
             }
         }
         if (this.controllers.size) {
             out.controllers = {};
-            for (const [name, v] of this.controllers.entries()) {
-                out.controllers[name] = v.toJSON();
+            for (const v of this.controllers.values()) {
+                out.controllers[v.name] = v.toJSON();
             }
         }
         if (this.types.size) {
             out.types = {};
-            for (const [name, v] of this.types.entries()) {
-                out.types[name] = v.toJSON();
+            for (const v of this.types.values()) {
+                out.types[v.name] = v.toJSON();
             }
         }
         if (this.parameters.length) {

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

@@ -25,6 +25,7 @@ exports.HttpParameter = function (owner, initArgs) {
     _this.deprecated = initArgs.deprecated;
     _this.required = initArgs.required;
     _this.arraySeparator = initArgs.arraySeparator;
+    _this.keyParam = initArgs.keyParam;
 };
 /**
  * @class HttpParameter
@@ -36,6 +37,7 @@ class HttpParameterClass extends value_js_1.Value {
             name: this.name,
             location: this.location,
             arraySeparator: this.arraySeparator,
+            keyParam: this.keyParam,
             required: this.required,
             deprecated: this.deprecated,
         });

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

@@ -33,6 +33,8 @@ export const ApiField = function (...args) {
     _this.exclusive = initArgs.exclusive;
     _this.translatable = initArgs.translatable;
     _this.deprecated = initArgs.deprecated;
+    _this.readonly = initArgs.readonly;
+    _this.writeonly = initArgs.writeonly;
     _this.examples = initArgs.examples;
 };
 /**
@@ -52,6 +54,8 @@ class ApiFieldClass extends DocumentElement {
             exclusive: this.exclusive,
             translatable: this.translatable,
             deprecated: this.deprecated,
+            readonly: this.readonly,
+            writeonly: this.writeonly,
             examples: this.examples,
         });
     }

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

@@ -143,6 +143,10 @@ class ComplexTypeBaseClass extends DataType {
         // Process fields
         let fieldName;
         for (const field of this.fields.values()) {
+            if ((context.ignoreReadonlyFields && field.readonly) || (context.ignoreWriteonlyFields && field.writeonly)) {
+                schema[field.name] = vg.isUndefined({ coerce: true });
+                continue;
+            }
             fieldName = field.name;
             let p;
             if (projection !== '*') {

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

@@ -57,6 +57,8 @@ export const ComplexType = function (...args) {
  */
 class ComplexTypeClass extends ComplexTypeBase {
     extendsFrom(baseType) {
+        if (!(baseType instanceof DataType))
+            baseType = this.node.getDataType(baseType);
         if (!(baseType instanceof ComplexTypeBase))
             return false;
         if (baseType === this)

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

@@ -35,6 +35,8 @@ export const EnumType = function (...args) {
  */
 class EnumTypeClass extends DataType {
     extendsFrom(baseType) {
+        if (!(baseType instanceof DataType))
+            baseType = this.node.getDataType(baseType);
         if (!(baseType instanceof EnumType))
             return false;
         if (baseType === this)

package/esm/document/data-type/extended-types/base64.type.js

@@ -17,6 +17,10 @@ let Base64Type = class Base64Type {
 Base64Type = __decorate([
     SimpleType({
         description: 'A stream of bytes, base64 encoded',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], Base64Type);

package/esm/document/data-type/extended-types/date-string.type.js

@@ -35,6 +35,10 @@ __decorate([
 DateStringType = __decorate([
     SimpleType({
         description: 'Date string value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     })
         .Example('2021-04-18', 'Full date value')
         .Example('2021-04', 'Date value without day')

package/esm/document/data-type/extended-types/date-time-string.type.js

@@ -35,6 +35,10 @@ __decorate([
 DateTimeStringType = __decorate([
     SimpleType({
         description: 'DateTime string value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     })
         .Example('2021-04-18T22:30:15+01:00', 'Full date-time value with timezone')
         .Example('2021-04-18T22:30:15', 'Full date-time value without timezone')

package/esm/document/data-type/extended-types/date-time.type.js

@@ -49,6 +49,10 @@ __decorate([
 DateTimeType = __decorate([
     SimpleType({
         description: 'A full datetime value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     })
         .Example('2021-04-18T22:30:15')
         .Example('2021-04-18 22:30:15')

package/esm/document/data-type/extended-types/date.type.js

@@ -49,6 +49,10 @@ __decorate([
 DateType = __decorate([
     SimpleType({
         description: 'A date without time',
+        nameMappings: {
+            js: 'Date',
+            json: 'string',
+        },
     }).Example('2021-04-18', 'Full date value'),
     __metadata("design:paramtypes", [Object])
 ], DateType);

package/esm/document/data-type/extended-types/email.type.js

@@ -81,6 +81,10 @@ __decorate([
 EmailType = __decorate([
     SimpleType({
         description: 'An email value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     }).Example('some.body@example.com'),
     __metadata("design:paramtypes", [Object])
 ], EmailType);

package/esm/document/data-type/extended-types/field-path.type.js

@@ -48,6 +48,10 @@ __decorate([
 FieldPathType = __decorate([
     SimpleType({
         description: 'Field path',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], FieldPathType);

package/esm/document/data-type/extended-types/filter.type.js

@@ -45,6 +45,10 @@ __decorate([
 FilterType = __decorate([
     SimpleType({
         description: 'A query filter',
+        nameMappings: {
+            js: 'object',
+            json: 'string',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], FilterType);

package/esm/document/data-type/extended-types/object-id.type.js

@@ -17,6 +17,10 @@ let ObjectIdType = class ObjectIdType {
 ObjectIdType = __decorate([
     SimpleType({
         description: 'A MongoDB ObjectID value',
+        nameMappings: {
+            js: 'object',
+            json: 'string',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], ObjectIdType);

package/esm/document/data-type/extended-types/time.type.js

@@ -39,6 +39,10 @@ __decorate([
 TimeType = __decorate([
     SimpleType({
         description: 'Time string in 24h format',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     })
         .Example('18:23:00', 'Full time value')
         .Example('18:23:00', 'Time value without seconds'),

package/esm/document/data-type/extended-types/url.type.js

@@ -17,6 +17,10 @@ let UrlType = class UrlType {
 UrlType = __decorate([
     SimpleType({
         description: 'A Uniform Resource Identifier Reference (RFC 3986 icon) value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     }).Example('http://tempuri.org'),
     __metadata("design:paramtypes", [Object])
 ], UrlType);

package/esm/document/data-type/extended-types/uuid.type.js

@@ -23,6 +23,10 @@ __decorate([
 UuidType = __decorate([
     SimpleType({
         description: 'A Universal Unique Identifier (UUID) value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], UuidType);

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

@@ -4,6 +4,7 @@ import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { ApiField } from './api-field.js';
 import { ComplexTypeBase } from './complex-type-base.js';
+import { DataType } from './data-type.js';
 import { getIsInheritedPredicateFn } from './utils/get-is-inherited-predicate-fn.js';
 /**
  * MappedType constructor
@@ -65,6 +66,8 @@ export const MappedType = function (...args) {
  */
 class MappedTypeClass extends ComplexTypeBase {
     extendsFrom(baseType) {
+        if (!(baseType instanceof DataType))
+            baseType = this.node.getDataType(baseType);
         if (!(baseType instanceof ComplexTypeBase))
             return false;
         if (baseType === this)

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

@@ -5,6 +5,7 @@ import { OpraSchema } from '../../schema/index.js';
 import { DATATYPE_METADATA, DECORATOR } from '../constants.js';
 import { ApiField } from './api-field.js';
 import { ComplexTypeBase } from './complex-type-base.js';
+import { DataType } from './data-type.js';
 /**
  * @class MixinType
  */
@@ -40,6 +41,8 @@ export const MixinType = function (...args) {
  */
 class MixinTypeClass extends ComplexTypeBase {
     extendsFrom(baseType) {
+        if (!(baseType instanceof DataType))
+            baseType = this.node.getDataType(baseType);
         if (!(baseType instanceof ComplexTypeBase))
             return false;
         if (baseType === this)

package/esm/document/data-type/primitive-types/bigint.type.js

@@ -22,6 +22,10 @@ let BigintType = class BigintType extends NumberType {
 BigintType = __decorate([
     SimpleType({
         description: 'BigInt number',
+        nameMappings: {
+            js: 'bigint',
+            json: 'string',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], BigintType);

package/esm/document/data-type/primitive-types/boolean.type.js

@@ -17,6 +17,10 @@ let BooleanType = class BooleanType {
 BooleanType = __decorate([
     SimpleType({
         description: 'Simple true/false value',
+        nameMappings: {
+            js: 'boolean',
+            json: 'boolean',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], BooleanType);

package/esm/document/data-type/primitive-types/integer.type.js

@@ -22,6 +22,10 @@ let IntegerType = class IntegerType extends NumberType {
 IntegerType = __decorate([
     SimpleType({
         description: 'An integer number',
+        nameMappings: {
+            js: 'number',
+            json: 'number',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], IntegerType);

package/esm/document/data-type/primitive-types/null.type.js

@@ -17,6 +17,10 @@ let NullType = class NullType {
 NullType = __decorate([
     SimpleType({
         description: 'A Null value',
+        nameMappings: {
+            js: 'null',
+            json: 'null',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], NullType);

package/esm/document/data-type/primitive-types/number.type.js

@@ -34,6 +34,10 @@ __decorate([
 NumberType = __decorate([
     SimpleType({
         description: 'Both Integer as well as Floating-Point numbers',
+        nameMappings: {
+            js: 'number',
+            json: 'number',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], NumberType);

package/esm/document/data-type/primitive-types/string.type.js

@@ -54,6 +54,10 @@ __decorate([
 StringType = __decorate([
     SimpleType({
         description: 'A sequence of characters',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], StringType);

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

@@ -25,6 +25,8 @@ export const SimpleType = function (...args) {
         _this.base = initArgs.base;
     }
     _this.properties = initArgs.properties;
+    _this.ownNameMappings = { ...initArgs.nameMappings };
+    _this.nameMappings = { ..._this.base?.nameMappings, ...initArgs.nameMappings };
     _this.ownAttributes = cloneObject(initArgs.attributes || {});
     _this.attributes = _this.base ? cloneObject(_this.base.attributes) : {};
     if (_this.ownAttributes) {
@@ -43,6 +45,8 @@ export const SimpleType = function (...args) {
  */
 class SimpleTypeClass extends DataType {
     extendsFrom(baseType) {
+        if (!(baseType instanceof DataType))
+            baseType = this.node.getDataType(baseType);
         if (!(baseType instanceof SimpleType))
             return false;
         if (baseType === this)
@@ -87,12 +91,15 @@ class SimpleTypeClass extends DataType {
             return o;
         }, {});
         const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : undefined;
-        return omitUndefined({
+        const out = omitUndefined({
             ...DataType.prototype.toJSON.apply(this),
             base: this.base ? (baseName ? baseName : this.base.toJSON()) : undefined,
             attributes: attributes && Object.keys(attributes).length ? attributes : undefined,
             properties: Object.keys(properties).length ? properties : undefined,
         });
+        if (Object.keys(this.ownNameMappings).length)
+            out.nameMappings = { ...this.ownNameMappings };
+        return out;
     }
 }
 SimpleType.prototype = SimpleTypeClass.prototype;

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

@@ -98,6 +98,31 @@ export function HttpControllerDecoratorFactory(options) {
         });
         return decorator;
     };
+    /**
+     *
+     */
+    decorator.KeyParam = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            if (!meta.path?.includes(':' + name))
+                meta.path = (meta.path || '') + '@:' + name;
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'path',
+                    type: arg1,
+                    keyParam: true,
+                }
+                : {
+                    ...arg1,
+                    name,
+                    location: 'path',
+                    keyParam: true,
+                };
+            meta.parameters = meta.parameters || [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
     /**
      *
      */