@mikro-orm/core 7.0.0-dev.30 → 7.0.0-dev.300

package/MikroORM.d.ts

@@ -3,13 +3,42 @@ 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 { Constructor, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
+import type { AnyEntity, Constructor, EntityClass, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
+/** @internal */
+export declare function loadOptionalDependencies(options: Options): Promise<void>;
 /**
- * Helper class for bootstrapping the MikroORM.
+ * The main class used to configure and bootstrap the ORM.
+ *
+ * @example
+ * ```ts
+ * // import from driver package
+ * import { MikroORM, defineEntity, p } from '@mikro-orm/sqlite';
+ *
+ * const User = defineEntity({
+ *   name: 'User',
+ *   properties: {
+ *     id: p.integer().primary(),
+ *     name: p.string(),
+ *   },
+ * });
+ *
+ * const orm = new MikroORM({
+ *   entities: [User],
+ *   dbName: 'my.db',
+ * });
+ * await orm.schema.update();
+ *
+ * const em = orm.em.fork();
+ * const u1 = em.create(User, { name: 'John' });
+ * const u2 = em.create(User, { name: 'Ben' });
+ * await em.flush();
+ * ```
  */
-export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = Driver[typeof EntityManagerType] & EntityManager> {
+export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends Driver[typeof EntityManagerType] & EntityManager<Driver> = Driver[typeof EntityManagerType] & EntityManager<Driver>, 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;
+    em: EM & {
+        '~entities'?: Entities;
+    };
     readonly driver: Driver;
     readonly config: Configuration<Driver>;
     private metadata;
@@ -19,16 +48,14 @@ 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>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, 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)
-     * - no loading of the `config` file, `options` parameter is mandatory
-     * - no support for folder based discovery
-     * - no check for mismatched package versions
+     * - folder-based discovery not supported
+     * - ORM extensions are not autoloaded
+     * - when metadata cache is enabled, `FileCacheAdapter` needs to be explicitly set in the config
      */
-    static initSync<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
-    constructor(options: Options<Driver, EM>);
+    constructor(options: Options<Driver, EM, Entities>);
     /**
      * Connects to the database.
      */
@@ -36,13 +63,13 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
     /**
      * Reconnects, possibly to a different database.
      */
-    reconnect(options?: Options): Promise<void>;
+    reconnect(options?: Partial<Options<Driver, EM, Entities>>): Promise<void>;
     /**
      * Checks whether the database connection is active.
      */
     isConnected(): Promise<boolean>;
     /**
-     * Checks whether the database connection is active, returns .
+     * Checks whether the database connection is active, returns the reason if not.
      */
     checkConnection(): Promise<{
         ok: true;
@@ -63,43 +90,25 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * Gets the `EntityMetadata` instance when provided with the `entityName` parameter.
      */
     getMetadata<Entity extends object>(entityName: EntityName<Entity>): EntityMetadata<Entity>;
-    discoverEntities(): Promise<void>;
-    discoverEntitiesSync(): void;
     private createEntityManager;
     /**
      * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
      */
-    discoverEntity<T extends Constructor | EntitySchema>(entities: T | T[], reset?: string | string[]): void;
+    discoverEntity<T extends Constructor | EntitySchema>(entities: T | T[], reset?: EntityName | EntityName[]): void;
     /**
      * Gets the SchemaGenerator.
      */
-    getSchemaGenerator(): ReturnType<ReturnType<Driver['getPlatform']>['getSchemaGenerator']>;
-    /**
-     * Gets the EntityGenerator.
-     */
-    getEntityGenerator<T extends IEntityGenerator = IEntityGenerator>(): T;
-    /**
-     * Gets the Migrator.
-     */
-    getMigrator<T extends IMigrator = IMigrator>(): T;
+    get schema(): ReturnType<ReturnType<Driver['getPlatform']>['getSchemaGenerator']>;
     /**
      * Gets the SeedManager
      */
-    getSeeder<T extends ISeedManager = ISeedManager>(): T;
-    /**
-     * Shortcut for `orm.getSchemaGenerator()`
-     */
-    get schema(): ReturnType<ReturnType<Driver["getPlatform"]>["getSchemaGenerator"]>;
-    /**
-     * Shortcut for `orm.getSeeder()`
-     */
     get seeder(): ISeedManager;
     /**
-     * Shortcut for `orm.getMigrator()`
+     * Gets the Migrator.
      */
     get migrator(): IMigrator;
     /**
-     * Shortcut for `orm.getEntityGenerator()`
+     * Gets the EntityGenerator.
      */
     get entityGenerator(): IEntityGenerator;
 }

package/MikroORM.js

@@ -1,14 +1,73 @@
 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';
+import { loadEnvironmentVars } from './utils/env-vars.js';
 import { Utils } from './utils/Utils.js';
 import { colors } from './logging/colors.js';
-import { NullCacheAdapter } from './cache/NullCacheAdapter.js';
+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 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 tryRegisterExtension('SeedManager', '@mikro-orm/seeder', extensions);
+    }
+    if (!exists('Migrator')) {
+        await tryRegisterExtension('Migrator', '@mikro-orm/migrations', extensions);
+    }
+    /* v8 ignore if */
+    if (!exists('Migrator')) {
+        await tryRegisterExtension('Migrator', '@mikro-orm/migrations-mongodb', extensions);
+    }
+    if (!exists('EntityGenerator')) {
+        await tryRegisterExtension('EntityGenerator', '@mikro-orm/entity-generator', extensions);
+    }
+    options.extensions = extensions;
+    const metadataCacheEnabled = options.metadataCache?.enabled || options.metadataProvider?.useCache?.();
+    if (metadataCacheEnabled) {
+        options.metadataCache ??= {};
+        options.metadataCache.adapter ??= await import('@mikro-orm/core/fs-utils').then(m => m.FileCacheAdapter);
+    }
+}
 /**
- * Helper class for bootstrapping the MikroORM.
+ * The main class used to configure and bootstrap the ORM.
+ *
+ * @example
+ * ```ts
+ * // import from driver package
+ * import { MikroORM, defineEntity, p } from '@mikro-orm/sqlite';
+ *
+ * const User = defineEntity({
+ *   name: 'User',
+ *   properties: {
+ *     id: p.integer().primary(),
+ *     name: p.string(),
+ *   },
+ * });
+ *
+ * const orm = new MikroORM({
+ *   entities: [User],
+ *   dbName: 'my.db',
+ * });
+ * await orm.schema.update();
+ *
+ * const em = orm.em.fork();
+ * const u1 = em.create(User, { name: 'John' });
+ * const u2 = em.create(User, { name: 'Ben' });
+ * await em.flush();
+ * ```
  */
 export class MikroORM {
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
@@ -23,103 +82,58 @@ export class MikroORM {
      * If you omit the `options` parameter, your CLI config will be used.
      */
     static async init(options) {
-        ConfigurationLoader.registerDotenv(options);
-        const coreVersion = ConfigurationLoader.checkPackageVersion();
-        const env = await ConfigurationLoader.loadEnvironmentVars();
+        /* v8 ignore next */
         if (!options) {
-            const configPathFromArg = ConfigurationLoader.configPathsFromArg();
-            const config = (await ConfigurationLoader.getConfiguration(process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default', configPathFromArg ?? ConfigurationLoader.getConfigPaths()));
-            options = config.getAll();
-            if (configPathFromArg) {
-                config.getLogger().warn('deprecated', 'Path for config file was inferred from the command line arguments. Instead, you should set the MIKRO_ORM_CLI_CONFIG environment variable to specify the path, or if you really must use the command line arguments, import the config manually based on them, and pass it to init.', { label: 'D0001' });
-            }
-        }
-        options = Utils.mergeConfig(options, env);
-        if ('DRIVER' in this && !options.driver) {
-            options.driver = this.DRIVER;
-        }
-        const orm = new MikroORM(options);
-        orm.logger.log('info', `MikroORM version: ${colors.green(coreVersion)}`);
-        // we need to allow global context here as we are not in a scope of requests yet
-        const allowGlobalContext = orm.config.get('allowGlobalContext');
-        orm.config.set('allowGlobalContext', true);
-        await orm.discoverEntities();
-        orm.config.set('allowGlobalContext', allowGlobalContext);
-        orm.driver.getPlatform().init(orm);
-        if (orm.config.get('connect')) {
-            await orm.connect();
-        }
-        for (const extension of orm.config.get('extensions')) {
-            extension.register(orm);
-        }
-        if (orm.config.get('connect') && orm.config.get('ensureIndexes')) {
-            await orm.getSchemaGenerator().ensureIndexes();
-        }
+            throw new Error(`options parameter is required`);
+        }
+        options = { ...options };
+        options.discovery ??= {};
+        options.discovery.skipSyncDiscovery ??= true;
+        await loadOptionalDependencies(options);
+        const orm = new this(options);
+        const preferTs = orm.config.get('preferTs', Utils.detectTypeScriptSupport());
+        orm.metadata = await orm.discovery.discover(preferTs);
+        orm.createEntityManager();
         return orm;
     }
     /**
      * 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)
-     * - no loading of the `config` file, `options` parameter is mandatory
-     * - no support for folder based discovery
-     * - no check for mismatched package versions
+     * - folder-based discovery not supported
+     * - ORM extensions are not autoloaded
+     * - when metadata cache is enabled, `FileCacheAdapter` needs to be explicitly set in the config
      */
-    static initSync(options) {
-        ConfigurationLoader.registerDotenv(options);
-        const env = ConfigurationLoader.loadEnvironmentVarsSync();
-        options = Utils.merge(options, env);
-        if ('DRIVER' in this && !options.driver) {
-            options.driver = this.DRIVER;
-        }
-        const orm = new MikroORM(options);
-        // we need to allow global context here as we are not in a scope of requests yet
-        const allowGlobalContext = orm.config.get('allowGlobalContext');
-        orm.config.set('allowGlobalContext', true);
-        orm.discoverEntitiesSync();
-        orm.config.set('allowGlobalContext', allowGlobalContext);
-        orm.driver.getPlatform().init(orm);
-        for (const extension of orm.config.get('extensions')) {
-            extension.register(orm);
-        }
-        return orm;
-    }
     constructor(options) {
+        const env = loadEnvironmentVars();
+        options = options.preferEnvVars
+            ? Utils.merge(options, env)
+            : Utils.merge(env, options);
         this.config = new Configuration(options);
         const discovery = this.config.get('discovery');
-        if (discovery.disableDynamicFileAccess) {
-            this.config.set('metadataProvider', ReflectMetadataProvider);
-            this.config.set('metadataCache', { adapter: NullCacheAdapter });
-            discovery.requireEntitiesArray = true;
-        }
         this.driver = this.config.getDriver();
         this.logger = this.config.getLogger();
+        this.logger.log('info', `MikroORM version: ${colors.green(Utils.getORMVersion())}`);
         this.discovery = new MetadataDiscovery(new MetadataStorage(), this.driver.getPlatform(), this.config);
+        this.driver.getPlatform().init(this);
+        for (const extension of this.config.get('extensions')) {
+            extension.register(this);
+        }
+        if (!discovery.skipSyncDiscovery) {
+            this.metadata = this.discovery.discoverSync();
+            this.createEntityManager();
+        }
     }
     /**
      * Connects to the database.
      */
     async connect() {
-        const connection = await this.driver.connect();
-        const clientUrl = connection.getClientUrl();
-        const dbName = this.config.get('dbName');
-        const db = dbName + (clientUrl ? ' on ' + clientUrl : '');
-        if (this.config.get('ensureDatabase')) {
-            const options = this.config.get('ensureDatabase');
-            await this.schema.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
-        }
-        if (await this.isConnected()) {
-            this.logger.log('info', `MikroORM successfully connected to database ${colors.green(db)}`);
-        }
-        else {
-            this.logger.error('info', `MikroORM failed to connect to database ${db}`);
-        }
+        await this.driver.connect();
         return this.driver;
     }
     /**
      * Reconnects, possibly to a different database.
      */
     async reconnect(options = {}) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         for (const key of Utils.keys(options)) {
             this.config.set(key, options[key]);
         }
@@ -132,7 +146,7 @@ export class MikroORM {
         return this.driver.getConnection().isConnected();
     }
     /**
-     * Checks whether the database connection is active, returns .
+     * Checks whether the database connection is active, returns the reason if not.
      */
     async checkConnection() {
         return this.driver.getConnection().checkConnection();
@@ -141,34 +155,19 @@ export class MikroORM {
      * Closes the database connection.
      */
     async close(force = false) {
-        if (await this.isConnected()) {
-            await this.driver.close(force);
-        }
-        if (this.config.getMetadataCacheAdapter()?.close) {
-            await this.config.getMetadataCacheAdapter().close();
-        }
-        if (this.config.getResultCacheAdapter()?.close) {
-            await this.config.getResultCacheAdapter().close();
-        }
+        await this.driver.close(force);
+        await this.config.getMetadataCacheAdapter()?.close?.();
+        await this.config.getResultCacheAdapter()?.close?.();
     }
     /**
      * Gets the `MetadataStorage` (without parameters) or `EntityMetadata` instance when provided with the `entityName` parameter.
      */
     getMetadata(entityName) {
         if (entityName) {
-            entityName = Utils.className(entityName);
             return this.metadata.get(entityName);
         }
         return this.metadata;
     }
-    async discoverEntities() {
-        this.metadata = await this.discovery.discover(this.config.get('preferTs'));
-        this.createEntityManager();
-    }
-    discoverEntitiesSync() {
-        this.metadata = this.discovery.discoverSync(this.config.get('preferTs'));
-        this.createEntityManager();
-    }
     createEntityManager() {
         this.driver.setMetadata(this.metadata);
         this.em = this.driver.createEntityManager();
@@ -180,72 +179,40 @@ 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 => {
-            this.metadata.set(meta.className, meta);
-            meta.root = this.metadata.get(meta.root.className);
-        });
+        for (const meta of metadata) {
+            this.metadata.set(meta.class, meta);
+            meta.root = this.metadata.get(meta.root.class);
+        }
         this.metadata.decorate(this.em);
     }
     /**
      * Gets the SchemaGenerator.
      */
-    getSchemaGenerator() {
-        const extension = this.config.getExtension('@mikro-orm/schema-generator');
-        if (extension) {
-            return extension;
-        }
-        /* v8 ignore next 2 */
-        throw new Error(`SchemaGenerator extension not registered.`);
-    }
-    /**
-     * Gets the EntityGenerator.
-     */
-    getEntityGenerator() {
-        return this.driver.getPlatform().getExtension('EntityGenerator', '@mikro-orm/entity-generator', '@mikro-orm/entity-generator', this.em);
-    }
-    /**
-     * Gets the Migrator.
-     */
-    getMigrator() {
-        return this.driver.getPlatform().getExtension('Migrator', '@mikro-orm/migrator', '@mikro-orm/migrations', this.em);
-    }
-    /**
-     * Gets the SeedManager
-     */
-    getSeeder() {
-        return this.driver.getPlatform().getExtension('SeedManager', '@mikro-orm/seeder', '@mikro-orm/seeder', this.em);
-    }
-    /**
-     * Shortcut for `orm.getSchemaGenerator()`
-     */
     get schema() {
-        return this.getSchemaGenerator();
+        return this.config.getExtension('@mikro-orm/schema-generator');
     }
     /**
-     * Shortcut for `orm.getSeeder()`
+     * Gets the SeedManager
      */
     get seeder() {
-        return this.getSeeder();
+        return this.driver.getPlatform().getExtension('SeedManager', '@mikro-orm/seeder', '@mikro-orm/seeder', this.em);
     }
     /**
-     * Shortcut for `orm.getMigrator()`
+     * Gets the Migrator.
      */
     get migrator() {
-        return this.getMigrator();
+        return this.driver.getPlatform().getExtension('Migrator', '@mikro-orm/migrator', '@mikro-orm/migrations', this.em);
     }
     /**
-     * Shortcut for `orm.getEntityGenerator()`
+     * Gets the EntityGenerator.
      */
     get entityGenerator() {
-        return this.getEntityGenerator();
+        return this.driver.getPlatform().getExtension('EntityGenerator', '@mikro-orm/entity-generator', '@mikro-orm/entity-generator', this.em);
     }
 }

package/README.md

@@ -381,6 +381,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

package/cache/FileCacheAdapter.d.ts

@@ -3,13 +3,12 @@ export declare class FileCacheAdapter implements SyncCacheAdapter {
     private readonly options;
     private readonly baseDir;
     private readonly pretty;
-    private readonly hashAlgorithm;
     private readonly VERSION;
     private cache;
     constructor(options: {
         cacheDir: string;
         combined?: boolean | string;
-    }, baseDir: string, pretty?: boolean, hashAlgorithm?: 'md5' | 'sha256');
+    } | undefined, baseDir: string, pretty?: boolean);
     /**
      * @inheritDoc
      */

package/cache/FileCacheAdapter.js

@@ -1,18 +1,17 @@
-import { globSync } from 'tinyglobby';
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { fs } from '../utils/fs-utils.js';
 import { Utils } from '../utils/Utils.js';
 export class FileCacheAdapter {
     options;
     baseDir;
     pretty;
-    hashAlgorithm;
     VERSION = Utils.getORMVersion();
     cache = {};
-    constructor(options, baseDir, pretty = false, hashAlgorithm = 'md5') {
+    constructor(options = {}, baseDir, pretty = false) {
         this.options = options;
         this.baseDir = baseDir;
         this.pretty = pretty;
-        this.hashAlgorithm = hashAlgorithm;
+        this.options.cacheDir ??= process.cwd() + '/temp';
     }
     /**
      * @inheritDoc
@@ -22,7 +21,7 @@ export class FileCacheAdapter {
         if (!existsSync(path)) {
             return null;
         }
-        const payload = Utils.readJSONSync(path);
+        const payload = fs.readJSONSync(path);
         const hash = this.getHash(payload.origin);
         if (!hash || payload.hash !== hash) {
             return null;
@@ -53,8 +52,16 @@ export class FileCacheAdapter {
      */
     clear() {
         const path = this.path('*');
-        const files = globSync(path);
-        files.forEach(file => unlinkSync(file));
+        const files = fs.glob(path);
+        for (const file of files) {
+            /* v8 ignore next */
+            try {
+                unlinkSync(file);
+            }
+            catch {
+                // ignore if file is already gone
+            }
+        }
         this.cache = {};
     }
     combine() {
@@ -64,21 +71,21 @@ export class FileCacheAdapter {
         let path = typeof this.options.combined === 'string'
             ? this.options.combined
             : './metadata.json';
-        path = Utils.normalizePath(this.options.cacheDir, path);
+        path = fs.normalizePath(this.options.cacheDir, path);
         this.options.combined = path; // override in the options, so we can log it from the CLI in `cache:generate` command
         writeFileSync(path, JSON.stringify(this.cache, null, this.pretty ? 2 : undefined));
         return path;
     }
     path(name) {
-        Utils.ensureDir(this.options.cacheDir);
+        fs.ensureDir(this.options.cacheDir);
         return `${this.options.cacheDir}/${name}.json`;
     }
     getHash(origin) {
-        origin = Utils.absolutePath(origin, this.baseDir);
+        origin = fs.absolutePath(origin, this.baseDir);
         if (!existsSync(origin)) {
             return null;
         }
         const contents = readFileSync(origin);
-        return Utils.hash(contents.toString() + this.VERSION, undefined, this.hashAlgorithm);
+        return Utils.hash(contents.toString() + this.VERSION);
     }
 }

package/cache/GeneratedCacheAdapter.d.ts

@@ -1,7 +1,6 @@
 import type { CacheAdapter } from './CacheAdapter.js';
 import type { Dictionary } from '../typings.js';
 export declare class GeneratedCacheAdapter implements CacheAdapter {
-    private readonly options;
     private readonly data;
     constructor(options: {
         data: Dictionary;

package/cache/GeneratedCacheAdapter.js

@@ -1,8 +1,6 @@
 export class GeneratedCacheAdapter {
-    options;
     data = new Map();
     constructor(options) {
-        this.options = options;
         this.data = new Map(Object.entries(options.data));
     }
     /**

package/cache/index.d.ts

@@ -1,5 +1,4 @@
 export * from './CacheAdapter.js';
 export * from './NullCacheAdapter.js';
-export * from './FileCacheAdapter.js';
 export * from './MemoryCacheAdapter.js';
 export * from './GeneratedCacheAdapter.js';

package/cache/index.js

@@ -1,5 +1,4 @@
 export * from './CacheAdapter.js';
 export * from './NullCacheAdapter.js';
-export * from './FileCacheAdapter.js';
 export * from './MemoryCacheAdapter.js';
 export * from './GeneratedCacheAdapter.js';

package/connections/Connection.d.ts

@@ -17,7 +17,9 @@ export declare abstract class Connection {
     /**
      * Establishes connection to database
      */
-    abstract connect(): void | Promise<void>;
+    abstract connect(options?: {
+        skipOnConnect?: boolean;
+    }): void | Promise<void>;
     /**
      * Are we connected to the database
      */
@@ -37,18 +39,24 @@ export declare abstract class Connection {
      */
     close(force?: boolean): Promise<void>;
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     ensureConnection(): Promise<void>;
+    /**
+     * Execute raw SQL queries, handy from running schema dump loaded from a file.
+     * This method doesn't support transactions, as opposed to `orm.schema.execute()`, which is used internally.
+     */
+    executeDump(dump: string): Promise<void>;
+    protected onConnect(): Promise<void>;
     transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
-        isolationLevel?: IsolationLevel;
+        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
         loggerContext?: LogContext;
     }): Promise<T>;
     begin(options?: {
-        isolationLevel?: IsolationLevel;
+        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
@@ -58,7 +66,6 @@ export declare abstract class Connection {
     rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
     abstract execute<T>(query: string, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<QueryResult<T> | any | any[]>;
     getConnectionOptions(): ConnectionConfig;
-    getClientUrl(): string;
     setMetadata(metadata: MetadataStorage): void;
     setPlatform(platform: Platform): void;
     getPlatform(): Platform;