@opra/common 0.33.13 → 1.0.0-alpha.2

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

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

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

@@ -0,0 +1,77 @@
+import { __decorate } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let EmailType = class EmailType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER](properties) {
+        return vg.isEmail({ ...properties, coerce: true });
+    }
+    [ENCODER](properties) {
+        return vg.isEmail({ ...properties, coerce: true });
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'If set to `true`, the validator will also match `Display Name <email-address>',
+        default: false,
+    })
+], EmailType.prototype, "allowDisplayName", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'If set to `true`, the validator will reject strings without the format `Display Name <email-address>',
+        default: false,
+    })
+], EmailType.prototype, "requireDisplayName", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: "If set to `false`, the validator will not allow any non-English UTF8 character in email address's local part",
+        default: true,
+    })
+], EmailType.prototype, "utf8LocalPart", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'If set to `true`, the validator will not check for the standard max length of an email',
+        default: false,
+    })
+], EmailType.prototype, "ignoreMaxLength", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'If set to `true`, the validator will allow IP addresses in the host part',
+        default: false,
+    })
+], EmailType.prototype, "allowIpDomain", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'If set to `true`, some additional validation will be enabled, ' +
+            'e.g. disallowing certain syntactically valid email addresses that are rejected by GMail.',
+        default: false,
+    })
+], EmailType.prototype, "domainSpecificValidation", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'If set to an array of strings and the part of the email after the @ symbol ' +
+            ' one of the strings defined in it, the validation fails.',
+    })
+], EmailType.prototype, "hostBlacklist", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'If set to an array of strings and the part of the email after the @ symbol ' +
+            ' matches none of the strings defined in it, the validation fails.',
+    })
+], EmailType.prototype, "hostWhitelist", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'If set to a string, then the validator will reject emails that include ' +
+            ' any of the characters in the string, in the name part.',
+    })
+], EmailType.prototype, "blacklistedChars", void 0);
+EmailType = __decorate([
+    SimpleType({
+        description: 'An email value',
+    }).Example('some.body@example.com')
+], EmailType);
+export { EmailType };

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

@@ -0,0 +1,50 @@
+import { __decorate } 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', function (input) {
+            return 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');
+        return {
+            dataType: dataType.name ? dataType.name : dataType.toJSON(),
+            allowSigns: properties.allowSigns,
+        };
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Data type which field belong to',
+    })
+], 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',
+    })
+], FieldPathType.prototype, "allowSigns", void 0);
+FieldPathType = __decorate([
+    SimpleType({
+        description: 'Field path',
+    })
+], FieldPathType);
+export { FieldPathType };

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

@@ -0,0 +1,71 @@
+import { __decorate } 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',
+    })
+], FilterType.prototype, "dataType", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Stringified JSON object defines filtering rules',
+        format: 'string',
+    })
+], FilterType.prototype, "rules", void 0);
+FilterType = __decorate([
+    SimpleType({
+        description: 'A query filter',
+    })
+], FilterType);
+export { FilterType };
+const decodeFilter = (dataType, rules) => {
+    return validator('decodeFilter', function (input, context, _this) {
+        if (typeof input === 'string') {
+            try {
+                const filter = OpraFilter.parse(input);
+                if (rules)
+                    return rules.normalizeFilter(filter, dataType);
+                return filter;
+            }
+            catch (e) {
+                context.fail(_this, `Not a valid filter expression. ${e.message}`, input, e.errors);
+                return;
+            }
+        }
+        context.fail(_this, `Nt a valid filter expression string`, input);
+    });
+};
+const encodeFilter = validator('encodeFilter', function (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,22 @@
+import { __decorate } 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',
+    })
+], ObjectIdType);
+export { ObjectIdType };

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;