@opra/common 0.5.0 → 0.7.0

package/cjs/schema/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectionMethods = exports.singletonMethods = exports.MAPPED_TYPE_METADATA = exports.IGNORE_RESOLVER_METHOD = exports.RESOLVER_METADATA = exports.RESOURCE_METADATA = exports.COMPLEXTYPE_FIELDS = exports.DATATYPE_METADATA = void 0;
+exports.DATATYPE_METADATA = 'opra:data_type.metadata';
+exports.COMPLEXTYPE_FIELDS = 'opra:complex_type.fields';
+exports.RESOURCE_METADATA = 'opra:resource.metadata';
+exports.RESOLVER_METADATA = 'opra:resolver.metadata';
+exports.IGNORE_RESOLVER_METHOD = 'opra:ignore_resolver-method';
+exports.MAPPED_TYPE_METADATA = 'opra:mapped_type.metadata';
+exports.singletonMethods = ['create', 'delete', 'get', 'update'];
+exports.collectionMethods = [...exports.singletonMethods, 'count', 'deleteMany', 'updateMany', 'search'];

package/cjs/schema/decorators/opr-collection-resource.decorator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprCollectionResource = void 0;
+require("reflect-metadata");
+const lodash_1 = require("lodash");
+const constants_js_1 = require("../constants.js");
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NAME_PATTERN = /^(.*)Resource$/;
+function OprCollectionResource(entityFunc, options) {
+    return function (target) {
+        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+        const meta = {
+            kind: 'CollectionResource',
+            type: entityFunc,
+            name
+        };
+        Object.assign(meta, (0, lodash_1.omit)(options, Object.keys(meta)));
+        Reflect.defineMetadata(constants_js_1.RESOURCE_METADATA, meta, target);
+        /* Define Injectable metadata for NestJS support*/
+        Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
+    };
+}
+exports.OprCollectionResource = OprCollectionResource;

package/cjs/schema/decorators/opr-complex-type.decorator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprComplexType = void 0;
+const lodash_1 = require("lodash");
+const constants_js_1 = require("../constants.js");
+const NAME_PATTERN = /^(.*)Type$/;
+function OprComplexType(options) {
+    return (target) => {
+        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+        const meta = {
+            kind: 'ComplexType',
+            name,
+        };
+        Object.assign(meta, (0, lodash_1.omit)(options, Object.keys(meta)));
+        const base = Object.getPrototypeOf(target);
+        const baseMeta = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, base);
+        if (baseMeta) {
+            if (baseMeta.additionalFields && meta.additionalFields == null)
+                meta.additionalFields = true;
+            meta.extends = [{
+                    type: base
+                }];
+        }
+        Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, meta, target);
+    };
+}
+exports.OprComplexType = OprComplexType;

package/cjs/schema/decorators/opr-field.decorator.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprField = void 0;
+const lodash_1 = require("lodash");
+const constants_js_1 = require("../constants.js");
+function OprField(args) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError(`Symbol properties can't be used as field`);
+        const designType = Reflect.getMetadata('design:type', target, propertyKey);
+        const metadata = {
+            type: args?.type
+        };
+        Object.assign(metadata, (0, lodash_1.omit)(args, Object.keys(metadata)));
+        if (designType === Array) {
+            metadata.isArray = true;
+            metadata.type = metadata.type || 'any';
+        }
+        else {
+            delete metadata.isArray;
+            metadata.type = metadata.type || designType;
+        }
+        const fields = Reflect.getOwnMetadata(constants_js_1.COMPLEXTYPE_FIELDS, target.constructor) || {};
+        fields[propertyKey] = metadata;
+        Reflect.defineMetadata(constants_js_1.COMPLEXTYPE_FIELDS, fields, target.constructor);
+    };
+}
+exports.OprField = OprField;

package/cjs/schema/decorators/opr-resolver.decorator.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprSearchResolver = exports.OprGetResolver = exports.OprUpdateManyResolver = exports.OprUpdateResolver = exports.OprDeleteManyResolver = exports.OprDeleteResolver = exports.OprCreateResolver = void 0;
+const constants_js_1 = require("../constants.js");
+function OprCreateResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'create')
+            throw new TypeError('This decorator can only be applied for the "create" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprCreateResolver = OprCreateResolver;
+function OprDeleteResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'delete')
+            throw new TypeError('This decorator can only be applied for the "delete" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprDeleteResolver = OprDeleteResolver;
+function OprDeleteManyResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'deleteMany')
+            throw new TypeError('This decorator can only be applied for the "deleteMany" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprDeleteManyResolver = OprDeleteManyResolver;
+function OprUpdateResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'update')
+            throw new TypeError('This decorator can only be applied for the "update" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprUpdateResolver = OprUpdateResolver;
+function OprUpdateManyResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'updateMany')
+            throw new TypeError('This decorator can only be applied for the "updateMany" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprUpdateManyResolver = OprUpdateManyResolver;
+function OprGetResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'get')
+            throw new TypeError('This decorator can only be applied for the "get" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprGetResolver = OprGetResolver;
+function OprSearchResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'search')
+            throw new TypeError('This decorator can only be applied for the "search" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprSearchResolver = OprSearchResolver;

package/cjs/schema/decorators/opr-simple-type.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprSimpleType = void 0;
+const lodash_1 = require("lodash");
+const constants_js_1 = require("../constants.js");
+const NAME_PATTERN = /^(.*)Type$/;
+function OprSimpleType(options) {
+    return (target) => {
+        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+        const meta = {
+            kind: 'SimpleType',
+            name
+        };
+        Object.assign(meta, (0, lodash_1.omit)(options, Object.keys(meta)));
+        Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, meta, target);
+    };
+}
+exports.OprSimpleType = OprSimpleType;

package/cjs/schema/decorators/opr-singleton-resource.decorator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprSingletonResource = void 0;
+require("reflect-metadata");
+const lodash_1 = require("lodash");
+const constants_js_1 = require("../constants.js");
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NAME_PATTERN = /^(.*)Resource$/;
+function OprSingletonResource(type, options) {
+    return function (target) {
+        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+        const meta = {
+            kind: 'SingletonResource',
+            type,
+            name
+        };
+        Object.assign(meta, (0, lodash_1.omit)(options, Object.keys(meta)));
+        Reflect.defineMetadata(constants_js_1.RESOURCE_METADATA, meta, target);
+        /* Define Injectable metadata for NestJS support*/
+        Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
+    };
+}
+exports.OprSingletonResource = OprSingletonResource;

package/cjs/schema/implementation/data-type/builtin/any.type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyType = void 0;
+exports.AnyType = {
+    kind: 'UnionType',
+    description: 'Any value',
+    ctor: Object,
+    types: []
+};

package/cjs/schema/implementation/data-type/builtin/base64-binary.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64BinaryType = void 0;
+const BufferConstructor = Object.getPrototypeOf(Buffer.from('')).constructor;
+exports.Base64BinaryType = {
+    kind: 'SimpleType',
+    description: 'A stream of bytes, base64 encoded',
+    ctor: BufferConstructor,
+    parse(v) {
+        return Buffer.from(v);
+    },
+    serialize(v) {
+        return Buffer.isBuffer(v) ? v.toString('base64') : undefined;
+    }
+};

package/cjs/schema/implementation/data-type/builtin/bigint.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntType = void 0;
+const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+exports.BigIntType = {
+    kind: 'SimpleType',
+    description: 'BigInt number',
+    ctor: BigIntConstructor,
+    parse(v) {
+        return BigInt(v);
+    },
+    serialize(v) {
+        return String(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/boolean.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.BooleanType = {
+    kind: 'SimpleType',
+    description: 'Simple true/false value',
+    ctor: Boolean,
+    parse(v) {
+        return (0, putil_varhelpers_1.toBoolean)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toBoolean)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/date-string.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateStringType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.DateStringType = {
+    kind: 'SimpleType',
+    description: 'A date, date-time or partial date in string format',
+    ctor: String,
+    parse(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/date.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.DateType = {
+    kind: 'SimpleType',
+    description: 'A date, date-time or partial date',
+    ctor: String,
+    parse(v) {
+        return (0, putil_varhelpers_1.toDate)(v);
+    },
+    serialize(v) {
+        return String(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/guid.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.GuidType = {
+    kind: 'SimpleType',
+    description: 'A guid value',
+    ctor: String,
+    parse(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/integer.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.IntegerType = {
+    kind: 'SimpleType',
+    description: 'An integer number',
+    ctor: Number,
+    parse(v) {
+        return (0, putil_varhelpers_1.toInt)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toInt)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/number.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.NumberType = {
+    kind: 'SimpleType',
+    description: 'Both Integer as well as Floating-Point numbers',
+    ctor: Number,
+    parse(v) {
+        return (0, putil_varhelpers_1.toNumber)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toNumber)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/object.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectType = void 0;
+exports.ObjectType = {
+    kind: 'ComplexType',
+    description: 'A non modelled object',
+    ctor: Object,
+    additionalFields: true,
+    parse(v) {
+        return v;
+    },
+    serialize(v) {
+        return v;
+    }
+};

package/cjs/schema/implementation/data-type/builtin/string.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.StringType = {
+    kind: 'SimpleType',
+    description: 'A sequence of characters',
+    ctor: String,
+    parse(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin-data-types.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primitiveClasses = exports.builtInTypes = void 0;
+const responsive_map_js_1 = require("../../../helpers/responsive-map.js");
+const any_type_js_1 = require("./builtin/any.type.js");
+const base64_binary_type_js_1 = require("./builtin/base64-binary.type.js");
+const bigint_type_js_1 = require("./builtin/bigint.type.js");
+const boolean_type_js_1 = require("./builtin/boolean.type.js");
+const date_type_js_1 = require("./builtin/date.type.js");
+const date_string_type_js_1 = require("./builtin/date-string.type.js");
+const guid_type_js_1 = require("./builtin/guid.type.js");
+const integer_type_js_1 = require("./builtin/integer.type.js");
+const number_type_js_1 = require("./builtin/number.type.js");
+const object_type_js_1 = require("./builtin/object.type.js");
+const string_type_js_1 = require("./builtin/string.type.js");
+const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+const BufferConstructor = Object.getPrototypeOf(Buffer.from('')).constructor;
+exports.builtInTypes = new responsive_map_js_1.ResponsiveMap();
+exports.builtInTypes.set('any', any_type_js_1.AnyType);
+exports.builtInTypes.set('base64Binary', base64_binary_type_js_1.Base64BinaryType);
+exports.builtInTypes.set('bigint', bigint_type_js_1.BigIntType);
+exports.builtInTypes.set('boolean', boolean_type_js_1.BooleanType);
+exports.builtInTypes.set('date', date_type_js_1.DateType);
+exports.builtInTypes.set('dateString', date_string_type_js_1.DateStringType);
+exports.builtInTypes.set('guid', guid_type_js_1.GuidType);
+exports.builtInTypes.set('integer', integer_type_js_1.IntegerType);
+exports.builtInTypes.set('number', number_type_js_1.NumberType);
+exports.builtInTypes.set('object', object_type_js_1.ObjectType);
+exports.builtInTypes.set('string', string_type_js_1.StringType);
+exports.primitiveClasses = new Map();
+exports.primitiveClasses.set(Boolean, 'boolean');
+exports.primitiveClasses.set(String, 'string');
+exports.primitiveClasses.set(Number, 'number');
+exports.primitiveClasses.set(Date, 'date');
+exports.primitiveClasses.set(BigIntConstructor, 'bigint');
+exports.primitiveClasses.set(BufferConstructor, 'base64Binary');
+exports.primitiveClasses.set(Object, 'object');

package/cjs/schema/implementation/data-type/complex-type.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComplexType = void 0;
+const responsive_map_js_1 = require("../../../helpers/responsive-map.js");
+const clone_object_util_js_1 = require("../../utils/clone-object.util.js");
+const inspect_util_js_1 = require("../../utils/inspect.util.js");
+const data_type_js_1 = require("./data-type.js");
+class ComplexType extends data_type_js_1.DataType {
+    _initialized = false;
+    _mixinAdditionalFields;
+    ownFields = new responsive_map_js_1.ResponsiveMap();
+    fields = new responsive_map_js_1.ResponsiveMap();
+    constructor(owner, name, args) {
+        super(owner, name, {
+            kind: 'ComplexType',
+            ...args
+        });
+    }
+    get abstract() {
+        return !!this._metadata.abstract;
+    }
+    get additionalFields() {
+        return this._metadata.additionalFields || this._mixinAdditionalFields;
+    }
+    get extends() {
+        return this._metadata.extends;
+    }
+    getField(fieldName) {
+        if (fieldName.includes('.')) {
+            let dt = this;
+            const arr = fieldName.split('.');
+            let field;
+            for (const a of arr) {
+                field = dt.getField(a);
+                dt = dt.document.getDataType(field.type || 'string');
+            }
+            // @ts-ignore
+            return field;
+        }
+        const t = this.fields.get(fieldName);
+        if (!t)
+            throw new Error(`"${this.name}" type doesn't have a field named "${fieldName}"`);
+        return t;
+    }
+    getFieldType(fieldName) {
+        const field = this.getField(fieldName);
+        return this.document.getDataType(field.type || 'string');
+    }
+    getOwnField(name) {
+        const t = this.ownFields.get(name);
+        if (!t)
+            throw new Error(`"${this.name}" type doesn't have an own field named "${name}"`);
+        return t;
+    }
+    getSchema() {
+        const out = super.getSchema();
+        if (this.additionalFields)
+            out.additionalFields = this.additionalFields;
+        if (this.ownFields.size) {
+            out.fields = {};
+            for (const [k, prop] of this.ownFields) {
+                out.fields[k] = (0, clone_object_util_js_1.cloneObject)(prop);
+                delete out.fields[k].name;
+            }
+        }
+        return out;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [inspect_util_js_1.nodeInspectCustom]() {
+        return `[${inspect_util_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + inspect_util_js_1.colorReset}` +
+            ` ${inspect_util_js_1.colorFgMagenta + this.name + inspect_util_js_1.colorReset}]`;
+    }
+    init() {
+        if (this._initialized)
+            return;
+        this._initialized = true;
+        const metadata = this._metadata;
+        if (metadata.extends) {
+            for (const ext of metadata.extends) {
+                const baseType = this.document.types.get(ext.type);
+                if (!baseType)
+                    throw new TypeError(`Extending schema (${ext.type}) of data type "${this.name}" does not exists`);
+                if (!(baseType instanceof ComplexType))
+                    throw new TypeError(`Cannot extend ${this.name} from a "${baseType.kind}"`);
+                baseType.init();
+                if (baseType.additionalFields)
+                    this._mixinAdditionalFields = true;
+                for (const [k, prop] of baseType.fields) {
+                    const f = (0, clone_object_util_js_1.cloneObject)(prop);
+                    f.name = k;
+                    f.parent = this;
+                    this.fields.set(k, f);
+                }
+            }
+        }
+        if (metadata.fields) {
+            for (const [k, prop] of Object.entries(metadata.fields)) {
+                const t = this.document.types.get(prop.type);
+                if (!t)
+                    throw new TypeError(`Type "${prop.type}" defined for "${this.name}.${k}" does not exists`);
+                const f = (0, clone_object_util_js_1.cloneObject)(prop);
+                f.name = k;
+                this.fields.set(k, f);
+                this.ownFields.set(k, f);
+            }
+        }
+    }
+}
+exports.ComplexType = ComplexType;

package/cjs/schema/implementation/data-type/data-type.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataType = void 0;
+const clone_object_util_js_1 = require("../../utils/clone-object.util.js");
+class DataType {
+    _document;
+    _metadata;
+    _name;
+    constructor(document, name, metadata) {
+        this._document = document;
+        this._name = name;
+        this._metadata = metadata;
+    }
+    get document() {
+        return this._document;
+    }
+    get kind() {
+        return this._metadata.kind;
+    }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._metadata.description;
+    }
+    get ctor() {
+        return this._metadata.ctor;
+    }
+    parse(value) {
+        return this._metadata.parse ? this._metadata.parse(value) : value;
+    }
+    getSchema(jsonOnly) {
+        return (0, clone_object_util_js_1.cloneObject)(this._metadata, jsonOnly);
+    }
+}
+exports.DataType = DataType;

package/cjs/schema/implementation/data-type/simple-type.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleType = void 0;
+const inspect_util_js_1 = require("../../utils/inspect.util.js");
+const data_type_js_1 = require("./data-type.js");
+class SimpleType extends data_type_js_1.DataType {
+    constructor(owner, name, args) {
+        super(owner, name, {
+            kind: 'SimpleType',
+            ...args
+        });
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [inspect_util_js_1.nodeInspectCustom]() {
+        return `[${inspect_util_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + inspect_util_js_1.colorReset}` +
+            ` ${inspect_util_js_1.colorFgMagenta + this.name + inspect_util_js_1.colorReset}]`;
+    }
+}
+exports.SimpleType = SimpleType;

package/cjs/schema/implementation/data-type/union-type.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionType = void 0;
+const lodash_1 = require("lodash");
+const inspect_util_js_1 = require("../../utils/inspect.util.js");
+const complex_type_js_1 = require("./complex-type.js");
+const data_type_js_1 = require("./data-type.js");
+class UnionType extends data_type_js_1.DataType {
+    types;
+    hasAdditionalFields;
+    constructor(owner, name, args) {
+        super(owner, name, (0, lodash_1.omit)({ kind: 'UnionType', ...args }, ['types']));
+        this.types = args.types;
+        this.hasAdditionalFields = name === 'any' ||
+            !!this.types.find(t => t instanceof complex_type_js_1.ComplexType && t.additionalFields);
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [inspect_util_js_1.nodeInspectCustom]() {
+        return `[${inspect_util_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + inspect_util_js_1.colorReset}` +
+            ` ${inspect_util_js_1.colorFgMagenta + this.name + inspect_util_js_1.colorReset}]`;
+    }
+}
+exports.UnionType = UnionType;