@opra/common 0.33.13 → 1.0.0-alpha.10

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

@@ -1,75 +1,98 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MappedType = exports.PartialType = exports.OmitType = exports.PickType = void 0;
-const tslib_1 = require("tslib");
+exports.MappedType = void 0;
 require("reflect-metadata");
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const ts_gems_1 = require("ts-gems");
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../schema/index.js");
-const constants_js_1 = require("../constants.js");
-const mapped_type_class_js_1 = require("./mapped-type-class.js");
+const api_field_js_1 = require("./api-field.js");
+const complex_type_base_js_1 = require("./complex-type-base.js");
+const data_type_js_1 = require("./data-type.js");
+const get_is_inherited_predicate_fn_js_1 = require("./utils/get-is-inherited-predicate-fn.js");
 /**
- *
- */
-function PickType(classRef, keys) {
-    return (0, exports.MappedType)(classRef, { pick: keys });
-}
-exports.PickType = PickType;
-/**
- *
+ * MappedType constructor
  */
-function OmitType(classRef, keys) {
-    return (0, exports.MappedType)(classRef, { omit: keys });
-}
-exports.OmitType = OmitType;
+exports.MappedType = function (...args) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    // Constructor
+    const [owner, initArgs, context] = args;
+    complex_type_base_js_1.ComplexTypeBase.call(this, owner, initArgs, context);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    _this.kind = index_js_2.OpraSchema.MappedType.Kind;
+    if (initArgs.base) {
+        // noinspection SuspiciousTypeOfGuard
+        if (!(initArgs.base instanceof complex_type_base_js_1.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 = (0, get_is_inherited_predicate_fn_js_1.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 api_field_js_1.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;
+    }
+};
 /**
  *
- */
-function PartialType(classRef, keys) {
-    return (0, exports.MappedType)(classRef, { partial: keys || true });
-}
-exports.PartialType = PartialType;
-/**
  * @class MappedType
  */
-exports.MappedType = function (...args) {
-    // Constructor
-    if (this) {
-        const [document, init] = args;
-        (0, putil_merge_1.default)(this, new mapped_type_class_js_1.MappedTypeClass(document, init), { descriptor: true });
-        return;
+class MappedTypeClass extends complex_type_base_js_1.ComplexTypeBase {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof data_type_js_1.DataType))
+            baseType = this.node.getDataType(baseType);
+        if (!(baseType instanceof complex_type_base_js_1.ComplexTypeBase))
+            return false;
+        if (baseType === this)
+            return true;
+        return !!this.base?.extendsFrom(baseType);
     }
-    // MappedType helper
-    const [mappedSource, options] = args;
-    const isInheritedPredicate = (0, mapped_type_class_js_1.getIsInheritedPredicateFn)(options.pick, options.omit);
-    class MappedClass {
-        constructor() {
-            (0, index_js_1.inheritPropertyInitializers)(this, mappedSource, isInheritedPredicate);
-        }
+    toJSON() {
+        const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : undefined;
+        return (0, index_js_1.omitUndefined)({
+            ...complex_type_base_js_1.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,
+        });
     }
-    (0, index_js_1.mergePrototype)(MappedClass.prototype, mappedSource.prototype);
-    // const mappedTypeMetadata: MappedType.TypeMapping[] = [];
-    const m = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, mappedSource);
-    if (!m)
-        throw new TypeError(`Class "${mappedSource}" doesn't have datatype metadata information`);
-    if (!(m.kind === index_js_2.OpraSchema.ComplexType.Kind || m.kind === index_js_2.OpraSchema.MappedType.Kind || m.kind === index_js_2.OpraSchema.MixinType.Kind))
-        throw new TypeError(`Class "${mappedSource}" is not a ${index_js_2.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(constants_js_1.DATATYPE_METADATA, metadata, MappedClass);
-    exports.MappedType._applyMixin(MappedClass, mappedSource, {
-        ...options,
-        isInheritedPredicate
-    });
-    return MappedClass;
-};
-exports.MappedType.prototype = mapped_type_class_js_1.MappedTypeClass.prototype;
-exports.MappedType._applyMixin = () => void 0;
+}
+exports.MappedType.prototype = MappedTypeClass.prototype;
+exports.MappedType._applyMixin = () => undefined;

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

@@ -1,51 +1,110 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MixinType = void 0;
-const tslib_1 = require("tslib");
 require("reflect-metadata");
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const ts_gems_1 = require("ts-gems");
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
-const mixin_type_class_js_1 = require("./mixin-type-class.js");
+const api_field_js_1 = require("./api-field.js");
+const complex_type_base_js_1 = require("./complex-type-base.js");
+const data_type_js_1 = require("./data-type.js");
 /**
  * @class MixinType
  */
 exports.MixinType = function (...args) {
+    // MixinType factory
+    if (!this)
+        return exports.MixinType[constants_js_1.DECORATOR].apply(undefined, args);
     // Constructor
-    if (this) {
-        const [document, init] = args;
-        (0, putil_merge_1.default)(this, new mixin_type_class_js_1.MixinTypeClass(document, init), { descriptor: true });
-        return;
+    const [owner, initArgs, context] = args;
+    complex_type_base_js_1.ComplexTypeBase.call(this, owner, initArgs, context);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    _this.kind = index_js_2.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 api_field_js_1.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 complex_type_base_js_1.ComplexTypeBase {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof data_type_js_1.DataType))
+            baseType = this.node.getDataType(baseType);
+        if (!(baseType instanceof complex_type_base_js_1.ComplexTypeBase))
+            return false;
+        if (baseType === this)
+            return true;
+        for (const t of this.types) {
+            if (t.extendsFrom(baseType))
+                return true;
+        }
+        return false;
     }
-    // MixinType helper
+    toJSON() {
+        return (0, index_js_1.omitUndefined)({
+            ...complex_type_base_js_1.ComplexTypeBase.prototype.toJSON.call(this),
+            kind: this.kind,
+            types: this.types.map(t => {
+                const baseName = this.node.getDataTypeNameWithNs(t);
+                return baseName ? baseName : t.toJSON();
+            }),
+        });
+    }
+}
+exports.MixinType.prototype = MixinTypeClass.prototype;
+exports.MixinType[constants_js_1.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)
-                (0, index_js_1.inheritPropertyInitializers)(this, c);
-        }
-    }
+    const className = clasRefs[0].name + 'Mixin';
+    const MixinClass = {
+        [className]: class {
+            constructor() {
+                for (const c of clasRefs)
+                    (0, index_js_1.inheritPropertyInitializers)(this, c);
+            }
+        },
+    }[className];
     const metadata = {
+        ...options,
         kind: index_js_2.OpraSchema.MixinType.Kind,
-        types: []
+        types: [],
     };
     Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, MixinClass);
     for (const c of clasRefs) {
         const itemMeta = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, c);
-        if (!(itemMeta && (itemMeta.kind === index_js_2.OpraSchema.ComplexType.Kind || itemMeta.kind === index_js_2.OpraSchema.MixinType.Kind ||
-            itemMeta.kind === index_js_2.OpraSchema.MappedType.Kind)))
+        if (!(itemMeta &&
+            (itemMeta.kind === index_js_2.OpraSchema.ComplexType.Kind ||
+                itemMeta.kind === index_js_2.OpraSchema.MixinType.Kind ||
+                itemMeta.kind === index_js_2.OpraSchema.MappedType.Kind))) {
             throw new TypeError(`Class "${c.name}" is not a ${index_js_2.OpraSchema.ComplexType.Kind}, ${index_js_2.OpraSchema.MixinType.Kind} or ${index_js_2.OpraSchema.MappedType.Kind}`);
+        }
         metadata.types.push(c);
-        (0, index_js_1.mergePrototype)(exports.MixinType.prototype, c.prototype);
+        (0, index_js_1.mergePrototype)(MixinClass.prototype, c.prototype);
     }
-    exports.MixinType._applyMixin(MixinClass, ...clasRefs);
     return MixinClass;
-};
-exports.MixinType.prototype = mixin_type_class_js_1.MixinTypeClass.prototype;
-exports.MixinType._applyMixin = () => void 0;
+}

package/cjs/document/data-type/omit-type.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitType = void 0;
+const create_mapped_class_js_1 = require("./utils/create-mapped-class.js");
+/**
+ *
+ */
+function OmitType(baseType, keys, options) {
+    return (0, create_mapped_class_js_1.createMappedClass)(baseType, { omit: keys }, options);
+}
+exports.OmitType = OmitType;

package/cjs/document/data-type/partial-type.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialType = void 0;
+const create_mapped_class_js_1 = require("./utils/create-mapped-class.js");
+/**
+ *
+ */
+function PartialType(base, ...args) {
+    const keys = Array.isArray(args[0]) ? args[0] : true;
+    const options = Array.isArray(args[0]) ? args[1] : args[0];
+    return (0, create_mapped_class_js_1.createMappedClass)(base, { partial: keys }, options);
+}
+exports.PartialType = PartialType;

package/cjs/document/data-type/pick-type.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickType = void 0;
+const create_mapped_class_js_1 = require("./utils/create-mapped-class.js");
+/**
+ *
+ */
+function PickType(baseType, keys, options) {
+    return (0, create_mapped_class_js_1.createMappedClass)(baseType, { pick: keys }, options);
+}
+exports.PickType = PickType;

package/cjs/document/data-type/primitive-types/any.type.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyType = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
+const simple_type_js_1 = require("../simple-type.js");
+let AnyType = class AnyType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
+    [constants_js_1.DECODER]() {
+        return valgen_1.isAny;
+    }
+    [constants_js_1.ENCODER]() {
+        return valgen_1.isAny;
+    }
+};
+exports.AnyType = AnyType;
+exports.AnyType = AnyType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'Represents any value',
+    }),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], AnyType);

package/cjs/document/data-type/primitive-types/bigint.type.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigintType = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
+const simple_type_js_1 = require("../simple-type.js");
+const number_type_js_1 = require("./number.type.js");
+let BigintType = class BigintType extends number_type_js_1.NumberType {
+    constructor(attributes) {
+        super(attributes);
+    }
+    [constants_js_1.DECODER](properties) {
+        const x = [];
+        if (properties.minValue)
+            x.push(valgen_1.vg.isGte(properties.minValue));
+        if (properties.maxValue)
+            x.push(valgen_1.vg.isLte(properties.maxValue));
+        return x.length > 0 ? valgen_1.vg.pipe([valgen_1.toBigint, ...x], { returnIndex: 0 }) : valgen_1.toBigint;
+    }
+    [constants_js_1.ENCODER](properties) {
+        return this[constants_js_1.DECODER](properties);
+    }
+};
+exports.BigintType = BigintType;
+exports.BigintType = BigintType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'BigInt number',
+        nameMappings: {
+            js: 'bigint',
+            json: 'string',
+        },
+    }),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], BigintType);

package/cjs/document/data-type/{builtin → primitive-types}/boolean.type.js

@@ -3,14 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BooleanType = void 0;
 const tslib_1 = require("tslib");
 const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
 const simple_type_js_1 = require("../simple-type.js");
 let BooleanType = class BooleanType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
+    [constants_js_1.DECODER]() {
+        return valgen_1.toBoolean;
+    }
+    [constants_js_1.ENCODER]() {
+        return valgen_1.toBoolean;
+    }
 };
 exports.BooleanType = BooleanType;
 exports.BooleanType = BooleanType = tslib_1.__decorate([
     (0, simple_type_js_1.SimpleType)({
         description: 'Simple true/false value',
-        decoder: valgen_1.isBoolean,
-        encoder: valgen_1.isBoolean
-    })
+        nameMappings: {
+            js: 'boolean',
+            json: 'boolean',
+        },
+    }),
+    tslib_1.__metadata("design:paramtypes", [Object])
 ], BooleanType);

package/cjs/document/data-type/primitive-types/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./any.type.js"), exports);
+tslib_1.__exportStar(require("./bigint.type.js"), exports);
+tslib_1.__exportStar(require("./boolean.type.js"), exports);
+tslib_1.__exportStar(require("./integer.type.js"), exports);
+tslib_1.__exportStar(require("./null.type.js"), exports);
+tslib_1.__exportStar(require("./number.type.js"), exports);
+tslib_1.__exportStar(require("./object.type.js"), exports);
+tslib_1.__exportStar(require("./string.type.js"), exports);

package/cjs/document/data-type/primitive-types/integer.type.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerType = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
+const simple_type_js_1 = require("../simple-type.js");
+const number_type_js_1 = require("./number.type.js");
+let IntegerType = class IntegerType extends number_type_js_1.NumberType {
+    constructor(properties) {
+        super(properties);
+    }
+    [constants_js_1.DECODER](properties) {
+        const x = [];
+        if (properties.minValue)
+            x.push(valgen_1.vg.isGte(properties.minValue));
+        if (properties.maxValue)
+            x.push(valgen_1.vg.isLte(properties.maxValue));
+        return x.length > 0 ? valgen_1.vg.pipe([valgen_1.toInteger, ...x], { returnIndex: 0 }) : valgen_1.toInteger;
+    }
+    [constants_js_1.ENCODER](properties) {
+        return this[constants_js_1.DECODER](properties);
+    }
+};
+exports.IntegerType = IntegerType;
+exports.IntegerType = IntegerType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'An integer number',
+        nameMappings: {
+            js: 'number',
+            json: 'number',
+        },
+    }),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], IntegerType);

package/cjs/document/data-type/primitive-types/null.type.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullType = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
+const simple_type_js_1 = require("../simple-type.js");
+let NullType = class NullType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
+    [constants_js_1.DECODER]() {
+        return valgen_1.isNull;
+    }
+    [constants_js_1.ENCODER]() {
+        return valgen_1.isNull;
+    }
+};
+exports.NullType = NullType;
+exports.NullType = NullType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'A Null value',
+        nameMappings: {
+            js: 'null',
+            json: 'null',
+        },
+    }),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], NullType);

package/cjs/document/data-type/primitive-types/number.type.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberType = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
+const simple_type_js_1 = require("../simple-type.js");
+let NumberType = class NumberType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
+    [constants_js_1.DECODER](properties) {
+        const x = [];
+        if (properties.minValue)
+            x.push(valgen_1.vg.isGte(properties.minValue));
+        if (properties.maxValue)
+            x.push(valgen_1.vg.isLte(properties.maxValue));
+        return x.length > 0 ? valgen_1.vg.pipe([valgen_1.toNumber, ...x], { returnIndex: 0 }) : valgen_1.toNumber;
+    }
+    [constants_js_1.ENCODER](properties) {
+        return this[constants_js_1.DECODER](properties);
+    }
+};
+exports.NumberType = NumberType;
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Determines the minimum value',
+    }),
+    tslib_1.__metadata("design:type", Number)
+], NumberType.prototype, "minValue", void 0);
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Determines the maximum value',
+    }),
+    tslib_1.__metadata("design:type", Number)
+], NumberType.prototype, "maxValue", void 0);
+exports.NumberType = NumberType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'Both Integer as well as Floating-Point numbers',
+        nameMappings: {
+            js: 'number',
+            json: 'number',
+        },
+    }),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], NumberType);

package/cjs/document/data-type/{builtin → primitive-types}/object.type.js

@@ -2,8 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectType = void 0;
 const tslib_1 = require("tslib");
+const constants_js_1 = require("../../constants.js");
 const complex_type_js_1 = require("../complex-type.js");
 let ObjectType = class ObjectType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
 };
 exports.ObjectType = ObjectType;
 exports.ObjectType = ObjectType = tslib_1.__decorate([
@@ -11,6 +16,8 @@ exports.ObjectType = ObjectType = tslib_1.__decorate([
         name: 'object',
         description: 'A non modelled object',
         additionalFields: true,
-        ctor: Object
-    })
+    }),
+    tslib_1.__metadata("design:paramtypes", [Object])
 ], ObjectType);
+const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, ObjectType);
+metadata.ctor = Object;

package/cjs/document/data-type/primitive-types/string.type.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringType = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
+const simple_type_js_1 = require("../simple-type.js");
+let StringType = class StringType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
+    [constants_js_1.DECODER](properties) {
+        const x = [];
+        if (properties.pattern) {
+            let formatName = properties.patternName;
+            if (!formatName) {
+                const meta = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, Object.getPrototypeOf(this).constructor);
+                formatName = meta.name;
+            }
+            x.push(valgen_1.vg.matches(properties.pattern, { formatName }));
+        }
+        if (properties.minLength)
+            x.push(valgen_1.vg.lengthMin(properties.minLength));
+        if (properties.maxLength)
+            x.push(valgen_1.vg.lengthMax(properties.maxLength));
+        return x.length > 0 ? valgen_1.vg.pipe([valgen_1.toString, ...x], { returnIndex: 0 }) : valgen_1.toString;
+    }
+    [constants_js_1.ENCODER](properties) {
+        return this[constants_js_1.DECODER](properties);
+    }
+};
+exports.StringType = StringType;
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Regex pattern to be used for validation',
+    }),
+    tslib_1.__metadata("design:type", Object)
+], StringType.prototype, "pattern", void 0);
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Name of the pattern',
+    }),
+    tslib_1.__metadata("design:type", String)
+], StringType.prototype, "patternName", void 0);
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Minimum number of characters',
+    }),
+    tslib_1.__metadata("design:type", Number)
+], StringType.prototype, "minLength", void 0);
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Minimum number of characters',
+    }),
+    tslib_1.__metadata("design:type", Number)
+], StringType.prototype, "maxLength", void 0);
+exports.StringType = StringType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'A sequence of characters',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], StringType);

package/cjs/document/data-type/required-type.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredType = void 0;
+const create_mapped_class_js_1 = require("./utils/create-mapped-class.js");
+/**
+ *
+ */
+function RequiredType(base, ...args) {
+    const keys = Array.isArray(args[0]) ? args[0] : true;
+    const options = Array.isArray(args[0]) ? args[1] : args[0];
+    return (0, create_mapped_class_js_1.createMappedClass)(base, { required: keys }, options);
+}
+exports.RequiredType = RequiredType;