@opra/common 0.5.0 → 0.6.0

package/cjs/schema/implementation/resource/collection-resource-info.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionResourceInfo = void 0;
+const constants_js_1 = require("../../constants.js");
+const normalize_field_array_util_js_1 = require("../../utils/normalize-field-array.util.js");
+const resource_info_js_1 = require("./resource-info.js");
+class CollectionResourceInfo extends resource_info_js_1.ResourceInfo {
+    dataType;
+    constructor(document, name, dataType, metadata) {
+        if (!metadata.keyFields)
+            throw new TypeError(`You should provide key fields for ${name}`);
+        super(document, name, metadata);
+        metadata.keyFields = Array.isArray(metadata.keyFields) ? metadata.keyFields : [metadata.keyFields];
+        metadata.keyFields.forEach(f => dataType.getField(f));
+        this.dataType = dataType;
+        if (metadata.search && metadata.search.sortFields) {
+            metadata.search.sortFields = (0, normalize_field_array_util_js_1.normalizeFieldArray)(document, dataType, metadata.search.sortFields);
+        }
+    }
+    get keyFields() {
+        return this.metadata.keyFields;
+    }
+    get create() {
+        return this.metadata.create;
+    }
+    get count() {
+        return this.metadata.count;
+    }
+    get delete() {
+        return this.metadata.delete;
+    }
+    get deleteMany() {
+        return this.metadata.deleteMany;
+    }
+    get get() {
+        return this.metadata.get;
+    }
+    get update() {
+        return this.metadata.update;
+    }
+    get updateMany() {
+        return this.metadata.updateMany;
+    }
+    get search() {
+        return this.metadata.search;
+    }
+    getSchema(jsonOnly) {
+        const out = super.getSchema(jsonOnly);
+        if (out.keyFields.length < 2)
+            out.keyFields = out.keyFields[0];
+        for (const k of constants_js_1.collectionMethods) {
+            if (typeof out[k] === 'object' && !Object.keys(out[k]).length)
+                out[k] = true;
+        }
+        return out;
+    }
+}
+exports.CollectionResourceInfo = CollectionResourceInfo;

package/cjs/schema/implementation/resource/container-resource-info.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerResourceInfo = void 0;
+const collection_resource_info_js_1 = require("./collection-resource-info.js");
+const resource_info_js_1 = require("./resource-info.js");
+const singleton_resource_info_js_1 = require("./singleton-resource-info.js");
+class ContainerResourceInfo extends resource_info_js_1.ResourceInfo {
+    constructor(service, name, metadata) {
+        super(service, name, metadata);
+    }
+    getResource(name) {
+        const t = this.metadata.resources[name];
+        if (!t)
+            throw new Error(`Resource "${name}" does not exists`);
+        return t;
+    }
+    getCollectionResource(name) {
+        const t = this.getResource(name);
+        if (!(t instanceof collection_resource_info_js_1.CollectionResourceInfo))
+            throw new Error(`"${name}" is not a Collection Resource`);
+        return t;
+    }
+    getSingletonResource(name) {
+        const t = this.getResource(name);
+        if (!(t instanceof singleton_resource_info_js_1.SingletonResourceInfo))
+            throw new Error(`"${name}" is not a SingletonResource`);
+        return t;
+    }
+}
+exports.ContainerResourceInfo = ContainerResourceInfo;

package/cjs/schema/implementation/resource/resource-info.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceInfo = void 0;
+const clone_object_util_js_1 = require("../../utils/clone-object.util.js");
+const inspect_util_js_1 = require("../../utils/inspect.util.js");
+class ResourceInfo {
+    metadata;
+    document;
+    name;
+    path;
+    constructor(document, name, metadata) {
+        this.document = document;
+        this.name = name;
+        this.metadata = metadata;
+    }
+    get instance() {
+        return this.metadata.instance;
+    }
+    get kind() {
+        return this.metadata.kind;
+    }
+    get description() {
+        return this.metadata.description;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    validateQueryOptions() {
+        //
+    }
+    getSchema(jsonOnly) {
+        return (0, clone_object_util_js_1.cloneObject)(this.metadata, jsonOnly);
+    }
+    [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.ResourceInfo = ResourceInfo;

package/cjs/schema/implementation/resource/singleton-resource-info.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonResourceInfo = void 0;
+const constants_js_1 = require("../../constants.js");
+const complex_type_js_1 = require("../data-type/complex-type.js");
+const resource_info_js_1 = require("./resource-info.js");
+class SingletonResourceInfo extends resource_info_js_1.ResourceInfo {
+    dataType;
+    constructor(document, name, dataType, metadata) {
+        // noinspection SuspiciousTypeOfGuard
+        if (!(dataType instanceof complex_type_js_1.ComplexType))
+            throw new TypeError(`You should provide a ComplexType as "dataType" argument`);
+        super(document, name, metadata);
+        this.dataType = dataType;
+    }
+    get create() {
+        return this.metadata.create;
+    }
+    get delete() {
+        return this.metadata.delete;
+    }
+    get get() {
+        return this.metadata.get;
+    }
+    get update() {
+        return this.metadata.update;
+    }
+    getSchema(jsonOnly) {
+        const out = super.getSchema(jsonOnly);
+        for (const k of constants_js_1.singletonMethods) {
+            if (typeof out[k] === 'object' && !Object.keys(out[k]).length)
+                out[k] = true;
+        }
+        return out;
+    }
+}
+exports.SingletonResourceInfo = SingletonResourceInfo;

package/cjs/schema/implementation/schema-builder/extract-resource-metadata.util.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractResourceSchema = void 0;
+const constants_js_1 = require("../../constants.js");
+const opra_schema_definition_js_1 = require("../../opra-schema.definition.js");
+const clone_object_util_js_1 = require("../../utils/clone-object.util.js");
+async function extractResourceSchema(instance) {
+    const proto = Object.getPrototypeOf(instance);
+    const ctor = proto.constructor;
+    const metadata = Reflect.getMetadata(constants_js_1.RESOURCE_METADATA, ctor);
+    if (!metadata)
+        throw new TypeError(`Class "${ctor.name}" doesn't have "Resource" metadata information`);
+    const schema = (0, clone_object_util_js_1.cloneObject)(metadata);
+    schema.instance = instance;
+    schema.name = metadata.name || ctor.name.replace(/(Resource|Controller)$/, '');
+    if (opra_schema_definition_js_1.OpraSchema.isCollectionResource(metadata))
+        return await processCollectionResource(schema);
+    if (opra_schema_definition_js_1.OpraSchema.isSingletonResource(metadata))
+        return await processSingletonResource(schema);
+    throw new TypeError(`Invalid Resource metadata`);
+}
+exports.extractResourceSchema = extractResourceSchema;
+async function processCollectionResource(schema) {
+    const instance = schema.instance;
+    const proto = Object.getPrototypeOf(schema.instance);
+    let methodMetadata;
+    let fn;
+    const locateFn = (inst, methodName) => {
+        fn = inst[methodName];
+        methodMetadata = Reflect.getMetadata(constants_js_1.RESOLVER_METADATA, inst, methodName);
+        if (fn == null) {
+            if (methodMetadata) {
+                inst = Object.getPrototypeOf(inst);
+                fn = inst[methodName];
+            }
+        }
+    };
+    for (const methodName of constants_js_1.collectionMethods) {
+        locateFn(instance, methodName);
+        if (typeof fn !== 'function')
+            continue;
+        const info = schema[methodName] = {
+            ...methodMetadata
+        };
+        if (!Reflect.hasMetadata(constants_js_1.IGNORE_RESOLVER_METHOD, proto.constructor, methodName)) {
+            info.handler = fn.bind(instance);
+            fn = instance['pre_' + methodName];
+            if (typeof fn === 'function')
+                schema['pre_' + methodName] = fn.bind(instance);
+        }
+    }
+    return schema;
+}
+async function processSingletonResource(schema) {
+    const instance = schema.instance;
+    const proto = Object.getPrototypeOf(schema.instance);
+    let methodMetadata;
+    let fn;
+    const locateFn = (inst, methodName) => {
+        fn = inst[methodName];
+        methodMetadata = Reflect.getMetadata(constants_js_1.RESOLVER_METADATA, inst, methodName);
+        if (fn == null) {
+            if (methodMetadata) {
+                inst = Object.getPrototypeOf(inst);
+                fn = inst[methodName];
+            }
+        }
+    };
+    for (const methodName of constants_js_1.singletonMethods) {
+        locateFn(instance, methodName);
+        if (typeof fn !== 'function')
+            continue;
+        const info = schema[methodName] = {
+            ...methodMetadata
+        };
+        if (!Reflect.hasMetadata(constants_js_1.IGNORE_RESOLVER_METHOD, proto.constructor, methodName)) {
+            info.handler = fn.bind(instance);
+            fn = instance['pre_' + methodName];
+            if (typeof fn === 'function')
+                schema['pre_' + methodName] = fn.bind(instance);
+        }
+    }
+    return schema;
+}

package/cjs/schema/implementation/schema-builder/extract-type-metadata.util.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDataTypeSchema = void 0;
+const tslib_1 = require("tslib");
+const Optionals = tslib_1.__importStar(require("@opra/optionals"));
+const constants_js_1 = require("../../constants.js");
+const opra_schema_definition_js_1 = require("../../opra-schema.definition.js");
+const clone_object_util_js_1 = require("../../utils/clone-object.util.js");
+const builtin_data_types_js_1 = require("../data-type/builtin-data-types.js");
+async function extractDataTypeSchema(ctor) {
+    const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, ctor);
+    if (!metadata)
+        throw new TypeError(`Class "${ctor}" doesn't have "DataType" metadata information`);
+    if (opra_schema_definition_js_1.OpraSchema.isComplexType(metadata))
+        return await extractComplexTypeSchema(ctor, metadata);
+    if (opra_schema_definition_js_1.OpraSchema.isSimpleType(metadata))
+        return await extractSimpleTypeSchema(ctor, metadata);
+    throw new TypeError(`Invalid DataType metadata`);
+}
+exports.extractDataTypeSchema = extractDataTypeSchema;
+async function extractSimpleTypeSchema(ctor, metadata) {
+    const out = (0, clone_object_util_js_1.cloneObject)(metadata);
+    out.ctor = ctor;
+    return out;
+}
+async function extractComplexTypeSchema(ctor, metadata) {
+    const out = (0, clone_object_util_js_1.cloneObject)(metadata);
+    out.ctor = ctor;
+    const mappedTypeMetadata = Reflect.getMetadata(constants_js_1.MAPPED_TYPE_METADATA, ctor);
+    if (mappedTypeMetadata) {
+        out.extends = [...mappedTypeMetadata.map(x => (0, clone_object_util_js_1.cloneObject)(x))];
+    }
+    const fields = Reflect.getMetadata(constants_js_1.COMPLEXTYPE_FIELDS, ctor);
+    if (fields) {
+        out.fields = (0, clone_object_util_js_1.cloneObject)(fields);
+        for (const [fieldName, field] of Object.entries(out.fields)) {
+            if (typeof field.type === 'function') {
+                const type = builtin_data_types_js_1.primitiveClasses.get(field.type);
+                if (type)
+                    field.type = type;
+            }
+            let sqbField;
+            if (Optionals.SqbConnect) {
+                const { EntityMetadata, isAssociationField } = Optionals.SqbConnect;
+                const meta = EntityMetadata.get(ctor);
+                sqbField = meta && EntityMetadata.getField(meta, fieldName);
+                if (sqbField) {
+                    if (field.type === Function || field.type === 'object' ||
+                        field.type === Object || field.type === 'any') {
+                        field.type = 'any';
+                        if (isAssociationField(sqbField)) {
+                            if (!sqbField.association.returnsMany())
+                                delete field.isArray;
+                            const trg = await sqbField.association.resolveTarget();
+                            if (trg) {
+                                field.type = trg.ctor;
+                            }
+                        }
+                    }
+                    if (sqbField.exclusive && field.exclusive === undefined)
+                        field.exclusive = sqbField.exclusive;
+                }
+            }
+            if (sqbField && sqbField.kind === 'column') {
+                const DataType = Optionals.SqbConnect.DataType;
+                if (field.type === 'number' || field.type === Number) {
+                    switch (sqbField.dataType) {
+                        case DataType.INTEGER:
+                        case DataType.SMALLINT:
+                            field.type = 'integer';
+                            break;
+                        case DataType.BIGINT:
+                            field.type = 'bigint';
+                            break;
+                    }
+                }
+                else if (field.type === 'string' || field.type === String) {
+                    switch (sqbField.dataType) {
+                        case DataType.GUID:
+                            field.type = 'guid';
+                            break;
+                    }
+                }
+                if (sqbField.notNull && field.required === undefined)
+                    field.required = sqbField.notNull;
+                if (sqbField.exclusive && field.exclusive === undefined)
+                    field.exclusive = sqbField.exclusive;
+                if (sqbField.default !== undefined && field.default === undefined)
+                    field.default = sqbField.default;
+            }
+        }
+    }
+    return out;
+}

package/cjs/schema/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("reflect-metadata");
+tslib_1.__exportStar(require("./constants.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./opra-schema.definition.js"), exports);
+tslib_1.__exportStar(require("./decorators/opr-complex-type.decorator.js"), exports);
+tslib_1.__exportStar(require("./decorators/opr-field.decorator.js"), exports);
+tslib_1.__exportStar(require("./decorators/opr-collection-resource.decorator.js"), exports);
+tslib_1.__exportStar(require("./decorators/opr-singleton-resource.decorator.js"), exports);
+tslib_1.__exportStar(require("./decorators/opr-resolver.decorator.js"), exports);
+tslib_1.__exportStar(require("./interfaces/resource-container.interface.js"), exports);
+tslib_1.__exportStar(require("./implementation/document-builder.js"), exports);
+tslib_1.__exportStar(require("./implementation/opra-document.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/data-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/complex-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/simple-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/union-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/resource-info.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/container-resource-info.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/collection-resource-info.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/singleton-resource-info.js"), exports);
+tslib_1.__exportStar(require("./implementation/query/index.js"), exports);
+tslib_1.__exportStar(require("./type-helpers/mixin-type.helper.js"), exports);
+tslib_1.__exportStar(require("./type-helpers/extend-type.helper.js"), exports);
+tslib_1.__exportStar(require("./implementation/schema-builder/extract-type-metadata.util.js"), exports);
+tslib_1.__exportStar(require("./implementation/schema-builder/extract-resource-metadata.util.js"), exports);

package/cjs/schema/interfaces/child-field-query.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/interfaces/data-type.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/interfaces/resource-container.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/interfaces/resource.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/opra-schema.definition.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraSchema = void 0;
+var OpraSchema;
+(function (OpraSchema) {
+    /**
+     * *** === Constants === ***
+     */
+    OpraSchema.Version = '1.0';
+    /**
+     * *** === Type Guards === ***
+     */
+    function isDataType(obj) {
+        return obj && typeof obj === 'object' &&
+            (obj.kind === 'ComplexType' || obj.kind === 'SimpleType' || obj.kind === 'UnionType');
+    }
+    OpraSchema.isDataType = isDataType;
+    function isComplexType(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'ComplexType';
+    }
+    OpraSchema.isComplexType = isComplexType;
+    function isSimpleType(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'SimpleType';
+    }
+    OpraSchema.isSimpleType = isSimpleType;
+    function isUnionTypee(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'UnionType';
+    }
+    OpraSchema.isUnionTypee = isUnionTypee;
+    function isResource(obj) {
+        return obj && typeof obj === 'object' &&
+            obj.kind === 'ContainerResource' ||
+            obj.kind === 'CollectionResource' ||
+            obj.kind === 'SingletonResource';
+    }
+    OpraSchema.isResource = isResource;
+    function isCollectionResource(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'CollectionResource';
+    }
+    OpraSchema.isCollectionResource = isCollectionResource;
+    function isSingletonResource(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'SingletonResource';
+    }
+    OpraSchema.isSingletonResource = isSingletonResource;
+    function isContainerResource(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'ContainerResource';
+    }
+    OpraSchema.isContainerResource = isContainerResource;
+})(OpraSchema = exports.OpraSchema || (exports.OpraSchema = {}));

package/cjs/schema/type-helpers/extend-type.helper.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitType = exports.PickType = void 0;
+const tslib_1 = require("tslib");
+const Optionals = tslib_1.__importStar(require("@opra/optionals"));
+const constants_js_1 = require("../constants.js");
+const mixin_utils_js_1 = require("./mixin.utils.js");
+function PickType(classRef, keys) {
+    return ExtendType(classRef, classRef, { pickKeys: keys });
+}
+exports.PickType = PickType;
+function OmitType(classRef, keys) {
+    return ExtendType(classRef, classRef, { omitKeys: keys });
+}
+exports.OmitType = OmitType;
+function ExtendType(classRef, orgClassRef, options) {
+    const pickKeys = options.pickKeys && options.pickKeys.map(x => String(x).toLowerCase());
+    const omitKeys = options.omitKeys && options.omitKeys.map(x => String(x).toLowerCase());
+    const isInheritedPredicate = (propertyName) => {
+        if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
+            return false;
+        if (pickKeys)
+            return pickKeys.includes(propertyName.toLowerCase());
+        return true;
+    };
+    // const isRequiredPredicate = (propertyName: string): boolean | undefined => {
+    //   if (options.requiredKeys && options.requiredKeys.includes(propertyName as RequiredKey))
+    //     return true;
+    //   if (options.partialKeys && options.partialKeys.includes(propertyName as PartialKey))
+    //     return false;
+    //   return;
+    // };
+    class MappedClass {
+        constructor() {
+            (0, mixin_utils_js_1.inheritPropertyInitializers)(this, classRef, isInheritedPredicate);
+        }
+    }
+    (0, mixin_utils_js_1.applyMixins)(MappedClass, classRef);
+    const mappedTypeMetadata = [];
+    const m = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, classRef);
+    if (m) {
+        if (!(m.kind === 'ComplexType'))
+            throw new TypeError(`Class "${classRef}" is not a ComplexType`);
+        const meta = {
+            type: classRef
+        };
+        if (options.pickKeys)
+            meta.pick = options.pickKeys;
+        if (options.omitKeys)
+            meta.omit = options.omitKeys;
+        mappedTypeMetadata.push(meta);
+    }
+    else
+        throw new TypeError(`Class "${classRef}" doesn't have datatype metadata information`);
+    if (Optionals.SqbConnect) {
+        const { Entity, EntityMetadata } = Optionals.SqbConnect;
+        const srcMeta = Entity.getMetadata(classRef);
+        if (srcMeta) {
+            const trgMeta = EntityMetadata.define(MappedClass);
+            EntityMetadata.mixin(trgMeta, srcMeta, k => isInheritedPredicate(k));
+        }
+    }
+    Reflect.defineMetadata(constants_js_1.MAPPED_TYPE_METADATA, mappedTypeMetadata, MappedClass);
+    return MappedClass;
+}

package/cjs/schema/type-helpers/mixin-type.helper.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MixinType = void 0;
+const tslib_1 = require("tslib");
+const Optionals = tslib_1.__importStar(require("@opra/optionals"));
+const constants_js_1 = require("../constants.js");
+const mixin_utils_js_1 = require("./mixin.utils.js");
+function MixinType(c1, c2, c3, c4) {
+    const clasRefs = [...arguments].filter(x => !!x);
+    if (!clasRefs.length)
+        throw new TypeError('You must provide base classeses');
+    if (clasRefs.length === 1)
+        return clasRefs[0];
+    class MappedClass {
+        constructor() {
+            for (const c of clasRefs)
+                (0, mixin_utils_js_1.inheritPropertyInitializers)(this, c);
+        }
+    }
+    const mappedTypeMetadata = [];
+    for (const c of clasRefs) {
+        const m = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, c);
+        if (m) {
+            if (!(m.kind === 'ComplexType'))
+                throw new TypeError(`Class "${c}" is not a ComplexType`);
+            mappedTypeMetadata.push({
+                type: c
+            });
+        }
+        else if (Reflect.hasMetadata(constants_js_1.MAPPED_TYPE_METADATA, c)) {
+            const mtm = Reflect.getMetadata(constants_js_1.MAPPED_TYPE_METADATA, c);
+            if (mtm)
+                mappedTypeMetadata.push(...mtm);
+        }
+        else
+            throw new TypeError(`Class "${c}" doesn't have datatype metadata information`);
+        (0, mixin_utils_js_1.applyMixins)(MappedClass, c);
+    }
+    if (Optionals.SqbConnect) {
+        const { Entity } = Optionals.SqbConnect;
+        Entity.mixin(MappedClass, ...clasRefs);
+    }
+    Reflect.defineMetadata(constants_js_1.MAPPED_TYPE_METADATA, mappedTypeMetadata, MappedClass);
+    return MappedClass;
+}
+exports.MixinType = MixinType;

package/cjs/schema/type-helpers/mixin.utils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inheritPropertyInitializers = exports.applyMixins = void 0;
+function applyMixins(derivedCtor, baseCtor, filter) {
+    for (const k of Object.getOwnPropertyNames(baseCtor.prototype)) {
+        if ((k === 'constructor' || k === '__proto__' || k === 'toJSON' || k === 'toString') ||
+            filter && !filter(k))
+            continue;
+        Object.defineProperty(derivedCtor.prototype, k, Object.getOwnPropertyDescriptor(baseCtor.prototype, k) ||
+            Object.create(null));
+    }
+}
+exports.applyMixins = applyMixins;
+function inheritPropertyInitializers(target, sourceClass, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+isPropertyInherited = (key) => true) {
+    try {
+        const tempInstance = new sourceClass();
+        const propertyNames = Object.getOwnPropertyNames(tempInstance);
+        propertyNames
+            .filter((propertyName) => typeof tempInstance[propertyName] !== 'undefined' &&
+            typeof target[propertyName] === 'undefined')
+            .filter((propertyName) => isPropertyInherited(propertyName))
+            .forEach((propertyName) => {
+            target[propertyName] = tempInstance[propertyName];
+        });
+    }
+    catch {
+        //
+    }
+}
+exports.inheritPropertyInitializers = inheritPropertyInitializers;

package/cjs/schema/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/utils/class.utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConstructor = void 0;
+function isConstructor(obj) {
+    return typeof obj === 'function' &&
+        !!(obj.prototype && obj.prototype.constructor);
+}
+exports.isConstructor = isConstructor;

package/cjs/schema/utils/clone-object.util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneObject = void 0;
+const tslib_1 = require("tslib");
+const putil_isplainobject_1 = tslib_1.__importDefault(require("putil-isplainobject"));
+const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+function cloneObject(obj, jsonOnly) {
+    return (0, putil_merge_1.default)({}, obj, {
+        deep: true,
+        clone: true,
+        filter: (source, key) => {
+            const v = source[key];
+            return v != null &&
+                !jsonOnly || (typeof v !== 'function' &&
+                (typeof v !== 'object' || (0, putil_isplainobject_1.default)(v) || Array.isArray(v)));
+        }
+    });
+}
+exports.cloneObject = cloneObject;

package/cjs/schema/utils/inspect.util.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorFgMagenta = exports.colorFgYellow = exports.colorReset = exports.nodeInspectCustom = void 0;
+exports.nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
+exports.colorReset = "\x1b[0m";
+exports.colorFgYellow = "\x1b[33m";
+exports.colorFgMagenta = "\x1b[35m";