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

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

@@ -79,9 +79,13 @@ __decorate([
     __metadata("design:type", String)
 ], EmailType.prototype, "blacklistedChars", void 0);
 EmailType = __decorate([
-    SimpleType({
+    (SimpleType({
         description: 'An email value',
-    }).Example('some.body@example.com'),
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }).Example('some.body@example.com')),
     __metadata("design:paramtypes", [Object])
 ], EmailType);
 export { EmailType };

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

@@ -12,9 +12,7 @@ let FieldPathType = class FieldPathType {
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
         const allowSigns = properties.allowSigns;
-        const decodeFieldPath = validator('decodeFieldPath', function (input) {
-            return dataType.normalizeFieldPath(input, { allowSigns });
-        });
+        const decodeFieldPath = validator('decodeFieldPath', (input) => dataType.normalizeFieldPath(input, { allowSigns }));
         return vg.pipe([toString, decodeFieldPath]);
     }
     [ENCODER](properties, element) {
@@ -48,6 +46,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,28 +45,30 @@ __decorate([
 FilterType = __decorate([
     SimpleType({
         description: 'A query filter',
+        nameMappings: {
+            js: 'object',
+            json: 'string',
+        },
     }),
     __metadata("design:paramtypes", [Object])
 ], FilterType);
 export { FilterType };
-const decodeFilter = (dataType, rules) => {
-    return validator('decodeFilter', function (input, context, _this) {
-        if (typeof input === 'string') {
-            try {
-                const filter = OpraFilter.parse(input);
-                if (rules)
-                    return rules.normalizeFilter(filter, dataType);
-                return filter;
-            }
-            catch (e) {
-                context.fail(_this, `Not a valid filter expression. ${e.message}`, input, e.errors);
-                return;
-            }
+const decodeFilter = (dataType, rules) => validator('decodeFilter', (input, context, _this) => {
+    if (typeof input === 'string') {
+        try {
+            const filter = OpraFilter.parse(input);
+            if (rules)
+                return rules.normalizeFilter(filter, dataType);
+            return filter;
         }
-        context.fail(_this, `Nt a valid filter expression string`, input);
-    });
-};
-const encodeFilter = validator('encodeFilter', function (input, context, _this) {
+        catch (e) {
+            context.fail(_this, `Not a valid filter expression. ${e.message}`, input, e.errors);
+            return;
+        }
+    }
+    context.fail(_this, `Nt a valid filter expression string`, input);
+});
+const encodeFilter = validator('encodeFilter', (input, context, _this) => {
     if (input instanceof OpraFilter.Ast) {
         return input.toString();
     }

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

@@ -37,11 +37,15 @@ __decorate([
     __metadata("design:type", String)
 ], TimeType.prototype, "maxValue", void 0);
 TimeType = __decorate([
-    SimpleType({
+    (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'),
+        .Example('18:23:00', 'Time value without seconds')),
     __metadata("design:paramtypes", [Object])
 ], TimeType);
 export { TimeType };

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

@@ -15,9 +15,13 @@ let UrlType = class UrlType {
     }
 };
 UrlType = __decorate([
-    SimpleType({
+    (SimpleType({
         description: 'A Uniform Resource Identifier Reference (RFC 3986 icon) value',
-    }).Example('http://tempuri.org'),
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }).Example('http://tempuri.org')),
     __metadata("design:paramtypes", [Object])
 ], UrlType);
 export { 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
@@ -18,22 +19,25 @@ export const MappedType = function (...args) {
     _this.kind = OpraSchema.MappedType.Kind;
     if (initArgs.base) {
         // noinspection SuspiciousTypeOfGuard
-        if (!(initArgs.base instanceof ComplexTypeBase))
+        if (!(initArgs.base instanceof ComplexTypeBase)) {
             throw new TypeError(`"${initArgs.base.kind}" can't be set as base for a "${this.kind}"`);
+        }
         _this.base = initArgs.base;
         _this.ctor = initArgs.ctor || _this.base.ctor;
         if (initArgs.pick)
             _this.pick = initArgs.pick.map(f => _this.base.normalizeFieldPath(f));
         else if (initArgs.omit)
             _this.omit = initArgs.omit.map(f => _this.base.normalizeFieldPath(f));
-        else if (initArgs.partial)
+        else if (initArgs.partial) {
             _this.partial = Array.isArray(initArgs.partial)
                 ? initArgs.partial.map(f => _this.base.normalizeFieldPath(f))
                 : initArgs.partial;
-        else if (initArgs.required)
+        }
+        else if (initArgs.required) {
             _this.required = Array.isArray(initArgs.required)
                 ? initArgs.required.map(f => _this.base.normalizeFieldPath(f))
                 : initArgs.required;
+        }
         /** Copy fields from base */
         const isInheritedPredicate = getIsInheritedPredicateFn(_this.pick, _this.omit);
         const partial = Array.isArray(_this.partial) ? _this.partial.map(x => x.toLowerCase()) : _this.partial;
@@ -53,8 +57,9 @@ export const MappedType = function (...args) {
         }
         if (!_this.pick ||
             _this.base.additionalFields === false ||
-            (Array.isArray(_this.base.additionalFields) && _this.base.additionalFields?.[0] === 'error'))
+            (Array.isArray(_this.base.additionalFields) && _this.base.additionalFields?.[0] === 'error')) {
             _this.additionalFields = _this.base.additionalFields;
+        }
         if (initArgs.base.keyField && isInheritedPredicate(initArgs.base.keyField))
             _this.keyField = initArgs.base.keyField;
     }
@@ -65,6 +70,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)
@@ -85,4 +92,4 @@ class MappedTypeClass extends ComplexTypeBase {
     }
 }
 MappedType.prototype = MappedTypeClass.prototype;
-MappedType._applyMixin = () => void 0;
+MappedType._applyMixin = () => undefined;

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)
@@ -94,8 +97,9 @@ function MixinTypeFactory(...args) {
         if (!(itemMeta &&
             (itemMeta.kind === OpraSchema.ComplexType.Kind ||
                 itemMeta.kind === OpraSchema.MixinType.Kind ||
-                itemMeta.kind === OpraSchema.MappedType.Kind)))
+                itemMeta.kind === OpraSchema.MappedType.Kind))) {
             throw new TypeError(`Class "${c.name}" is not a ${OpraSchema.ComplexType.Kind}, ${OpraSchema.MixinType.Kind} or ${OpraSchema.MappedType.Kind}`);
+        }
         metadata.types.push(c);
         mergePrototype(MixinClass.prototype, c.prototype);
     }

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

@@ -1,4 +1,10 @@
 import { createMappedClass } from './utils/create-mapped-class.js';
+/**
+ * Create a new MappedType that omits given fields from base type
+ * @param baseType
+ * @param keys
+ * @param options
+ */
 /**
  *
  */

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

@@ -1,4 +1,10 @@
 import { createMappedClass } from './utils/create-mapped-class.js';
+/**
+ * Create a new MappedType that marks given or all fields as optional
+ * @param baseType
+ * @param keys
+ * @param options
+ */
 /**
  *
  */

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/object.type.js

@@ -1,5 +1,4 @@
 import { __decorate, __metadata } from "tslib";
-import { DATATYPE_METADATA } from '../../constants.js';
 import { ComplexType } from '../complex-type.js';
 let ObjectType = class ObjectType {
     constructor(properties) {
@@ -16,5 +15,3 @@ ObjectType = __decorate([
     __metadata("design:paramtypes", [Object])
 ], ObjectType);
 export { ObjectType };
-const metadata = Reflect.getMetadata(DATATYPE_METADATA, ObjectType);
-metadata.ctor = Object;

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

@@ -20,11 +20,14 @@ export const SimpleType = function (...args) {
     _this.kind = OpraSchema.SimpleType.Kind;
     if (initArgs.base) {
         // noinspection SuspiciousTypeOfGuard
-        if (!(initArgs.base instanceof SimpleType))
+        if (!(initArgs.base instanceof SimpleType)) {
             throw new TypeError(`"${initArgs.base.kind}" can't be set as base for a "${this.kind}"`);
+        }
         _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 +46,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)
@@ -63,15 +68,13 @@ class SimpleTypeClass extends DataType {
             }
             return isAny;
         }
-        else {
-            let t = this;
-            while (t) {
-                if (t._generateEncoder)
-                    return t._generateEncoder(prop, options?.documentElement || this.owner);
-                t = this.base;
-            }
-            return isAny;
+        let t = this;
+        while (t) {
+            if (t._generateEncoder)
+                return t._generateEncoder(prop, options?.documentElement || this.owner);
+            t = this.base;
         }
+        return isAny;
     }
     toJSON() {
         const attributes = omitUndefined(this.ownAttributes);
@@ -80,19 +83,17 @@ class SimpleTypeClass extends DataType {
             properties = this.properties.toJSON(this.properties, this.owner);
         }
         else
-            properties = this.properties || {};
-        properties = Object.keys(this.attributes).reduce((o, k) => {
-            if (properties[k] !== undefined)
-                o[k] = properties[k];
-            return o;
-        }, {});
+            properties = this.properties ? cloneObject(this.properties) : {};
         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/data-type/utils/create-mapped-class.js

@@ -23,8 +23,9 @@ export function createMappedClass(source, config, options) {
             throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
         if (!(m.kind === OpraSchema.ComplexType.Kind ||
             m.kind === OpraSchema.MappedType.Kind ||
-            m.kind === OpraSchema.MixinType.Kind))
+            m.kind === OpraSchema.MixinType.Kind)) {
             throw new TypeError(`Class "${source}" is not a ${OpraSchema.ComplexType.Kind}`);
+        }
     }
     const metadata = {
         ...options,

package/esm/document/decorators/api-field-decorator.js

@@ -1,4 +1,3 @@
-import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DATATYPE_METADATA } from '../constants.js';
 export function ApiFieldDecorator(options) {
@@ -17,6 +16,6 @@ export function ApiFieldDecorator(options) {
         }
         else
             elemMeta.type = elemMeta.type || designType;
-        Reflect.defineMetadata(DATATYPE_METADATA, omitUndefined(metadata), target.constructor);
+        Reflect.defineMetadata(DATATYPE_METADATA, metadata, target.constructor);
     };
 }

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