@opra/common 0.33.13 → 1.0.0-alpha.10

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

@@ -0,0 +1,56 @@
+import { __decorate, __metadata } from "tslib";
+import { toString, validator, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let FieldPathType = class FieldPathType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER](properties, element) {
+        const dataType = properties.dataType
+            ? element.node.getComplexType(properties.dataType)
+            : element.node.getComplexType('object');
+        const allowSigns = properties.allowSigns;
+        const decodeFieldPath = validator('decodeFieldPath', (input) => dataType.normalizeFieldPath(input, { allowSigns }));
+        return vg.pipe([toString, decodeFieldPath]);
+    }
+    [ENCODER](properties, element) {
+        return this[DECODER](properties, element);
+    }
+    toJSON(properties, element) {
+        const dataType = properties.dataType
+            ? element.node.getComplexType(properties.dataType)
+            : element.node.getComplexType('object');
+        const typeName = dataType ? element.node.getDataTypeNameWithNs(dataType) : undefined;
+        return {
+            dataType: typeName ? typeName : dataType.toJSON(),
+            allowSigns: properties.allowSigns,
+        };
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Data type which field belong to',
+    }),
+    __metadata("design:type", Object)
+], FieldPathType.prototype, "dataType", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Determines if signs (+,-) are allowed. ' +
+            'If set "first" signs are allowed only beginning of the field path' +
+            'If set "each" signs are allowed at each field in the path',
+    }),
+    __metadata("design:type", String)
+], FieldPathType.prototype, "allowSigns", void 0);
+FieldPathType = __decorate([
+    SimpleType({
+        description: 'Field path',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], FieldPathType);
+export { FieldPathType };

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

@@ -0,0 +1,76 @@
+import { __decorate, __metadata } from "tslib";
+import { validator } from 'valgen';
+import { FilterRules } from '../../../filter/filter-rules.js';
+import { OpraFilter } from '../../../filter/index.js';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let FilterType = class FilterType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER](properties, element) {
+        const dataType = properties.dataType
+            ? element.node.getComplexType(properties.dataType)
+            : element.node.getComplexType('object');
+        const rules = properties.rules ? new FilterRules(properties.rules) : undefined;
+        return decodeFilter(dataType, rules);
+    }
+    [ENCODER]() {
+        return encodeFilter;
+    }
+    toJSON(properties, element) {
+        const dataType = properties.dataType
+            ? element.node.getComplexType(properties.dataType)
+            : element.node.getComplexType('object');
+        return {
+            dataType: dataType.name ? dataType.name : dataType.toJSON(),
+            rules: properties.rules,
+        };
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Data type which filtering fields belong to',
+    }),
+    __metadata("design:type", Object)
+], FilterType.prototype, "dataType", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Stringified JSON object defines filtering rules',
+        format: 'string',
+    }),
+    __metadata("design:type", Object)
+], FilterType.prototype, "rules", void 0);
+FilterType = __decorate([
+    SimpleType({
+        description: 'A query filter',
+        nameMappings: {
+            js: 'object',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], FilterType);
+export { FilterType };
+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;
+        }
+        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();
+    }
+    context.fail(_this, `Not a valid filter expression`, input);
+});

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

@@ -0,0 +1,13 @@
+export * from './base64.type.js';
+export * from './date.type.js';
+export * from './date-string.type.js';
+export * from './date-time.type.js';
+export * from './date-time-string.type.js';
+export * from './email.type.js';
+export * from './field-path.type.js';
+export * from './filter.type.js';
+export * from './object-id.type.js';
+export * from './operation-result.type.js';
+export * from './time.type.js';
+export * from './url.type.js';
+export * from './uuid.type.js';

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

@@ -0,0 +1,27 @@
+import { __decorate, __metadata } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let ObjectIdType = class ObjectIdType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER]() {
+        return vg.isObjectId({ coerce: true });
+    }
+    [ENCODER]() {
+        return vg.isObjectId({ coerce: true });
+    }
+};
+ObjectIdType = __decorate([
+    SimpleType({
+        description: 'A MongoDB ObjectID value',
+        nameMappings: {
+            js: 'object',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], ObjectIdType);
+export { ObjectIdType };

package/esm/document/data-type/extended-types/operation-result.type.js

@@ -0,0 +1,63 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiField } from '../api-field.js';
+import { ComplexType } from '../complex-type.js';
+let OperationResult = class OperationResult {
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+    }
+};
+__decorate([
+    ApiField(),
+    __metadata("design:type", Number)
+], OperationResult.prototype, "affected", void 0);
+__decorate([
+    ApiField(),
+    __metadata("design:type", Number)
+], OperationResult.prototype, "totalMatches", void 0);
+__decorate([
+    ApiField(),
+    __metadata("design:type", String)
+], OperationResult.prototype, "context", void 0);
+__decorate([
+    ApiField(),
+    __metadata("design:type", String)
+], OperationResult.prototype, "type", void 0);
+__decorate([
+    ApiField(),
+    __metadata("design:type", String)
+], OperationResult.prototype, "message", void 0);
+__decorate([
+    ApiField({ type: 'any' }),
+    __metadata("design:type", Object)
+], OperationResult.prototype, "payload", void 0);
+__decorate([
+    ApiField({ type: 'object' }),
+    __metadata("design:type", Array)
+], OperationResult.prototype, "errors", void 0);
+OperationResult = __decorate([
+    ComplexType({
+        description: 'Operation result',
+    }),
+    __metadata("design:paramtypes", [Object])
+], OperationResult);
+export { OperationResult };
+(function (OperationResult) {
+    function forPayload(type) {
+        let OperationResult_ = class OperationResult_ extends OperationResult {
+            constructor(...args) {
+                super(...args);
+            }
+        };
+        __decorate([
+            ApiField({ type, required: true }),
+            __metadata("design:type", Object)
+        ], OperationResult_.prototype, "payload", void 0);
+        OperationResult_ = __decorate([
+            ComplexType({ embedded: true }),
+            __metadata("design:paramtypes", [Object])
+        ], OperationResult_);
+        return OperationResult_;
+    }
+    OperationResult.forPayload = forPayload;
+})(OperationResult || (OperationResult = {}));

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

@@ -0,0 +1,51 @@
+import { __decorate, __metadata } 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',
+    }),
+    __metadata("design:type", String)
+], TimeType.prototype, "minValue", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Maximum value',
+    }),
+    __metadata("design:type", String)
+], TimeType.prototype, "maxValue", void 0);
+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'),
+    __metadata("design:paramtypes", [Object])
+], TimeType);
+export { TimeType };

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

@@ -0,0 +1,27 @@
+import { __decorate, __metadata } 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',
+        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

@@ -0,0 +1,33 @@
+import { __decorate, __metadata } 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',
+    }),
+    __metadata("design:type", Number)
+], UuidType.prototype, "version", void 0);
+UuidType = __decorate([
+    SimpleType({
+        description: 'A Universal Unique Identifier (UUID) value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], UuidType);
+export { UuidType };

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

@@ -1,68 +1,95 @@
 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 { DataType } from './data-type.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 DataType))
+            baseType = this.node.getDataType(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;
+MappedType._applyMixin = () => undefined;

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

@@ -1,47 +1,107 @@
 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';
+import { DataType } from './data-type.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 DataType))
+            baseType = this.node.getDataType(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;
+    }
+    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 helper
+}
+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);
+}