@opra/common 0.33.13 → 1.0.0-alpha.2

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

@@ -0,0 +1,180 @@
+import { asMutable } from 'ts-gems';
+import { validator, vg } from 'valgen';
+import { parseFieldsProjection, ResponsiveMap } from '../../helpers/index.js';
+import { translate } from '../../i18n/index.js';
+import { DataType } from './data-type.js';
+export const FIELD_PATH_PATTERN = /^([+-])?([a-z$_][\w.]*)$/i;
+/**
+ *
+ * @constructor
+ */
+export const ComplexTypeBase = function (...args) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    // Constructor
+    const [owner, initArgs, context] = args;
+    DataType.call(this, owner, initArgs, context);
+    const _this = asMutable(this);
+    _this.fields = new ResponsiveMap();
+};
+/**
+ *
+ */
+class ComplexTypeBaseClass extends DataType {
+    /**
+     *
+     */
+    findField(nameOrPath) {
+        if (nameOrPath.includes('.')) {
+            const fieldPath = this.parseFieldPath(nameOrPath);
+            const lastItem = fieldPath.pop();
+            return lastItem?.field;
+        }
+        return this.fields.get(nameOrPath);
+    }
+    /**
+     *
+     */
+    getField(nameOrPath) {
+        const field = this.findField(nameOrPath);
+        if (!field)
+            throw new Error(translate('error:UNKNOWN_FIELD', { field: nameOrPath }));
+        return field;
+    }
+    /**
+     *
+     */
+    parseFieldPath(fieldPath, options) {
+        let dataType = this;
+        let field;
+        const arr = fieldPath.split('.');
+        const len = arr.length;
+        const out = [];
+        const objectType = this.owner.node.getDataType('object');
+        const allowSigns = options?.allowSigns;
+        const getStrPath = () => out.map(x => x.fieldName).join('.');
+        for (let i = 0; i < len; i++) {
+            const item = {
+                fieldName: arr[i],
+                dataType: objectType,
+            };
+            out.push(item);
+            const m = FIELD_PATH_PATTERN.exec(arr[i]);
+            if (!m)
+                throw new TypeError(`Invalid field name (${getStrPath()})`);
+            if (m[1]) {
+                if ((i === 0 && allowSigns === 'first') || allowSigns === 'each')
+                    item.sign = m[1];
+                item.fieldName = m[2];
+            }
+            if (dataType) {
+                if (dataType instanceof ComplexTypeBase) {
+                    field = dataType.fields.get(item.fieldName);
+                    if (field) {
+                        item.fieldName = field.name;
+                        item.field = field;
+                        item.dataType = field.type;
+                        dataType = field.type;
+                        continue;
+                    }
+                    if (dataType.additionalFields?.[0] === true) {
+                        item.additionalField = true;
+                        item.dataType = objectType;
+                        dataType = undefined;
+                        continue;
+                    }
+                    if (dataType.additionalFields?.[0] === 'type' && dataType.additionalFields?.[1] instanceof DataType) {
+                        item.additionalField = true;
+                        item.dataType = dataType.additionalFields[1];
+                        dataType = dataType.additionalFields[1];
+                        continue;
+                    }
+                    throw new Error(`Unknown field (${out.map(x => x.fieldName).join('.')})`);
+                }
+                throw new TypeError(`"${out.map(x => x.fieldName).join('.')}" field is not a complex type and has no child fields`);
+            }
+            item.additionalField = true;
+            item.dataType = objectType;
+        }
+        return out;
+    }
+    /**
+     *
+     */
+    normalizeFieldPath(fieldPath, options) {
+        return this.parseFieldPath(fieldPath, options)
+            .map(x => (x.sign || '') + x.fieldName)
+            .join('.');
+    }
+    /**
+     *
+     */
+    generateCodec(codec, options) {
+        const projection = Array.isArray(options?.projection)
+            ? parseFieldsProjection(options.projection)
+            : options?.projection;
+        const schema = this._generateSchema(codec, { ...options, projection, currentPath: '' });
+        let additionalFields;
+        if (this.additionalFields instanceof DataType)
+            additionalFields = this.additionalFields.generateCodec(codec, options);
+        else if (typeof this.additionalFields === 'boolean')
+            additionalFields = this.additionalFields;
+        else if (Array.isArray(this.additionalFields)) {
+            if (this.additionalFields.length < 2)
+                additionalFields = 'error';
+            else {
+                const message = additionalFields[1];
+                additionalFields = validator((input, context, _this) => context.fail(_this, message, input));
+            }
+        }
+        return vg.isObject(schema, {
+            ctor: this.ctor,
+            additionalFields,
+            name: this.name,
+            coerce: true,
+            caseInSensitive: options?.caseInSensitive,
+            onFail: options?.onFail,
+        });
+    }
+    _generateSchema(codec, context) {
+        const schema = {};
+        const { currentPath, projection } = context;
+        const pickList = !!(projection && Object.values(projection).find(p => !p.sign));
+        // Process fields
+        let fieldName;
+        for (const field of this.fields.values()) {
+            fieldName = field.name;
+            let p;
+            if (projection !== '*') {
+                p = projection?.[fieldName.toLowerCase()];
+                if (
+                /** Ignore if field is omitted */
+                p?.sign === '-' ||
+                    /** Ignore if default fields ignored and field is not in projection */
+                    (pickList && !p) ||
+                    /** Ignore if default fields enabled and fields is exclusive */
+                    (!pickList && field.exclusive && !p)) {
+                    schema[field.name] = vg.isUndefined({ coerce: true });
+                    continue;
+                }
+            }
+            const fn = this._generateFieldCodec(codec, field, {
+                ...context,
+                partial: context.partial === 'deep' ? context.partial : undefined,
+                projection: projection !== '*' ? projection : p?.projection,
+                currentPath: currentPath + (currentPath ? '.' : '') + fieldName,
+            });
+            schema[fieldName] = context.partial || !field.required ? vg.optional(fn) : vg.required(fn);
+        }
+        return schema;
+    }
+    _generateFieldCodec(codec, field, context) {
+        let fn = field.type.generateCodec(codec, context);
+        if (field.fixed)
+            fn = vg.isEnum([field.fixed]);
+        if (field.isArray)
+            fn = vg.isArray(fn);
+        return fn;
+    }
+}
+ComplexTypeBase.prototype = ComplexTypeBaseClass.prototype;

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

@@ -1,22 +1,99 @@
 import 'reflect-metadata';
-import merge from 'putil-merge';
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
 import { DECORATOR } from '../constants.js';
-import { ComplexTypeDecorator } from './complex-type.decorator.js';
-import { ComplexTypeClass } from './complex-type-class.js';
+import { ComplexTypeDecorator } from '../decorators/complex-type.decorator.js';
+import { ApiField } from './api-field.js';
+import { ComplexTypeBase } from './complex-type-base.js';
+import { DataType } from './data-type.js';
 /**
- * @class ComplexType
- * @decorator ComplexType
+ * ComplexType constructor
  */
 export const ComplexType = function (...args) {
     // Decorator
-    if (!this) {
-        const [options] = args;
-        return ComplexType[DECORATOR](options);
-    }
+    if (!this)
+        return ComplexType[DECORATOR].apply(undefined, args);
     // Constructor
-    const [document, init] = args;
-    merge(this, new ComplexTypeClass(document, init), { descriptor: true });
+    const [owner, initArgs] = args;
+    const context = args[2] || new DocumentInitContext({ maxErrors: 0 });
+    ComplexTypeBase.call(this, owner, initArgs, context);
+    const _this = asMutable(this);
+    _this.kind = OpraSchema.ComplexType.Kind;
+    _this.additionalFields = initArgs.additionalFields;
+    _this.keyField = initArgs.keyField;
+    if (initArgs.base) {
+        context.enter('.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;
+            if (_this.additionalFields == null && _this.base.additionalFields)
+                _this.additionalFields = _this.base.additionalFields;
+            /** Copy fields from base */
+            for (const v of _this.base.fields.values()) {
+                this.fields.set(v.name, new ApiField(this, v));
+            }
+        });
+    }
+    _this.ctor = initArgs.ctor || _this.base?.ctor;
+    /** Add own fields */
+    if (initArgs.fields) {
+        context.enter('.fields', () => {
+            for (const [k, v] of Object.entries(initArgs.fields)) {
+                const field = new ApiField(this, {
+                    ...v,
+                    name: k,
+                });
+                this.fields.set(field.name, field);
+            }
+        });
+    }
 };
+/**
+ *
+ * @class ComplexType
+ */
+class ComplexTypeClass extends ComplexTypeBase {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof ComplexTypeBase))
+            return false;
+        if (baseType === this)
+            return true;
+        return !!this.base?.extendsFrom(baseType);
+    }
+    toJSON() {
+        const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : undefined;
+        const out = omitUndefined({
+            ...ComplexTypeBase.prototype.toJSON.call(this),
+            kind: this.kind,
+            base: this.base ? (baseName ? baseName : this.base.toJSON()) : undefined,
+        });
+        if (this.additionalFields) {
+            if (this.additionalFields instanceof DataType) {
+                out.additionalFields = this.additionalFields[1].name
+                    ? this.additionalFields[1].name
+                    : this.additionalFields[1].toJSON();
+            }
+            else
+                out.additionalFields = this.additionalFields;
+        }
+        if (this.fields.size) {
+            const fields = {};
+            let i = 0;
+            for (const field of this.fields.values()) {
+                if (field.origin === this) {
+                    fields[field.name] = field.toJSON();
+                    i++;
+                }
+            }
+            if (i)
+                out.fields = fields;
+        }
+        return omitUndefined(out);
+    }
+}
 ComplexType.prototype = ComplexTypeClass.prototype;
 Object.assign(ComplexType, ComplexTypeDecorator);
 ComplexType[DECORATOR] = ComplexTypeDecorator;

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

@@ -1,40 +1,48 @@
+import { asMutable } from 'ts-gems';
 import { omitUndefined } from '../../helpers/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { CLASS_NAME_PATTERN } from '../constants.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
 /**
+ * DataType constructor
+ */
+export const DataType = function (owner, initArgs, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+context) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    if (initArgs?.name && !CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`"${initArgs.name}" is not a valid DataType name`);
+    DocumentElement.call(this, owner);
+    const _this = asMutable(this);
+    _this.kind = initArgs.kind;
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.abstract = initArgs.abstract;
+    _this.examples = initArgs.examples;
+};
+/**
+ *
  * @class DataType
- * @abstract
  */
-export class DataType {
-    constructor(document, init) {
-        this.document = document;
-        this.name = init?.name;
-        this.own = {};
-        this.description = init?.description;
-        if (!this.name)
-            this.isEmbedded = true;
+class DataTypeClass extends DocumentElement {
+    get embedded() {
+        return !this.name;
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    exportSchema(options) {
+    toJSON() {
         return omitUndefined({
             kind: this.kind,
-            description: this.description
+            description: this.description,
+            abstract: this.abstract,
+            examples: this.examples,
         });
     }
-    extendsFrom(type) {
-        const dataType = type instanceof DataType ? type : this.document.getDataType(type);
-        let t = this;
-        while (t) {
-            if (t === dataType)
-                return true;
-            t = t.base;
-        }
-        return false;
-    }
     toString() {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || '#Embedded'}]`;
     }
     [nodeInspectCustom]() {
-        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
-            ` ${colorFgMagenta + this.name + colorReset}]`;
+        return (`[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
+            ` ${colorFgMagenta + this.name + colorReset}]`);
     }
 }
+DataType.prototype = DataTypeClass.prototype;

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

@@ -1,48 +1,105 @@
 import 'reflect-metadata';
-import merge from 'putil-merge';
-import { omitUndefined } from '../../helpers/index.js';
+import { asMutable } from 'ts-gems';
+import { vg } from 'valgen';
+import { cloneObject, omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { DATATYPE_METADATA } from '../constants.js';
-import { EnumTypeClass } from './enum-type-class.js';
+import { DATATYPE_METADATA, DECORATOR } from '../constants.js';
+import { DataType } from './data-type.js';
 /**
  * @class EnumType
  */
 export const EnumType = function (...args) {
     // Injector
-    if (!this) {
-        const [enumSource, options] = args;
-        let values = {};
-        if (Array.isArray(enumSource)) {
-            values = {};
-            enumSource.forEach(k => {
-                const description = options?.meanings?.[k];
-                values[k] = omitUndefined({ description });
-            });
+    if (!this)
+        return EnumType[DECORATOR].apply(undefined, args);
+    // Constructor
+    const [owner, initArgs, context] = args;
+    DataType.call(this, owner, initArgs, context);
+    const _this = asMutable(this);
+    _this.kind = OpraSchema.EnumType.Kind;
+    if (initArgs.base) {
+        // noinspection SuspiciousTypeOfGuard
+        if (!(initArgs.base instanceof EnumType))
+            throw new TypeError(`"${initArgs.base.kind}" can't be set as base for a "${this.kind}"`);
+        _this.base = initArgs.base;
+    }
+    _this.instance = initArgs.instance;
+    _this.ownAttributes = cloneObject(initArgs.attributes || {});
+    _this.attributes = _this.base ? cloneObject(_this.base.attributes) : {};
+    for (const [k, el] of Object.entries(_this.ownAttributes)) {
+        _this.attributes[k] = el;
+    }
+};
+/**
+ * @class EnumType
+ */
+class EnumTypeClass extends DataType {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof EnumType))
+            return false;
+        if (baseType === this)
+            return true;
+        return !!this.base?.extendsFrom(baseType);
+    }
+    generateCodec() {
+        return vg.isEnum(Object.keys(this.attributes));
+    }
+    toJSON() {
+        const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : undefined;
+        return omitUndefined({
+            ...DataType.prototype.toJSON.call(this),
+            base: this.base ? (baseName ? baseName : this.base.toJSON()) : undefined,
+            attributes: cloneObject(this.ownAttributes),
+        });
+    }
+}
+EnumType.prototype = EnumTypeClass.prototype;
+Object.assign(EnumType, EnumTypeClass);
+/**
+ *
+ */
+function EnumTypeFactory(enumSource, ...args) {
+    const base = args.length >= 2 ? args[0] : undefined;
+    const options = args.length >= 2 ? args[1] : args[0];
+    let attributes = {};
+    let out = enumSource;
+    if (Array.isArray(enumSource)) {
+        if (base) {
+            if (!Array.isArray(base))
+                throw new TypeError('Both "target" and "base" arguments should be array');
+            out = [...base, ...enumSource];
         }
-        else {
-            Object.keys(enumSource).forEach(k => {
-                const description = options?.meanings?.[k];
-                values[enumSource[k]] = omitUndefined({ key: k, description });
-            });
+        attributes = {};
+        enumSource.forEach(k => {
+            const description = options?.meanings?.[k];
+            attributes[k] = omitUndefined({ description });
+        });
+    }
+    else {
+        if (base) {
+            if (Array.isArray(base))
+                throw new TypeError('Both "target" and "base" arguments should be enum object');
+            out = { ...base, ...enumSource };
         }
-        const metadata = {
-            kind: OpraSchema.EnumType.Kind,
-            values,
-            base: options?.base,
-            name: options?.name,
-            description: options?.description
-        };
-        Object.defineProperty(enumSource, DATATYPE_METADATA, {
-            value: metadata,
-            enumerable: false,
-            configurable: true,
-            writable: true
+        Object.keys(enumSource).forEach(k => {
+            const description = options?.meanings?.[k];
+            attributes[enumSource[k]] = omitUndefined({ alias: k, description });
         });
-        return metadata;
     }
-    // Constructor
-    const [document, init] = args;
-    merge(this, new EnumTypeClass(document, init), { descriptor: true });
-    return;
-};
+    const metadata = {
+        kind: OpraSchema.EnumType.Kind,
+        attributes,
+        base: options.base,
+        name: options.name,
+        description: options?.description,
+    };
+    Object.defineProperty(enumSource, DATATYPE_METADATA, {
+        value: metadata,
+        enumerable: false,
+        configurable: true,
+        writable: true,
+    });
+    return out;
+}
 EnumType.prototype = EnumTypeClass.prototype;
+EnumType[DECORATOR] = EnumTypeFactory;

package/esm/document/data-type/extended-types/base64.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 Base64Type = class Base64Type {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER]() {
+        return vg.isBase64({ coerce: true });
+    }
+    [ENCODER]() {
+        return vg.isBase64({ coerce: true });
+    }
+};
+Base64Type = __decorate([
+    SimpleType({
+        description: 'A stream of bytes, base64 encoded',
+    })
+], Base64Type);
+export { Base64Type };

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

@@ -0,0 +1,41 @@
+import { __decorate } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let DateStringType = class DateStringType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER](properties) {
+        const fn = vg.isDateString({ trim: 'date', 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',
+    })
+], DateStringType.prototype, "minValue", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Maximum value',
+    })
+], DateStringType.prototype, "maxValue", void 0);
+DateStringType = __decorate([
+    SimpleType({
+        description: 'Date string value',
+    })
+        .Example('2021-04-18', 'Full date value')
+        .Example('2021-04', 'Date value without day')
+        .Example('2021', 'Year only value')
+], DateStringType);
+export { DateStringType };

package/esm/document/data-type/extended-types/date-time-string.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';
+let DateTimeStringType = class DateTimeStringType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER](properties) {
+        const fn = vg.isDateString({ 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]) : fn;
+    }
+    [ENCODER](properties) {
+        return this[DECODER](properties);
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Minimum value',
+    })
+], DateTimeStringType.prototype, "minValue", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Maximum value',
+    })
+], DateTimeStringType.prototype, "maxValue", void 0);
+DateTimeStringType = __decorate([
+    SimpleType({
+        description: 'DateTime string value',
+    })
+        .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')
+        .Example('2021-04-18 22:30', 'Date-time value')
+        .Example('2021-04-18', 'Date value')
+        .Example('2021-04', 'Date value without day')
+        .Example('2021', 'Year only value')
+], DateTimeStringType);
+export { DateTimeStringType };

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

@@ -0,0 +1,55 @@
+import { __decorate } from "tslib";
+import { isDateString, toString, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let DateTimeType = class DateTimeType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER](properties) {
+        const fn = vg.isDate({ precision: 'time', coerce: true });
+        const x = [];
+        if (properties.minValue) {
+            isDateString(properties.minValue);
+            x.push(toString, vg.isGte(properties.minValue));
+        }
+        if (properties.maxValue) {
+            isDateString(properties.maxValue);
+            x.push(toString, vg.isLte(properties.maxValue));
+        }
+        return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    }
+    [ENCODER](properties) {
+        const fn = vg.isDateString({ precision: 'time', trim: 'time', coerce: true });
+        const x = [];
+        if (properties.minValue) {
+            isDateString(properties.minValue);
+            x.push(vg.isGte(properties.minValue));
+        }
+        if (properties.maxValue) {
+            isDateString(properties.maxValue);
+            x.push(vg.isLte(properties.maxValue));
+        }
+        return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Minimum value',
+    })
+], DateTimeType.prototype, "minValue", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Maximum value',
+    })
+], DateTimeType.prototype, "maxValue", void 0);
+DateTimeType = __decorate([
+    SimpleType({
+        description: 'A full datetime value',
+    })
+        .Example('2021-04-18T22:30:15')
+        .Example('2021-04-18 22:30:15')
+        .Example('2021-04-18 22:30')
+], DateTimeType);
+export { DateTimeType };