@opra/common 0.18.4 → 0.19.0

package/esm/document/data-type/builtin/boolean.type.js

@@ -1,25 +1,12 @@
 import { __decorate } from "tslib";
-import { toBoolean } from 'putil-varhelpers';
+import { isBoolean } from 'valgen';
 import { SimpleType } from '../simple-type.js';
-let BooleanType = class BooleanType {
-    decode(v) {
-        if (v == null)
-            return v;
-        return toBoolean(v);
-    }
-    encode(v) {
-        if (v == null)
-            return v;
-        return toBoolean(v);
-    }
-    coerce(v) {
-        return this.decode(v);
-    }
+export let BooleanType = class BooleanType {
 };
 BooleanType = __decorate([
     SimpleType({
         description: 'Simple true/false value',
-        ctor: Boolean
+        decoder: isBoolean(),
+        encoder: isBoolean()
     })
 ], BooleanType);
-export { BooleanType };

package/esm/document/data-type/builtin/date.type.js

@@ -1,15 +1,19 @@
 import { __decorate } from "tslib";
+import { isDate, isDateString } from 'valgen';
 import { SimpleType } from '../simple-type.js';
-import { TimestampType } from './timestamp.type.js';
-let DateType = class DateType extends TimestampType {
-    constructor() {
-        super(...arguments);
-        this.format = 'YYYY-MM-DD';
-    }
+export let DateType = class DateType {
 };
 DateType = __decorate([
     SimpleType({
-        description: 'full-date notation as defined by RFC 3339, section 5.6, for example, 2021-04-18',
+        description: 'Date only string, for example, 2021-04-18',
+        decoder: isDate({
+            format: ['YYYY-MM-DD', 'YYYY',
+                'YYYY-MM-DDTHH:mm:ss',
+                'YYYY-MM-DDTHH:mm',
+                'YYYY-MM-DD HH:mm:ss',
+                'YYYY-MM-DD HH:mm'
+            ]
+        }),
+        encoder: isDateString({ format: 'YYYY-MM-DD' })
     })
 ], DateType);
-export { DateType };

package/esm/document/data-type/builtin/index.js

@@ -3,8 +3,10 @@ export * from './base64.type.js';
 export * from './bigint.type.js';
 export * from './boolean.type.js';
 export * from './date.type.js';
-export * from './guid.type.js';
+export * from './uuid.type.js';
 export * from './integer.type.js';
 export * from './number.type.js';
 export * from './object.type.js';
 export * from './string.type.js';
+export * from './time.type.js';
+export * from './timestamp.type.js';

package/esm/document/data-type/builtin/integer.type.js

@@ -1,25 +1,12 @@
 import { __decorate } from "tslib";
-import { toInt } from 'putil-varhelpers';
+import { isInteger } from 'valgen';
 import { SimpleType } from '../simple-type.js';
-import { NumberType } from './number.type.js';
-let IntegerType = class IntegerType extends NumberType {
-    decode(v) {
-        if (v == null)
-            return v;
-        return toInt(super.decode(v));
-    }
-    encode(v) {
-        if (v == null)
-            return v;
-        return toInt(super.encode(v));
-    }
-    coerce(v) {
-        return this.decode(v);
-    }
+export let IntegerType = class IntegerType {
 };
 IntegerType = __decorate([
     SimpleType({
         description: 'An integer number',
+        decoder: isInteger(),
+        encoder: isInteger()
     })
 ], IntegerType);
-export { IntegerType };

package/esm/document/data-type/builtin/number.type.js

@@ -1,30 +1,12 @@
 import { __decorate } from "tslib";
-import { toNumber } from 'putil-varhelpers';
+import { isNumber } from 'valgen';
 import { SimpleType } from '../simple-type.js';
-let NumberType = class NumberType {
-    decode(v) {
-        if (v == null)
-            return v;
-        const x = toNumber(v);
-        if (x)
-            this.validate(x);
-        return x;
-    }
-    encode(v) {
-        return this.decode(v);
-    }
-    coerce(v) {
-        return this.decode(v);
-    }
-    validate(v) {
-        if (typeof v !== 'number' || isNaN(v))
-            throw new TypeError(`Invalid number value "${v}"`);
-    }
+export let NumberType = class NumberType {
 };
 NumberType = __decorate([
     SimpleType({
         description: 'Both Integer as well as Floating-Point numbers',
-        ctor: Number
+        decoder: isNumber(),
+        encoder: isNumber()
     })
 ], NumberType);
-export { NumberType };

package/esm/document/data-type/builtin/object.type.js

@@ -1,17 +1,12 @@
 import { __decorate } from "tslib";
 import { ComplexType } from '../complex-type.js';
-let ObjectType = class ObjectType {
-    coerce(v) {
-        if (v == null)
-            return v;
-        return typeof v === 'object' ? v : {};
-    }
+export let ObjectType = class ObjectType {
 };
 ObjectType = __decorate([
     ComplexType({
         name: 'object',
         description: 'A non modelled object',
-        additionalFields: true
+        additionalFields: true,
+        ctor: Object
     })
 ], ObjectType);
-export { ObjectType };

package/esm/document/data-type/builtin/string.type.js

@@ -1,21 +1,12 @@
 import { __decorate } from "tslib";
-import { toString } from 'putil-varhelpers';
+import { isString } from 'valgen';
 import { SimpleType } from '../simple-type.js';
-let StringType = class StringType {
-    decode(v) {
-        return toString(v);
-    }
-    encode(v) {
-        return toString(v);
-    }
-    coerce(v) {
-        return this.decode(v);
-    }
+export let StringType = class StringType {
 };
 StringType = __decorate([
     SimpleType({
         description: 'A sequence of characters',
-        ctor: String
+        decoder: isString(),
+        encoder: isString(),
     })
 ], StringType);
-export { StringType };

package/esm/document/data-type/builtin/time.type.js

@@ -1,29 +1,17 @@
 import { __decorate } from "tslib";
+import { isDateString } from 'valgen';
 import { SimpleType } from '../simple-type.js';
-import { StringType } from './string.type.js';
-const TIME_PATTERN = /^([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?$/;
-let TimeType = class TimeType extends StringType {
-    decode(v) {
-        if (v == null)
-            return v;
-        this.validate(v);
-        return v;
-    }
-    encode(v) {
-        return this.decode(v);
-    }
-    coerce(v) {
-        return this.decode(v);
-    }
-    validate(v) {
-        // noinspection SuspiciousTypeOfGuard
-        if (typeof v === 'string' && !TIME_PATTERN.test(v))
-            throw new TypeError(`Invalid Time value "${v}"`);
-    }
+export let TimeType = class TimeType {
 };
 TimeType = __decorate([
     SimpleType({
-        description: 'Time formatted string',
+        description: 'Time string in 24h format, for example, 18:23:00',
+        decoder: isDateString({
+            format: ['HH:mm:ss', 'HH:mm'],
+            onFail: () => '{{label}} is not a valid time'
+        }),
+        encoder: isDateString({ format: ['HH:mm:ss', 'HH:mm'],
+            onFail: () => '{{label}} is not a valid time'
+        })
     })
 ], TimeType);
-export { TimeType };

package/esm/document/data-type/builtin/timestamp.type.js

@@ -1,26 +1,14 @@
 import { __decorate } from "tslib";
-import dayjs from 'dayjs';
+import { isDate, isDateString } from 'valgen';
 import { SimpleType } from '../simple-type.js';
-let TimestampType = class TimestampType {
-    constructor() {
-        this.format = 'YYYY-MM-DDTHH:mm:ss';
-    }
-    decode(v) {
-        return dayjs(v).toDate();
-    }
-    encode(v) {
-        if (!v)
-            return undefined;
-        const d = dayjs(v);
-        if (!d.isValid())
-            throw new TypeError(`Invalid date value ${v}`);
-        return dayjs(v).format(this.format);
-    }
+export let TimestampType = class TimestampType {
 };
 TimestampType = __decorate([
     SimpleType({
-        description: 'date-time notation as defined by RFC 3339, section 5.6, for example, 2021-04-18T09:12:53',
-        ctor: Date
+        description: 'Timestamp, for example, 2021-04-18T09:12:53',
+        decoder: isDate({
+            format: ['YYYY-MM-DDTHH:mm:ss', 'YYYY-MM-DD HH:mm:ss', 'YYYY-MM-DD', 'YYYY']
+        }),
+        encoder: isDateString({ format: 'YYYY-MM-DDTHH:mm:ss' })
     })
 ], TimestampType);
-export { TimestampType };

package/esm/document/data-type/builtin/uuid.type.js

@@ -0,0 +1,12 @@
+import { __decorate } from "tslib";
+import { isUUID } from 'valgen';
+import { SimpleType } from '../simple-type.js';
+export let UuidType = class UuidType {
+};
+UuidType = __decorate([
+    SimpleType({
+        description: 'A Universal Unique Identifier (UUID) value',
+        decoder: isUUID(),
+        encoder: isUUID()
+    })
+], UuidType);

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

@@ -1,4 +1,6 @@
 import omit from 'lodash.omit';
+import merge from 'putil-merge';
+import * as vg from 'valgen';
 import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY, TYPENAME_PATTERN } from '../constants.js';
@@ -7,106 +9,64 @@ import { DataType } from './data-type.js';
 /**
  * @class ComplexType
  */
-export const ComplexType = function (...args) {
-    // ClassDecorator
-    if (!this) {
-        const [options] = args;
-        return function (target) {
-            const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
-            let metadata = Reflect.getOwnMetadata(METADATA_KEY, target);
-            if (!metadata) {
-                metadata = {};
-                Reflect.defineMetadata(METADATA_KEY, metadata, target);
-            }
-            metadata.kind = OpraSchema.ComplexType.Kind;
-            metadata.name = name;
-            // Merge options
-            if (options)
-                Object.assign(metadata, omit(options, ['kind', 'name', 'base', 'ctor', 'fields']));
-        };
-    }
-    // Constructor
-    // call super()
-    DataType.apply(this, args);
-    const [, init] = args;
-    const _this = this;
-    const own = _this.own;
-    own.ctor = init?.ctor;
-    own.fields = new ResponsiveMap();
-    own.abstract = init?.abstract;
-    own.additionalFields = init?.additionalFields;
-    _this.kind = OpraSchema.ComplexType.Kind;
-    _this.base = init?.base;
-    _this.ctor = own.ctor || Object;
-    _this.abstract = own.abstract;
-    _this.additionalFields = own.additionalFields;
-    _this.fields = new ResponsiveMap();
-    if (_this.base) {
-        if (_this.additionalFields == null)
-            _this.additionalFields = _this.base.additionalFields;
-        if (own.ctor == null && _this.base instanceof ComplexType)
-            _this.ctor = _this.base.ctor;
-        if (_this.base.fields)
-            for (const [k, el] of _this.base.fields.entries()) {
-                const newEl = new ApiField(_this, el);
-                _this.fields.set(k, newEl);
-            }
-    }
-};
-Object.setPrototypeOf(ComplexType.prototype, DataType.prototype);
-const proto = {
-    extendsFrom(t) {
-        const base = t instanceof DataType ? t : this.document.getDataType(t);
+class ComplexTypeClass extends DataType {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = OpraSchema.ComplexType.Kind;
+        const own = this.own = {};
+        own.ctor = init?.ctor;
+        own.abstract = init?.abstract;
+        own.additionalFields = init?.additionalFields;
+        own.fields = new ResponsiveMap();
+        this.kind = OpraSchema.ComplexType.Kind;
+        this.base = init?.base;
+        this.ctor = own.ctor || Object;
+        this.abstract = own.abstract;
+        this.additionalFields = own.additionalFields;
+        this.fields = new ResponsiveMap();
         if (this.base) {
-            if (this.base === base)
-                return true;
-            return this.base.extendsFrom(base);
-        }
-        return false;
-    },
-    exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
-            base: this.base ?
-                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-            abstract: this.own.abstract,
-            additionalFields: this.own.additionalFields
-        }));
-        if (this.own.fields.size) {
-            const fields = out.fields = {};
-            for (const field of this.own.fields.values()) {
-                fields[field.name] = field.exportSchema();
-            }
+            if (this.additionalFields == null)
+                this.additionalFields = this.base.additionalFields;
+            if (own.ctor == null && this.base instanceof ComplexType)
+                this.ctor = this.base.ctor;
+            if (this.base.fields)
+                for (const [k, el] of this.base.fields.entries()) {
+                    const newEl = new ApiField(this, el);
+                    this.fields.set(k, newEl);
+                }
         }
-        return omitUndefined(out);
-    },
+    }
     addField(init) {
         const field = new ApiField(this, init);
         this.own.fields.set(field.name, field);
         this.fields.set(field.name, field);
         return field;
-    },
+    }
     findField(nameOrPath) {
         let field;
-        for (const [, f] of this.iteratePath(nameOrPath, true)) {
-            if (!f)
-                return;
-            field = f;
+        if (nameOrPath.includes('.')) {
+            for (const [, f] of this.iteratePath(nameOrPath, true)) {
+                if (!f)
+                    return;
+                field = f;
+            }
+            return field;
         }
-        return field;
-    },
+        return this.fields.get(nameOrPath);
+    }
     getField(nameOrPath) {
         let field;
-        for (const [, f, path] of this.iteratePath(nameOrPath)) {
-            if (!f)
-                throw new Error(`Invalid field definition "${path}"`);
-            field = f;
+        if (nameOrPath.includes('.')) {
+            for (const [, f] of this.iteratePath(nameOrPath)) {
+                field = f;
+            }
         }
-        /* istanbul ignore next */
+        else
+            field = this.fields.get(nameOrPath);
         if (!field)
-            throw new Error(`Invalid field definition "${nameOrPath}"`);
+            throw new Error(`Unknown field "${nameOrPath}"`);
         return field;
-    },
+    }
     iteratePath(path, silent) {
         const arr = path.split('.');
         const len = arr.length;
@@ -148,16 +108,115 @@ const proto = {
                 };
             }
         };
-    },
-    normalizeFieldPath(path) {
-        if (Array.isArray(path))
-            return path.map((s) => this.normalizeFieldPath(s));
+    }
+    normalizeFieldPath(fieldPaths) {
+        if (Array.isArray(fieldPaths))
+            return fieldPaths.map((s) => this.normalizeFieldPath(s));
         let curPath = '';
-        for (const [, , p] of this.iteratePath(path)) {
+        for (const [, , p] of this.iteratePath(fieldPaths)) {
             curPath = p;
         }
         return curPath;
     }
+    exportSchema() {
+        const out = super.exportSchema();
+        Object.assign(out, omitUndefined({
+            base: this.base ?
+                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
+            abstract: this.own.abstract,
+            additionalFields: this.own.additionalFields
+        }));
+        if (this.own.fields.size) {
+            const fields = out.fields = {};
+            for (const field of this.own.fields.values()) {
+                fields[field.name] = field.exportSchema();
+            }
+        }
+        return omitUndefined(out);
+    }
+    isTypeOf(t) {
+        return t === this.own.ctor;
+    }
+    extendsFrom(t) {
+        const base = t instanceof DataType ? t : this.document.getDataType(t);
+        if (this.base) {
+            if (this.base === base)
+                return true;
+            return this.base.extendsFrom(base);
+        }
+        return false;
+    }
+    decode(v) {
+        return this._getDecoder()(v, { coerce: true });
+    }
+    encode(v) {
+        return this._getEncoder()(v, { coerce: true });
+    }
+    validate(v) {
+        return this._getEncoder()(v);
+    }
+    _getDecoder() {
+        if (this._decoder)
+            return this._decoder;
+        const schema = {};
+        for (const f of this.fields.values()) {
+            let t = f.type._getDecoder();
+            if (f.isArray)
+                t = vg.isArray(t);
+            schema[f.name] = f.required ? vg.required(t) : vg.optional(t);
+        }
+        this._decoder = vg.isObject(schema, {
+            ctor: this.ctor,
+            additionalFields: this.additionalFields ?? 'ignore',
+            name: this.name,
+            caseInSensitive: true,
+        });
+        return this._decoder;
+    }
+    _getEncoder() {
+        if (this._encoder)
+            return this._encoder;
+        const schema = {};
+        for (const f of this.fields.values()) {
+            let t = f.type._getEncoder();
+            if (f.isArray)
+                t = vg.isArray(t);
+            schema[f.name] = t;
+        }
+        this._encoder = vg.isObject(schema, {
+            ctor: this.ctor,
+            additionalFields: this.additionalFields,
+            name: this.name,
+            caseInSensitive: true,
+            detectCircular: true
+        });
+        return this._encoder;
+    }
+}
+/**
+ * @class ComplexType
+ */
+export const ComplexType = function (...args) {
+    // Constructor
+    if (this) {
+        const [document, init] = args;
+        merge(this, new ComplexTypeClass(document, init), { descriptor: true });
+        return;
+    }
+    // ClassDecorator
+    const [options] = args;
+    return function (target) {
+        const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
+        let metadata = Reflect.getOwnMetadata(METADATA_KEY, target);
+        if (!metadata) {
+            metadata = {};
+            Reflect.defineMetadata(METADATA_KEY, metadata, target);
+        }
+        metadata.kind = OpraSchema.ComplexType.Kind;
+        metadata.name = name;
+        // Merge options
+        if (options)
+            Object.assign(metadata, omit(options, ['kind', 'name', 'base', 'fields']));
+    };
 };
-Object.assign(ComplexType.prototype, proto);
-Object.setPrototypeOf(ComplexType.prototype, DataType.prototype);
+ComplexType.prototype = ComplexTypeClass.prototype;

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

@@ -1,43 +1,43 @@
 import { omitUndefined } from '../../helpers/index.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
-export const DataType = function (document, init) {
-    if (!(this instanceof DataType)) {
-        throw new TypeError(`Class constructor must be called with "new" keyword`);
-        // noinspection UnreachableCodeJS
-        return;
-    }
-    const _this = this;
-    _this.document = document;
-    _this.name = init?.name;
-    _this.own = {
-        description: init?.description
-    };
-    _this.description = init?.description;
-    return this;
-};
-const proto = {
-    get isAnonymous() {
-        return !this.name;
-    },
-    coerce(value) {
-        return value;
-    },
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    extendsFrom(t) {
-        return false;
-    },
+export class DataType {
+    constructor(document, init) {
+        this.document = document;
+        this.name = init?.name;
+        this.own = {};
+        this.description = init?.description;
+        this.isAnonymous = !this.name;
+    }
+    decode(v) {
+        return this._getDecoder()(v, { coerce: true });
+    }
+    encode(v) {
+        return this._getEncoder()(v, { coerce: true });
+    }
+    validate(v) {
+        return this._getEncoder()(v);
+    }
     exportSchema() {
         return omitUndefined({
             kind: this.kind,
-            description: this.own.description
+            description: this.description
         });
-    },
+    }
+    extendsFrom(type) {
+        const dataType = type instanceof DataType ? type : this.document.getDataType(type);
+        let t = this.base;
+        while (t) {
+            if (t === dataType)
+                return true;
+            t = t.base;
+        }
+        return false;
+    }
     toString() {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || '#anonymous'}]`;
-    },
+    }
     [nodeInspectCustom]() {
         return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
             ` ${colorFgMagenta + this.name + colorReset}]`;
     }
-};
-Object.assign(DataType.prototype, proto);
+}