@mikro-orm/core 7.0.0-dev.49 → 7.0.0-dev.50

package/MikroORM.d.ts

@@ -3,11 +3,11 @@ import { type EntitySchema } from './metadata/EntitySchema.js';
 import { MetadataStorage } from './metadata/MetadataStorage.js';
 import { Configuration, type Options } from './utils/Configuration.js';
 import type { EntityManager } from './EntityManager.js';
-import type { AnyEntity, Constructor, EntityClass, EntityClassGroup, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
+import type { AnyEntity, Constructor, EntityClass, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
 /**
  * Helper class for bootstrapping the MikroORM.
  */
-export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = Driver[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]> {
+export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = Driver[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> {
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
     em: EM & {
         '~entities'?: Entities;
@@ -21,7 +21,7 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
      * If you omit the `options` parameter, your CLI config will be used.
      */
-    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
+    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * Synchronous variant of the `init` method with some limitations:
      * - database connection will be established when you first interact with the database (or you can use `orm.connect()` explicitly)

package/MikroORM.js

@@ -1,6 +1,5 @@
 import { MetadataDiscovery } from './metadata/MetadataDiscovery.js';
 import { MetadataStorage } from './metadata/MetadataStorage.js';
-import { MetadataValidator } from './metadata/MetadataValidator.js';
 import { ReflectMetadataProvider } from './metadata/ReflectMetadataProvider.js';
 import { Configuration } from './utils/Configuration.js';
 import { ConfigurationLoader } from './utils/ConfigurationLoader.js';
@@ -118,7 +117,8 @@ export class MikroORM {
         // we need to allow global context here as we are not in a scope of requests yet
         const allowGlobalContext = this.config.get('allowGlobalContext');
         this.config.set('allowGlobalContext', true);
-        this.metadata = await this.discovery.discover(this.config.get('preferTs'));
+        const preferTs = this.config.get('preferTs', Utils.detectTypeScriptSupport());
+        this.metadata = await this.discovery.discover(preferTs);
         this.createEntityManager();
         this.config.set('allowGlobalContext', allowGlobalContext);
     }
@@ -141,19 +141,16 @@ export class MikroORM {
      * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
      */
     discoverEntity(entities, reset) {
-        entities = Utils.asArray(entities);
         for (const className of Utils.asArray(reset)) {
             this.metadata.reset(className);
             this.discovery.reset(className);
         }
-        const tmp = this.discovery.discoverReferences(entities);
-        const options = this.config.get('discovery');
-        new MetadataValidator().validateDiscovered([...Object.values(this.metadata.getAll()), ...tmp], options);
+        const tmp = this.discovery.discoverReferences(Utils.asArray(entities));
         const metadata = this.discovery.processDiscoveredEntities(tmp);
-        metadata.forEach(meta => {
+        for (const meta of metadata) {
             this.metadata.set(meta.className, meta);
             meta.root = this.metadata.get(meta.root.className);
-        });
+        }
         this.metadata.decorate(this.em);
     }
     /**

package/errors.d.ts

@@ -44,7 +44,6 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static fromWrongOwnership(meta: EntityMetadata, prop: EntityProperty, key: 'inversedBy' | 'mappedBy'): MetadataError;
     static fromWrongReferenceKind(meta: EntityMetadata, owner: EntityProperty, prop: EntityProperty): MetadataError;
     static fromInversideSidePrimary(meta: EntityMetadata, owner: EntityProperty, prop: EntityProperty): MetadataError;
-    static entityNotFound(name: string, path: string): MetadataError;
     static unknownIndexProperty(meta: EntityMetadata, prop: string, type: string): MetadataError;
     static multipleVersionFields(meta: EntityMetadata, fields: string[]): MetadataError;
     static invalidVersionFieldType(meta: EntityMetadata): MetadataError;

package/errors.js

@@ -154,10 +154,6 @@ export class MetadataError extends ValidationError {
     static fromInversideSidePrimary(meta, owner, prop) {
         return new MetadataError(`${meta.className}.${prop.name} cannot be primary key as it is defined as inverse side. Maybe you should swap the use of 'inversedBy' and 'mappedBy'.`);
     }
-    /* v8 ignore next 3 */
-    static entityNotFound(name, path) {
-        return new MetadataError(`Entity '${name}' not found in ${path}`);
-    }
     static unknownIndexProperty(meta, prop, type) {
         return new MetadataError(`Entity ${meta.className} has wrong ${type} definition: '${prop}' does not exist. You need to use property name, not column name.`);
     }

package/index.d.ts

@@ -3,7 +3,7 @@
  * @module core
  */
 export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config } from './typings.js';
-export type { Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, RequiredEntityData, CheckCallback, IndexCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, } from './typings.js';
+export type { Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, RequiredEntityData, CheckCallback, IndexCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/MetadataDiscovery.d.ts

@@ -17,6 +17,7 @@ export declare class MetadataDiscovery {
     constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
     discover(preferTs?: boolean): Promise<MetadataStorage>;
     discoverSync(): MetadataStorage;
+    validateDiscovered(metadata: EntityMetadata[]): void;
     private mapDiscoveredEntities;
     private initAccessors;
     processDiscoveredEntities(discovered: EntityMetadata[]): EntityMetadata[];
@@ -24,9 +25,8 @@ export declare class MetadataDiscovery {
     private discoverMissingTargets;
     private tryDiscoverTargets;
     private discoverDirectories;
-    discoverReferences<T>(refs: (Constructor<T> | EntitySchema<T>)[]): EntityMetadata<T>[];
+    discoverReferences<T>(refs: (Constructor<T> | EntitySchema<T>)[], validate?: boolean): EntityMetadata<T>[];
     reset(className: string): void;
-    private prepare;
     private getSchema;
     private discoverEntity;
     private saveToCache;

package/metadata/MetadataDiscovery.js

@@ -1,13 +1,13 @@
 import { basename, extname } from 'node:path';
 import { glob } from 'tinyglobby';
-import { EntityMetadata, } from '../typings.js';
+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 { t, Type } from '../types/index.js';
 import { colors } from '../logging/colors.js';
 import { raw, RawQueryFragment } from '../utils/RawQueryFragment.js';
 export class MetadataDiscovery {
@@ -63,6 +63,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
@@ -154,24 +157,18 @@ export class MetadataDiscovery {
     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 key = (preferTs && 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.`);
             }
-            return this.discoverDirectories(paths).then(() => {
-                this.discoverReferences(refs);
-                this.discoverMissingTargets();
-                this.validator.validateDiscovered(this.discovered, options);
-                return this.discovered;
+            return this.discoverDirectories(paths).then(targets => {
+                return this.discoverReferences([...targets, ...refs]);
             });
         }
-        this.discoverReferences(refs);
-        this.discoverMissingTargets();
-        this.validator.validateDiscovered(this.discovered, options);
-        return this.discovered;
+        return this.discoverReferences(refs);
     }
     discoverMissingTargets() {
         const unwrap = (type) => type
@@ -201,7 +198,7 @@ export class MetadataDiscovery {
         for (const target of targets) {
             const isDiscoverable = typeof target === 'function' || target instanceof EntitySchema;
             if (isDiscoverable && target.name && !this.metadata.has(target.name)) {
-                this.discoverReferences([target]);
+                this.discoverReferences([target], false);
                 this.discoverMissingTargets();
             }
         }
@@ -210,40 +207,21 @@ export class MetadataDiscovery {
         paths = paths.map(path => Utils.normalizePath(path));
         const files = await glob(paths, { cwd: Utils.normalizePath(this.config.get('baseDir')) });
         this.logger.log('discovery', `- processing ${colors.cyan('' + files.length)} files`);
-        const found = [];
+        const found = new Map();
         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$/)) {
+            if (!filename.match(/\.[cm]?[jt]s$/) || filename.match(/\.d\.[cm]?ts/)) {
                 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);
+            await this.getEntityClassOrSchema(filepath, found);
         }
+        return found.keys();
     }
-    discoverReferences(refs) {
+    discoverReferences(refs, validate = true) {
         const found = [];
         for (const entity of refs) {
-            const schema = this.getSchema(this.prepare(entity));
+            const schema = this.getSchema(entity);
             const meta = schema.init().meta;
             this.metadata.set(meta.className, meta);
             found.push(schema);
@@ -252,10 +230,10 @@ 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);
             }
             if (typeof parent === 'function' && parent.name && !this.metadata.has(parent.name)) {
-                this.discoverReferences([parent]);
+                this.discoverReferences([parent], false);
             }
             /* v8 ignore next 3 */
             if (!meta.class) {
@@ -263,12 +241,16 @@ export class MetadataDiscovery {
             }
             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) {
@@ -278,22 +260,11 @@ 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);
-            }
             const meta = Utils.copy(entity.meta, false);
             return EntitySchema.fromMetadata(meta);
         }
@@ -310,11 +281,12 @@ 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})` : '')}`);
+    discoverEntity(schema) {
         const meta = schema.meta;
+        const path = meta.path;
+        this.logger.log('discovery', `- processing entity ${colors.cyan(meta.className)}${colors.grey(path ? ` (${path})` : '')}`);
         const root = Utils.getRootEntity(this.metadata, meta);
-        schema.meta.path = Utils.relativePath(path || meta.path, this.config.get('baseDir'));
+        schema.meta.path = Utils.relativePath(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.cyan(meta.className)}`);
@@ -1145,44 +1117,44 @@ export class MetadataDiscovery {
             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 JsonType();
+            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 JsonType();
+            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 && isArray) {
-            prop.customType = new ArrayType();
+            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, DateType]
+            [t.bigint, t.double, t.decimal, t.interval, t.date]
                 .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' && ![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 {
@@ -1202,7 +1174,7 @@ 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();
             }
         }
@@ -1223,7 +1195,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}`];
             }
@@ -1266,7 +1238,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)
@@ -1349,29 +1321,26 @@ export class MetadataDiscovery {
             prop.index ??= true;
         }
     }
-    async getEntityClassOrSchema(path, name) {
+    async getEntityClassOrSchema(filepath, allTargets) {
+        const path = Utils.normalizePath(this.config.get('baseDir'), filepath);
         const exports = await Utils.dynamicImport(path);
-        const targets = Object.values(exports)
-            .filter(item => item instanceof EntitySchema || (item instanceof Function && MetadataStorage.isKnownEntity(item.name)));
+        const targets = Object.values(exports);
         // ignore class implementations that are linked from an EntitySchema
         for (const item of targets) {
             if (item instanceof EntitySchema) {
-                targets.forEach((item2, idx) => {
+                for (const item2 of targets) {
                     if (item.meta.class === item2) {
-                        targets.splice(idx, 1);
+                        targets.splice(targets.indexOf(item2), 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'), '.'));
+        for (const item of targets) {
+            const validTarget = item instanceof EntitySchema || (item instanceof Function && MetadataStorage.isKnownEntity(item.name));
+            if (validTarget && !allTargets.has(item)) {
+                allTargets.set(item, path);
+            }
         }
-        return [target];
     }
     shouldForceConstructorUsage(meta) {
         const forceConstructor = this.config.get('forceEntityConstructor');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.49",
+  "version": "7.0.0-dev.50",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",
@@ -54,7 +54,7 @@
     "dataloader": "2.2.3",
     "dotenv": "17.2.3",
     "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.49",
+    "mikro-orm": "7.0.0-dev.50",
     "reflect-metadata": "0.2.2",
     "tinyglobby": "0.2.13"
   }

package/typings.d.ts

@@ -212,10 +212,6 @@ export type AnyEntity<T = any> = Partial<T>;
 export type EntityClass<T> = Function & {
     prototype: T;
 };
-export type EntityClassGroup<T> = {
-    entity: EntityClass<T>;
-    schema: EntityMetadata<T> | EntitySchema<T>;
-};
 export type EntityName<T> = string | EntityClass<T> | EntitySchema<T, any> | {
     name: string;
 };

package/utils/Configuration.d.ts

@@ -2,7 +2,7 @@ import type { NamingStrategy } from '../naming-strategy/NamingStrategy.js';
 import { FileCacheAdapter } from '../cache/FileCacheAdapter.js';
 import { type SyncCacheAdapter, type CacheAdapter } from '../cache/CacheAdapter.js';
 import type { EntityRepository } from '../entity/EntityRepository.js';
-import type { AnyEntity, Constructor, Dictionary, EntityClass, EntityClassGroup, FilterDef, Highlighter, HydratorConstructor, IHydrator, IMigrationGenerator, IPrimaryKey, MaybePromise, MigrationObject, EntityMetadata, EnsureDatabaseOptions, GenerateOptions, Migration } from '../typings.js';
+import type { AnyEntity, Constructor, Dictionary, EntityClass, FilterDef, Highlighter, HydratorConstructor, IHydrator, IMigrationGenerator, IPrimaryKey, MaybePromise, MigrationObject, EntityMetadata, EnsureDatabaseOptions, GenerateOptions, Migration } from '../typings.js';
 import { ObjectHydrator } from '../hydration/ObjectHydrator.js';
 import { NullHighlighter } from '../utils/NullHighlighter.js';
 import { type Logger, type LoggerNamespace, type LoggerOptions } from '../logging/Logger.js';
@@ -234,7 +234,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
 /**
  * Type helper to make it easier to use `mikro-orm.config.js`.
  */
-export declare function defineConfig<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Options<D, EM, Entities>;
+export declare function defineConfig<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Options<D, EM, Entities>;
 export interface ConnectionOptions {
     dbName?: string;
     schema?: string;
@@ -299,8 +299,8 @@ export interface MetadataDiscoveryOptions {
     skipSyncDiscovery?: boolean;
 }
 export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = EntityManager> extends ConnectionOptions {
-    entities: (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[];
-    entitiesTs: (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[];
+    entities: (string | EntityClass<AnyEntity> | EntitySchema)[];
+    entitiesTs: (string | EntityClass<AnyEntity> | EntitySchema)[];
     extensions: {
         register: (orm: MikroORM) => void;
     }[];
@@ -415,6 +415,6 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     dynamicImportProvider: (id: string) => Promise<unknown>;
     hashAlgorithm: 'md5' | 'sha256';
 }
-export interface Options<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]> extends Pick<MikroORMOptions<D, EM>, Exclude<keyof MikroORMOptions, keyof typeof Configuration.DEFAULTS>>, Partial<MikroORMOptions<D, EM>> {
+export interface Options<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends Pick<MikroORMOptions<D, EM>, Exclude<keyof MikroORMOptions, keyof typeof Configuration.DEFAULTS>>, Partial<MikroORMOptions<D, EM>> {
     entities?: Entities;
 }