@opra/common 0.33.13 → 1.0.0-alpha.1

package/esm/document/{resource/types → data-type/extended-types}/operation-result.type.js

@@ -1,6 +1,6 @@
 import { __decorate } from "tslib";
-import { ComplexType } from '../../data-type/complex-type.js';
-import { ApiField } from '../../data-type/field.js';
+import { ApiField } from '../api-field.js';
+import { ComplexType } from '../complex-type.js';
 let OperationResult = class OperationResult {
     constructor(init) {
         if (init)
@@ -9,25 +9,19 @@ let OperationResult = class OperationResult {
 };
 __decorate([
     ApiField()
-], OperationResult.prototype, "context", void 0);
-__decorate([
-    ApiField()
-], OperationResult.prototype, "contextUrl", void 0);
-__decorate([
-    ApiField()
-], OperationResult.prototype, "type", void 0);
+], OperationResult.prototype, "affected", void 0);
 __decorate([
     ApiField()
-], OperationResult.prototype, "typeUrl", void 0);
+], OperationResult.prototype, "totalMatches", void 0);
 __decorate([
     ApiField()
-], OperationResult.prototype, "affected", void 0);
+], OperationResult.prototype, "context", void 0);
 __decorate([
     ApiField()
-], OperationResult.prototype, "count", void 0);
+], OperationResult.prototype, "type", void 0);
 __decorate([
     ApiField()
-], OperationResult.prototype, "totalMatches", void 0);
+], OperationResult.prototype, "message", void 0);
 __decorate([
     ApiField({ type: 'any' })
 ], OperationResult.prototype, "payload", void 0);
@@ -36,7 +30,24 @@ __decorate([
 ], OperationResult.prototype, "errors", void 0);
 OperationResult = __decorate([
     ComplexType({
-        description: 'Operation result'
+        description: 'Operation result',
     })
 ], OperationResult);
 export { OperationResult };
+(function (OperationResult) {
+    function forPayload(type) {
+        let OperationResult_ = class OperationResult_ extends OperationResult {
+            constructor(...args) {
+                super(...args);
+            }
+        };
+        __decorate([
+            ApiField({ type, required: true })
+        ], OperationResult_.prototype, "payload", void 0);
+        OperationResult_ = __decorate([
+            ComplexType({ embedded: true })
+        ], OperationResult_);
+        return OperationResult_;
+    }
+    OperationResult.forPayload = forPayload;
+})(OperationResult || (OperationResult = {}));

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

@@ -0,0 +1,44 @@
+import { __decorate } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+const TIME_PATTERN = /^([0-1][0-9]|2[0-4]):([0-5][0-9])(?::([0-5][0-9]))?$/;
+let TimeType = class TimeType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER](properties) {
+        const fn = vg.matches(TIME_PATTERN, {
+            formatName: 'time',
+            coerce: true,
+        });
+        const x = [];
+        if (properties.minValue)
+            x.push(vg.isGte(properties.minValue));
+        if (properties.maxValue)
+            x.push(vg.isLte(properties.maxValue));
+        return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    }
+    [ENCODER](properties) {
+        return this[DECODER](properties);
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Minimum value',
+    })
+], TimeType.prototype, "minValue", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Maximum value',
+    })
+], TimeType.prototype, "maxValue", void 0);
+TimeType = __decorate([
+    SimpleType({
+        description: 'Time string in 24h format',
+    })
+        .Example('18:23:00', 'Full time value')
+        .Example('18:23:00', 'Time value without seconds')
+], TimeType);
+export { TimeType };

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

@@ -0,0 +1,22 @@
+import { __decorate } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let UrlType = class UrlType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER]() {
+        return vg.isURL({ coerce: true });
+    }
+    [ENCODER]() {
+        return vg.isURL({ coerce: true });
+    }
+};
+UrlType = __decorate([
+    SimpleType({
+        description: 'A Uniform Resource Identifier Reference (RFC 3986 icon) value',
+    }).Example('http://tempuri.org')
+], UrlType);
+export { UrlType };

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

@@ -0,0 +1,27 @@
+import { __decorate } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let UuidType = class UuidType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER](properties) {
+        return vg.isUUID(properties?.version, { coerce: true });
+    }
+    [ENCODER](properties) {
+        return vg.isUUID(properties?.version, { coerce: true });
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Version of the UUID',
+    })
+], UuidType.prototype, "version", void 0);
+UuidType = __decorate([
+    SimpleType({
+        description: 'A Universal Unique Identifier (UUID) value',
+    })
+], UuidType);
+export { UuidType };

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

@@ -1,68 +1,88 @@
 import 'reflect-metadata';
-import merge from 'putil-merge';
-import { inheritPropertyInitializers, mergePrototype } from '../../helpers/index.js';
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { DATATYPE_METADATA } from '../constants.js';
-import { getIsInheritedPredicateFn, MappedTypeClass } from './mapped-type-class.js';
+import { ApiField } from './api-field.js';
+import { ComplexTypeBase } from './complex-type-base.js';
+import { getIsInheritedPredicateFn } from './utils/get-is-inherited-predicate-fn.js';
 /**
- *
- */
-export function PickType(classRef, keys) {
-    return MappedType(classRef, { pick: keys });
-}
-/**
- *
+ * MappedType constructor
  */
-export function OmitType(classRef, keys) {
-    return MappedType(classRef, { omit: keys });
-}
+export const MappedType = function (...args) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    // Constructor
+    const [owner, initArgs, context] = args;
+    ComplexTypeBase.call(this, owner, initArgs, context);
+    const _this = asMutable(this);
+    _this.kind = OpraSchema.MappedType.Kind;
+    if (initArgs.base) {
+        // noinspection SuspiciousTypeOfGuard
+        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)
+            _this.partial = Array.isArray(initArgs.partial)
+                ? initArgs.partial.map(f => _this.base.normalizeFieldPath(f))
+                : initArgs.partial;
+        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;
+        const required = Array.isArray(_this.required) ? _this.required.map(x => x.toLowerCase()) : _this.required;
+        for (const [k, v] of _this.base.fields.entries()) {
+            if (!isInheritedPredicate(k))
+                continue;
+            const meta = { ...v };
+            if (partial === true || (Array.isArray(partial) && partial.includes(v.name.toLowerCase()))) {
+                meta.required = false;
+            }
+            else if (required === true || (Array.isArray(required) && required.includes(v.name.toLowerCase()))) {
+                meta.required = true;
+            }
+            const field = new ApiField(this, meta);
+            _this.fields.set(field.name, field);
+        }
+        if (!_this.pick ||
+            _this.base.additionalFields === false ||
+            (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;
+    }
+};
 /**
  *
- */
-export function PartialType(classRef, keys) {
-    return MappedType(classRef, { partial: keys || true });
-}
-/**
  * @class MappedType
  */
-export const MappedType = function (...args) {
-    // Constructor
-    if (this) {
-        const [document, init] = args;
-        merge(this, new MappedTypeClass(document, init), { descriptor: true });
-        return;
+class MappedTypeClass extends ComplexTypeBase {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof ComplexTypeBase))
+            return false;
+        if (baseType === this)
+            return true;
+        return !!this.base?.extendsFrom(baseType);
     }
-    // MappedType helper
-    const [mappedSource, options] = args;
-    const isInheritedPredicate = getIsInheritedPredicateFn(options.pick, options.omit);
-    class MappedClass {
-        constructor() {
-            inheritPropertyInitializers(this, mappedSource, isInheritedPredicate);
-        }
+    toJSON() {
+        const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : undefined;
+        return omitUndefined({
+            ...ComplexTypeBase.prototype.toJSON.call(this),
+            base: baseName ? baseName : this.base.toJSON(),
+            kind: this.kind,
+            pick: this.pick,
+            omit: this.omit,
+            partial: this.partial,
+            required: this.required,
+        });
     }
-    mergePrototype(MappedClass.prototype, mappedSource.prototype);
-    // const mappedTypeMetadata: MappedType.TypeMapping[] = [];
-    const m = Reflect.getOwnMetadata(DATATYPE_METADATA, mappedSource);
-    if (!m)
-        throw new TypeError(`Class "${mappedSource}" doesn't have datatype metadata information`);
-    if (!(m.kind === OpraSchema.ComplexType.Kind || m.kind === OpraSchema.MappedType.Kind || m.kind === OpraSchema.MixinType.Kind))
-        throw new TypeError(`Class "${mappedSource}" is not a ${OpraSchema.ComplexType.Kind}`);
-    const metadata = {
-        kind: 'MappedType',
-        base: mappedSource
-    };
-    if (options.pick)
-        metadata.pick = options.pick;
-    if (options.omit)
-        metadata.omit = options.omit;
-    if (options.partial)
-        metadata.partial = options.partial;
-    Reflect.defineMetadata(DATATYPE_METADATA, metadata, MappedClass);
-    MappedType._applyMixin(MappedClass, mappedSource, {
-        ...options,
-        isInheritedPredicate
-    });
-    return MappedClass;
-};
+}
 MappedType.prototype = MappedTypeClass.prototype;
 MappedType._applyMixin = () => void 0;

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

@@ -1,47 +1,103 @@
 import 'reflect-metadata';
-import merge from 'putil-merge';
-import { inheritPropertyInitializers, mergePrototype, } from '../../helpers/index.js';
+import { asMutable } from 'ts-gems';
+import { inheritPropertyInitializers, mergePrototype, omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { DATATYPE_METADATA } from '../constants.js';
-import { MixinTypeClass } from './mixin-type-class.js';
+import { DATATYPE_METADATA, DECORATOR } from '../constants.js';
+import { ApiField } from './api-field.js';
+import { ComplexTypeBase } from './complex-type-base.js';
 /**
  * @class MixinType
  */
 export const MixinType = function (...args) {
+    // MixinType factory
+    if (!this)
+        return MixinType[DECORATOR].apply(undefined, args);
     // Constructor
-    if (this) {
-        const [document, init] = args;
-        merge(this, new MixinTypeClass(document, init), { descriptor: true });
-        return;
+    const [owner, initArgs, context] = args;
+    ComplexTypeBase.call(this, owner, initArgs, context);
+    const _this = asMutable(this);
+    _this.kind = OpraSchema.MixinType.Kind;
+    _this.types = [];
+    for (const base of initArgs.types) {
+        if (_this.additionalFields !== true) {
+            if (base.additionalFields === true)
+                _this.additionalFields = true;
+            else if (!_this.additionalFields)
+                _this.additionalFields = base.additionalFields;
+        }
+        for (const v of base.fields.values()) {
+            const field = new ApiField(this, v);
+            _this.fields.set(field.name, field);
+        }
+        _this.types.push(base);
+        if (base.keyField)
+            _this.keyField = base.keyField;
+    }
+};
+/**
+ *
+ * @class MixinType
+ */
+class MixinTypeClass extends ComplexTypeBase {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof ComplexTypeBase))
+            return false;
+        if (baseType === this)
+            return true;
+        for (const t of this.types) {
+            if (t.extendsFrom(baseType))
+                return true;
+        }
+        return false;
     }
-    // MixinType helper
+    toJSON() {
+        return omitUndefined({
+            ...ComplexTypeBase.prototype.toJSON.call(this),
+            kind: this.kind,
+            types: this.types.map(t => {
+                const baseName = this.node.getDataTypeNameWithNs(t);
+                return baseName ? baseName : t.toJSON();
+            }),
+        });
+    }
+}
+MixinType.prototype = MixinTypeClass.prototype;
+MixinType[DECORATOR] = MixinTypeFactory;
+/**
+ *
+ */
+function MixinTypeFactory(...args) {
     // Filter undefined items
-    const clasRefs = [...args].filter(x => !!x);
+    const clasRefs = args.filter(x => typeof x === 'function');
+    const options = typeof args[args.length - 1] === 'object' ? args[args.length - 1] : undefined;
     if (!clasRefs.length)
         throw new TypeError('No Class has been provided');
     if (clasRefs.length === 1)
         return clasRefs[0];
-    class MixinClass {
-        constructor() {
-            for (const c of clasRefs)
-                inheritPropertyInitializers(this, c);
-        }
-    }
+    const className = clasRefs[0].name + 'Mixin';
+    const MixinClass = {
+        [className]: class {
+            constructor() {
+                for (const c of clasRefs)
+                    inheritPropertyInitializers(this, c);
+            }
+        },
+    }[className];
     const metadata = {
+        ...options,
         kind: OpraSchema.MixinType.Kind,
-        types: []
+        types: [],
     };
     Reflect.defineMetadata(DATATYPE_METADATA, metadata, MixinClass);
     for (const c of clasRefs) {
         const itemMeta = Reflect.getMetadata(DATATYPE_METADATA, c);
-        if (!(itemMeta && (itemMeta.kind === OpraSchema.ComplexType.Kind || itemMeta.kind === OpraSchema.MixinType.Kind ||
-            itemMeta.kind === OpraSchema.MappedType.Kind)))
+        if (!(itemMeta &&
+            (itemMeta.kind === OpraSchema.ComplexType.Kind ||
+                itemMeta.kind === OpraSchema.MixinType.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(MixinType.prototype, c.prototype);
+        mergePrototype(MixinClass.prototype, c.prototype);
     }
-    MixinType._applyMixin(MixinClass, ...clasRefs);
     return MixinClass;
-};
-MixinType.prototype = MixinTypeClass.prototype;
-MixinType._applyMixin = () => void 0;
+}

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

@@ -0,0 +1,7 @@
+import { createMappedClass } from './utils/create-mapped-class.js';
+/**
+ *
+ */
+export function OmitType(baseType, keys, options) {
+    return createMappedClass(baseType, { omit: keys }, options);
+}

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

@@ -0,0 +1,9 @@
+import { createMappedClass } from './utils/create-mapped-class.js';
+/**
+ *
+ */
+export function PartialType(base, ...args) {
+    const keys = Array.isArray(args[0]) ? args[0] : true;
+    const options = Array.isArray(args[0]) ? args[1] : args[0];
+    return createMappedClass(base, { partial: keys }, options);
+}

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

@@ -0,0 +1,7 @@
+import { createMappedClass } from './utils/create-mapped-class.js';
+/**
+ *
+ */
+export function PickType(baseType, keys, options) {
+    return createMappedClass(baseType, { pick: keys }, options);
+}

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

@@ -0,0 +1,22 @@
+import { __decorate } from "tslib";
+import { isAny } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let AnyType = class AnyType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
+    [DECODER]() {
+        return isAny;
+    }
+    [ENCODER]() {
+        return isAny;
+    }
+};
+AnyType = __decorate([
+    SimpleType({
+        description: 'Represents any value',
+    })
+], AnyType);
+export { AnyType };

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

@@ -0,0 +1,27 @@
+import { __decorate } from "tslib";
+import { toBigint, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+import { NumberType } from './number.type.js';
+let BigintType = class BigintType extends NumberType {
+    constructor(attributes) {
+        super(attributes);
+    }
+    [DECODER](properties) {
+        const x = [];
+        if (properties.minValue)
+            x.push(vg.isGte(properties.minValue));
+        if (properties.maxValue)
+            x.push(vg.isLte(properties.maxValue));
+        return x.length > 0 ? vg.pipe([toBigint, ...x], { returnIndex: 0 }) : toBigint;
+    }
+    [ENCODER](properties) {
+        return this[DECODER](properties);
+    }
+};
+BigintType = __decorate([
+    SimpleType({
+        description: 'BigInt number',
+    })
+], BigintType);
+export { BigintType };

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

@@ -0,0 +1,22 @@
+import { __decorate } from "tslib";
+import { toBoolean } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let BooleanType = class BooleanType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
+    [DECODER]() {
+        return toBoolean;
+    }
+    [ENCODER]() {
+        return toBoolean;
+    }
+};
+BooleanType = __decorate([
+    SimpleType({
+        description: 'Simple true/false value',
+    })
+], BooleanType);
+export { BooleanType };

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

@@ -0,0 +1,8 @@
+export * from './any.type.js';
+export * from './bigint.type.js';
+export * from './boolean.type.js';
+export * from './integer.type.js';
+export * from './null.type.js';
+export * from './number.type.js';
+export * from './object.type.js';
+export * from './string.type.js';

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

@@ -0,0 +1,27 @@
+import { __decorate } from "tslib";
+import { toInteger, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+import { NumberType } from './number.type.js';
+let IntegerType = class IntegerType extends NumberType {
+    constructor(properties) {
+        super(properties);
+    }
+    [DECODER](properties) {
+        const x = [];
+        if (properties.minValue)
+            x.push(vg.isGte(properties.minValue));
+        if (properties.maxValue)
+            x.push(vg.isLte(properties.maxValue));
+        return x.length > 0 ? vg.pipe([toInteger, ...x], { returnIndex: 0 }) : toInteger;
+    }
+    [ENCODER](properties) {
+        return this[DECODER](properties);
+    }
+};
+IntegerType = __decorate([
+    SimpleType({
+        description: 'An integer number',
+    })
+], IntegerType);
+export { IntegerType };

package/esm/document/data-type/{builtin → primitive-types}/null.type.js

@@ -1,13 +1,22 @@
 import { __decorate } from "tslib";
 import { isNull } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
 let NullType = class NullType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
+    [DECODER]() {
+        return isNull;
+    }
+    [ENCODER]() {
+        return isNull;
+    }
 };
 NullType = __decorate([
     SimpleType({
         description: 'A Null value',
-        decoder: isNull,
-        encoder: isNull
     })
 ], NullType);
 export { NullType };

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

@@ -0,0 +1,37 @@
+import { __decorate } from "tslib";
+import { toNumber, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let NumberType = class NumberType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
+    [DECODER](properties) {
+        const x = [];
+        if (properties.minValue)
+            x.push(vg.isGte(properties.minValue));
+        if (properties.maxValue)
+            x.push(vg.isLte(properties.maxValue));
+        return x.length > 0 ? vg.pipe([toNumber, ...x], { returnIndex: 0 }) : toNumber;
+    }
+    [ENCODER](properties) {
+        return this[DECODER](properties);
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Determines the minimum value',
+    })
+], NumberType.prototype, "minValue", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Determines the maximum value',
+    })
+], NumberType.prototype, "maxValue", void 0);
+NumberType = __decorate([
+    SimpleType({
+        description: 'Both Integer as well as Floating-Point numbers',
+    })
+], NumberType);
+export { NumberType };

package/esm/document/data-type/{builtin → primitive-types}/object.type.js

@@ -1,13 +1,19 @@
 import { __decorate } from "tslib";
+import { DATATYPE_METADATA } from '../../constants.js';
 import { ComplexType } from '../complex-type.js';
 let ObjectType = class ObjectType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
 };
 ObjectType = __decorate([
     ComplexType({
         name: 'object',
         description: 'A non modelled object',
         additionalFields: true,
-        ctor: Object
     })
 ], ObjectType);
 export { ObjectType };
+const metadata = Reflect.getMetadata(DATATYPE_METADATA, ObjectType);
+metadata.ctor = Object;