@mikro-orm/core 7.0.0-dev.215 → 7.0.0-dev.216

package/MikroORM.d.ts

@@ -5,7 +5,7 @@ import { Configuration, type Options } from './utils/Configuration.js';
 import type { EntityManager } from './EntityManager.js';
 import type { AnyEntity, Constructor, EntityClass, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
 /** @internal */
-export declare function lookupExtensions(options: Options): Promise<void>;
+export declare function loadOptionalDependencies(options: Options): Promise<void>;
 /**
  * The main class used to configure and bootstrap the ORM.
  *

package/MikroORM.js

@@ -4,31 +4,35 @@ import { Configuration } from './utils/Configuration.js';
 import { loadEnvironmentVars } from './utils/env-vars.js';
 import { Utils } from './utils/Utils.js';
 import { colors } from './logging/colors.js';
-async function registerExtension(name, mod, extensions) {
-    /* v8 ignore next */
-    const resolved = await mod.catch(() => null);
-    const module = resolved?.[name];
-    /* v8 ignore else */
-    if (module) {
-        extensions.push(module);
+async function tryRegisterExtension(name, pkg, extensions) {
+    try {
+        const url = import.meta.resolve(pkg);
+        const mod = await import(url);
+        if (mod[name]) {
+            extensions.push(mod[name]);
+        }
+    }
+    catch {
+        // not installed
     }
 }
 /** @internal */
-export async function lookupExtensions(options) {
+export async function loadOptionalDependencies(options) {
+    await import('@mikro-orm/core/fs-utils').then(m => m.fs.init()).catch(() => null);
     const extensions = options.extensions ?? [];
     const exists = (name) => extensions.some(ext => ext.name === name);
     if (!exists('SeedManager')) {
-        await registerExtension('SeedManager', import((() => '@mikro-orm/seeder')()), extensions);
+        await tryRegisterExtension('SeedManager', '@mikro-orm/seeder', extensions);
     }
     if (!exists('Migrator')) {
-        await registerExtension('Migrator', import((() => '@mikro-orm/migrations')()), extensions);
+        await tryRegisterExtension('Migrator', '@mikro-orm/migrations', extensions);
     }
     /* v8 ignore if */
     if (!exists('Migrator')) {
-        await registerExtension('Migrator', import((() => '@mikro-orm/migrations-mongodb')()), extensions);
+        await tryRegisterExtension('Migrator', '@mikro-orm/migrations-mongodb', extensions);
     }
     if (!exists('EntityGenerator')) {
-        await registerExtension('EntityGenerator', import((() => '@mikro-orm/entity-generator')()), extensions);
+        await tryRegisterExtension('EntityGenerator', '@mikro-orm/entity-generator', extensions);
     }
     options.extensions = extensions;
     const metadataCacheEnabled = options.metadataCache?.enabled || options.metadataProvider?.useCache?.();
@@ -85,7 +89,7 @@ export class MikroORM {
         options = { ...options };
         options.discovery ??= {};
         options.discovery.skipSyncDiscovery ??= true;
-        await lookupExtensions(options);
+        await loadOptionalDependencies(options);
         const orm = new this(options);
         const preferTs = orm.config.get('preferTs', Utils.detectTypeScriptSupport());
         orm.metadata = await orm.discovery.discover(preferTs);

package/entity/WrappedEntity.d.ts

@@ -58,7 +58,7 @@ export declare class WrappedEntity<Entity extends object> {
     setPrimaryKey(id: Primary<Entity> | null): void;
     getSerializedPrimaryKey(): string;
     get __meta(): EntityMetadata<Entity>;
-    get __platform(): import("@mikro-orm/sql").Platform;
-    get __config(): import("@mikro-orm/sql").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("@mikro-orm/sql").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("@mikro-orm/sql").Connection>>>;
+    get __platform(): import("../index.js").Platform;
+    get __config(): import("../index.js").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>>>;
     get __primaryKeys(): Primary<Entity>[];
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.215",
+  "version": "7.0.0-dev.216",
   "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",

package/utils/Configuration.d.ts

@@ -35,7 +35,7 @@ declare const DEFAULTS: {
         readonly inferDefaultValues: true;
     };
     readonly validateRequired: true;
-    readonly context: (name: string) => EntityManager<IDatabaseDriver<import("@mikro-orm/sql").Connection>> | undefined;
+    readonly context: (name: string) => EntityManager<IDatabaseDriver<import("../index.js").Connection>> | undefined;
     readonly contextName: "default";
     readonly allowGlobalContext: false;
     readonly logger: (message?: any, ...optionalParams: any[]) => void;

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.215';
+    static #ORM_VERSION = '7.0.0-dev.216';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */

package/utils/fs-utils.d.ts

@@ -1,5 +1,6 @@
 import { type Dictionary } from '../typings.js';
 export declare const fs: {
+    init(): Promise<void>;
     pathExists(path: string): boolean;
     ensureDir(path: string): void;
     readJSONSync<T = Dictionary>(path: string): T;

package/utils/fs-utils.js

@@ -1,9 +1,25 @@
-import { existsSync, globSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { existsSync, globSync as nodeGlobSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { isAbsolute, join, normalize, relative } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Utils } from './Utils.js';
 import { colors } from '../logging/colors.js';
+let globSync = (patterns, options) => {
+    const files = nodeGlobSync(patterns, { ...options, withFileTypes: true });
+    return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+};
 export const fs = {
+    async init() {
+        const tinyGlobby = await import('tinyglobby').catch(() => null);
+        if (tinyGlobby) {
+            globSync = (patterns, options) => {
+                patterns = Utils.asArray(patterns).map(p => p.replace(/\\/g, '/'));
+                if (options?.cwd) {
+                    options = { ...options, cwd: options.cwd.replace(/\\/g, '/') };
+                }
+                return tinyGlobby.globSync(patterns, { ...options, expandDirectories: false });
+            };
+        }
+    },
     pathExists(path) {
         if (/[*?[\]]/.test(path)) {
             return globSync(path).length > 0;
@@ -49,16 +65,14 @@ export const fs = {
             try {
                 const s = statSync(cwd ? this.normalizePath(cwd, input) : input);
                 if (s.isDirectory()) {
-                    const files = globSync(join(input, '**'), { cwd, withFileTypes: true });
-                    return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+                    return globSync(join(input, '**'), { cwd });
                 }
             }
             catch {
                 // ignore
             }
         }
-        const files = globSync(input, { cwd, withFileTypes: true });
-        return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+        return globSync(input, { cwd });
     },
     getPackageConfig(basePath = process.cwd()) {
         if (this.pathExists(`${basePath}/package.json`)) {