@mikro-orm/core 7.0.0-dev.8 → 7.0.0-dev.81

package/metadata/MetadataDiscovery.js

@@ -1,5 +1,3 @@
-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';
@@ -7,7 +5,7 @@ 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, DecimalType, DoubleType, EnumArrayType, IntervalType, JsonType, t, Type, Uint8ArrayType, UnknownType, } from '../types/index.js';
+import { t, Type } from '../types/index.js';
 import { colors } from '../logging/colors.js';
 import { raw, RawQueryFragment } from '../utils/RawQueryFragment.js';
 export class MetadataDiscovery {
@@ -16,7 +14,6 @@ export class MetadataDiscovery {
     config;
     namingStrategy;
     metadataProvider;
-    cache;
     logger;
     schemaHelper;
     validator = new MetadataValidator();
@@ -27,11 +24,11 @@ export class MetadataDiscovery {
         this.config = config;
         this.namingStrategy = this.config.getNamingStrategy();
         this.metadataProvider = this.config.getMetadataProvider();
-        this.cache = this.config.getMetadataCacheAdapter();
         this.logger = this.config.getLogger();
         this.schemaHelper = this.platform.getSchemaHelper();
     }
     async discover(preferTs = true) {
+        this.discovered.length = 0;
         const startTime = Date.now();
         this.logger.log('discovery', `ORM entity discovery started, using ${colors.cyan(this.metadataProvider.constructor.name)}`);
         await this.findEntities(preferTs);
@@ -47,10 +44,12 @@ export class MetadataDiscovery {
         await this.config.get('discovery').afterDiscovered?.(storage, this.platform);
         return storage;
     }
-    discoverSync(preferTs = true) {
+    discoverSync() {
+        this.discovered.length = 0;
         const startTime = Date.now();
         this.logger.log('discovery', `ORM entity discovery started, using ${colors.cyan(this.metadataProvider.constructor.name)} in sync mode`);
-        this.findEntities(preferTs, true);
+        const refs = this.config.get('entities');
+        this.discoverReferences(refs);
         for (const meta of this.discovered) {
             /* v8 ignore next */
             void this.config.get('discovery').onMetadata?.(meta, this.platform);
@@ -63,6 +62,9 @@ export class MetadataDiscovery {
         void this.config.get('discovery').afterDiscovered?.(storage, this.platform);
         return storage;
     }
+    validateDiscovered(metadata) {
+        return this.validator.validateDiscovered(metadata, this.config.get('discovery'));
+    }
     mapDiscoveredEntities() {
         const discovered = new MetadataStorage();
         this.discovered
@@ -74,11 +76,41 @@ export class MetadataDiscovery {
         });
         return discovered;
     }
+    initAccessors(meta) {
+        for (const prop of Object.values(meta.properties)) {
+            if (!prop.accessor || meta.properties[prop.accessor]) {
+                continue;
+            }
+            const desc = Object.getOwnPropertyDescriptor(meta.prototype, prop.name);
+            if (desc?.get || desc?.set) {
+                this.initFieldName(prop);
+                const accessor = prop.name;
+                prop.name = typeof prop.accessor === 'string' ? prop.accessor : prop.name;
+                if (prop.accessor === true) {
+                    prop.getter = prop.setter = true;
+                }
+                else {
+                    prop.getter = prop.setter = false;
+                }
+                prop.accessor = accessor;
+                prop.serializedName ??= accessor;
+                Utils.renameKey(meta.properties, accessor, prop.name);
+            }
+            else {
+                const name = prop.name;
+                prop.name = prop.accessor;
+                this.initFieldName(prop);
+                prop.serializedName ??= prop.accessor;
+                prop.name = name;
+            }
+        }
+    }
     processDiscoveredEntities(discovered) {
         for (const meta of discovered) {
             let i = 1;
             Object.values(meta.properties).forEach(prop => meta.propertyOrder.set(prop.name, i++));
             Object.values(meta.properties).forEach(prop => this.initPolyEmbeddables(prop, discovered));
+            this.initAccessors(meta);
         }
         // ignore base entities (not annotated with @Entity)
         const filtered = discovered.filter(meta => meta.root.name);
@@ -101,10 +133,6 @@ export class MetadataDiscovery {
                 this.initDefaultValue(prop);
                 this.inferTypeFromDefault(prop);
                 this.initColumnType(prop);
-                // change tracking on scalars is used only for "auto" flushMode
-                if (this.config.get('flushMode') !== 'auto' && [ReferenceKind.SCALAR, ReferenceKind.EMBEDDED].includes(prop.kind)) {
-                    prop.trackChanges = false;
-                }
             }
         }
         filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initIndexes(meta, prop)));
@@ -114,38 +142,27 @@ export class MetadataDiscovery {
             discovered.push(...this.processEntity(meta));
         }
         discovered.forEach(meta => meta.sync(true));
-        const combinedCachePath = this.cache.combine?.();
-        // override the path in the options, so we can log it from the CLI in `cache:generate` command
-        if (combinedCachePath) {
-            this.config.get('metadataCache').combined = combinedCachePath;
-        }
+        this.metadataProvider.combineCache();
         return discovered.map(meta => {
             meta = this.metadata.get(meta.className);
             meta.sync(true);
             return meta;
         });
     }
-    findEntities(preferTs, sync = false) {
-        this.discovered.length = 0;
-        const options = this.config.get('discovery');
-        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.`);
+    async findEntities(preferTs) {
+        const { entities, entitiesTs, baseDir } = this.config.getAll();
+        const targets = (preferTs && entitiesTs.length > 0) ? entitiesTs : entities;
+        const processed = [];
+        for (const entity of targets) {
+            if (typeof entity === 'string') {
+                const { discoverEntities } = await import('@mikro-orm/core/file-discovery');
+                processed.push(...await discoverEntities(entity, { baseDir }));
+            }
+            else {
+                processed.push(entity);
             }
-            return this.discoverDirectories(paths).then(() => {
-                this.discoverReferences(refs);
-                this.discoverMissingTargets();
-                this.validator.validateDiscovered(this.discovered, options);
-                return this.discovered;
-            });
         }
-        this.discoverReferences(refs);
-        this.discoverMissingTargets();
-        this.validator.validateDiscovered(this.discovered, options);
-        return this.discovered;
+        return this.discoverReferences(processed);
     }
     discoverMissingTargets() {
         const unwrap = (type) => type
@@ -173,50 +190,20 @@ export class MetadataDiscovery {
     }
     tryDiscoverTargets(targets) {
         for (const target of targets) {
-            if (typeof target === 'function' && target.name && !this.metadata.has(target.name)) {
-                this.discoverReferences([target]);
+            const isDiscoverable = typeof target === 'function' || target instanceof EntitySchema;
+            if (isDiscoverable && target.name && !this.metadata.has(target.name)) {
+                this.discoverReferences([target], false);
                 this.discoverMissingTargets();
             }
         }
     }
-    async discoverDirectories(paths) {
-        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 = basename(filepath);
-            if (!filename.match(/\.[cm]?[jt]s$/) ||
-                filename.endsWith('.js.map') ||
-                filename.match(/\.d\.[cm]?ts/) ||
-                filename.startsWith('.') ||
-                filename.match(/index\.[cm]?[jt]s$/)) {
-                this.logger.log('discovery', `- ignoring file ${filename}`);
-                continue;
-            }
-            const name = this.namingStrategy.getClassName(filename);
-            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)) {
-                    this.logger.log('discovery', `- ignoring file ${filename}`);
-                    continue;
-                }
-                const entity = this.prepare(target);
-                const schema = this.getSchema(entity, path);
-                const meta = schema.init().meta;
-                this.metadata.set(meta.className, meta);
-                found.push([schema, path]);
-            }
-        }
-        for (const [schema, path] of found) {
-            this.discoverEntity(schema, path);
-        }
-    }
-    discoverReferences(refs) {
+    discoverReferences(refs, validate = true) {
         const found = [];
         for (const entity of refs) {
-            const schema = this.getSchema(this.prepare(entity));
+            if (typeof entity === 'string') {
+                throw new Error('Folder based discovery requires the async `MikroORM.init()` method.');
+            }
+            const schema = this.getSchema(entity);
             const meta = schema.init().meta;
             this.metadata.set(meta.className, meta);
             found.push(schema);
@@ -225,20 +212,27 @@ export class MetadataDiscovery {
         for (const meta of this.metadata) {
             let parent = meta.extends;
             if (parent instanceof EntitySchema && !this.metadata.has(parent.meta.className)) {
-                this.discoverReferences([parent]);
+                this.discoverReferences([parent], false);
             }
-            /* v8 ignore next 3 */
+            if (typeof parent === 'function' && parent.name && !this.metadata.has(parent.name)) {
+                this.discoverReferences([parent], false);
+            }
+            /* v8 ignore next */
             if (!meta.class) {
                 continue;
             }
             parent = Object.getPrototypeOf(meta.class);
             if (parent.name !== '' && !this.metadata.has(parent.name)) {
-                this.discoverReferences([parent]);
+                this.discoverReferences([parent], false);
             }
         }
         for (const schema of found) {
             this.discoverEntity(schema);
         }
+        this.discoverMissingTargets();
+        if (validate) {
+            this.validateDiscovered(this.discovered);
+        }
         return this.discovered.filter(meta => found.find(m => m.name === meta.className));
     }
     reset(className) {
@@ -248,23 +242,13 @@ export class MetadataDiscovery {
             this.discovered.splice(exists, 1);
         }
     }
-    prepare(entity) {
-        /* v8 ignore next 3 */
-        if ('schema' in entity && entity.schema instanceof EntitySchema) {
-            return entity.schema;
-        }
+    getSchema(entity) {
         if (EntitySchema.REGISTRY.has(entity)) {
-            return EntitySchema.REGISTRY.get(entity);
+            entity = EntitySchema.REGISTRY.get(entity);
         }
-        return entity;
-    }
-    getSchema(entity, filepath) {
         if (entity instanceof EntitySchema) {
-            if (filepath) {
-                // initialize global metadata for given entity
-                MetadataStorage.getMetadata(entity.meta.className, filepath);
-            }
-            return entity;
+            const meta = Utils.copy(entity.meta, false);
+            return EntitySchema.fromMetadata(meta);
         }
         const path = entity[MetadataStorage.PATH_SYMBOL];
         if (path) {
@@ -279,16 +263,26 @@ export class MetadataDiscovery {
         schema.setClass(entity);
         return schema;
     }
-    discoverEntity(schema, path) {
-        this.logger.log('discovery', `- processing entity ${colors.cyan(schema.meta.className)}${colors.grey(path ? ` (${path})` : '')}`);
+    getRootEntity(meta) {
+        const base = meta.extends && this.metadata.find(Utils.className(meta.extends));
+        if (!base || base === meta) { // make sure we do not fall into infinite loop
+            return meta;
+        }
+        const root = this.getRootEntity(base);
+        if (root.discriminatorColumn) {
+            return root;
+        }
+        return meta;
+    }
+    discoverEntity(schema) {
         const meta = schema.meta;
-        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));
+        const path = meta.path;
+        this.logger.log('discovery', `- processing entity ${colors.cyan(meta.className)}${colors.grey(path ? ` (${path})` : '')}`);
+        const root = this.getRootEntity(meta);
+        schema.meta.path = Utils.relativePath(meta.path, this.config.get('baseDir'));
+        const cache = this.metadataProvider.getCachedMetadata(meta, root);
         if (cache) {
             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);
             return;
         }
@@ -297,50 +291,18 @@ export class MetadataDiscovery {
             this.inferDefaultValue(meta, prop);
         }
         // if the definition is using EntitySchema we still want it to go through the metadata provider to validate no types are missing
-        this.metadataProvider.loadEntityMetadata(meta, meta.className);
+        this.metadataProvider.loadEntityMetadata(meta);
         if (!meta.collection && meta.name) {
             const entityName = root.discriminatorColumn ? root.name : meta.name;
             meta.collection = this.namingStrategy.classToTableName(entityName);
         }
-        delete meta.root; // to allow caching (as root can contain cycles)
-        this.saveToCache(meta);
+        this.metadataProvider.saveToCache(meta);
         meta.root = root;
         this.discovered.push(meta);
     }
-    saveToCache(meta) {
-        if (!this.metadataProvider.useCache()) {
-            return;
-        }
-        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 + extname(meta.path), copy, meta.path);
-        }
-    }
     initNullability(prop) {
-        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 === 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.defaultValue(prop, 'nullable', prop.optional || !prop.owner);
         }
         return Utils.defaultValue(prop, 'nullable', prop.optional);
     }
@@ -375,7 +337,7 @@ export 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));
-                    /* v8 ignore next 3 */
+                    /* v8 ignore next */
                     if (!matched) {
                         throw MetadataError.fromWrongForeignKey(meta, prop, 'columnTypes');
                     }
@@ -497,10 +459,9 @@ export class MetadataDiscovery {
         }
         this.initOwnColumns(meta);
         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]) {
-            serializedPKProp.persist = false;
+        meta.serializedPrimaryKey ??= meta.props.find(prop => prop.serializedPrimaryKey)?.name;
+        if (meta.serializedPrimaryKey && meta.serializedPrimaryKey !== meta.primaryKeys[0]) {
+            meta.properties[meta.serializedPrimaryKey].persist ??= false;
         }
         if (this.platform.usesPivotTable()) {
             return Object.values(meta.properties)
@@ -539,7 +500,7 @@ export class MetadataDiscovery {
         }
         else if (fks.length >= 2) {
             [first, second] = fks;
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
         }
         else {
             return [];
@@ -618,7 +579,7 @@ export class MetadataDiscovery {
         }
         data.properties[meta.name + '_owner'] = this.definePivotProperty(prop, meta.name + '_owner', meta.className, targetType + '_inverse', true, meta.className === targetType);
         data.properties[targetType + '_inverse'] = this.definePivotProperty(prop, targetType + '_inverse', targetType, meta.name + '_owner', false, meta.className === targetType);
-        return this.metadata.set(data.className, data);
+        return this.metadata.set(data.className, EntitySchema.fromMetadata(data).init().meta);
     }
     defineFixedOrderProperty(prop, targetType) {
         const pk = prop.fixedOrderColumn || this.namingStrategy.referenceColumnName();
@@ -653,6 +614,7 @@ export class MetadataDiscovery {
             autoincrement: false,
             updateRule: prop.updateRule,
             deleteRule: prop.deleteRule,
+            createForeignKeyConstraint: prop.createForeignKeyConstraint,
         };
         if (selfReferencing && !this.platform.supportsMultipleCascadePaths()) {
             ret.updateRule ??= 'no action';
@@ -739,12 +701,9 @@ export class MetadataDiscovery {
         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) {
+        if ((meta.constructorParams?.length ?? 0) === 0 && (base.constructorParams?.length ?? 0) > 0) {
             meta.constructorParams = [...base.constructorParams];
         }
-        if (meta.toJsonParams.length === 0 && base.toJsonParams.length > 0) {
-            meta.toJsonParams = [...base.toJsonParams];
-        }
         return order;
     }
     initPolyEmbeddables(embeddedProp, discovered, visited = new Set()) {
@@ -765,6 +724,7 @@ export 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;
@@ -819,9 +779,16 @@ export class MetadataDiscovery {
             }
             return prop.embedded ? isParentObject(meta.properties[prop.embedded[0]]) : false;
         };
+        const isParentArray = (prop) => {
+            if (prop.array) {
+                return true;
+            }
+            return prop.embedded ? isParentArray(meta.properties[prop.embedded[0]]) : false;
+        };
         const rootProperty = getRootProperty(embeddedProp);
         const parentProperty = meta.properties[embeddedProp.embedded?.[0] ?? ''];
         const object = isParentObject(embeddedProp);
+        const array = isParentArray(embeddedProp);
         this.initFieldName(embeddedProp, rootProperty !== embeddedProp && object);
         // the prefix of the parent cannot be a boolean; it already passed here
         const prefix = this.getPrefix(embeddedProp, parentProperty);
@@ -834,7 +801,8 @@ export class MetadataDiscovery {
             meta.propertyOrder.set(name, (order += 0.01));
             embeddedProp.embeddedProps[prop.name] = meta.properties[name];
             meta.properties[name].persist ??= embeddedProp.persist;
-            if (embeddedProp.nullable) {
+            const refInArray = array && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.owner;
+            if (embeddedProp.nullable || refInArray) {
                 meta.properties[name].nullable = true;
             }
             if (meta.properties[name].fieldNames) {
@@ -872,6 +840,7 @@ export class MetadataDiscovery {
                 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
                 meta.properties[name].object = true;
+                this.initCustomType(meta, meta.properties[name], false, true);
             }
             this.initEmbeddables(meta, meta.properties[name], visited);
         }
@@ -924,7 +893,7 @@ export class MetadataDiscovery {
         }
         let i = 1;
         Object.values(meta.properties).forEach(prop => {
-            const newProp = 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);
@@ -940,7 +909,7 @@ export class MetadataDiscovery {
                 newProp.items = Utils.unique([...meta.root.properties[prop.name].items, ...prop.items]);
             }
             newProp.nullable = true;
-            newProp.inherited = true;
+            newProp.inherited = !meta.root.properties[prop.name];
             meta.root.addProperty(newProp);
         });
         meta.collection = meta.root.collection;
@@ -965,7 +934,7 @@ export class MetadataDiscovery {
         }
     }
     initCheckConstraints(meta) {
-        const map = this.createColumnMappingObject(meta);
+        const map = meta.createColumnMappingObject();
         for (const check of meta.checks) {
             const columns = check.property ? meta.properties[check.property].fieldNames : [];
             check.name ??= this.namingStrategy.indexName(meta.tableName, columns, 'check');
@@ -975,7 +944,7 @@ export class MetadataDiscovery {
         }
         if (this.platform.usesEnumCheckConstraints() && !meta.embeddable) {
             for (const prop of meta.props) {
-                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => Utils.isString(item))) {
+                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
                     this.initFieldName(prop);
                     meta.checks.push({
                         name: this.namingStrategy.indexName(meta.tableName, prop.fieldNames, 'check'),
@@ -1000,35 +969,28 @@ export class MetadataDiscovery {
             }
             return;
         }
-        const map = this.createColumnMappingObject(meta);
+        const map = meta.createColumnMappingObject();
         if (prop.generated instanceof Function) {
             prop.generated = prop.generated(map);
         }
     }
-    createColumnMappingObject(meta) {
-        return Object.values(meta.properties).reduce((o, prop) => {
-            if (prop.fieldNames) {
-                o[prop.name] = prop.fieldNames[0];
-            }
-            return o;
-        }, {});
-    }
-    getDefaultVersionValue(prop) {
+    getDefaultVersionValue(meta, prop) {
         if (typeof prop.defaultRaw !== 'undefined') {
             return prop.defaultRaw;
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (prop.default != null) {
             return '' + this.platform.quoteVersionValue(prop.default, prop);
         }
-        if (prop.type.toLowerCase() === 'date') {
+        this.initCustomType(meta, prop, true);
+        const type = prop.customType?.runtimeType ?? prop.runtimeType ?? prop.type;
+        if (type === 'Date') {
             prop.length ??= this.platform.getDefaultVersionLength();
             return this.platform.getCurrentTimestampSQL(prop.length);
         }
         return '1';
     }
     inferDefaultValue(meta, prop) {
-        /* v8 ignore next 3 */
         if (!meta.class) {
             return;
         }
@@ -1064,7 +1026,7 @@ export class MetadataDiscovery {
             prop.defaultRaw = this.platform.formatQuery(raw.sql, raw.params);
             return;
         }
-        if (prop.customType instanceof ArrayType && Array.isArray(prop.default)) {
+        if (Array.isArray(prop.default) && prop.customType) {
             val = prop.customType.convertToDatabaseValue(prop.default, this.platform);
         }
         prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;
@@ -1092,13 +1054,13 @@ export class MetadataDiscovery {
         if (prop.version) {
             this.initDefaultValue(prop);
             meta.versionProperty = prop.name;
-            prop.defaultRaw = this.getDefaultVersionValue(prop);
+            prop.defaultRaw = this.getDefaultVersionValue(meta, prop);
         }
         if (prop.concurrencyCheck && !prop.primary) {
             meta.concurrencyCheckKeys.add(prop.name);
         }
     }
-    initCustomType(meta, prop) {
+    initCustomType(meta, prop, simple = false, objectEmbeddable = false) {
         // `prop.type` might be actually instance of custom type class
         if (Type.isMappedType(prop.type) && !prop.customType) {
             prop.customType = prop.type;
@@ -1106,47 +1068,70 @@ export class MetadataDiscovery {
         }
         // `prop.type` might also be custom type class (not instance), so `typeof MyType` will give us `function`, not `object`
         if (typeof prop.type === 'function' && Type.isMappedType(prop.type.prototype) && !prop.customType) {
-            prop.customType = new prop.type();
-            prop.type = prop.customType.constructor.name;
+            // if the type is an ORM defined mapped type without `ensureComparable: true`,
+            // we use just the type name, to have more performant hydration code
+            const type = Utils.keys(t).find(type => {
+                return !Type.getType(t[type]).ensureComparable(meta, prop) && prop.type === t[type];
+            });
+            if (type) {
+                prop.type = type === 'datetime' ? 'Date' : type;
+            }
+            else {
+                prop.customType = new prop.type();
+                prop.type = prop.customType.constructor.name;
+            }
+        }
+        if (simple) {
+            return;
         }
         if (!prop.customType && ['json', 'jsonb'].includes(prop.type?.toLowerCase())) {
-            prop.customType = new JsonType();
+            prop.customType = new t.json();
         }
         if (prop.kind === ReferenceKind.SCALAR && !prop.customType && prop.columnTypes && ['json', 'jsonb'].includes(prop.columnTypes[0])) {
-            prop.customType = new JsonType();
+            prop.customType = new t.json();
+        }
+        if (prop.kind === ReferenceKind.EMBEDDED && !prop.customType && (prop.object || prop.array)) {
+            prop.customType = new t.json();
         }
         if (!prop.customType && prop.array && prop.items) {
-            prop.customType = new EnumArrayType(`${meta.className}.${prop.name}`, prop.items);
+            prop.customType = new t.enumArray(`${meta.className}.${prop.name}`, prop.items);
+        }
+        const isArray = prop.type?.toLowerCase() === 'array' || prop.type?.toString().endsWith('[]');
+        if (objectEmbeddable && !prop.customType && isArray) {
+            prop.customType = new t.json();
         }
         // for number arrays we make sure to convert the items to numbers
         if (!prop.customType && prop.type === 'number[]') {
-            prop.customType = new ArrayType(i => +i);
+            prop.customType = new t.array(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 ArrayType();
+        if (!prop.customType && isArray) {
+            prop.customType = new t.array();
         }
         if (!prop.customType && prop.type?.toLowerCase() === 'buffer') {
-            prop.customType = new BlobType();
+            prop.customType = new t.blob();
         }
         if (!prop.customType && prop.type?.toLowerCase() === 'uint8array') {
-            prop.customType = new Uint8ArrayType();
+            prop.customType = new t.uint8array();
         }
         const mappedType = this.getMappedType(prop);
         if (prop.fieldNames?.length === 1 && !prop.customType) {
-            [BigIntType, DoubleType, DecimalType, IntervalType]
+            [t.bigint, t.double, t.decimal, t.interval, t.date]
                 .filter(type => mappedType instanceof type)
-                .forEach(type => prop.customType = new 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' && ![JsonType].some(t => prop.customType instanceof t)) {
+            if (prop.customType.compareAsType() === 'any' && ![t.json].some(t => prop.customType instanceof t)) {
                 prop.runtimeType ??= mappedType.runtimeType;
             }
             else {
                 prop.runtimeType ??= prop.customType.runtimeType;
             }
         }
+        else if (prop.runtimeType === 'object') {
+            prop.runtimeType = mappedType.runtimeType;
+        }
         else {
             prop.runtimeType ??= mappedType.runtimeType;
         }
@@ -1157,11 +1142,11 @@ export 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 BigIntType && ['string', 'bigint', 'number'].includes(prop.runtimeType.toLowerCase())) {
+            if (prop.customType instanceof t.bigint && ['string', 'bigint', 'number'].includes(prop.runtimeType.toLowerCase())) {
                 prop.customType.mode = prop.runtimeType.toLowerCase();
             }
         }
-        if (Type.isMappedType(prop.customType) && prop.kind === ReferenceKind.SCALAR && !prop.type?.toString().endsWith('[]')) {
+        if (Type.isMappedType(prop.customType) && prop.kind === ReferenceKind.SCALAR && !isArray) {
             prop.type = prop.customType.name;
         }
         if (!prop.customType && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && this.metadata.get(prop.type).compositePK) {
@@ -1178,7 +1163,7 @@ export class MetadataDiscovery {
                 }
             }
         }
-        if (prop.kind === ReferenceKind.SCALAR && !(mappedType instanceof UnknownType)) {
+        if (prop.kind === ReferenceKind.SCALAR && !(mappedType instanceof t.unknown)) {
             if (!prop.columnTypes && prop.nativeEnumName && meta.schema !== this.platform.getDefaultSchemaName() && meta.schema && !prop.nativeEnumName.includes('.')) {
                 prop.columnTypes = [`${meta.schema}.${prop.nativeEnumName}`];
             }
@@ -1221,7 +1206,7 @@ export class MetadataDiscovery {
         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 UnknownType
+            if (mappedType instanceof t.unknown
                 && !prop.columnTypes
                 // it could be a runtime type from reflect-metadata
                 && !SCALAR_TYPES.includes(prop.type)
@@ -1265,7 +1250,7 @@ export class MetadataDiscovery {
             t = 'enum';
         }
         else if (prop.enum) {
-            t = prop.items?.every(item => Utils.isString(item)) ? 'enum' : 'tinyint';
+            t = prop.items?.every(item => typeof item === 'string') ? 'enum' : 'tinyint';
         }
         if (t === 'Date') {
             t = 'datetime';
@@ -1304,30 +1289,6 @@ export class MetadataDiscovery {
             prop.index ??= true;
         }
     }
-    async getEntityClassOrSchema(path, name) {
-        const exports = await Utils.dynamicImport(path);
-        const targets = Object.values(exports)
-            .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) {
-                targets.forEach((item2, idx) => {
-                    if (item.meta.class === item2) {
-                        targets.splice(idx, 1);
-                    }
-                });
-            }
-        }
-        if (targets.length > 0) {
-            return targets;
-        }
-        const target = exports.default ?? exports[name];
-        /* v8 ignore next 3 */
-        if (!target) {
-            throw MetadataError.entityNotFound(name, path.replace(this.config.get('baseDir'), '.'));
-        }
-        return [target];
-    }
     shouldForceConstructorUsage(meta) {
         const forceConstructor = this.config.get('forceEntityConstructor');
         if (Array.isArray(forceConstructor)) {