@mikro-orm/core 7.0.4 → 7.0.5-dev.0

package/metadata/discover-entities.d.ts

@@ -1,8 +1,5 @@
 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,45 +4,47 @@ 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) {
-    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);
-      }
+    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;
+    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);
     }
-    await getEntityClassOrSchema(filepath, found, baseDir);
-  }
-  return found.keys();
+    return found.keys();
 }