@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.11

package/metadata/MetadataDiscovery.js

@@ -1,22 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataDiscovery = void 0;
-const node_path_1 = require("node:path");
-const globby_1 = __importDefault(require("globby"));
-const typings_1 = require("../typings");
-const Utils_1 = require("../utils/Utils");
-const MetadataValidator_1 = require("./MetadataValidator");
-const MetadataStorage_1 = require("./MetadataStorage");
-const EntitySchema_1 = require("./EntitySchema");
-const enums_1 = require("../enums");
-const errors_1 = require("../errors");
-const types_1 = require("../types");
-const colors_1 = require("../logging/colors");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
-class MetadataDiscovery {
+import { basename, extname } from 'node:path';
+import globby from 'globby';
+import { EntityMetadata, } from '../typings.js';
+import { Utils } from '../utils/Utils.js';
+import { MetadataValidator } from './MetadataValidator.js';
+import { MetadataStorage } from './MetadataStorage.js';
+import { EntitySchema } from './EntitySchema.js';
+import { Cascade, ReferenceKind } from '../enums.js';
+import { MetadataError } from '../errors.js';
+import { ArrayType, BigIntType, BlobType, DateType, DecimalType, DoubleType, EnumArrayType, IntervalType, JsonType, t, Type, Uint8ArrayType, UnknownType, } from '../types/index.js';
+import { colors } from '../logging/colors.js';
+import { raw, RawQueryFragment } from '../utils/RawQueryFragment.js';
+export class MetadataDiscovery {
     metadata;
     platform;
     config;
@@ -25,7 +19,7 @@ class MetadataDiscovery {
     cache;
     logger;
     schemaHelper;
-    validator = new MetadataValidator_1.MetadataValidator();
+    validator = new MetadataValidator();
     discovered = [];
     constructor(metadata, platform, config) {
         this.metadata = metadata;
@@ -37,36 +31,40 @@ class MetadataDiscovery {
         this.logger = this.config.getLogger();
         this.schemaHelper = this.platform.getSchemaHelper();
     }
-    async discover(preferTsNode = true) {
+    async discover(preferTs = true) {
         const startTime = Date.now();
-        this.logger.log('discovery', `ORM entity discovery started, using ${colors_1.colors.cyan(this.metadataProvider.constructor.name)}`);
-        await this.findEntities(preferTsNode);
+        this.logger.log('discovery', `ORM entity discovery started, using ${colors.cyan(this.metadataProvider.constructor.name)}`);
+        await this.findEntities(preferTs);
         for (const meta of this.discovered) {
+            /* v8 ignore next */
             await this.config.get('discovery').onMetadata?.(meta, this.platform);
         }
         this.processDiscoveredEntities(this.discovered);
         const diff = Date.now() - startTime;
-        this.logger.log('discovery', `- entity discovery finished, found ${colors_1.colors.green('' + this.discovered.length)} entities, took ${colors_1.colors.green(`${diff} ms`)}`);
+        this.logger.log('discovery', `- entity discovery finished, found ${colors.green('' + this.discovered.length)} entities, took ${colors.green(`${diff} ms`)}`);
         const storage = this.mapDiscoveredEntities();
+        /* v8 ignore next */
         await this.config.get('discovery').afterDiscovered?.(storage, this.platform);
         return storage;
     }
-    discoverSync(preferTsNode = true) {
+    discoverSync(preferTs = true) {
         const startTime = Date.now();
-        this.logger.log('discovery', `ORM entity discovery started, using ${colors_1.colors.cyan(this.metadataProvider.constructor.name)} in sync mode`);
-        this.findEntities(preferTsNode, true);
+        this.logger.log('discovery', `ORM entity discovery started, using ${colors.cyan(this.metadataProvider.constructor.name)} in sync mode`);
+        this.findEntities(preferTs, true);
         for (const meta of this.discovered) {
+            /* v8 ignore next */
             void this.config.get('discovery').onMetadata?.(meta, this.platform);
         }
         this.processDiscoveredEntities(this.discovered);
         const diff = Date.now() - startTime;
-        this.logger.log('discovery', `- entity discovery finished, found ${colors_1.colors.green('' + this.discovered.length)} entities, took ${colors_1.colors.green(`${diff} ms`)}`);
+        this.logger.log('discovery', `- entity discovery finished, found ${colors.green('' + this.discovered.length)} entities, took ${colors.green(`${diff} ms`)}`);
         const storage = this.mapDiscoveredEntities();
+        /* v8 ignore next */
         void this.config.get('discovery').afterDiscovered?.(storage, this.platform);
         return storage;
     }
     mapDiscoveredEntities() {
-        const discovered = new MetadataStorage_1.MetadataStorage();
+        const discovered = new MetadataStorage();
         this.discovered
             .filter(meta => meta.root.name)
             .sort((a, b) => b.root.name.localeCompare(a.root.name))
@@ -88,7 +86,7 @@ class MetadataDiscovery {
         filtered.sort((a, b) => !a.embeddable === !b.embeddable ? 0 : (a.embeddable ? 1 : -1));
         filtered.forEach(meta => this.initSingleTableInheritance(meta, filtered));
         filtered.forEach(meta => this.defineBaseEntityProperties(meta));
-        filtered.forEach(meta => this.metadata.set(meta.className, EntitySchema_1.EntitySchema.fromMetadata(meta).init().meta));
+        filtered.forEach(meta => this.metadata.set(meta.className, EntitySchema.fromMetadata(meta).init().meta));
         filtered.forEach(meta => this.initAutoincrement(meta));
         filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initEmbeddables(meta, prop)));
         filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initFactoryField(meta, prop)));
@@ -104,7 +102,7 @@ class MetadataDiscovery {
                 this.inferTypeFromDefault(prop);
                 this.initColumnType(prop);
                 // change tracking on scalars is used only for "auto" flushMode
-                if (this.config.get('flushMode') !== 'auto' && [enums_1.ReferenceKind.SCALAR, enums_1.ReferenceKind.EMBEDDED].includes(prop.kind)) {
+                if (this.config.get('flushMode') !== 'auto' && [ReferenceKind.SCALAR, ReferenceKind.EMBEDDED].includes(prop.kind)) {
                     prop.trackChanges = false;
                 }
             }
@@ -130,9 +128,9 @@ class MetadataDiscovery {
     findEntities(preferTs, sync = false) {
         this.discovered.length = 0;
         const options = this.config.get('discovery');
-        const key = (preferTs && this.config.get('preferTs', Utils_1.Utils.detectTsNode()) && this.config.get('entitiesTs').length > 0) ? 'entitiesTs' : 'entities';
-        const paths = this.config.get(key).filter(item => Utils_1.Utils.isString(item));
-        const refs = this.config.get(key).filter(item => !Utils_1.Utils.isString(item));
+        const key = (preferTs && this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.config.get('entitiesTs').length > 0) ? 'entitiesTs' : 'entities';
+        const paths = this.config.get(key).filter(item => Utils.isString(item));
+        const refs = this.config.get(key).filter(item => !Utils.isString(item));
         if (paths.length > 0) {
             if (sync || options.requireEntitiesArray) {
                 throw new Error(`[requireEntitiesArray] Explicit list of entities is required, please use the 'entities' option.`);
@@ -156,17 +154,17 @@ class MetadataDiscovery {
             .replace(/\((.*)\)/, '$1'); // unwrap union types
         const missing = [];
         this.discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
-            if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.pivotEntity && !this.discovered.find(m => m.className === Utils_1.Utils.className(prop.pivotEntity))) {
+            if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.pivotEntity && !this.discovered.find(m => m.className === Utils.className(prop.pivotEntity))) {
                 const target = typeof prop.pivotEntity === 'function'
                     ? prop.pivotEntity()
                     : prop.pivotEntity;
                 missing.push(target);
             }
-            if (prop.kind !== enums_1.ReferenceKind.SCALAR && !unwrap(prop.type).split(/ ?\| ?/).every(type => this.discovered.find(m => m.className === type))) {
+            if (prop.kind !== ReferenceKind.SCALAR && !unwrap(prop.type).split(/ ?\| ?/).every(type => this.discovered.find(m => m.className === type))) {
                 const target = typeof prop.entity === 'function'
                     ? prop.entity()
                     : prop.type;
-                missing.push(...Utils_1.Utils.asArray(target));
+                missing.push(...Utils.asArray(target));
             }
         }));
         if (missing.length > 0) {
@@ -182,12 +180,12 @@ class MetadataDiscovery {
         }
     }
     async discoverDirectories(paths) {
-        paths = paths.map(path => Utils_1.Utils.normalizePath(path));
-        const files = await (0, globby_1.default)(paths, { cwd: Utils_1.Utils.normalizePath(this.config.get('baseDir')) });
-        this.logger.log('discovery', `- processing ${colors_1.colors.cyan('' + files.length)} files`);
+        paths = paths.map(path => Utils.normalizePath(path));
+        const files = await globby(paths, { cwd: Utils.normalizePath(this.config.get('baseDir')) });
+        this.logger.log('discovery', `- processing ${colors.cyan('' + files.length)} files`);
         const found = [];
         for (const filepath of files) {
-            const filename = (0, node_path_1.basename)(filepath);
+            const filename = basename(filepath);
             if (!filename.match(/\.[cm]?[jt]s$/) ||
                 filename.endsWith('.js.map') ||
                 filename.match(/\.d\.[cm]?ts/) ||
@@ -197,10 +195,10 @@ class MetadataDiscovery {
                 continue;
             }
             const name = this.namingStrategy.getClassName(filename);
-            const path = Utils_1.Utils.normalizePath(this.config.get('baseDir'), filepath);
+            const path = Utils.normalizePath(this.config.get('baseDir'), filepath);
             const targets = await this.getEntityClassOrSchema(path, name);
             for (const target of targets) {
-                if (!(target instanceof Function) && !(target instanceof EntitySchema_1.EntitySchema)) {
+                if (!(target instanceof Function) && !(target instanceof EntitySchema)) {
                     this.logger.log('discovery', `- ignoring file ${filename}`);
                     continue;
                 }
@@ -226,9 +224,10 @@ class MetadataDiscovery {
         // discover parents (base entities) automatically
         for (const meta of this.metadata) {
             let parent = meta.extends;
-            if (parent instanceof EntitySchema_1.EntitySchema && !this.metadata.has(parent.meta.className)) {
+            if (parent instanceof EntitySchema && !this.metadata.has(parent.meta.className)) {
                 this.discoverReferences([parent]);
             }
+            /* v8 ignore next 3 */
             if (!meta.class) {
                 continue;
             }
@@ -250,44 +249,44 @@ class MetadataDiscovery {
         }
     }
     prepare(entity) {
-        if ('schema' in entity && entity.schema instanceof EntitySchema_1.EntitySchema) {
+        /* v8 ignore next 3 */
+        if ('schema' in entity && entity.schema instanceof EntitySchema) {
             return entity.schema;
         }
-        if (EntitySchema_1.EntitySchema.REGISTRY.has(entity)) {
-            return EntitySchema_1.EntitySchema.REGISTRY.get(entity);
+        if (EntitySchema.REGISTRY.has(entity)) {
+            return EntitySchema.REGISTRY.get(entity);
         }
         return entity;
     }
     getSchema(entity, filepath) {
-        if (entity instanceof EntitySchema_1.EntitySchema) {
+        if (entity instanceof EntitySchema) {
             if (filepath) {
                 // initialize global metadata for given entity
-                MetadataStorage_1.MetadataStorage.getMetadata(entity.meta.className, filepath);
+                MetadataStorage.getMetadata(entity.meta.className, filepath);
             }
             return entity;
         }
-        const path = entity[MetadataStorage_1.MetadataStorage.PATH_SYMBOL];
+        const path = entity[MetadataStorage.PATH_SYMBOL];
         if (path) {
-            const meta = Utils_1.Utils.copy(MetadataStorage_1.MetadataStorage.getMetadata(entity.name, path), false);
-            meta.path = Utils_1.Utils.relativePath(path, this.config.get('baseDir'));
+            const meta = Utils.copy(MetadataStorage.getMetadata(entity.name, path), false);
+            meta.path = Utils.relativePath(path, this.config.get('baseDir'));
             this.metadata.set(entity.name, meta);
         }
         const exists = this.metadata.has(entity.name);
         const meta = this.metadata.get(entity.name, true);
         meta.abstract ??= !(exists && meta.name);
-        const schema = EntitySchema_1.EntitySchema.fromMetadata(meta);
+        const schema = EntitySchema.fromMetadata(meta);
         schema.setClass(entity);
-        schema.meta.useCache = this.metadataProvider.useCache();
         return schema;
     }
     discoverEntity(schema, path) {
-        this.logger.log('discovery', `- processing entity ${colors_1.colors.cyan(schema.meta.className)}${colors_1.colors.grey(path ? ` (${path})` : '')}`);
+        this.logger.log('discovery', `- processing entity ${colors.cyan(schema.meta.className)}${colors.grey(path ? ` (${path})` : '')}`);
         const meta = schema.meta;
-        const root = Utils_1.Utils.getRootEntity(this.metadata, meta);
-        schema.meta.path = Utils_1.Utils.relativePath(path || meta.path, this.config.get('baseDir'));
-        const cache = meta.useCache && meta.path && this.cache.get(meta.className + (0, node_path_1.extname)(meta.path));
+        const root = Utils.getRootEntity(this.metadata, meta);
+        schema.meta.path = Utils.relativePath(path || meta.path, this.config.get('baseDir'));
+        const cache = this.metadataProvider.useCache() && meta.path && this.cache.get(meta.className + extname(meta.path));
         if (cache) {
-            this.logger.log('discovery', `- using cached metadata for entity ${colors_1.colors.cyan(meta.className)}`);
+            this.logger.log('discovery', `- using cached metadata for entity ${colors.cyan(meta.className)}`);
             this.metadataProvider.loadFromCache(meta, cache);
             meta.root = root;
             this.discovered.push(meta);
@@ -309,62 +308,60 @@ class MetadataDiscovery {
         this.discovered.push(meta);
     }
     saveToCache(meta) {
-        if (!meta.useCache) {
+        if (!this.metadataProvider.useCache()) {
             return;
         }
-        const copy = Utils_1.Utils.copy(meta, false);
-        copy.props
-            .filter(prop => types_1.Type.isMappedType(prop.type))
-            .forEach(prop => {
-            ['type', 'customType']
-                .filter(k => types_1.Type.isMappedType(prop[k]))
-                .forEach(k => delete prop[k]);
-        });
-        copy.props
-            .filter(prop => prop.default)
-            .forEach(prop => {
-            const raw = RawQueryFragment_1.RawQueryFragment.getKnownFragment(prop.default);
-            if (raw) {
-                prop.defaultRaw ??= this.platform.formatQuery(raw.sql, raw.params);
-                delete prop.default;
+        const copy = Utils.copy(meta, false);
+        for (const prop of copy.props) {
+            if (Type.isMappedType(prop.type)) {
+                Reflect.deleteProperty(prop, 'type');
+                Reflect.deleteProperty(prop, 'customType');
             }
-        });
+            if (prop.default) {
+                const raw = RawQueryFragment.getKnownFragment(prop.default);
+                if (raw) {
+                    prop.defaultRaw ??= this.platform.formatQuery(raw.sql, raw.params);
+                    Reflect.deleteProperty(prop, 'default');
+                }
+            }
+            Reflect.deleteProperty(prop, 'targetMeta');
+        }
         [
             'prototype', 'props', 'referencingProperties', 'propertyOrder', 'relations',
             'concurrencyCheckKeys', 'checks',
         ].forEach(key => delete copy[key]);
         // base entity without properties might not have path, but nothing to cache there
         if (meta.path) {
-            this.cache.set(meta.className + (0, node_path_1.extname)(meta.path), copy, meta.path);
+            this.cache.set(meta.className + extname(meta.path), copy, meta.path);
         }
     }
     initNullability(prop) {
-        if (prop.kind === enums_1.ReferenceKind.MANY_TO_ONE) {
-            return Utils_1.Utils.defaultValue(prop, 'nullable', prop.optional || prop.cascade.includes(enums_1.Cascade.REMOVE) || prop.cascade.includes(enums_1.Cascade.ALL));
+        if (prop.kind === ReferenceKind.MANY_TO_ONE) {
+            return Utils.defaultValue(prop, 'nullable', prop.optional || prop.cascade.includes(Cascade.REMOVE) || prop.cascade.includes(Cascade.ALL));
         }
-        if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE) {
-            return Utils_1.Utils.defaultValue(prop, 'nullable', prop.optional || !prop.owner || prop.cascade.includes(enums_1.Cascade.REMOVE) || prop.cascade.includes(enums_1.Cascade.ALL));
+        if (prop.kind === ReferenceKind.ONE_TO_ONE) {
+            return Utils.defaultValue(prop, 'nullable', prop.optional || !prop.owner || prop.cascade.includes(Cascade.REMOVE) || prop.cascade.includes(Cascade.ALL));
         }
-        return Utils_1.Utils.defaultValue(prop, 'nullable', prop.optional);
+        return Utils.defaultValue(prop, 'nullable', prop.optional);
     }
     applyNamingStrategy(meta, prop) {
         if (!prop.fieldNames) {
             this.initFieldName(prop);
         }
-        if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+        if (prop.kind === ReferenceKind.MANY_TO_MANY) {
             this.initManyToManyFields(meta, prop);
         }
-        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             this.initManyToOneFields(prop);
         }
-        if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY) {
+        if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             this.initOneToManyFields(prop);
         }
     }
     initOwnColumns(meta) {
         meta.sync();
         for (const prop of meta.props) {
-            if (!prop.joinColumns || !prop.columnTypes || prop.ownColumns || ![enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+            if (!prop.joinColumns || !prop.columnTypes || prop.ownColumns || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 continue;
             }
             if (prop.joinColumns.length > 1) {
@@ -378,15 +375,15 @@ class MetadataDiscovery {
             if (prop.joinColumns.length !== prop.columnTypes.length) {
                 prop.columnTypes = prop.joinColumns.flatMap(field => {
                     const matched = meta.props.find(p => p.fieldNames?.includes(field));
-                    if (matched) {
-                        return matched.columnTypes;
+                    /* v8 ignore next 3 */
+                    if (!matched) {
+                        throw MetadataError.fromWrongForeignKey(meta, prop, 'columnTypes');
                     }
-                    /* istanbul ignore next */
-                    throw errors_1.MetadataError.fromWrongForeignKey(meta, prop, 'columnTypes');
+                    return matched.columnTypes;
                 });
             }
             if (prop.joinColumns.length !== prop.referencedColumnNames.length) {
-                throw errors_1.MetadataError.fromWrongForeignKey(meta, prop, 'referencedColumnNames');
+                throw MetadataError.fromWrongForeignKey(meta, prop, 'referencedColumnNames');
             }
         }
     }
@@ -394,13 +391,13 @@ class MetadataDiscovery {
         if (prop.fieldNames && prop.fieldNames.length > 0) {
             return;
         }
-        if (prop.kind === enums_1.ReferenceKind.SCALAR || prop.kind === enums_1.ReferenceKind.EMBEDDED) {
+        if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED) {
             prop.fieldNames = [this.namingStrategy.propertyToColumnName(prop.name, object)];
         }
-        else if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             prop.fieldNames = this.initManyToOneFieldName(prop, prop.name);
         }
-        else if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner) {
+        else if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
             prop.fieldNames = this.initManyToManyFieldName(prop, prop.name);
         }
     }
@@ -421,11 +418,11 @@ class MetadataDiscovery {
     }
     initManyToManyFields(meta, prop) {
         const meta2 = this.metadata.get(prop.type);
-        Utils_1.Utils.defaultValue(prop, 'fixedOrder', !!prop.fixedOrderColumn);
+        Utils.defaultValue(prop, 'fixedOrder', !!prop.fixedOrderColumn);
         const pivotMeta = this.metadata.find(prop.pivotEntity);
         const props = Object.values(pivotMeta?.properties ?? {});
         const pks = props.filter(p => p.primary);
-        const fks = props.filter(p => p.kind === enums_1.ReferenceKind.MANY_TO_ONE);
+        const fks = props.filter(p => p.kind === ReferenceKind.MANY_TO_ONE);
         if (pivotMeta) {
             pivotMeta.pivotTable = true;
             prop.pivotTable = pivotMeta.tableName;
@@ -453,14 +450,14 @@ class MetadataDiscovery {
             prop.joinColumns = prop2.inverseJoinColumns;
             prop.inverseJoinColumns = prop2.joinColumns;
         }
-        prop.referencedColumnNames ??= Utils_1.Utils.flatten(meta.primaryKeys.map(primaryKey => meta.properties[primaryKey].fieldNames));
+        prop.referencedColumnNames ??= Utils.flatten(meta.primaryKeys.map(primaryKey => meta.properties[primaryKey].fieldNames));
         prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK));
         prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className);
     }
     initManyToOneFields(prop) {
         const meta2 = this.metadata.get(prop.type);
-        const fieldNames = Utils_1.Utils.flatten(meta2.primaryKeys.map(primaryKey => meta2.properties[primaryKey].fieldNames));
-        Utils_1.Utils.defaultValue(prop, 'referencedTableName', meta2.collection);
+        const fieldNames = Utils.flatten(meta2.primaryKeys.map(primaryKey => meta2.properties[primaryKey].fieldNames));
+        Utils.defaultValue(prop, 'referencedTableName', meta2.collection);
         if (!prop.joinColumns) {
             prop.joinColumns = fieldNames.map(fieldName => this.namingStrategy.joinKeyColumnName(prop.name, fieldName, fieldNames.length > 1));
         }
@@ -475,7 +472,7 @@ class MetadataDiscovery {
         }
         if (!prop.referencedColumnNames) {
             meta2.getPrimaryProps().forEach(pk => this.applyNamingStrategy(meta2, pk));
-            prop.referencedColumnNames = Utils_1.Utils.flatten(meta2.getPrimaryProps().map(pk => pk.fieldNames));
+            prop.referencedColumnNames = Utils.flatten(meta2.getPrimaryProps().map(pk => pk.fieldNames));
         }
     }
     processEntity(meta) {
@@ -483,7 +480,7 @@ class MetadataDiscovery {
         meta.primaryKeys = pks.map(prop => prop.name);
         meta.compositePK = pks.length > 1;
         // FK used as PK, we need to cascade
-        if (pks.length === 1 && pks[0].kind !== enums_1.ReferenceKind.SCALAR) {
+        if (pks.length === 1 && pks[0].kind !== ReferenceKind.SCALAR) {
             pks[0].deleteRule ??= 'cascade';
         }
         meta.forceConstructor ??= this.shouldForceConstructorUsage(meta);
@@ -499,7 +496,7 @@ class MetadataDiscovery {
             this.initRelation(prop);
         }
         this.initOwnColumns(meta);
-        meta.simplePK = pks.length === 1 && pks[0].kind === enums_1.ReferenceKind.SCALAR && !pks[0].customType && pks[0].runtimeType !== 'Date';
+        meta.simplePK = pks.length === 1 && pks[0].kind === ReferenceKind.SCALAR && !pks[0].customType && pks[0].runtimeType !== 'Date';
         meta.serializedPrimaryKey = this.platform.getSerializedPrimaryKeyField(meta.primaryKeys[0]);
         const serializedPKProp = meta.properties[meta.serializedPrimaryKey];
         if (serializedPKProp && meta.serializedPrimaryKey !== meta.primaryKeys[0]) {
@@ -507,7 +504,7 @@ class MetadataDiscovery {
         }
         if (this.platform.usesPivotTable()) {
             return Object.values(meta.properties)
-                .filter(prop => prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner && prop.pivotTable)
+                .filter(prop => prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && prop.pivotTable)
                 .map(prop => this.definePivotTableEntity(meta, prop));
         }
         return [];
@@ -515,7 +512,7 @@ class MetadataDiscovery {
     findReferencingProperties(meta, metadata) {
         for (const meta2 of metadata) {
             for (const prop2 of meta2.relations) {
-                if (prop2.kind !== enums_1.ReferenceKind.SCALAR && prop2.type === meta.className) {
+                if (prop2.kind !== ReferenceKind.SCALAR && prop2.type === meta.className) {
                     meta.referencingProperties.push({ meta: meta2, prop: prop2 });
                 }
             }
@@ -528,23 +525,23 @@ class MetadataDiscovery {
                 const meta2 = this.metadata.get(prop.type);
                 prop[type] = value(meta2.properties)?.name;
                 if (prop[type] == null) {
-                    throw errors_1.MetadataError.fromWrongReference(meta, prop, type);
+                    throw MetadataError.fromWrongReference(meta, prop, type);
                 }
             }
         });
     }
     ensureCorrectFKOrderInPivotEntity(meta, owner) {
         const pks = Object.values(meta.properties).filter(p => p.primary);
-        const fks = Object.values(meta.properties).filter(p => p.kind === enums_1.ReferenceKind.MANY_TO_ONE);
+        const fks = Object.values(meta.properties).filter(p => p.kind === ReferenceKind.MANY_TO_ONE);
         let first, second;
         if (pks.length === 2) {
             [first, second] = pks;
         }
         else if (fks.length >= 2) {
             [first, second] = fks;
+            /* v8 ignore next 3 */
         }
         else {
-            /* istanbul ignore next */
             return [];
         }
         // wrong FK order, first FK needs to point to the owning side
@@ -565,7 +562,7 @@ class MetadataDiscovery {
             prop.inversedBy = inverseName;
             const inverseProp = {
                 name: inverseName,
-                kind: enums_1.ReferenceKind.MANY_TO_MANY,
+                kind: ReferenceKind.MANY_TO_MANY,
                 type: meta.className,
                 mappedBy: prop.name,
                 pivotEntity: prop.pivotEntity,
@@ -594,7 +591,7 @@ class MetadataDiscovery {
         }
         schemaName ??= meta.schema;
         const targetType = prop.targetMeta.className;
-        const data = new typings_1.EntityMetadata({
+        const data = new EntityMetadata({
             name: prop.pivotTable,
             className: prop.pivotTable,
             collection: tableName,
@@ -628,7 +625,7 @@ class MetadataDiscovery {
         const primaryProp = {
             name: pk,
             type: 'number',
-            kind: enums_1.ReferenceKind.SCALAR,
+            kind: ReferenceKind.SCALAR,
             primary: true,
             autoincrement: true,
             unsigned: this.platform.supportsUnsigned(),
@@ -647,8 +644,8 @@ class MetadataDiscovery {
         const ret = {
             name,
             type,
-            kind: enums_1.ReferenceKind.MANY_TO_ONE,
-            cascade: [enums_1.Cascade.ALL],
+            kind: ReferenceKind.MANY_TO_ONE,
+            cascade: [Cascade.ALL],
             fixedOrder: prop.fixedOrder,
             fixedOrderColumn: prop.fixedOrderColumn,
             index: this.platform.indexForeignKeys(),
@@ -701,7 +698,7 @@ class MetadataDiscovery {
     }
     autoWireBidirectionalProperties(meta) {
         Object.values(meta.properties)
-            .filter(prop => prop.kind !== enums_1.ReferenceKind.SCALAR && !prop.owner && prop.mappedBy)
+            .filter(prop => prop.kind !== ReferenceKind.SCALAR && !prop.owner && prop.mappedBy)
             .forEach(prop => {
             const meta2 = this.metadata.get(prop.type);
             const prop2 = meta2.properties[prop.mappedBy];
@@ -711,7 +708,7 @@ class MetadataDiscovery {
         });
     }
     defineBaseEntityProperties(meta) {
-        const base = meta.extends && this.metadata.get(Utils_1.Utils.className(meta.extends));
+        const base = meta.extends && this.metadata.get(Utils.className(meta.extends));
         if (!base || base === meta) { // make sure we do not fall into infinite loop
             return 0;
         }
@@ -732,15 +729,15 @@ class MetadataDiscovery {
                 meta.propertyOrder.set(prop.name, (order += 0.01));
             });
         }
-        meta.indexes = Utils_1.Utils.unique([...base.indexes, ...meta.indexes]);
-        meta.uniques = Utils_1.Utils.unique([...base.uniques, ...meta.uniques]);
-        meta.checks = Utils_1.Utils.unique([...base.checks, ...meta.checks]);
+        meta.indexes = Utils.unique([...base.indexes, ...meta.indexes]);
+        meta.uniques = Utils.unique([...base.uniques, ...meta.uniques]);
+        meta.checks = Utils.unique([...base.checks, ...meta.checks]);
         const pks = Object.values(meta.properties).filter(p => p.primary).map(p => p.name);
         if (pks.length > 0 && meta.primaryKeys.length === 0) {
             meta.primaryKeys = pks;
         }
-        Utils_1.Utils.keys(base.hooks).forEach(type => {
-            meta.hooks[type] = Utils_1.Utils.unique([...base.hooks[type], ...(meta.hooks[type] || [])]);
+        Utils.keys(base.hooks).forEach(type => {
+            meta.hooks[type] = Utils.unique([...base.hooks[type], ...(meta.hooks[type] || [])]);
         });
         if (meta.constructorParams.length === 0 && base.constructorParams.length > 0) {
             meta.constructorParams = [...base.constructorParams];
@@ -751,7 +748,7 @@ class MetadataDiscovery {
         return order;
     }
     initPolyEmbeddables(embeddedProp, discovered, visited = new Set()) {
-        if (embeddedProp.kind !== enums_1.ReferenceKind.EMBEDDED || visited.has(embeddedProp)) {
+        if (embeddedProp.kind !== ReferenceKind.EMBEDDED || visited.has(embeddedProp)) {
             return;
         }
         visited.add(embeddedProp);
@@ -768,6 +765,7 @@ class MetadataDiscovery {
                     delete prop.default;
                     if (properties[prop.name] && properties[prop.name].type !== prop.type) {
                         properties[prop.name].type = `${properties[prop.name].type} | ${prop.type}`;
+                        properties[prop.name].runtimeType = 'any';
                         return properties[prop.name];
                     }
                     return properties[prop.name] = prop;
@@ -775,7 +773,7 @@ class MetadataDiscovery {
             };
             const processExtensions = (meta) => {
                 const parent = this.discovered.find(m => {
-                    return meta.extends && Utils_1.Utils.className(meta.extends) === m.className;
+                    return meta.extends && Utils.className(meta.extends) === m.className;
                 });
                 if (!parent) {
                     return;
@@ -789,7 +787,7 @@ class MetadataDiscovery {
                 processExtensions(meta);
             });
             const name = polymorphs.map(t => t.className).sort().join(' | ');
-            embeddable = new typings_1.EntityMetadata({
+            embeddable = new EntityMetadata({
                 name,
                 className: name,
                 embeddable: true,
@@ -804,13 +802,13 @@ class MetadataDiscovery {
         }
     }
     initEmbeddables(meta, embeddedProp, visited = new Set()) {
-        if (embeddedProp.kind !== enums_1.ReferenceKind.EMBEDDED || visited.has(embeddedProp)) {
+        if (embeddedProp.kind !== ReferenceKind.EMBEDDED || visited.has(embeddedProp)) {
             return;
         }
         visited.add(embeddedProp);
         const embeddable = this.discovered.find(m => m.name === embeddedProp.type);
         if (!embeddable) {
-            throw errors_1.MetadataError.fromUnknownEntity(embeddedProp.type, `${meta.className}.${embeddedProp.name}`);
+            throw MetadataError.fromUnknownEntity(embeddedProp.type, `${meta.className}.${embeddedProp.name}`);
         }
         embeddedProp.embeddable = embeddable.class;
         embeddedProp.embeddedProps = {};
@@ -831,7 +829,7 @@ class MetadataDiscovery {
         const glue = object ? '~' : '_';
         for (const prop of Object.values(embeddable.properties)) {
             const name = (embeddedProp.embeddedPath?.join(glue) ?? embeddedProp.fieldNames[0] + glue) + prop.name;
-            meta.properties[name] = Utils_1.Utils.copy(prop, false);
+            meta.properties[name] = Utils.copy(prop, false);
             meta.properties[name].name = name;
             meta.properties[name].embedded = [embeddedProp.name, prop.name];
             meta.propertyOrder.set(name, (order += 0.01));
@@ -870,7 +868,7 @@ class MetadataDiscovery {
                 path.push(prop.fieldNames[0]);
                 meta.properties[name].fieldNames = prop.fieldNames;
                 meta.properties[name].embeddedPath = path;
-                const fieldName = (0, RawQueryFragment_1.raw)(this.platform.getSearchJsonPropertySQL(path.join('->'), prop.runtimeType ?? prop.type, true));
+                const fieldName = raw(this.platform.getSearchJsonPropertySQL(path.join('->'), prop.runtimeType ?? prop.type, true));
                 meta.properties[name].fieldNameRaw = fieldName.sql; // for querying in SQL drivers
                 meta.properties[name].persist = false; // only virtual as we store the whole object
                 meta.properties[name].userDefined = false; // mark this as a generated/internal property, so we can distinguish from user-defined non-persist properties
@@ -881,7 +879,7 @@ class MetadataDiscovery {
         for (const index of embeddable.indexes) {
             meta.indexes.push({
                 ...index,
-                properties: Utils_1.Utils.asArray(index.properties).map(p => {
+                properties: Utils.asArray(index.properties).map(p => {
                     return embeddedProp.embeddedProps[p].name;
                 }),
             });
@@ -889,7 +887,7 @@ class MetadataDiscovery {
         for (const unique of embeddable.uniques) {
             meta.uniques.push({
                 ...unique,
-                properties: Utils_1.Utils.asArray(unique.properties).map(p => {
+                properties: Utils.asArray(unique.properties).map(p => {
                     return embeddedProp.embeddedProps[p].name;
                 }),
             });
@@ -908,24 +906,26 @@ class MetadataDiscovery {
         }
         if (!meta.root.discriminatorMap) {
             meta.root.discriminatorMap = {};
-            const children = metadata.filter(m => m.root.className === meta.root.className && !m.abstract);
-            children.forEach(m => {
+            const children = metadata
+                .filter(m => m.root.className === meta.root.className && !m.abstract)
+                .sort((a, b) => a.className.localeCompare(b.className));
+            for (const m of children) {
                 const name = m.discriminatorValue ?? this.namingStrategy.classToTableName(m.className);
                 meta.root.discriminatorMap[name] = m.className;
-            });
+            }
         }
         meta.discriminatorValue = Object.entries(meta.root.discriminatorMap).find(([, className]) => className === meta.className)?.[0];
         if (!meta.root.properties[meta.root.discriminatorColumn]) {
             this.createDiscriminatorProperty(meta.root);
         }
-        Utils_1.Utils.defaultValue(meta.root.properties[meta.root.discriminatorColumn], 'items', Object.keys(meta.root.discriminatorMap));
-        Utils_1.Utils.defaultValue(meta.root.properties[meta.root.discriminatorColumn], 'index', true);
+        Utils.defaultValue(meta.root.properties[meta.root.discriminatorColumn], 'items', Object.keys(meta.root.discriminatorMap));
+        Utils.defaultValue(meta.root.properties[meta.root.discriminatorColumn], 'index', true);
         if (meta.root === meta) {
             return;
         }
         let i = 1;
         Object.values(meta.properties).forEach(prop => {
-            const newProp = Utils_1.Utils.copy(prop, false);
+            const newProp = { ...prop };
             if (meta.root.properties[prop.name] && meta.root.properties[prop.name].type !== prop.type) {
                 const name = newProp.name;
                 this.initFieldName(newProp, newProp.object);
@@ -938,29 +938,30 @@ class MetadataDiscovery {
                 return;
             }
             if (prop.enum && prop.items && meta.root.properties[prop.name]?.items) {
-                newProp.items = Utils_1.Utils.unique([...meta.root.properties[prop.name].items, ...prop.items]);
+                newProp.items = Utils.unique([...meta.root.properties[prop.name].items, ...prop.items]);
             }
             newProp.nullable = true;
             newProp.inherited = true;
             meta.root.addProperty(newProp);
         });
         meta.collection = meta.root.collection;
-        meta.root.indexes = Utils_1.Utils.unique([...meta.root.indexes, ...meta.indexes]);
-        meta.root.uniques = Utils_1.Utils.unique([...meta.root.uniques, ...meta.uniques]);
+        meta.root.indexes = Utils.unique([...meta.root.indexes, ...meta.indexes]);
+        meta.root.uniques = Utils.unique([...meta.root.uniques, ...meta.uniques]);
+        meta.root.checks = Utils.unique([...meta.root.checks, ...meta.checks]);
     }
     createDiscriminatorProperty(meta) {
         meta.addProperty({
             name: meta.discriminatorColumn,
             type: 'string',
             enum: true,
-            kind: enums_1.ReferenceKind.SCALAR,
+            kind: ReferenceKind.SCALAR,
             userDefined: false,
         });
     }
     initAutoincrement(meta) {
         const pks = meta.getPrimaryProps();
         if (pks.length === 1 && this.platform.isNumericProperty(pks[0])) {
-            /* istanbul ignore next */
+            /* v8 ignore next */
             pks[0].autoincrement ??= true;
         }
     }
@@ -975,7 +976,7 @@ class MetadataDiscovery {
         }
         if (this.platform.usesEnumCheckConstraints() && !meta.embeddable) {
             for (const prop of meta.props) {
-                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => Utils_1.Utils.isString(item))) {
+                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => Utils.isString(item))) {
                     this.initFieldName(prop);
                     meta.checks.push({
                         name: this.namingStrategy.indexName(meta.tableName, prop.fieldNames, 'check'),
@@ -1017,7 +1018,7 @@ class MetadataDiscovery {
         if (typeof prop.defaultRaw !== 'undefined') {
             return prop.defaultRaw;
         }
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (prop.default != null) {
             return '' + this.platform.quoteVersionValue(prop.default, prop);
         }
@@ -1028,7 +1029,7 @@ class MetadataDiscovery {
         return '1';
     }
     inferDefaultValue(meta, prop) {
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (!meta.class) {
             return;
         }
@@ -1046,8 +1047,8 @@ class MetadataDiscovery {
                 prop.nullable ??= true;
             }
             // but still use object values for type inference if not explicitly set, e.g. `createdAt = new Date()`
-            if (prop.kind === enums_1.ReferenceKind.SCALAR && prop.type == null && entity1[prop.name] != null) {
-                prop.type = prop.runtimeType = Utils_1.Utils.getObjectType(entity1[prop.name]);
+            if (prop.kind === ReferenceKind.SCALAR && prop.type == null && entity1[prop.name] != null) {
+                prop.type = prop.runtimeType = Utils.getObjectType(entity1[prop.name]);
             }
         }
         catch {
@@ -1059,12 +1060,12 @@ class MetadataDiscovery {
             return;
         }
         let val = prop.default;
-        const raw = RawQueryFragment_1.RawQueryFragment.getKnownFragment(val);
+        const raw = RawQueryFragment.getKnownFragment(val);
         if (raw) {
             prop.defaultRaw = this.platform.formatQuery(raw.sql, raw.params);
             return;
         }
-        if (prop.customType instanceof types_1.ArrayType && Array.isArray(prop.default)) {
+        if (prop.customType instanceof ArrayType && Array.isArray(prop.default)) {
             val = prop.customType.convertToDatabaseValue(prop.default, this.platform);
         }
         prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;
@@ -1100,47 +1101,47 @@ class MetadataDiscovery {
     }
     initCustomType(meta, prop) {
         // `prop.type` might be actually instance of custom type class
-        if (types_1.Type.isMappedType(prop.type) && !prop.customType) {
+        if (Type.isMappedType(prop.type) && !prop.customType) {
             prop.customType = prop.type;
             prop.type = prop.customType.constructor.name;
         }
         // `prop.type` might also be custom type class (not instance), so `typeof MyType` will give us `function`, not `object`
-        if (typeof prop.type === 'function' && types_1.Type.isMappedType(prop.type.prototype) && !prop.customType) {
+        if (typeof prop.type === 'function' && Type.isMappedType(prop.type.prototype) && !prop.customType) {
             prop.customType = new prop.type();
             prop.type = prop.customType.constructor.name;
         }
         if (!prop.customType && ['json', 'jsonb'].includes(prop.type?.toLowerCase())) {
-            prop.customType = new types_1.JsonType();
+            prop.customType = new JsonType();
         }
-        if (prop.kind === enums_1.ReferenceKind.SCALAR && !prop.customType && prop.columnTypes && ['json', 'jsonb'].includes(prop.columnTypes[0])) {
-            prop.customType = new types_1.JsonType();
+        if (prop.kind === ReferenceKind.SCALAR && !prop.customType && prop.columnTypes && ['json', 'jsonb'].includes(prop.columnTypes[0])) {
+            prop.customType = new JsonType();
         }
         if (!prop.customType && prop.array && prop.items) {
-            prop.customType = new types_1.EnumArrayType(`${meta.className}.${prop.name}`, prop.items);
+            prop.customType = new EnumArrayType(`${meta.className}.${prop.name}`, prop.items);
         }
         // for number arrays we make sure to convert the items to numbers
         if (!prop.customType && prop.type === 'number[]') {
-            prop.customType = new types_1.ArrayType(i => +i);
+            prop.customType = new ArrayType(i => +i);
         }
         // `string[]` can be returned via ts-morph, while reflect metadata will give us just `array`
         if (!prop.customType && (prop.type?.toLowerCase() === 'array' || prop.type?.toString().endsWith('[]'))) {
-            prop.customType = new types_1.ArrayType();
+            prop.customType = new ArrayType();
         }
         if (!prop.customType && prop.type?.toLowerCase() === 'buffer') {
-            prop.customType = new types_1.BlobType();
+            prop.customType = new BlobType();
         }
         if (!prop.customType && prop.type?.toLowerCase() === 'uint8array') {
-            prop.customType = new types_1.Uint8ArrayType();
+            prop.customType = new Uint8ArrayType();
         }
         const mappedType = this.getMappedType(prop);
         if (prop.fieldNames?.length === 1 && !prop.customType) {
-            [types_1.BigIntType, types_1.DoubleType, types_1.DecimalType, types_1.IntervalType]
+            [BigIntType, DoubleType, DecimalType, IntervalType, DateType]
                 .filter(type => mappedType instanceof type)
                 .forEach(type => prop.customType = new type());
         }
         if (prop.customType && !prop.columnTypes) {
             const mappedType = this.getMappedType({ columnTypes: [prop.customType.getColumnType(prop, this.platform)] });
-            if (prop.customType.compareAsType() === 'any' && ![types_1.JsonType].some(t => prop.customType instanceof t)) {
+            if (prop.customType.compareAsType() === 'any' && ![JsonType].some(t => prop.customType instanceof t)) {
                 prop.runtimeType ??= mappedType.runtimeType;
             }
             else {
@@ -1157,19 +1158,20 @@ class MetadataDiscovery {
             prop.columnTypes ??= [prop.customType.getColumnType(prop, this.platform)];
             prop.hasConvertToJSValueSQL = !!prop.customType.convertToJSValueSQL && prop.customType.convertToJSValueSQL('', this.platform) !== '';
             prop.hasConvertToDatabaseValueSQL = !!prop.customType.convertToDatabaseValueSQL && prop.customType.convertToDatabaseValueSQL('', this.platform) !== '';
-            if (prop.customType instanceof types_1.BigIntType && ['string', 'bigint', 'number'].includes(prop.runtimeType.toLowerCase())) {
+            if (prop.customType instanceof BigIntType && ['string', 'bigint', 'number'].includes(prop.runtimeType.toLowerCase())) {
                 prop.customType.mode = prop.runtimeType.toLowerCase();
             }
         }
-        if (types_1.Type.isMappedType(prop.customType) && prop.kind === enums_1.ReferenceKind.SCALAR && !prop.type?.toString().endsWith('[]')) {
+        if (Type.isMappedType(prop.customType) && prop.kind === ReferenceKind.SCALAR && !prop.type?.toString().endsWith('[]')) {
             prop.type = prop.customType.name;
         }
-        if (!prop.customType && [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) && this.metadata.get(prop.type).compositePK) {
+        if (!prop.customType && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && this.metadata.get(prop.type).compositePK) {
             prop.customTypes = [];
             for (const pk of this.metadata.get(prop.type).getPrimaryProps()) {
                 if (pk.customType) {
                     prop.customTypes.push(pk.customType);
                     prop.hasConvertToJSValueSQL ||= !!pk.customType.convertToJSValueSQL && pk.customType.convertToJSValueSQL('', this.platform) !== '';
+                    /* v8 ignore next */
                     prop.hasConvertToDatabaseValueSQL ||= !!pk.customType.convertToDatabaseValueSQL && pk.customType.convertToDatabaseValueSQL('', this.platform) !== '';
                 }
                 else {
@@ -1177,7 +1179,7 @@ class MetadataDiscovery {
                 }
             }
         }
-        if (prop.kind === enums_1.ReferenceKind.SCALAR && !(mappedType instanceof types_1.UnknownType)) {
+        if (prop.kind === ReferenceKind.SCALAR && !(mappedType instanceof UnknownType)) {
             if (!prop.columnTypes && prop.nativeEnumName && meta.schema !== this.platform.getDefaultSchemaName() && meta.schema && !prop.nativeEnumName.includes('.')) {
                 prop.columnTypes = [`${meta.schema}.${prop.nativeEnumName}`];
             }
@@ -1186,19 +1188,19 @@ class MetadataDiscovery {
             }
             // use only custom types provided by user, we don't need to use the ones provided by ORM,
             // with exception for ArrayType and JsonType, those two are handled in
-            if (!Object.values(types_1.t).some(type => type === mappedType.constructor)) {
+            if (!Object.values(t).some(type => type === mappedType.constructor)) {
                 prop.customType ??= mappedType;
             }
         }
     }
     initRelation(prop) {
-        if (prop.kind === enums_1.ReferenceKind.SCALAR) {
+        if (prop.kind === ReferenceKind.SCALAR) {
             return;
         }
         const meta2 = this.discovered.find(m => m.className === prop.type);
         prop.referencedPKs = meta2.primaryKeys;
         prop.targetMeta = meta2;
-        if (!prop.formula && prop.persist === false && [enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.embedded) {
+        if (!prop.formula && prop.persist === false && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.embedded) {
             prop.formula = a => `${a}.${this.platform.quoteIdentifier(prop.fieldNames[0])}`;
         }
     }
@@ -1209,7 +1211,7 @@ class MetadataDiscovery {
             prop.precision ??= pk.precision;
             prop.scale ??= pk.scale;
         });
-        if (prop.kind === enums_1.ReferenceKind.SCALAR && (prop.type == null || prop.type === 'object') && prop.columnTypes?.[0]) {
+        if (prop.kind === ReferenceKind.SCALAR && (prop.type == null || prop.type === 'object') && prop.columnTypes?.[0]) {
             delete prop.type;
             const mappedType = this.getMappedType(prop);
             prop.type = mappedType.compareAsType();
@@ -1217,10 +1219,10 @@ class MetadataDiscovery {
         if (prop.columnTypes || !this.schemaHelper) {
             return;
         }
-        if (prop.kind === enums_1.ReferenceKind.SCALAR) {
+        if (prop.kind === ReferenceKind.SCALAR) {
             const mappedType = this.getMappedType(prop);
             const SCALAR_TYPES = ['string', 'number', 'boolean', 'bigint', 'Date', 'Buffer', 'RegExp', 'any', 'unknown'];
-            if (mappedType instanceof types_1.UnknownType
+            if (mappedType instanceof UnknownType
                 && !prop.columnTypes
                 // it could be a runtime type from reflect-metadata
                 && !SCALAR_TYPES.includes(prop.type)
@@ -1234,7 +1236,7 @@ class MetadataDiscovery {
             }
             return;
         }
-        if (prop.kind === enums_1.ReferenceKind.EMBEDDED && prop.object && !prop.columnTypes) {
+        if (prop.kind === ReferenceKind.EMBEDDED && prop.object && !prop.columnTypes) {
             prop.columnTypes = [this.platform.getJsonDeclarationSQL()];
             return;
         }
@@ -1258,13 +1260,13 @@ class MetadataDiscovery {
         if (prop.customType) {
             return prop.customType;
         }
-        /* istanbul ignore next */
+        /* v8 ignore next */
         let t = prop.columnTypes?.[0] ?? prop.type ?? '';
         if (prop.nativeEnumName) {
             t = 'enum';
         }
         else if (prop.enum) {
-            t = prop.items?.every(item => Utils_1.Utils.isString(item)) ? 'enum' : 'tinyint';
+            t = prop.items?.every(item => Utils.isString(item)) ? 'enum' : 'tinyint';
         }
         if (t === 'Date') {
             t = 'datetime';
@@ -1287,7 +1289,7 @@ class MetadataDiscovery {
         if (prop.unsigned != null) {
             return;
         }
-        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             const meta2 = this.metadata.get(prop.type);
             prop.unsigned = meta2.getPrimaryProps().some(pk => {
                 this.initUnsigned(pk);
@@ -1299,17 +1301,17 @@ class MetadataDiscovery {
     }
     initIndexes(meta, prop) {
         const hasIndex = meta.indexes.some(idx => idx.properties?.length === 1 && idx.properties[0] === prop.name);
-        if (prop.kind === enums_1.ReferenceKind.MANY_TO_ONE && this.platform.indexForeignKeys() && !hasIndex) {
+        if (prop.kind === ReferenceKind.MANY_TO_ONE && this.platform.indexForeignKeys() && !hasIndex) {
             prop.index ??= true;
         }
     }
     async getEntityClassOrSchema(path, name) {
-        const exports = await Utils_1.Utils.dynamicImport(path);
+        const exports = await Utils.dynamicImport(path);
         const targets = Object.values(exports)
-            .filter(item => item instanceof EntitySchema_1.EntitySchema || (item instanceof Function && MetadataStorage_1.MetadataStorage.isKnownEntity(item.name)));
+            .filter(item => item instanceof EntitySchema || (item instanceof Function && MetadataStorage.isKnownEntity(item.name)));
         // ignore class implementations that are linked from an EntitySchema
         for (const item of targets) {
-            if (item instanceof EntitySchema_1.EntitySchema) {
+            if (item instanceof EntitySchema) {
                 targets.forEach((item2, idx) => {
                     if (item.meta.class === item2) {
                         targets.splice(idx, 1);
@@ -1321,18 +1323,17 @@ class MetadataDiscovery {
             return targets;
         }
         const target = exports.default ?? exports[name];
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (!target) {
-            throw errors_1.MetadataError.entityNotFound(name, path.replace(this.config.get('baseDir'), '.'));
+            throw MetadataError.entityNotFound(name, path.replace(this.config.get('baseDir'), '.'));
         }
         return [target];
     }
     shouldForceConstructorUsage(meta) {
         const forceConstructor = this.config.get('forceEntityConstructor');
         if (Array.isArray(forceConstructor)) {
-            return forceConstructor.some(cls => Utils_1.Utils.className(cls) === meta.className);
+            return forceConstructor.some(cls => Utils.className(cls) === meta.className);
         }
         return forceConstructor;
     }
 }
-exports.MetadataDiscovery = MetadataDiscovery;