@opra/common 1.0.0-alpha.2 → 1.0.0-alpha.20

package/cjs/helpers/parse-fields-projection.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = exports.parseFieldsProjection = exports.FieldsProjection = void 0;
+exports.FieldsProjection = void 0;
+exports.parseFieldsProjection = parseFieldsProjection;
+exports.parse = parse;
 const fast_tokenizer_1 = require("fast-tokenizer");
 const FIELD_PATTERN = /^([+-])?([a-z_$]\w*)$/i;
 const NO_DOT_BRACKET_PATTERN = /[^.]\(/g;
@@ -24,12 +26,9 @@ function parseFieldsProjection(projection, keepCase) {
     }
     return out;
 }
-exports.parseFieldsProjection = parseFieldsProjection;
 function parse(input, target) {
     /** Add dot before brackets which is required to split fields */
-    input = input.replace(NO_DOT_BRACKET_PATTERN, s => {
-        return s.charAt(0) + '.' + s.substring(1);
-    });
+    input = input.replace(NO_DOT_BRACKET_PATTERN, s => s.charAt(0) + '.' + s.substring(1));
     const fields = (0, fast_tokenizer_1.splitString)(input, {
         delimiters: '.',
         brackets: true,
@@ -64,4 +63,3 @@ function parse(input, target) {
         }
     }
 }
-exports.parse = parse;

package/cjs/helpers/responsive-map.js

@@ -41,13 +41,14 @@ class ResponsiveMap {
             },
             enumerable: false,
         });
-        if (options?.wellKnownKeys)
+        if (options?.wellKnownKeys) {
             options.wellKnownKeys.forEach(k => {
                 if (caseSensitive)
                     this[kWellKnownKeys][k] = k;
                 else
                     this[kWellKnownKeys][k.toLowerCase()] = k;
             });
+        }
         this.clear();
         if (init)
             this.setAll(init);
@@ -73,12 +74,12 @@ class ResponsiveMap {
     has(key) {
         if (!key)
             return false;
-        return this[kEntries].hasOwnProperty(this._getStoringKey(key));
+        return Object.prototype.hasOwnProperty.call(this[kEntries], this._getStoringKey(key));
     }
     set(key, value) {
         const storeKey = this._getStoringKey(key);
         key = this._getOriginalKey(key);
-        const exists = this[kEntries].hasOwnProperty(storeKey);
+        const exists = Object.prototype.hasOwnProperty.call(this[kEntries], storeKey);
         this[kEntries][storeKey] = value;
         if (!exists)
             this[kSize]++;
@@ -103,7 +104,7 @@ class ResponsiveMap {
     }
     delete(key) {
         const storeKey = this._getStoringKey(key);
-        const exists = this[kEntries].hasOwnProperty(storeKey);
+        const exists = Object.prototype.hasOwnProperty.call(this[kEntries], storeKey);
         delete this[kEntries][storeKey];
         delete this[kKeyMap][storeKey];
         if (!exists)

package/cjs/helpers/type-guards.js

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAsyncIterable = exports.isIterable = exports.isURL = exports.isFormData = exports.isBlob = exports.isReadableStream = exports.isWritable = exports.isReadable = exports.isStream = exports.isConstructor = void 0;
+exports.isConstructor = isConstructor;
+exports.isStream = isStream;
+exports.isReadable = isReadable;
+exports.isWritable = isWritable;
+exports.isReadableStream = isReadableStream;
+exports.isBlob = isBlob;
+exports.isFormData = isFormData;
+exports.isURL = isURL;
+exports.isIterable = isIterable;
+exports.isAsyncIterable = isAsyncIterable;
 function isConstructor(fn) {
     return (typeof fn === 'function' &&
         fn.prototype &&
@@ -8,26 +17,21 @@ function isConstructor(fn) {
         fn.prototype.constructor.name !== 'Function' &&
         fn.prototype.constructor.name !== 'embedded');
 }
-exports.isConstructor = isConstructor;
 function isStream(x) {
     return x !== null && typeof x === 'object' && typeof x.pipe === 'function';
 }
-exports.isStream = isStream;
 function isReadable(x) {
     return isStream(x) && typeof x._read === 'function' && typeof x._readableState === 'object';
 }
-exports.isReadable = isReadable;
 function isWritable(x) {
     return isStream(x) && typeof x._write === 'function';
 }
-exports.isWritable = isWritable;
 function isReadableStream(x) {
     return (isStream(x) &&
         typeof x.getReader === 'function' &&
         typeof x.pipeThrough === 'function' &&
         typeof x.pipeTo === 'function');
 }
-exports.isReadableStream = isReadableStream;
 function isBlob(x) {
     return (x !== null &&
         typeof x === 'object' &&
@@ -35,7 +39,6 @@ function isBlob(x) {
         typeof x.arrayBuffer === 'function' &&
         typeof x.stream === 'function');
 }
-exports.isBlob = isBlob;
 function isFormData(x) {
     return (x !== null &&
         typeof x.constructor === 'function' &&
@@ -43,16 +46,12 @@ function isFormData(x) {
         typeof x.append === 'function' &&
         typeof x.getAll === 'function');
 }
-exports.isFormData = isFormData;
 function isURL(x) {
     return x !== null && typeof x == 'object' && typeof x.host === 'string' && typeof x.href === 'string';
 }
-exports.isURL = isURL;
 function isIterable(x) {
     return Symbol.iterator in x;
 }
-exports.isIterable = isIterable;
 function isAsyncIterable(x) {
     return Symbol.asyncIterator in x;
 }
-exports.isAsyncIterable = isAsyncIterable;

package/cjs/i18n/i18n.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.I18n = exports.BaseI18n = void 0;
 const tslib_1 = require("tslib");
-const fast_tokenizer_1 = require("fast-tokenizer");
 const i18next_1 = tslib_1.__importDefault(require("@browsery/i18next"));
+const fast_tokenizer_1 = require("fast-tokenizer");
 const string_utils_js_1 = require("./string-utils.js");
 exports.BaseI18n = Object.getPrototypeOf(i18next_1.default.createInstance()).constructor;
 class I18n extends exports.BaseI18n {
@@ -42,7 +42,7 @@ class I18n extends exports.BaseI18n {
         const objectStack = new WeakMap();
         return this._deepTranslate(input, objectStack, options);
     }
-    createInstance(options = {}, callback) {
+    createInstance(options, callback) {
         return new I18n(options, callback);
     }
     static createInstance(options, callback) {
@@ -106,8 +106,9 @@ class I18n extends exports.BaseI18n {
                 input instanceof Map ||
                 input instanceof Set ||
                 input instanceof WeakMap ||
-                input instanceof WeakSet)
+                input instanceof WeakSet) {
                 return input;
+            }
             const out = {};
             objectStack.set(input, out);
             const keys = Object.keys(input);

package/cjs/i18n/index.js

@@ -7,4 +7,4 @@ tslib_1.__exportStar(require("./i18n.js"), exports);
 tslib_1.__exportStar(require("./translate.js"), exports);
 const i18n = i18n_js_1.I18n.createInstance();
 exports.i18n = i18n;
-i18n.init().catch(() => void 0);
+i18n.init().catch(() => undefined);

package/cjs/i18n/string-utils.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unescapeString = exports.escapeString = void 0;
+exports.escapeString = escapeString;
+exports.unescapeString = unescapeString;
 const unescapeRegEx = /\\(.)/g;
 const escapeRegEx = /(\\)/g;
 function escapeString(s) {
     return s.replace(escapeRegEx, '\\\\');
 }
-exports.escapeString = escapeString;
 function unescapeString(s) {
     return s.replace(unescapeRegEx, '$1');
 }
-exports.unescapeString = unescapeString;

package/cjs/i18n/translate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translate = void 0;
+exports.translate = translate;
 const string_utils_js_1 = require("./string-utils.js");
 const bracketRegEx = /(\))/g;
 function translate(key, arg0, arg1) {
@@ -12,4 +12,3 @@ function translate(key, arg0, arg1) {
         (fallback ? '?' + (0, string_utils_js_1.escapeString)(fallback).replace(bracketRegEx, '\\$1') : '') +
         ')');
 }
-exports.translate = translate;

package/cjs/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uid = void 0;
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./document/index.js"), exports);
 tslib_1.__exportStar(require("./exception/index.js"), exports);
 tslib_1.__exportStar(require("./filter/index.js"), exports);
@@ -10,5 +9,6 @@ tslib_1.__exportStar(require("./helpers/index.js"), exports);
 tslib_1.__exportStar(require("./http/index.js"), exports);
 tslib_1.__exportStar(require("./i18n/index.js"), exports);
 tslib_1.__exportStar(require("./schema/index.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
 var uid_1 = require("uid");
 Object.defineProperty(exports, "uid", { enumerable: true, get: function () { return uid_1.uid; } });

package/cjs/schema/type-guards.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isHttpController = exports.isEnumType = exports.isMappedType = exports.isMixinType = exports.isSimpleType = exports.isComplexType = exports.isDataType = void 0;
+exports.isDataType = isDataType;
+exports.isComplexType = isComplexType;
+exports.isSimpleType = isSimpleType;
+exports.isMixinType = isMixinType;
+exports.isMappedType = isMappedType;
+exports.isEnumType = isEnumType;
+exports.isHttpController = isHttpController;
 const complex_type_interface_js_1 = require("./data-type/complex-type.interface.js");
 const enum_type_interface_js_1 = require("./data-type/enum-type.interface.js");
 const mapped_type_interface_js_1 = require("./data-type/mapped-type.interface.js");
@@ -16,28 +22,21 @@ function isDataType(obj) {
             obj.kind === simple_type_interface_js_1.SimpleType.Kind ||
             obj.kind === mixin_type_interface_js_1.MixinType.Kind));
 }
-exports.isDataType = isDataType;
 function isComplexType(obj) {
     return obj && typeof obj === 'object' && obj.kind === complex_type_interface_js_1.ComplexType.Kind;
 }
-exports.isComplexType = isComplexType;
 function isSimpleType(obj) {
     return obj && typeof obj === 'object' && obj.kind === simple_type_interface_js_1.SimpleType.Kind;
 }
-exports.isSimpleType = isSimpleType;
 function isMixinType(obj) {
     return obj && typeof obj === 'object' && obj.kind === mixin_type_interface_js_1.MixinType.Kind;
 }
-exports.isMixinType = isMixinType;
 function isMappedType(obj) {
     return obj && typeof obj === 'object' && obj.kind === mapped_type_interface_js_1.MappedType.Kind;
 }
-exports.isMappedType = isMappedType;
 function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === enum_type_interface_js_1.EnumType.Kind;
 }
-exports.isEnumType = isEnumType;
 function isHttpController(obj) {
     return obj && typeof obj === 'object' && obj.kind === http_controller_interface_js_1.HttpController.Kind;
 }
-exports.isHttpController = isHttpController;

package/esm/document/api-document.js

@@ -1,4 +1,5 @@
 var _a;
+import crypto from 'node:crypto';
 import { cloneObject, omitUndefined, ResponsiveMap } from '../helpers/index.js';
 import { OpraSchema } from '../schema/index.js';
 import { DataTypeMap } from './common/data-type-map.js';
@@ -27,18 +28,29 @@ export class ApiDocument extends DocumentElement {
         if (dt)
             return this[kTypeNSMap].get(dt);
     }
+    findDocument(id) {
+        if (this.id === id)
+            return this;
+        for (const doc of this.references.values()) {
+            if (doc.id === id)
+                return doc;
+            const d = doc.findDocument(id);
+            if (d)
+                return d;
+        }
+    }
     toJSON() {
         return this.export();
     }
     /**
      * Export as Opra schema definition object
      */
-    export(options) {
+    export() {
         const out = omitUndefined({
             spec: OpraSchema.SpecVersion,
+            id: this.id,
             url: this.url,
             info: cloneObject(this.info, true),
-            // api: this.api ? this.api.toJSON() : undefined,
         });
         if (this.references.size) {
             let i = 0;
@@ -46,16 +58,11 @@ export class ApiDocument extends DocumentElement {
             for (const [ns, doc] of this.references.entries()) {
                 if (doc[BUILTIN])
                     continue;
-                if (options?.references === 'external-url') {
-                    if (doc.url)
-                        references[ns] = doc.url;
-                    else
-                        references[ns] = `/$schema?ns=${ns}`;
-                }
-                else if (options?.references === 'relative-url')
-                    references[ns] = `/$schema?ns=${ns}`;
-                else
-                    references[ns] = doc.export(options);
+                references[ns] = {
+                    id: doc.id,
+                    url: doc.url,
+                    info: cloneObject(doc.info, true),
+                };
                 i++;
             }
             if (i)
@@ -71,6 +78,14 @@ export class ApiDocument extends DocumentElement {
             out.api = this.api.toJSON();
         return out;
     }
+    invalidate() {
+        /** Generate id */
+        const x = this.export();
+        delete x.id;
+        this.id = crypto.createHash('md5').update(JSON.stringify(x)).digest('base64url');
+        /** Clear [kTypeNSMap] */
+        this[kTypeNSMap] = new WeakMap();
+    }
     _findDataType(nameOrCtor, visitedRefs) {
         let result = this.types.get(nameOrCtor);
         if (result || !this.references.size)

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

@@ -20,7 +20,7 @@ export class DataTypeMap {
     }
     get(nameOrCtor) {
         let name = typeof nameOrCtor === 'string' ? nameOrCtor : this[kCtorMap].get(nameOrCtor);
-        if (!name) {
+        if (!name && typeof nameOrCtor === 'function') {
             const metadata = Reflect.getMetadata(DATATYPE_METADATA, nameOrCtor);
             name = metadata?.name;
         }

package/esm/document/common/document-element.js

@@ -1,3 +1,4 @@
+import crypto from 'node:crypto';
 import { asMutable } from 'ts-gems';
 import { DocumentNode } from './document-node.js';
 /**
@@ -8,17 +9,19 @@ export const DocumentElement = function (owner) {
     if (!this)
         throw new TypeError('"this" should be passed to call class constructor');
     const _this = asMutable(this);
+    _this.id = crypto.randomBytes(16).toString('base64url');
     Object.defineProperty(_this, 'node', {
         value: new DocumentNode(this, owner?.node),
         enumerable: false,
         writable: true,
     });
-    if (owner)
+    if (owner) {
         Object.defineProperty(_this, 'owner', {
             value: owner,
             enumerable: false,
             writable: true,
         });
+    }
 };
 /**
  * @class DocumentElement

package/esm/document/constants.js

@@ -4,7 +4,7 @@ export const DECODER = Symbol.for('opra.type.decoder');
 export const ENCODER = Symbol('opra.type.encoder');
 export const DECORATOR = Symbol.for('DECORATOR');
 export const BUILTIN = Symbol.for('BUILTIN');
-export const NAMESPACE_PATTERN = /([a-z$_]\w+)(:.+)/i;
+export const NAMESPACE_PATTERN = /([a-z$_]\w+):(.+)/i;
 export const CLASS_NAME_PATTERN = /^[a-z][\w_]*$/i;
 export const EXTRACT_TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
 export const kDataTypeMap = Symbol.for('kDataTypeMap');

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

@@ -21,8 +21,9 @@ export const ApiField = function (...args) {
     _this.name = initArgs.name;
     const origin = initArgs.origin || owner;
     /* istanbul ignore next */
-    if (!(origin instanceof ComplexTypeBase))
+    if (!(origin instanceof ComplexTypeBase)) {
         throw new Error('Field origin should be one of ComplexType, MappedType or MixinType');
+    }
     _this.origin = origin;
     _this.type = initArgs.type || owner.node.getDataType('any');
     _this.description = initArgs.description;
@@ -33,6 +34,8 @@ export const ApiField = function (...args) {
     _this.exclusive = initArgs.exclusive;
     _this.translatable = initArgs.translatable;
     _this.deprecated = initArgs.deprecated;
+    _this.readonly = initArgs.readonly;
+    _this.writeonly = initArgs.writeonly;
     _this.examples = initArgs.examples;
 };
 /**
@@ -43,7 +46,7 @@ class ApiFieldClass extends DocumentElement {
     toJSON() {
         const typeName = this.type ? this.node.getDataTypeNameWithNs(this.type) : undefined;
         return omitUndefined({
-            type: this.type ? (typeName ? typeName : this.type?.toJSON()) : undefined,
+            type: typeName ? typeName : this.type?.toJSON(),
             description: this.description,
             isArray: this.isArray,
             default: this.default,
@@ -52,6 +55,8 @@ class ApiFieldClass extends DocumentElement {
             exclusive: this.exclusive,
             translatable: this.translatable,
             deprecated: this.deprecated,
+            readonly: this.readonly,
+            writeonly: this.writeonly,
             examples: this.examples,
         });
     }

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

@@ -115,8 +115,9 @@ class ComplexTypeBaseClass extends DataType {
             : options?.projection;
         const schema = this._generateSchema(codec, { ...options, projection, currentPath: '' });
         let additionalFields;
-        if (this.additionalFields instanceof DataType)
+        if (this.additionalFields instanceof DataType) {
             additionalFields = this.additionalFields.generateCodec(codec, options);
+        }
         else if (typeof this.additionalFields === 'boolean')
             additionalFields = this.additionalFields;
         else if (Array.isArray(this.additionalFields)) {
@@ -143,6 +144,10 @@ class ComplexTypeBaseClass extends DataType {
         // Process fields
         let fieldName;
         for (const field of this.fields.values()) {
+            if ((context.ignoreReadonlyFields && field.readonly) || (context.ignoreWriteonlyFields && field.writeonly)) {
+                schema[field.name] = vg.isUndefined({ coerce: true });
+                continue;
+            }
             fieldName = field.name;
             let p;
             if (projection !== '*') {

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

@@ -26,11 +26,13 @@ export const ComplexType = function (...args) {
     if (initArgs.base) {
         context.enter('.base', () => {
             // noinspection SuspiciousTypeOfGuard
-            if (!(initArgs.base instanceof ComplexTypeBase))
+            if (!(initArgs.base instanceof ComplexTypeBase)) {
                 throw new TypeError(`"${initArgs.base.kind}" can't be set as base for a "${this.kind}"`);
+            }
             _this.base = initArgs.base;
-            if (_this.additionalFields == null && _this.base.additionalFields)
+            if (_this.additionalFields == null && _this.base.additionalFields) {
                 _this.additionalFields = _this.base.additionalFields;
+            }
             /** Copy fields from base */
             for (const v of _this.base.fields.values()) {
                 this.fields.set(v.name, new ApiField(this, v));
@@ -57,6 +59,8 @@ export const ComplexType = function (...args) {
  */
 class ComplexTypeClass extends ComplexTypeBase {
     extendsFrom(baseType) {
+        if (!(baseType instanceof DataType))
+            baseType = this.node.getDataType(baseType);
         if (!(baseType instanceof ComplexTypeBase))
             return false;
         if (baseType === this)
@@ -72,9 +76,8 @@ class ComplexTypeClass extends ComplexTypeBase {
         });
         if (this.additionalFields) {
             if (this.additionalFields instanceof DataType) {
-                out.additionalFields = this.additionalFields[1].name
-                    ? this.additionalFields[1].name
-                    : this.additionalFields[1].toJSON();
+                const typeName = this.node.getDataTypeNameWithNs(this.additionalFields);
+                out.additionalFields = typeName ? typeName : this.additionalFields.toJSON();
             }
             else
                 out.additionalFields = this.additionalFields;

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

@@ -11,8 +11,9 @@ export const DataType = function (owner, initArgs,
 context) {
     if (!this)
         throw new TypeError('"this" should be passed to call class constructor');
-    if (initArgs?.name && !CLASS_NAME_PATTERN.test(initArgs.name))
+    if (initArgs?.name && !CLASS_NAME_PATTERN.test(initArgs.name)) {
         throw new TypeError(`"${initArgs.name}" is not a valid DataType name`);
+    }
     DocumentElement.call(this, owner);
     const _this = asMutable(this);
     _this.kind = initArgs.kind;

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

@@ -19,8 +19,9 @@ export const EnumType = function (...args) {
     _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}"`);
+        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;
@@ -35,6 +36,8 @@ export const EnumType = function (...args) {
  */
 class EnumTypeClass extends DataType {
     extendsFrom(baseType) {
+        if (!(baseType instanceof DataType))
+            baseType = this.node.getDataType(baseType);
         if (!(baseType instanceof EnumType))
             return false;
         if (baseType === this)

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -17,6 +17,11 @@ let Base64Type = class Base64Type {
 Base64Type = __decorate([
     SimpleType({
         description: 'A stream of bytes, base64 encoded',
-    })
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
 ], Base64Type);
 export { Base64Type };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -23,19 +23,26 @@ let DateStringType = class DateStringType {
 __decorate([
     SimpleType.Attribute({
         description: 'Minimum value',
-    })
+    }),
+    __metadata("design:type", String)
 ], DateStringType.prototype, "minValue", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Maximum value',
-    })
+    }),
+    __metadata("design:type", String)
 ], DateStringType.prototype, "maxValue", void 0);
 DateStringType = __decorate([
-    SimpleType({
+    (SimpleType({
         description: 'Date string value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     })
         .Example('2021-04-18', 'Full date value')
         .Example('2021-04', 'Date value without day')
-        .Example('2021', 'Year only value')
+        .Example('2021', 'Year only value')),
+    __metadata("design:paramtypes", [Object])
 ], DateStringType);
 export { DateStringType };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -23,22 +23,29 @@ let DateTimeStringType = class DateTimeStringType {
 __decorate([
     SimpleType.Attribute({
         description: 'Minimum value',
-    })
+    }),
+    __metadata("design:type", String)
 ], DateTimeStringType.prototype, "minValue", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Maximum value',
-    })
+    }),
+    __metadata("design:type", String)
 ], DateTimeStringType.prototype, "maxValue", void 0);
 DateTimeStringType = __decorate([
-    SimpleType({
+    (SimpleType({
         description: 'DateTime string value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     })
         .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')
+        .Example('2021', 'Year only value')),
+    __metadata("design:paramtypes", [Object])
 ], DateTimeStringType);
 export { DateTimeStringType };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { isDateString, toString, vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -37,19 +37,26 @@ let DateTimeType = class DateTimeType {
 __decorate([
     SimpleType.Attribute({
         description: 'Minimum value',
-    })
+    }),
+    __metadata("design:type", String)
 ], DateTimeType.prototype, "minValue", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Maximum value',
-    })
+    }),
+    __metadata("design:type", String)
 ], DateTimeType.prototype, "maxValue", void 0);
 DateTimeType = __decorate([
-    SimpleType({
+    (SimpleType({
         description: 'A full datetime value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
     })
         .Example('2021-04-18T22:30:15')
         .Example('2021-04-18 22:30:15')
-        .Example('2021-04-18 22:30')
+        .Example('2021-04-18 22:30')),
+    __metadata("design:paramtypes", [Object])
 ], DateTimeType);
 export { DateTimeType };