@opra/common 0.33.13 → 1.0.0-alpha.1

package/esm/document/data-type/decorators/simple-type.decorator.js

@@ -0,0 +1,61 @@
+import omit from 'lodash.omit';
+import { OpraSchema } from '../../../schema/index.js';
+import { CLASS_NAME_PATTERN, DATATYPE_METADATA, EXTRACT_TYPENAME_PATTERN } from '../../constants.js';
+export function SimpleTypeDecoratorFactory(options) {
+    const decoratorChain = [];
+    /**
+     *
+     */
+    const decorator = function (target) {
+        let name;
+        if (!options?.embedded) {
+            if (options?.name) {
+                if (!CLASS_NAME_PATTERN.test(options.name))
+                    throw new TypeError(`"${options.name}" is not a valid type name`);
+                name = options.name;
+            }
+            else {
+                name = target.name.match(EXTRACT_TYPENAME_PATTERN)?.[1] || target.name;
+                name = name.toLowerCase();
+            }
+        }
+        const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target) || {};
+        metadata.kind = OpraSchema.SimpleType.Kind;
+        metadata.name = name;
+        if (options)
+            Object.assign(metadata, omit(options, ['kind', 'name']));
+        Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
+    };
+    decorator.Example = (value, description) => {
+        decoratorChain.push((meta) => {
+            meta.examples = meta.examples || [];
+            meta.examples.push({
+                description,
+                value,
+            });
+        });
+        return decorator;
+    };
+    return decorator;
+}
+export function AttributeDecoratorFactory(options) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError(`Symbol properties can't be decorated with Attribute`);
+        const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
+        const designType = Reflect.getMetadata('design:type', target, propertyKey);
+        let format = 'string';
+        if (designType === Boolean)
+            format = 'boolean';
+        else if (designType === Number)
+            format = 'number';
+        metadata.kind = OpraSchema.SimpleType.Kind;
+        metadata.attributes = metadata.attributes || {};
+        metadata.attributes[propertyKey] = {
+            format: options?.format || format,
+            description: options?.description,
+            deprecated: options?.deprecated,
+        };
+        Reflect.defineMetadata(DATATYPE_METADATA, metadata, target.constructor);
+    };
+}

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 };

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 };