@mikro-orm/core 7.0.4-dev.8 → 7.0.4

package/metadata/discover-entities.d.ts

@@ -1,5 +1,8 @@
 import { type Constructor } from '../typings.js';
 import { EntitySchema } from './EntitySchema.js';
-export declare function discoverEntities(paths: string | string[], options?: {
+export declare function discoverEntities(
+  paths: string | string[],
+  options?: {
     baseDir?: string;
-}): Promise<Iterable<EntitySchema | Constructor>>;
+  },
+): Promise<Iterable<EntitySchema | Constructor>>;

package/metadata/discover-entities.js

@@ -4,37 +4,45 @@ import { Utils } from '../utils/Utils.js';
 import { MetadataStorage } from './MetadataStorage.js';
 import { EntitySchema } from './EntitySchema.js';
 async function getEntityClassOrSchema(filepath, allTargets, baseDir) {
-    const path = fs.normalizePath(baseDir, filepath);
-    const exports = await fs.dynamicImport(path);
-    const targets = Object.values(exports);
-    // ignore class implementations that are linked from an EntitySchema
-    for (const item of targets) {
-        if (EntitySchema.is(item)) {
-            for (const item2 of targets) {
-                if (item.meta.class === item2) {
-                    targets.splice(targets.indexOf(item2), 1);
-                }
-            }
+  const path = fs.normalizePath(baseDir, filepath);
+  const exports = await fs.dynamicImport(path);
+  const targets = Object.values(exports);
+  // ignore class implementations that are linked from an EntitySchema
+  for (const item of targets) {
+    if (EntitySchema.is(item)) {
+      for (const item2 of targets) {
+        if (item.meta.class === item2) {
+          targets.splice(targets.indexOf(item2), 1);
         }
+      }
     }
-    for (const item of targets) {
-        const validTarget = EntitySchema.is(item) || (item instanceof Function && MetadataStorage.isKnownEntity(item.name));
-        if (validTarget && !allTargets.has(item)) {
-            allTargets.set(item, path);
-        }
+  }
+  for (const item of targets) {
+    if (EntitySchema.is(item)) {
+      if (!allTargets.has(item)) {
+        allTargets.set(item, path);
+      }
+    } else if (item instanceof Function) {
+      const schema = EntitySchema.REGISTRY.get(item);
+      if (schema && !allTargets.has(schema)) {
+        allTargets.set(schema, path);
+      } else if (!schema && MetadataStorage.isKnownEntity(item.name) && !allTargets.has(item)) {
+        allTargets.set(item, path);
+      }
     }
+  }
 }
 export async function discoverEntities(paths, options) {
-    paths = Utils.asArray(paths).map(path => fs.normalizePath(path));
-    const baseDir = fs.absolutePath(options?.baseDir ?? process.cwd());
-    const files = fs.glob(paths, fs.normalizePath(baseDir));
-    const found = new Map();
-    for (const filepath of files) {
-        const filename = basename(filepath);
-        if (!/\.[cm]?[jt]s$/.exec(filename) || /\.d\.[cm]?ts/.exec(filename)) {
-            continue;
-        }
-        await getEntityClassOrSchema(filepath, found, baseDir);
+  paths = Utils.asArray(paths).map(path => fs.normalizePath(path));
+  const baseDir = fs.absolutePath(options?.baseDir ?? process.cwd());
+  const files = fs.glob(paths, fs.normalizePath(baseDir));
+  const found = new Map();
+  for (const filepath of files) {
+    const filename = basename(filepath);
+    if (!/\.[cm]?[jt]s$/.exec(filename) || /\.d\.[cm]?ts/.exec(filename)) {
+      continue;
     }
-    return found.keys();
+    await getEntityClassOrSchema(filepath, found, baseDir);
+  }
+  return found.keys();
 }