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

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

@@ -72,9 +72,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/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,7 @@ let Base64Type = class Base64Type {
 Base64Type = __decorate([
     SimpleType({
         description: 'A stream of bytes, base64 encoded',
-    })
+    }),
+    __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,12 +23,14 @@ 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({
@@ -36,6 +38,7 @@ DateStringType = __decorate([
     })
         .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,12 +23,14 @@ 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({
@@ -39,6 +41,7 @@ DateTimeStringType = __decorate([
         .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,12 +37,14 @@ 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({
@@ -50,6 +52,7 @@ DateTimeType = __decorate([
     })
         .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 };

package/esm/document/data-type/extended-types/date.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,16 +37,19 @@ let DateType = class DateType {
 __decorate([
     SimpleType.Attribute({
         description: 'Minimum value',
-    })
+    }),
+    __metadata("design:type", String)
 ], DateType.prototype, "minValue", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Maximum value',
-    })
+    }),
+    __metadata("design:type", String)
 ], DateType.prototype, "maxValue", void 0);
 DateType = __decorate([
     SimpleType({
         description: 'A date without time',
-    }).Example('2021-04-18', 'Full date value')
+    }).Example('2021-04-18', 'Full date value'),
+    __metadata("design:paramtypes", [Object])
 ], DateType);
 export { DateType };

package/esm/document/data-type/extended-types/email.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';
@@ -18,60 +18,70 @@ __decorate([
     SimpleType.Attribute({
         description: 'If set to `true`, the validator will also match `Display Name <email-address>',
         default: false,
-    })
+    }),
+    __metadata("design:type", Boolean)
 ], 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,
-    })
+    }),
+    __metadata("design:type", Boolean)
 ], 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,
-    })
+    }),
+    __metadata("design:type", Boolean)
 ], 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,
-    })
+    }),
+    __metadata("design:type", Boolean)
 ], 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,
-    })
+    }),
+    __metadata("design:type", Boolean)
 ], 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,
-    })
+    }),
+    __metadata("design:type", Boolean)
 ], 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.',
-    })
+    }),
+    __metadata("design:type", Array)
 ], 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.',
-    })
+    }),
+    __metadata("design:type", Array)
 ], 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.',
-    })
+    }),
+    __metadata("design:type", String)
 ], EmailType.prototype, "blacklistedChars", void 0);
 EmailType = __decorate([
     SimpleType({
         description: 'An email value',
-    }).Example('some.body@example.com')
+    }).Example('some.body@example.com'),
+    __metadata("design:paramtypes", [Object])
 ], EmailType);
 export { EmailType };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { toString, validator, vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -24,8 +24,9 @@ let FieldPathType = class FieldPathType {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
+        const typeName = dataType ? element.node.getDataTypeNameWithNs(dataType) : undefined;
         return {
-            dataType: dataType.name ? dataType.name : dataType.toJSON(),
+            dataType: typeName ? typeName : dataType.toJSON(),
             allowSigns: properties.allowSigns,
         };
     }
@@ -33,18 +34,21 @@ let FieldPathType = class FieldPathType {
 __decorate([
     SimpleType.Attribute({
         description: 'Data type which field belong to',
-    })
+    }),
+    __metadata("design:type", Object)
 ], FieldPathType.prototype, "dataType", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Determines if signs (+,-) are allowed. ' +
             'If set "first" signs are allowed only beginning of the field path' +
             'If set "each" signs are allowed at each field in the path',
-    })
+    }),
+    __metadata("design:type", String)
 ], FieldPathType.prototype, "allowSigns", void 0);
 FieldPathType = __decorate([
     SimpleType({
         description: 'Field path',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], FieldPathType);
 export { FieldPathType };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { validator } from 'valgen';
 import { FilterRules } from '../../../filter/filter-rules.js';
 import { OpraFilter } from '../../../filter/index.js';
@@ -32,18 +32,21 @@ let FilterType = class FilterType {
 __decorate([
     SimpleType.Attribute({
         description: 'Data type which filtering fields belong to',
-    })
+    }),
+    __metadata("design:type", Object)
 ], FilterType.prototype, "dataType", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Stringified JSON object defines filtering rules',
         format: 'string',
-    })
+    }),
+    __metadata("design:type", Object)
 ], FilterType.prototype, "rules", void 0);
 FilterType = __decorate([
     SimpleType({
         description: 'A query filter',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], FilterType);
 export { FilterType };
 const decodeFilter = (dataType, rules) => {

package/esm/document/data-type/extended-types/object-id.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,7 @@ let ObjectIdType = class ObjectIdType {
 ObjectIdType = __decorate([
     SimpleType({
         description: 'A MongoDB ObjectID value',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], ObjectIdType);
 export { ObjectIdType };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { ApiField } from '../api-field.js';
 import { ComplexType } from '../complex-type.js';
 let OperationResult = class OperationResult {
@@ -8,30 +8,38 @@ let OperationResult = class OperationResult {
     }
 };
 __decorate([
-    ApiField()
+    ApiField(),
+    __metadata("design:type", Number)
 ], OperationResult.prototype, "affected", void 0);
 __decorate([
-    ApiField()
+    ApiField(),
+    __metadata("design:type", Number)
 ], OperationResult.prototype, "totalMatches", void 0);
 __decorate([
-    ApiField()
+    ApiField(),
+    __metadata("design:type", String)
 ], OperationResult.prototype, "context", void 0);
 __decorate([
-    ApiField()
+    ApiField(),
+    __metadata("design:type", String)
 ], OperationResult.prototype, "type", void 0);
 __decorate([
-    ApiField()
+    ApiField(),
+    __metadata("design:type", String)
 ], OperationResult.prototype, "message", void 0);
 __decorate([
-    ApiField({ type: 'any' })
+    ApiField({ type: 'any' }),
+    __metadata("design:type", Object)
 ], OperationResult.prototype, "payload", void 0);
 __decorate([
-    ApiField({ type: 'object' })
+    ApiField({ type: 'object' }),
+    __metadata("design:type", Array)
 ], OperationResult.prototype, "errors", void 0);
 OperationResult = __decorate([
     ComplexType({
         description: 'Operation result',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], OperationResult);
 export { OperationResult };
 (function (OperationResult) {
@@ -42,10 +50,12 @@ export { OperationResult };
             }
         };
         __decorate([
-            ApiField({ type, required: true })
+            ApiField({ type, required: true }),
+            __metadata("design:type", Object)
         ], OperationResult_.prototype, "payload", void 0);
         OperationResult_ = __decorate([
-            ComplexType({ embedded: true })
+            ComplexType({ embedded: true }),
+            __metadata("design:paramtypes", [Object])
         ], OperationResult_);
         return OperationResult_;
     }

package/esm/document/data-type/extended-types/time.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';
@@ -27,18 +27,21 @@ let TimeType = class TimeType {
 __decorate([
     SimpleType.Attribute({
         description: 'Minimum value',
-    })
+    }),
+    __metadata("design:type", String)
 ], TimeType.prototype, "minValue", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Maximum value',
-    })
+    }),
+    __metadata("design:type", String)
 ], TimeType.prototype, "maxValue", void 0);
 TimeType = __decorate([
     SimpleType({
         description: 'Time string in 24h format',
     })
         .Example('18:23:00', 'Full time value')
-        .Example('18:23:00', 'Time value without seconds')
+        .Example('18:23:00', 'Time value without seconds'),
+    __metadata("design:paramtypes", [Object])
 ], TimeType);
 export { TimeType };

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

@@ -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,7 @@ let UrlType = class UrlType {
 UrlType = __decorate([
     SimpleType({
         description: 'A Uniform Resource Identifier Reference (RFC 3986 icon) value',
-    }).Example('http://tempuri.org')
+    }).Example('http://tempuri.org'),
+    __metadata("design:paramtypes", [Object])
 ], UrlType);
 export { UrlType };

package/esm/document/data-type/extended-types/uuid.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,11 +17,13 @@ let UuidType = class UuidType {
 __decorate([
     SimpleType.Attribute({
         description: 'Version of the UUID',
-    })
+    }),
+    __metadata("design:type", Number)
 ], UuidType.prototype, "version", void 0);
 UuidType = __decorate([
     SimpleType({
         description: 'A Universal Unique Identifier (UUID) value',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], UuidType);
 export { UuidType };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { isAny } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -17,6 +17,7 @@ let AnyType = class AnyType {
 AnyType = __decorate([
     SimpleType({
         description: 'Represents any value',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], AnyType);
 export { AnyType };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { toBigint, vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -22,6 +22,7 @@ let BigintType = class BigintType extends NumberType {
 BigintType = __decorate([
     SimpleType({
         description: 'BigInt number',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], BigintType);
 export { BigintType };

package/esm/document/data-type/primitive-types/boolean.type.js

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { toBoolean } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -17,6 +17,7 @@ let BooleanType = class BooleanType {
 BooleanType = __decorate([
     SimpleType({
         description: 'Simple true/false value',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], BooleanType);
 export { BooleanType };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { toInteger, vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -22,6 +22,7 @@ let IntegerType = class IntegerType extends NumberType {
 IntegerType = __decorate([
     SimpleType({
         description: 'An integer number',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], IntegerType);
 export { IntegerType };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { isNull } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -17,6 +17,7 @@ let NullType = class NullType {
 NullType = __decorate([
     SimpleType({
         description: 'A Null value',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], NullType);
 export { NullType };

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { toNumber, vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -22,16 +22,19 @@ let NumberType = class NumberType {
 __decorate([
     SimpleType.Attribute({
         description: 'Determines the minimum value',
-    })
+    }),
+    __metadata("design:type", Number)
 ], NumberType.prototype, "minValue", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Determines the maximum value',
-    })
+    }),
+    __metadata("design:type", Number)
 ], NumberType.prototype, "maxValue", void 0);
 NumberType = __decorate([
     SimpleType({
         description: 'Both Integer as well as Floating-Point numbers',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], NumberType);
 export { NumberType };

package/esm/document/data-type/primitive-types/object.type.js

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { DATATYPE_METADATA } from '../../constants.js';
 import { ComplexType } from '../complex-type.js';
 let ObjectType = class ObjectType {
@@ -12,7 +12,8 @@ ObjectType = __decorate([
         name: 'object',
         description: 'A non modelled object',
         additionalFields: true,
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], ObjectType);
 export { ObjectType };
 const metadata = Reflect.getMetadata(DATATYPE_METADATA, ObjectType);

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

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { toString, vg } from 'valgen';
 import { DATATYPE_METADATA, DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -30,26 +30,31 @@ let StringType = class StringType {
 __decorate([
     SimpleType.Attribute({
         description: 'Regex pattern to be used for validation',
-    })
+    }),
+    __metadata("design:type", Object)
 ], StringType.prototype, "pattern", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Name of the pattern',
-    })
+    }),
+    __metadata("design:type", String)
 ], StringType.prototype, "patternName", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Minimum number of characters',
-    })
+    }),
+    __metadata("design:type", Number)
 ], StringType.prototype, "minLength", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Minimum number of characters',
-    })
+    }),
+    __metadata("design:type", Number)
 ], StringType.prototype, "maxLength", void 0);
 StringType = __decorate([
     SimpleType({
         description: 'A sequence of characters',
-    })
+    }),
+    __metadata("design:paramtypes", [Object])
 ], StringType);
 export { StringType };

package/esm/document/factory/api-document.factory.js

@@ -1,3 +1,5 @@
+import crypto from 'node:crypto';
+import { asMutable } from 'ts-gems';
 import { resolveThunk } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { ApiDocument } from '../api-document.js';
@@ -109,6 +111,8 @@ export class ApiDocumentFactory {
                     context.addError(`Unknown service protocol (${init.api.protocol})`);
             });
         }
+        const x = document.export();
+        asMutable(document).id = crypto.createHash('md5').update(JSON.stringify(x)).digest('base64url');
     }
     /**
      *

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

@@ -287,7 +287,7 @@ export class DataTypeFactory {
                         const fieldMeta = typeof v === 'string' ? { type: v } : v;
                         if (fieldMeta.isArray && !fieldMeta.type)
                             return context.addError(`"type" must be defined explicitly for array fields`);
-                        const t = await this._importDataTypeArgs(context, owner, fieldMeta.type);
+                        const t = await this._importDataTypeArgs(context, owner, fieldMeta.type || 'any');
                         if (!t)
                             return;
                         initArgs.fields[k] = {