@mikro-orm/core 7.0.0-dev.114 → 7.0.0-dev.115

package/metadata/MetadataDiscovery.js

@@ -8,6 +8,7 @@ import { MetadataError } from '../errors.js';
 import { t, Type } from '../types/index.js';
 import { colors } from '../logging/colors.js';
 import { raw, Raw } from '../utils/RawQueryFragment.js';
+import { BaseEntity } from '../entity/BaseEntity.js';
 export class MetadataDiscovery {
     metadata;
     platform;
@@ -62,9 +63,6 @@ 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
@@ -72,8 +70,11 @@ export class MetadataDiscovery {
             .sort((a, b) => b.root.name.localeCompare(a.root.name))
             .forEach(meta => {
             this.platform.validateMetadata(meta);
-            discovered.set(meta.className, meta);
+            discovered.set(meta.class, meta);
         });
+        for (const meta of discovered) {
+            meta.root = discovered.get(meta.root.class);
+        }
         return discovered;
     }
     initAccessors(meta) {
@@ -118,34 +119,40 @@ export 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.fromMetadata(meta).init().meta));
+        filtered.forEach(meta => {
+            const newMeta = EntitySchema.fromMetadata(meta).init().meta;
+            return this.metadata.set(newMeta.class, newMeta);
+        });
         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)));
-        filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initFieldName(prop)));
-        filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initVersionProperty(meta, prop)));
-        filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initCustomType(meta, prop)));
-        filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initGeneratedColumn(meta, prop)));
+        const forEachProp = (cb) => {
+            filtered.forEach(meta => Object.values(meta.properties).forEach(prop => cb(meta, prop)));
+        };
+        forEachProp((m, p) => this.initFactoryField(m, p));
+        forEachProp((_m, p) => this.initRelation(p));
+        forEachProp((m, p) => this.initEmbeddables(m, p));
+        forEachProp((_m, p) => this.initFieldName(p));
+        forEachProp((m, p) => this.initVersionProperty(m, p));
+        forEachProp((m, p) => this.initCustomType(m, p));
+        forEachProp((m, p) => this.initGeneratedColumn(m, p));
         filtered.forEach(meta => this.initAutoincrement(meta)); // once again after we init custom types
         filtered.forEach(meta => this.initCheckConstraints(meta));
-        for (const meta of filtered) {
-            for (const prop of Object.values(meta.properties)) {
-                this.initDefaultValue(prop);
-                this.inferTypeFromDefault(prop);
-                this.initColumnType(prop);
-            }
-        }
-        filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initIndexes(meta, prop)));
+        forEachProp((_m, p) => {
+            this.initDefaultValue(p);
+            this.inferTypeFromDefault(p);
+            this.initRelation(p);
+            this.initColumnType(p);
+        });
+        forEachProp((m, p) => this.initIndexes(m, p));
         filtered.forEach(meta => this.autoWireBidirectionalProperties(meta));
-        filtered.forEach(meta => this.findReferencingProperties(meta, filtered));
         for (const meta of filtered) {
             discovered.push(...this.processEntity(meta));
         }
         discovered.forEach(meta => meta.sync(true));
         this.metadataProvider.combineCache();
         return discovered.map(meta => {
-            meta = this.metadata.get(meta.className);
+            meta = this.metadata.get(meta.class);
             meta.sync(true);
+            this.findReferencingProperties(meta, filtered);
             return meta;
         });
     }
@@ -175,17 +182,22 @@ export class MetadataDiscovery {
             .replace(/\((.*)\)/, '$1'); // unwrap union types
         const missing = [];
         this.discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
-            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 === ReferenceKind.MANY_TO_MANY && prop.pivotEntity) {
+                const pivotEntity = prop.pivotEntity;
+                const target = typeof pivotEntity === 'function' && !pivotEntity.prototype
+                    ? pivotEntity()
+                    : pivotEntity;
+                if (!this.discovered.find(m => m.className === Utils.className(target))) {
+                    missing.push(target);
+                }
             }
-            if (prop.kind !== ReferenceKind.SCALAR && !unwrap(prop.type).split(/ ?\| ?/).every(type => this.discovered.find(m => m.className === type))) {
-                const target = typeof prop.entity === 'function'
+            if (prop.kind !== ReferenceKind.SCALAR) {
+                const target = typeof prop.entity === 'function' && !prop.entity.prototype
                     ? prop.entity()
                     : prop.type;
-                missing.push(...Utils.asArray(target));
+                if (!unwrap(prop.type).split(/ ?\| ?/).every(type => this.discovered.find(m => m.className === type))) {
+                    missing.push(...Utils.asArray(target));
+                }
             }
         }));
         if (missing.length > 0) {
@@ -195,7 +207,7 @@ export class MetadataDiscovery {
     tryDiscoverTargets(targets) {
         for (const target of targets) {
             const isDiscoverable = typeof target === 'function' || target instanceof EntitySchema;
-            if (isDiscoverable && target.name && !this.metadata.has(target.name)) {
+            if (isDiscoverable && target.name && !this.metadata.has(target)) {
                 this.discoverReferences([target], false);
                 this.discoverMissingTargets();
             }
@@ -209,16 +221,16 @@ export class MetadataDiscovery {
             }
             const schema = this.getSchema(entity);
             const meta = schema.init().meta;
-            this.metadata.set(meta.className, meta);
+            this.metadata.set(meta.class, meta);
             found.push(schema);
         }
         // discover parents (base entities) automatically
         for (const meta of this.metadata) {
             let parent = meta.extends;
-            if (parent instanceof EntitySchema && !this.metadata.has(parent.meta.className)) {
+            if (parent instanceof EntitySchema && !this.metadata.has(parent.init().meta.class)) {
                 this.discoverReferences([parent], false);
             }
-            if (typeof parent === 'function' && parent.name && !this.metadata.has(parent.name)) {
+            if (typeof parent === 'function' && parent.name && !this.metadata.has(parent)) {
                 this.discoverReferences([parent], false);
             }
             /* v8 ignore next */
@@ -226,7 +238,7 @@ export class MetadataDiscovery {
                 continue;
             }
             parent = Object.getPrototypeOf(meta.class);
-            if (parent.name !== '' && !this.metadata.has(parent.name)) {
+            if (parent.name !== '' && !this.metadata.has(parent) && parent !== BaseEntity) {
                 this.discoverReferences([parent], false);
             }
         }
@@ -235,14 +247,14 @@ export class MetadataDiscovery {
         }
         this.discoverMissingTargets();
         if (validate) {
-            this.validateDiscovered(this.discovered);
+            this.validator.validateDiscovered(this.discovered, this.config.get('discovery'));
         }
         return this.discovered.filter(meta => found.find(m => m.name === meta.className));
     }
-    reset(className) {
-        const exists = this.discovered.findIndex(m => m.className === className);
+    reset(entityName) {
+        const exists = this.discovered.findIndex(m => m.class === entityName || m.className === Utils.className(entityName));
         if (exists !== -1) {
-            this.metadata.reset(this.discovered[exists].className);
+            this.metadata.reset(this.discovered[exists].class);
             this.discovered.splice(exists, 1);
         }
     }
@@ -258,17 +270,17 @@ export class MetadataDiscovery {
         if (path) {
             const meta = Utils.copy(MetadataStorage.getMetadata(entity.name, path), false);
             meta.path = path;
-            this.metadata.set(entity.name, meta);
+            this.metadata.set(entity, meta);
         }
-        const exists = this.metadata.has(entity.name);
-        const meta = this.metadata.get(entity.name, true);
+        const exists = this.metadata.has(entity);
+        const meta = this.metadata.get(entity, true);
         meta.abstract ??= !(exists && meta.name);
         const schema = EntitySchema.fromMetadata(meta);
         schema.setClass(entity);
         return schema;
     }
     getRootEntity(meta) {
-        const base = meta.extends && this.metadata.find(Utils.className(meta.extends));
+        const base = meta.extends && this.metadata.find(meta.extends);
         if (!base || base === meta) { // make sure we do not fall into infinite loop
             return meta;
         }
@@ -368,7 +380,7 @@ export class MetadataDiscovery {
         }
     }
     initManyToOneFieldName(prop, name) {
-        const meta2 = this.metadata.get(prop.type);
+        const meta2 = prop.targetMeta;
         const ret = [];
         for (const primaryKey of meta2.primaryKeys) {
             this.initFieldName(meta2.properties[primaryKey]);
@@ -379,11 +391,11 @@ export class MetadataDiscovery {
         return ret;
     }
     initManyToManyFieldName(prop, name) {
-        const meta2 = this.metadata.get(prop.type);
+        const meta2 = prop.targetMeta;
         return meta2.primaryKeys.map(() => this.namingStrategy.propertyToColumnName(name));
     }
     initManyToManyFields(meta, prop) {
-        const meta2 = this.metadata.get(prop.type);
+        const meta2 = prop.targetMeta;
         Utils.defaultValue(prop, 'fixedOrder', !!prop.fixedOrderColumn);
         const pivotMeta = this.metadata.find(prop.pivotEntity);
         const props = Object.values(pivotMeta?.properties ?? {});
@@ -410,7 +422,7 @@ export class MetadataDiscovery {
             const prop2 = meta2.properties[prop.mappedBy];
             this.initManyToManyFields(meta2, prop2);
             prop.pivotTable = prop2.pivotTable;
-            prop.pivotEntity = prop2.pivotEntity ?? prop2.pivotTable;
+            prop.pivotEntity = prop2.pivotEntity;
             prop.fixedOrder = prop2.fixedOrder;
             prop.fixedOrderColumn = prop2.fixedOrderColumn;
             prop.joinColumns = prop2.inverseJoinColumns;
@@ -421,7 +433,7 @@ export class MetadataDiscovery {
         prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className);
     }
     initManyToOneFields(prop) {
-        const meta2 = this.metadata.get(prop.type);
+        const meta2 = prop.targetMeta;
         const fieldNames = Utils.flatten(meta2.primaryKeys.map(primaryKey => meta2.properties[primaryKey].fieldNames));
         Utils.defaultValue(prop, 'referencedTableName', meta2.tableName);
         if (!prop.joinColumns) {
@@ -432,7 +444,7 @@ export class MetadataDiscovery {
         }
     }
     initOneToManyFields(prop) {
-        const meta2 = this.metadata.get(prop.type);
+        const meta2 = prop.targetMeta;
         if (!prop.joinColumns) {
             prop.joinColumns = [this.namingStrategy.joinColumnName(prop.name)];
         }
@@ -450,7 +462,7 @@ export class MetadataDiscovery {
             pks[0].deleteRule ??= 'cascade';
         }
         meta.forceConstructor ??= this.shouldForceConstructorUsage(meta);
-        this.validator.validateEntityDefinition(this.metadata, meta.className, this.config.get('discovery'));
+        this.validator.validateEntityDefinition(this.metadata, meta.class, this.config.get('discovery'));
         for (const prop of Object.values(meta.properties)) {
             this.initNullability(prop);
             this.applyNamingStrategy(meta, prop);
@@ -470,7 +482,14 @@ export class MetadataDiscovery {
         if (this.platform.usesPivotTable()) {
             return Object.values(meta.properties)
                 .filter(prop => prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && prop.pivotTable)
-                .map(prop => this.definePivotTableEntity(meta, prop));
+                .map(prop => {
+                const pivotMeta = this.definePivotTableEntity(meta, prop);
+                prop.pivotEntity = pivotMeta.class;
+                if (prop.inversedBy) {
+                    prop.targetMeta.properties[prop.inversedBy].pivotEntity = pivotMeta.class;
+                }
+                return pivotMeta;
+            });
         }
         return [];
     }
@@ -487,8 +506,11 @@ export class MetadataDiscovery {
         ['mappedBy', 'inversedBy', 'pivotEntity'].forEach(type => {
             const value = prop[type];
             if (value instanceof Function) {
-                const meta2 = this.metadata.get(prop.type);
+                const meta2 = prop.targetMeta ?? this.metadata.get(prop.target);
                 prop[type] = value(meta2.properties)?.name;
+                if (type === 'pivotEntity' && value) {
+                    prop[type] = value(meta2.properties);
+                }
                 if (prop[type] == null) {
                     throw MetadataError.fromWrongReference(meta, prop, type);
                 }
@@ -504,9 +526,9 @@ export class MetadataDiscovery {
         }
         else if (fks.length >= 2) {
             [first, second] = fks;
-            /* v8 ignore next */
         }
         else {
+            /* v8 ignore next */
             return [];
         }
         // wrong FK order, first FK needs to point to the owning side
@@ -520,7 +542,9 @@ export class MetadataDiscovery {
         return [first, second];
     }
     definePivotTableEntity(meta, prop) {
-        const pivotMeta = this.metadata.find(prop.pivotEntity);
+        const pivotMeta = prop.pivotEntity
+            ? this.metadata.find(prop.pivotEntity)
+            : this.metadata.getByClassName(prop.pivotTable, false);
         // ensure inverse side exists so we can join it when populating via pivot tables
         if (!prop.inversedBy && prop.targetMeta) {
             const inverseName = `${meta.className}_${prop.name}__inverse`;
@@ -529,6 +553,8 @@ export class MetadataDiscovery {
                 name: inverseName,
                 kind: ReferenceKind.MANY_TO_MANY,
                 type: meta.className,
+                target: meta.class,
+                targetMeta: meta,
                 mappedBy: prop.name,
                 pivotEntity: prop.pivotEntity,
                 pivotTable: prop.pivotTable,
@@ -537,55 +563,51 @@ export class MetadataDiscovery {
             };
             this.applyNamingStrategy(prop.targetMeta, inverseProp);
             this.initCustomType(prop.targetMeta, inverseProp);
-            this.initRelation(inverseProp);
             prop.targetMeta.properties[inverseName] = inverseProp;
         }
         if (pivotMeta) {
+            prop.pivotEntity = pivotMeta.class;
             this.ensureCorrectFKOrderInPivotEntity(pivotMeta, prop);
             return pivotMeta;
         }
-        const exists = this.metadata.find(prop.pivotTable);
-        if (exists) {
-            prop.pivotEntity = exists.className;
-            return exists;
-        }
         let tableName = prop.pivotTable;
         let schemaName;
         if (prop.pivotTable.includes('.')) {
             [schemaName, tableName] = prop.pivotTable.split('.');
         }
         schemaName ??= meta.schema;
-        const targetType = prop.targetMeta.className;
-        const data = new EntityMetadata({
+        const targetMeta = prop.targetMeta;
+        const targetType = targetMeta.className;
+        const pivotMeta2 = new EntityMetadata({
             name: prop.pivotTable,
             className: prop.pivotTable,
             collection: tableName,
             schema: schemaName,
             pivotTable: true,
         });
-        prop.pivotEntity = data.className;
+        prop.pivotEntity = pivotMeta2.class;
         if (prop.fixedOrder) {
-            const primaryProp = this.defineFixedOrderProperty(prop, targetType);
-            data.properties[primaryProp.name] = primaryProp;
+            const primaryProp = this.defineFixedOrderProperty(prop, targetMeta);
+            pivotMeta2.properties[primaryProp.name] = primaryProp;
         }
         else {
-            data.compositePK = true;
+            pivotMeta2.compositePK = true;
         }
         // handle self-referenced m:n with same default field names
         if (meta.className === targetType && prop.joinColumns.every((joinColumn, idx) => joinColumn === prop.inverseJoinColumns[idx])) {
             prop.joinColumns = prop.referencedColumnNames.map(name => this.namingStrategy.joinKeyColumnName(meta.tableName + '_1', name, meta.compositePK));
             prop.inverseJoinColumns = prop.referencedColumnNames.map(name => this.namingStrategy.joinKeyColumnName(meta.tableName + '_2', name, meta.compositePK));
             if (prop.inversedBy) {
-                const prop2 = this.metadata.get(targetType).properties[prop.inversedBy];
+                const prop2 = targetMeta.properties[prop.inversedBy];
                 prop2.inverseJoinColumns = prop.joinColumns;
                 prop2.joinColumns = prop.inverseJoinColumns;
             }
         }
-        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, EntitySchema.fromMetadata(data).init().meta);
+        pivotMeta2.properties[meta.name + '_owner'] = this.definePivotProperty(prop, meta.name + '_owner', meta.class, targetType + '_inverse', true, meta.className === targetType);
+        pivotMeta2.properties[targetType + '_inverse'] = this.definePivotProperty(prop, targetType + '_inverse', targetMeta.class, meta.name + '_owner', false, meta.className === targetType);
+        return this.metadata.set(pivotMeta2.class, EntitySchema.fromMetadata(pivotMeta2).init().meta);
     }
-    defineFixedOrderProperty(prop, targetType) {
+    defineFixedOrderProperty(prop, targetMeta) {
         const pk = prop.fixedOrderColumn || this.namingStrategy.referenceColumnName();
         const primaryProp = {
             name: pk,
@@ -599,7 +621,7 @@ export class MetadataDiscovery {
         this.initColumnType(primaryProp);
         prop.fixedOrderColumn = pk;
         if (prop.inversedBy) {
-            const prop2 = this.metadata.get(targetType).properties[prop.inversedBy];
+            const prop2 = targetMeta.properties[prop.inversedBy];
             prop2.fixedOrder = true;
             prop2.fixedOrderColumn = pk;
         }
@@ -608,7 +630,8 @@ export class MetadataDiscovery {
     definePivotProperty(prop, name, type, inverse, owner, selfReferencing) {
         const ret = {
             name,
-            type,
+            type: Utils.className(type),
+            target: type,
             kind: ReferenceKind.MANY_TO_ONE,
             cascade: [Cascade.ALL],
             fixedOrder: prop.fixedOrder,
@@ -666,7 +689,7 @@ export class MetadataDiscovery {
         Object.values(meta.properties)
             .filter(prop => prop.kind !== ReferenceKind.SCALAR && !prop.owner && prop.mappedBy)
             .forEach(prop => {
-            const meta2 = this.metadata.get(prop.type);
+            const meta2 = prop.targetMeta;
             const prop2 = meta2.properties[prop.mappedBy];
             if (prop2 && !prop2.inversedBy) {
                 prop2.inversedBy = prop.name;
@@ -674,7 +697,7 @@ export class MetadataDiscovery {
         });
     }
     defineBaseEntityProperties(meta) {
-        const base = meta.extends && this.metadata.get(Utils.className(meta.extends));
+        const base = meta.extends && this.metadata.get(meta.extends);
         if (!base || base === meta) { // make sure we do not fall into infinite loop
             return 0;
         }
@@ -867,7 +890,7 @@ export class MetadataDiscovery {
     }
     initSingleTableInheritance(meta, metadata) {
         if (meta.root !== meta && !meta.__processed) {
-            meta.root = metadata.find(m => m.className === meta.root.className);
+            meta.root = metadata.find(m => m.class === meta.root.class);
             meta.root.__processed = true;
         }
         else {
@@ -876,17 +899,23 @@ export class MetadataDiscovery {
         if (!meta.root.discriminatorColumn) {
             return;
         }
-        if (!meta.root.discriminatorMap) {
+        if (meta.root.discriminatorMap) {
+            const map = meta.root.discriminatorMap;
+            Object.keys(map)
+                .filter(key => typeof map[key] === 'string')
+                .forEach(key => map[key] = this.metadata.getByClassName(map[key]).class);
+        }
+        else {
             meta.root.discriminatorMap = {};
             const children = metadata
-                .filter(m => m.root.className === meta.root.className && !m.abstract)
+                .filter(m => m.root.class === meta.root.class && !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.root.discriminatorMap[name] = m.class;
             }
         }
-        meta.discriminatorValue = Object.entries(meta.root.discriminatorMap).find(([, className]) => className === meta.className)?.[0];
+        meta.discriminatorValue = Object.entries(meta.root.discriminatorMap).find(([, cls]) => cls === meta.class)?.[0];
         if (!meta.root.properties[meta.root.discriminatorColumn]) {
             this.createDiscriminatorProperty(meta.root);
         }
@@ -995,9 +1024,6 @@ export class MetadataDiscovery {
         return '1';
     }
     inferDefaultValue(meta, prop) {
-        if (!meta.class) {
-            return;
-        }
         try {
             // try to create two entity instances to detect the value is stable
             const now = Date.now();
@@ -1153,9 +1179,9 @@ export class MetadataDiscovery {
         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) {
+        if (!prop.customType && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && prop.targetMeta.compositePK) {
             prop.customTypes = [];
-            for (const pk of this.metadata.get(prop.type).getPrimaryProps()) {
+            for (const pk of prop.targetMeta.getPrimaryProps()) {
                 if (pk.customType) {
                     prop.customTypes.push(pk.customType);
                     prop.hasConvertToJSValueSQL ||= !!pk.customType.convertToJSValueSQL && pk.customType.convertToJSValueSQL('', this.platform) !== '';
@@ -1185,7 +1211,8 @@ export class MetadataDiscovery {
         if (prop.kind === ReferenceKind.SCALAR) {
             return;
         }
-        const meta2 = this.discovered.find(m => m.className === prop.type);
+        // when the target is a polymorphic embedded entity, `prop.target` is an array of classes, we need to get the metadata by the type name instead
+        const meta2 = this.metadata.find(prop.target) ?? this.metadata.getByClassName(prop.type);
         prop.referencedPKs = meta2.primaryKeys;
         prop.targetMeta = meta2;
         if (!prop.formula && prop.persist === false && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.embedded) {
@@ -1194,7 +1221,7 @@ export class MetadataDiscovery {
     }
     initColumnType(prop) {
         this.initUnsigned(prop);
-        this.metadata.find(prop.type)?.getPrimaryProps().map(pk => {
+        prop.targetMeta?.getPrimaryProps().map(pk => {
             prop.length ??= pk.length;
             prop.precision ??= pk.precision;
             prop.scale ??= pk.scale;
@@ -1211,7 +1238,6 @@ export class MetadataDiscovery {
             const mappedType = this.getMappedType(prop);
             const SCALAR_TYPES = ['string', 'number', 'boolean', 'bigint', 'Date', 'Buffer', 'RegExp', 'any', 'unknown'];
             if (mappedType instanceof t.unknown
-                && !prop.columnTypes
                 // it could be a runtime type from reflect-metadata
                 && !SCALAR_TYPES.includes(prop.type)
                 // or it might be inferred via ts-morph to some generic type alias
@@ -1224,11 +1250,12 @@ export class MetadataDiscovery {
             }
             return;
         }
-        if (prop.kind === ReferenceKind.EMBEDDED && prop.object && !prop.columnTypes) {
+        /* v8 ignore next */
+        if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
             prop.columnTypes = [this.platform.getJsonDeclarationSQL()];
             return;
         }
-        const targetMeta = this.metadata.get(prop.type);
+        const targetMeta = prop.targetMeta;
         prop.columnTypes = [];
         for (const pk of targetMeta.getPrimaryProps()) {
             this.initCustomType(targetMeta, pk);
@@ -1278,7 +1305,7 @@ export class MetadataDiscovery {
             return;
         }
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-            const meta2 = this.metadata.get(prop.type);
+            const meta2 = prop.targetMeta;
             prop.unsigned = meta2.getPrimaryProps().some(pk => {
                 this.initUnsigned(pk);
                 return pk.unsigned;

package/metadata/MetadataProvider.js

@@ -1,4 +1,5 @@
 import { Utils } from '../utils/Utils.js';
+import { EntitySchema } from './EntitySchema.js';
 export class MetadataProvider {
     config;
     constructor(config) {
@@ -13,6 +14,7 @@ export class MetadataProvider {
             else if (prop.entity) {
                 const tmp = prop.entity();
                 prop.type = Array.isArray(tmp) ? tmp.map(t => Utils.className(t)).sort().join(' | ') : Utils.className(tmp);
+                prop.target = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
             }
             else if (!prop.type && !(prop.enum && (prop.items?.length ?? 0) > 0)) {
                 throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}.`);

package/metadata/MetadataStorage.d.ts

@@ -1,20 +1,27 @@
-import { EntityMetadata, type Dictionary, type EntityName } from '../typings.js';
+import { type Dictionary, EntityMetadata, type EntityName } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class MetadataStorage {
     static readonly PATH_SYMBOL: unique symbol;
     private static readonly metadata;
     private readonly metadata;
+    private readonly idMap;
+    private readonly classNameMap;
+    private readonly uniqueNameMap;
     constructor(metadata?: Dictionary<EntityMetadata>);
     static getMetadata(): Dictionary<EntityMetadata>;
     static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;
     static isKnownEntity(name: string): boolean;
     static clear(): void;
-    getAll(): Dictionary<EntityMetadata>;
-    get<T = any>(entityName: EntityName<T>, init?: boolean, validate?: boolean): EntityMetadata<T>;
+    getAll(): Map<EntityName, EntityMetadata>;
+    get<T = any>(entityName: EntityName<T>, init?: boolean): EntityMetadata<T>;
     find<T = any>(entityName: EntityName<T>): EntityMetadata<T> | undefined;
-    has(entity: string): boolean;
-    set(entity: string, meta: EntityMetadata): EntityMetadata;
-    reset(entity: string): void;
+    has<T>(entityName: EntityName<T>): boolean;
+    set<T>(entityName: EntityName<T>, meta: EntityMetadata): EntityMetadata;
+    reset<T>(entityName: EntityName<T>): void;
     decorate(em: EntityManager): void;
     [Symbol.iterator](): IterableIterator<EntityMetadata>;
+    getById<T>(id: number): EntityMetadata<T>;
+    getByClassName<T = any, V extends boolean = true>(className: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
+    getByUniqueName<T = any, V extends boolean = true>(uniqueName: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
+    private validate;
 }