@mikro-orm/cli 7.0.0-dev.33 → 7.0.0-dev.331

package/CLIConfigurator.d.ts

@@ -1,21 +1,19 @@
-import { type CommandModule } from 'yargs';
+import { type Argv, type CommandModule } from 'yargs';
 /**
  * @internal
  */
-export type BaseArgs = Awaited<ReturnType<typeof CLIConfigurator['createBasicConfig']>['argv']>;
+export type BaseArgs = Awaited<ReturnType<typeof createBasicConfig>['argv']>;
 /**
  * @internal
  */
 export interface BaseCommand<CommandArgs extends BaseArgs = BaseArgs> extends CommandModule<BaseArgs, CommandArgs> {
 }
-/**
- * @internal
- */
-export declare class CLIConfigurator {
-    private static createBasicConfig;
-    static configure(): Promise<import("yargs").Argv<{
-        config: string[] | undefined;
-    } & {
-        contextName: string;
-    }>>;
-}
+declare function createBasicConfig(): Argv<{
+    config: string[] | undefined;
+    contextName: string;
+}>;
+export declare function configure(): Promise<Argv<{
+    config: string[] | undefined;
+    contextName: string;
+}>>;
+export {};

package/CLIConfigurator.js

@@ -1,4 +1,5 @@
-import { ConfigurationLoader, Utils } from '@mikro-orm/core';
+import { Utils } from '@mikro-orm/core';
+import { fs } from '@mikro-orm/core/fs-utils';
 import yargs from 'yargs';
 import { ClearCacheCommand } from './commands/ClearCacheCommand.js';
 import { CreateDatabaseCommand } from './commands/CreateDatabaseCommand.js';
@@ -6,69 +7,67 @@ import { CreateSeederCommand } from './commands/CreateSeederCommand.js';
 import { DatabaseSeedCommand } from './commands/DatabaseSeedCommand.js';
 import { DebugCommand } from './commands/DebugCommand.js';
 import { GenerateCacheCommand } from './commands/GenerateCacheCommand.js';
+import { CompileCommand } from './commands/CompileCommand.js';
 import { GenerateEntitiesCommand } from './commands/GenerateEntitiesCommand.js';
 import { ImportCommand } from './commands/ImportCommand.js';
 import { MigrationCommandFactory } from './commands/MigrationCommandFactory.js';
 import { SchemaCommandFactory } from './commands/SchemaCommandFactory.js';
-/**
- * @internal
- */
-export class CLIConfigurator {
-    static createBasicConfig() {
-        return yargs()
-            .scriptName('mikro-orm')
-            .usage('Usage: $0 <command> [options]')
-            .example('$0 debug', 'Show debugging information')
-            .example('$0 schema:update --run', 'Runs schema synchronization')
-            .option('config', {
-            type: 'string',
-            array: true,
-            desc: `Set path to the ORM configuration file`,
-        })
-            .option('contextName', {
-            alias: 'context',
-            type: 'string',
-            desc: 'Set name of config to load out of the ORM configuration file. Used when config file exports an array or a function',
-            default: process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default',
-        })
-            .alias('v', 'version')
-            .alias('h', 'help')
-            .recommendCommands()
-            .showHelpOnFail(true)
-            .demandCommand(1, '')
-            .strict();
-    }
-    static async configure() {
-        ConfigurationLoader.checkPackageVersion();
-        const settings = ConfigurationLoader.getSettings();
-        const version = Utils.getORMVersion();
-        if (settings.preferTs !== false) {
-            const preferTs = await ConfigurationLoader.registerTypeScriptSupport(settings.tsConfigPath);
-            /* v8 ignore next 3 */
-            if (!preferTs) {
-                process.env.MIKRO_ORM_CLI_PREFER_TS ??= '0';
-            }
+import { CLIHelper } from './CLIHelper.js';
+function createBasicConfig() {
+    return yargs()
+        .scriptName('mikro-orm')
+        .usage('Usage: $0 <command> [options]')
+        .example('$0 debug', 'Show debugging information')
+        .example('$0 schema:update --run', 'Runs schema synchronization')
+        .option('config', {
+        type: 'string',
+        array: true,
+        desc: `Set path to the ORM configuration file`,
+    })
+        .option('contextName', {
+        alias: 'context',
+        type: 'string',
+        desc: 'Set name of config to load out of the ORM configuration file. Used when config file exports an array or a function',
+        default: process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default',
+    })
+        .alias('v', 'version')
+        .alias('h', 'help')
+        .recommendCommands()
+        .showHelpOnFail(true)
+        .demandCommand(1, '')
+        .strict();
+}
+export async function configure() {
+    fs.checkPackageVersion();
+    const settings = CLIHelper.getSettings();
+    const version = Utils.getORMVersion();
+    if (settings.preferTs !== false) {
+        const preferTs = await CLIHelper.registerTypeScriptSupport(settings.tsConfigPath, settings.tsLoader);
+        /* v8 ignore next */
+        if (!preferTs) {
+            process.env.MIKRO_ORM_CLI_PREFER_TS ??= '0';
         }
-        return CLIConfigurator.createBasicConfig()
-            .version(version)
-            .command(new ClearCacheCommand())
-            .command(new GenerateCacheCommand())
-            .command(new GenerateEntitiesCommand())
-            .command(new CreateDatabaseCommand())
-            .command(new ImportCommand())
-            .command(new DatabaseSeedCommand())
-            .command(new CreateSeederCommand())
-            .command(SchemaCommandFactory.create('create'))
-            .command(SchemaCommandFactory.create('drop'))
-            .command(SchemaCommandFactory.create('update'))
-            .command(SchemaCommandFactory.create('fresh'))
-            .command(MigrationCommandFactory.create('create'))
-            .command(MigrationCommandFactory.create('up'))
-            .command(MigrationCommandFactory.create('down'))
-            .command(MigrationCommandFactory.create('list'))
-            .command(MigrationCommandFactory.create('check'))
-            .command(MigrationCommandFactory.create('pending'))
-            .command(MigrationCommandFactory.create('fresh'))
-            .command(new DebugCommand());
     }
+    return createBasicConfig()
+        .version(version)
+        .command(new ClearCacheCommand())
+        .command(new GenerateCacheCommand())
+        .command(new CompileCommand())
+        .command(new GenerateEntitiesCommand())
+        .command(new CreateDatabaseCommand())
+        .command(new ImportCommand())
+        .command(new DatabaseSeedCommand())
+        .command(new CreateSeederCommand())
+        .command(SchemaCommandFactory.create('create'))
+        .command(SchemaCommandFactory.create('drop'))
+        .command(SchemaCommandFactory.create('update'))
+        .command(SchemaCommandFactory.create('fresh'))
+        .command(MigrationCommandFactory.create('create'))
+        .command(MigrationCommandFactory.create('up'))
+        .command(MigrationCommandFactory.create('down'))
+        .command(MigrationCommandFactory.create('list'))
+        .command(MigrationCommandFactory.create('check'))
+        .command(MigrationCommandFactory.create('pending'))
+        .command(MigrationCommandFactory.create('fresh'))
+        .command(new DebugCommand());
 }

package/CLIHelper.d.ts

@@ -1,22 +1,52 @@
-import { MikroORM, type Configuration, type IDatabaseDriver, type Options } from '@mikro-orm/core';
+import { Configuration, type EntityManager, type EntityManagerType, type IDatabaseDriver, MikroORM, type Options } from '@mikro-orm/core';
 /**
  * @internal
  */
 export declare class CLIHelper {
-    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver>(contextName?: string, configPaths?: string[], options?: Partial<Options<D>>): Promise<Configuration<D>>;
+    /**
+     * Gets a named configuration
+     *
+     * @param contextName Load a config with the given `contextName` value. Used when config file exports array or factory function. Setting it to "default" matches also config objects without `contextName` set.
+     * @param paths Array of possible paths for a configuration file. Files will be checked in order, and the first existing one will be used. Defaults to the output of {@link fs.getConfigPaths}.
+     * @param options Additional options to augment the final configuration with.
+     */
+    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>>(contextName?: string, paths?: string[], options?: Partial<Options<D>>): Promise<Configuration<D, EM>>;
+    static commonJSCompat(options: Partial<Options>): void;
     static getORM<D extends IDatabaseDriver = IDatabaseDriver>(contextName?: string, configPaths?: string[], opts?: Partial<Options<D>>): Promise<MikroORM<D>>;
     static isDBConnected(config: Configuration, reason?: false): Promise<boolean>;
     static isDBConnected(config: Configuration, reason: true): Promise<true | string>;
-    static getNodeVersion(): string;
     static getDriverDependencies(config: Configuration): string[];
     static dump(text: string, config?: Configuration): void;
-    static getConfigPaths(): string[];
-    static dumpDependencies(): Promise<void>;
-    static getModuleVersion(name: string): Promise<string>;
+    static getSettings(): Settings;
+    static getConfigPaths(): Promise<string[]>;
+    private static getConfigFile;
+    private static loadEnvironmentVars;
+    static dumpDependencies(): void;
+    static getModuleVersion(name: string): string;
+    /**
+     * Resolve path to a module.
+     * @param id The module to require
+     * @param [from] Location to start the node resolution
+     */
+    private static resolveModulePath;
     static dumpTable(options: {
         columns: string[];
         rows: string[][];
         empty: string;
     }): void;
+    /**
+     * Tries to register TS support in the following order: swc, tsx, jiti, tsimp
+     * Use `MIKRO_ORM_CLI_TS_LOADER` env var to set the loader explicitly.
+     * This method is used only in CLI context.
+     */
+    static registerTypeScriptSupport(configPath?: string, tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto'): Promise<boolean>;
+    static isESM(): boolean;
     static showHelp(): void;
 }
+export interface Settings {
+    verbose?: boolean;
+    preferTs?: boolean;
+    tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto';
+    tsConfigPath?: string;
+    configPaths?: string[];
+}

package/CLIHelper.js

@@ -1,27 +1,111 @@
-import { readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import yargs from 'yargs';
-import { colors, ConfigurationLoader, MikroORM, Utils } from '@mikro-orm/core';
+import { colors, Configuration, loadEnvironmentVars, loadOptionalDependencies, MikroORM, Utils, } from '@mikro-orm/core';
+import { fs } from '@mikro-orm/core/fs-utils';
 /**
  * @internal
  */
 export class CLIHelper {
-    static async getConfiguration(contextName, configPaths, options = {}) {
-        const deps = ConfigurationLoader.getORMPackages();
+    /**
+     * Gets a named configuration
+     *
+     * @param contextName Load a config with the given `contextName` value. Used when config file exports array or factory function. Setting it to "default" matches also config objects without `contextName` set.
+     * @param paths Array of possible paths for a configuration file. Files will be checked in order, and the first existing one will be used. Defaults to the output of {@link fs.getConfigPaths}.
+     * @param options Additional options to augment the final configuration with.
+     */
+    static async getConfiguration(contextName, paths, options = {}) {
+        this.commonJSCompat(options);
+        paths ??= await this.getConfigPaths();
+        const deps = fs.getORMPackages();
         if (!deps.has('@mikro-orm/cli') && !process.env.MIKRO_ORM_ALLOW_GLOBAL_CLI) {
             throw new Error('@mikro-orm/cli needs to be installed as a local dependency!');
         }
-        ConfigurationLoader.registerDotenv(options);
-        configPaths ??= ConfigurationLoader.getConfigPaths();
         contextName ??= process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default';
-        return ConfigurationLoader.getConfiguration(contextName, configPaths, options);
+        const env = await this.loadEnvironmentVars();
+        await loadOptionalDependencies(options);
+        // oxfmt-ignore
+        const configFinder = (cfg) => {
+            return typeof cfg === 'object' && cfg !== null && ('contextName' in cfg ? cfg.contextName === contextName : contextName === 'default');
+        };
+        const isValidConfigFactoryResult = (cfg) => {
+            return typeof cfg === 'object' && cfg !== null && (!('contextName' in cfg) || cfg.contextName === contextName);
+        };
+        const result = await this.getConfigFile(paths);
+        if (!result[0]) {
+            if (Utils.hasObjectKeys(env)) {
+                return new Configuration(Utils.mergeConfig({ contextName }, options.preferEnvVars ? options : env, options.preferEnvVars ? env : options));
+            }
+            throw new Error(`MikroORM config file not found in ['${paths.join(`', '`)}']`);
+        }
+        const path = result[0];
+        let tmp = result[1];
+        if (Array.isArray(tmp)) {
+            const tmpFirstIndex = tmp.findIndex(configFinder);
+            if (tmpFirstIndex === -1) {
+                // Static config not found. Try factory functions
+                let configCandidate;
+                for (let i = 0, l = tmp.length; i < l; ++i) {
+                    const f = tmp[i];
+                    if (typeof f !== 'function') {
+                        continue;
+                    }
+                    configCandidate = await f(contextName);
+                    if (!isValidConfigFactoryResult(configCandidate)) {
+                        continue;
+                    }
+                    tmp = configCandidate;
+                    break;
+                }
+                if (Array.isArray(tmp)) {
+                    throw new Error(`MikroORM config '${contextName}' was not found within the config file '${path}'. Either add a config with this name to the array, or add a function that when given this name will return a configuration object without a name, or with name set to this name.`);
+                }
+            }
+            else {
+                const tmpLastIndex = tmp.findLastIndex(configFinder);
+                if (tmpLastIndex !== tmpFirstIndex) {
+                    throw new Error(`MikroORM config '${contextName}' is not unique within the array exported by '${path}' (first occurrence index: ${tmpFirstIndex}; last occurrence index: ${tmpLastIndex})`);
+                }
+                tmp = tmp[tmpFirstIndex];
+            }
+        }
+        else {
+            if (tmp instanceof Function) {
+                tmp = await tmp(contextName);
+                if (!isValidConfigFactoryResult(tmp)) {
+                    throw new Error(`MikroORM config '${contextName}' was not what the function exported from '${path}' provided. Ensure it returns a config object with no name, or name matching the requested one.`);
+                }
+            }
+            else {
+                if (!configFinder(tmp)) {
+                    throw new Error(`MikroORM config '${contextName}' was not what the default export from '${path}' provided.`);
+                }
+            }
+        }
+        const esmConfigOptions = this.isESM() ? { entityGenerator: { esmImport: true } } : {};
+        await loadOptionalDependencies(tmp);
+        const preferEnvVars = options.preferEnvVars ?? tmp.preferEnvVars;
+        return new Configuration(Utils.mergeConfig({}, esmConfigOptions, tmp, preferEnvVars ? options : env, preferEnvVars ? env : options));
+    }
+    static commonJSCompat(options) {
+        if (this.isESM()) {
+            return;
+        }
+        /* v8 ignore next */
+        options.dynamicImportProvider ??=
+            globalThis.dynamicImportProvider ??
+                ((id) => {
+                    return createRequire(process.cwd())(fileURLToPath(id));
+                });
+        globalThis.dynamicImportProvider = options.dynamicImportProvider;
     }
     static async getORM(contextName, configPaths, opts = {}) {
-        const options = await CLIHelper.getConfiguration(contextName, configPaths, opts);
-        const settings = ConfigurationLoader.getSettings();
+        const options = await this.getConfiguration(contextName, configPaths, opts);
+        const settings = this.getSettings();
         options.set('allowGlobalContext', true);
         options.set('debug', !!settings.verbose);
         options.getLogger().setDebugMode(!!settings.verbose);
-        options.set('connect', false);
         if (settings.preferTs !== false) {
             options.set('preferTs', true);
         }
@@ -43,9 +127,6 @@ export class CLIHelper {
             return false;
         }
     }
-    static getNodeVersion() {
-        return process.versions.node;
-    }
     static getDriverDependencies(config) {
         try {
             return config.getDriver().getDependencies();
@@ -61,21 +142,97 @@ export class CLIHelper {
         // eslint-disable-next-line no-console
         console.log(text);
     }
-    static getConfigPaths() {
-        return ConfigurationLoader.getConfigPaths();
+    static getSettings() {
+        const config = fs.getPackageConfig();
+        const settings = { ...config['mikro-orm'] };
+        const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
+        settings.preferTs =
+            process.env.MIKRO_ORM_CLI_PREFER_TS != null ? bool(process.env.MIKRO_ORM_CLI_PREFER_TS) : settings.preferTs;
+        settings.tsLoader = process.env.MIKRO_ORM_CLI_TS_LOADER ?? settings.tsLoader;
+        settings.tsConfigPath = process.env.MIKRO_ORM_CLI_TS_CONFIG_PATH ?? settings.tsConfigPath;
+        settings.verbose =
+            process.env.MIKRO_ORM_CLI_VERBOSE != null ? bool(process.env.MIKRO_ORM_CLI_VERBOSE) : settings.verbose;
+        if (process.env.MIKRO_ORM_CLI_CONFIG?.endsWith('.ts')) {
+            settings.preferTs = true;
+        }
+        return settings;
+    }
+    static async getConfigPaths() {
+        const settings = this.getSettings();
+        const typeScriptSupport = settings.preferTs ?? Utils.detectTypeScriptSupport();
+        const paths = [];
+        if (process.env.MIKRO_ORM_CLI_CONFIG) {
+            paths.push(process.env.MIKRO_ORM_CLI_CONFIG);
+        }
+        paths.push(...(settings.configPaths || []));
+        if (typeScriptSupport) {
+            paths.push('./src/mikro-orm.config.ts');
+            paths.push('./mikro-orm.config.ts');
+        }
+        const distDir = fs.pathExists(process.cwd() + '/dist');
+        const buildDir = fs.pathExists(process.cwd() + '/build');
+        /* v8 ignore next */
+        const path = distDir ? 'dist' : buildDir ? 'build' : 'src';
+        paths.push(`./${path}/mikro-orm.config.js`);
+        paths.push('./mikro-orm.config.js');
+        /* v8 ignore next */
+        return Utils.unique(paths).filter(p => !/\.[mc]?ts$/.exec(p) || typeScriptSupport);
+    }
+    static async getConfigFile(paths) {
+        for (let path of paths) {
+            path = fs.absolutePath(path);
+            path = fs.normalizePath(path);
+            if (fs.pathExists(path)) {
+                const config = await fs.dynamicImport(path);
+                /* v8 ignore next */
+                return [path, await (config.default ?? config)];
+            }
+        }
+        return [];
     }
-    static async dumpDependencies() {
+    static async loadEnvironmentVars() {
+        const ret = loadEnvironmentVars();
+        /* v8 ignore next */
+        switch (process.env.MIKRO_ORM_TYPE) {
+            case 'mongo':
+                ret.driver ??= await import('@mikro-orm/sqlite').then(m => m.SqliteDriver);
+                break;
+            case 'mysql':
+                ret.driver ??= await import('@mikro-orm/mysql').then(m => m.MySqlDriver);
+                break;
+            case 'mssql':
+                ret.driver ??= await import('@mikro-orm/mssql').then(m => m.MsSqlDriver);
+                break;
+            case 'mariadb':
+                ret.driver ??= await import('@mikro-orm/mariadb').then(m => m.MariaDbDriver);
+                break;
+            case 'postgresql':
+                ret.driver ??= await import('@mikro-orm/postgresql').then(m => m.PostgreSqlDriver);
+                break;
+            case 'sqlite':
+                ret.driver ??= await import('@mikro-orm/sqlite').then(m => m.SqliteDriver);
+                break;
+            case 'libsql':
+                ret.driver ??= await import('@mikro-orm/libsql').then(m => m.LibSqlDriver);
+                break;
+            case 'oracledb':
+                ret.driver ??= await import('@mikro-orm/oracledb').then(m => m.OracleDriver);
+                break;
+        }
+        return ret;
+    }
+    static dumpDependencies() {
         const version = Utils.getORMVersion();
         CLIHelper.dump(' - dependencies:');
         CLIHelper.dump(`   - mikro-orm ${colors.green(version)}`);
-        CLIHelper.dump(`   - node ${colors.green(CLIHelper.getNodeVersion())}`);
-        if (Utils.pathExistsSync(process.cwd() + '/package.json')) {
-            /* v8 ignore next 3 */
+        CLIHelper.dump(`   - node ${colors.green(process.versions.node)}`);
+        if (fs.pathExists(process.cwd() + '/package.json')) {
+            /* v8 ignore if */
             if (process.versions.bun) {
                 CLIHelper.dump(`   - typescript via bun`);
             }
             else {
-                CLIHelper.dump(`   - typescript ${await CLIHelper.getModuleVersion('typescript')}`);
+                CLIHelper.dump(`   - typescript ${CLIHelper.getModuleVersion('typescript')}`);
             }
             CLIHelper.dump(' - package.json ' + colors.green('found'));
         }
@@ -83,22 +240,31 @@ export class CLIHelper {
             CLIHelper.dump(' - package.json ' + colors.red('not found'));
         }
     }
-    static async getModuleVersion(name) {
+    static getModuleVersion(name) {
         try {
-            const pkg = Utils.requireFrom(`${name}/package.json`);
+            const path = `${this.resolveModulePath(name)}/package.json`;
+            const pkg = fs.readJSONSync(path);
             return colors.green(pkg.version);
         }
         catch {
-            try {
-                const path = `${Utils.resolveModulePath(name)}/package.json`;
-                const pkg = await readFile(path, { encoding: 'utf8' });
-                return colors.green(JSON.parse(pkg).version);
-            }
-            catch {
-                return '';
-            }
+            return '';
         }
     }
+    /**
+     * Resolve path to a module.
+     * @param id The module to require
+     * @param [from] Location to start the node resolution
+     */
+    static resolveModulePath(id, from = process.cwd()) {
+        if (!extname(from)) {
+            from = join(from, '__fake.js');
+        }
+        const path = fs.normalizePath(import.meta.resolve(id, pathToFileURL(from)));
+        const parts = path.split('/');
+        const idx = parts.lastIndexOf(id) + 1;
+        parts.splice(idx, parts.length - idx);
+        return parts.join('/');
+    }
     static dumpTable(options) {
         if (options.rows.length === 0) {
             return CLIHelper.dump(options.empty);
@@ -112,15 +278,69 @@ export class CLIHelper {
         });
         let ret = '';
         ret += colors.grey('┌' + lengths.map(length => '─'.repeat(length)).join('┬') + '┐\n');
-        ret += colors.grey('│') + lengths.map((length, idx) => ' ' + colors.red(options.columns[idx]) + ' '.repeat(length - options.columns[idx].length - 1)).join(colors.grey('│')) + colors.grey('│\n');
+        ret +=
+            colors.grey('│') +
+                lengths
+                    .map((length, idx) => ' ' + colors.red(options.columns[idx]) + ' '.repeat(length - options.columns[idx].length - 1))
+                    .join(colors.grey('│')) +
+                colors.grey('│\n');
         ret += colors.grey('├' + lengths.map(length => '─'.repeat(length)).join('┼') + '┤\n');
         options.rows.forEach(row => {
-            ret += colors.grey('│') + lengths.map((length, idx) => ' ' + row[idx] + ' '.repeat(length - row[idx].length - 1)).join(colors.grey('│')) + colors.grey('│\n');
+            ret +=
+                colors.grey('│') +
+                    lengths.map((length, idx) => ' ' + row[idx] + ' '.repeat(length - row[idx].length - 1)).join(colors.grey('│')) +
+                    colors.grey('│\n');
         });
         ret += colors.grey('└' + lengths.map(length => '─'.repeat(length)).join('┴') + '┘');
         CLIHelper.dump(ret);
     }
-    /* v8 ignore next 3 */
+    /**
+     * Tries to register TS support in the following order: swc, tsx, jiti, tsimp
+     * Use `MIKRO_ORM_CLI_TS_LOADER` env var to set the loader explicitly.
+     * This method is used only in CLI context.
+     */
+    static async registerTypeScriptSupport(configPath = 'tsconfig.json', tsLoader) {
+        /* v8 ignore if */
+        if (process.versions.bun) {
+            return true;
+        }
+        process.env.SWC_NODE_PROJECT ??= configPath;
+        process.env.TSIMP_PROJECT ??= configPath;
+        process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS ??= '1';
+        const explicitLoader = tsLoader ?? process.env.MIKRO_ORM_CLI_TS_LOADER ?? 'auto';
+        const setEsmImportProvider = () => {
+            return (globalThis.dynamicImportProvider = (id) => import(id).then(mod => mod?.default ?? mod));
+        };
+        const loaders = {
+            swc: { esm: '@swc-node/register/esm-register', cjs: '@swc-node/register' },
+            tsx: { esm: 'tsx/esm/api', cjs: 'tsx/cjs/api', cb: (tsx) => tsx.register({ tsconfig: configPath }) },
+            jiti: { cjs: 'jiti/register', cb: setEsmImportProvider },
+            tsimp: { cjs: 'tsimp/import', cb: setEsmImportProvider },
+        };
+        for (const loader of Utils.keys(loaders)) {
+            if (explicitLoader !== 'auto' && loader !== explicitLoader) {
+                continue;
+            }
+            const { esm, cjs, cb } = loaders[loader];
+            const isEsm = this.isESM();
+            const module = isEsm && esm ? esm : cjs;
+            const mod = await Utils.tryImport({ module });
+            if (mod) {
+                cb?.(mod);
+                process.env.MIKRO_ORM_CLI_TS_LOADER = loader;
+                return true;
+            }
+        }
+        // eslint-disable-next-line no-console
+        console.warn('Neither `swc`, `tsx`, `jiti` nor `tsimp` found in the project dependencies, support for working with TypeScript files might not work. To use `swc`, you need to install both `@swc-node/register` and `@swc/core`.');
+        return false;
+    }
+    static isESM() {
+        const config = fs.getPackageConfig();
+        const type = config?.type ?? '';
+        return type === 'module';
+    }
+    /* v8 ignore next */
     static showHelp() {
         yargs(process.argv.slice(2)).showHelp();
     }

package/README.md

@@ -2,14 +2,14 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite (including libSQL) databases. 
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
-[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
-[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
+[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
-[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
@@ -181,6 +181,7 @@ yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
+yarn add @mikro-orm/core @mikro-orm/oracledb      # for oracle
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
@@ -381,6 +382,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/cli

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { CLIHelper } from './CLIHelper.js';
-import { CLIConfigurator } from './CLIConfigurator.js';
-const argv = await CLIConfigurator.configure();
+import { configure } from './CLIConfigurator.js';
+const argv = await configure();
 const args = await argv.parse(process.argv.slice(2));
 if (args._.length === 0) {
     CLIHelper.showHelp();

package/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { CLIHelper } from './CLIHelper.js';
-import { CLIConfigurator } from './CLIConfigurator.js';
-const argv = await CLIConfigurator.configure();
+import { configure } from './CLIConfigurator.js';
+const argv = await configure();
 const args = await argv.parse(process.argv.slice(2));
 if (args._.length === 0) {
     CLIHelper.showHelp();

package/commands/CompileCommand.d.ts

@@ -0,0 +1,21 @@
+import type { ArgumentsCamelCase, Argv } from 'yargs';
+import { MetadataStorage, type Configuration } from '@mikro-orm/core';
+import type { BaseArgs, BaseCommand } from '../CLIConfigurator.js';
+type CompileArgs = BaseArgs & {
+    out?: string;
+};
+export declare class CompileCommand implements BaseCommand<CompileArgs> {
+    command: string;
+    describe: string;
+    builder: (args: Argv<BaseArgs>) => Argv<CompileArgs>;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase<CompileArgs>): Promise<void>;
+    static capture(metadata: MetadataStorage, config: Configuration): {
+        key: string;
+        contextKeys: string[];
+        code: string;
+    }[];
+}
+export {};

package/commands/CompileCommand.js

@@ -0,0 +1,94 @@
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { MetadataDiscovery, MetadataStorage, Utils, EntityComparator, ObjectHydrator, colors, } from '@mikro-orm/core';
+import { fs } from '@mikro-orm/core/fs-utils';
+import { CLIHelper } from '../CLIHelper.js';
+export class CompileCommand {
+    command = 'compile';
+    describe = 'Pre-compile optimized entity functions for runtimes that prohibit eval (e.g. Cloudflare Workers)';
+    builder = (args) => {
+        args.option('out', {
+            type: 'string',
+            desc: 'Output path for the generated file (defaults to next to your ORM config)',
+        });
+        return args;
+    };
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const config = await CLIHelper.getConfiguration(args.contextName, args.config);
+        const settings = CLIHelper.getSettings();
+        config.set('debug', !!settings.verbose);
+        const metadata = await new MetadataDiscovery(new MetadataStorage(), config.getDriver().getPlatform(), config).discover(false);
+        // Default output path to next to the ORM config file
+        if (!args.out) {
+            const configPaths = args.config ?? (await CLIHelper.getConfigPaths());
+            for (const configPath of configPaths) {
+                const absPath = fs.absolutePath(configPath);
+                if (fs.pathExists(absPath)) {
+                    args.out = resolve(dirname(absPath), 'compiled-functions.js');
+                    break;
+                }
+            }
+        }
+        const captured = CompileCommand.capture(metadata, config);
+        const entries = captured.map(({ key, contextKeys, code }) => {
+            const params = contextKeys.join(', ');
+            const indentedCode = code.replace(/\n/g, '\n    ');
+            return `  '${key}': function(${params}) {\n    ${indentedCode}\n  }`;
+        });
+        const esm = CLIHelper.isESM();
+        const version = Utils.getORMVersion();
+        const output = esm
+            ? `export default {\n  __version: '${version}',\n${entries.join(',\n')}\n};\n`
+            : `'use strict';\nmodule.exports = {\n  __version: '${version}',\n${entries.join(',\n')}\n};\n`;
+        const outPath = args.out ?? resolve(process.cwd(), 'compiled-functions.js');
+        const dtsPath = outPath.replace(/\.js$/, '.d.ts');
+        const dts = esm
+            ? `import type { CompiledFunctions } from '@mikro-orm/core';\ndeclare const compiledFunctions: CompiledFunctions;\nexport default compiledFunctions;\n`
+            : `import type { CompiledFunctions } from '@mikro-orm/core';\ndeclare const compiledFunctions: CompiledFunctions;\nexport = compiledFunctions;\n`;
+        mkdirSync(dirname(outPath), { recursive: true });
+        writeFileSync(outPath, output);
+        writeFileSync(dtsPath, dts);
+        CLIHelper.dump(colors.green(`Compiled functions generated to ${outPath} (${captured.length} functions)`));
+        CLIHelper.dump(`\nExample usage in your ORM config:\n`);
+        const importPath = esm ? './compiled-functions.js' : './compiled-functions';
+        CLIHelper.dump(`  ${esm ? 'import' : 'const'} compiledFunctions ${esm ? 'from ' : '= require('}${colors.cyan(`'${importPath}'`)}${esm ? '' : ')'};`);
+        CLIHelper.dump('');
+        CLIHelper.dump(`  export default defineConfig({ compiledFunctions });\n`);
+    }
+    static capture(metadata, config) {
+        const captured = [];
+        const original = Utils.createFunction;
+        Utils.createFunction = (context, code, _compiledFunctions, key) => {
+            captured.push({ key: key, contextKeys: [...context.keys()], code });
+            return original.call(Utils, context, code);
+        };
+        try {
+            const platform = config.getDriver().getPlatform();
+            const hydrator = new ObjectHydrator(metadata, platform, config);
+            const comparator = new EntityComparator(metadata, platform, config);
+            for (const meta of metadata) {
+                hydrator.getEntityHydrator(meta, 'full', false);
+                hydrator.getEntityHydrator(meta, 'full', true);
+                comparator.getEntityComparator(meta.class);
+                comparator.getSnapshotGenerator(meta.class);
+                comparator.getResultMapper(meta);
+                if (!meta.embeddable && !meta.virtual) {
+                    hydrator.getEntityHydrator(meta, 'reference', false);
+                    hydrator.getEntityHydrator(meta, 'reference', true);
+                }
+                if (meta.primaryKeys.length > 0) {
+                    comparator.getPkGetter(meta);
+                    comparator.getPkGetterConverted(meta);
+                    comparator.getPkSerializer(meta);
+                }
+            }
+        }
+        finally {
+            Utils.createFunction = original;
+        }
+        return captured;
+    }
+}

package/commands/CreateDatabaseCommand.js

@@ -7,8 +7,7 @@ export class CreateDatabaseCommand {
      */
     async handler(args) {
         const orm = await CLIHelper.getORM(args.contextName, args.config);
-        const schemaGenerator = orm.getSchemaGenerator();
-        await schemaGenerator.ensureDatabase();
+        await orm.schema.ensureDatabase();
         await orm.close(true);
     }
 }

package/commands/CreateSeederCommand.js

@@ -16,8 +16,7 @@ export class CreateSeederCommand {
     async handler(args) {
         const className = CreateSeederCommand.getSeederClassName(args.seeder);
         const orm = await CLIHelper.getORM(args.contextName, args.config);
-        const seeder = orm.getSeeder();
-        const path = await seeder.createSeeder(className);
+        const path = await orm.seeder.create(className);
         CLIHelper.dump(colors.green(`Seeder ${args.seeder} successfully created at ${path}`));
         await orm.close(true);
     }
@@ -25,7 +24,7 @@ export class CreateSeederCommand {
      * Will return a seeder name that is formatted like this EntitySeeder
      */
     static getSeederClassName(name) {
-        name = name.match(/(.+)seeder/i)?.[1] ?? name;
+        name = /(.+)seeder/i.exec(name)?.[1] ?? name;
         const parts = name.split('-');
         return parts.map(name => name.charAt(0).toUpperCase() + name.slice(1)).join('') + 'Seeder';
     }

package/commands/DatabaseSeedCommand.js

@@ -17,7 +17,7 @@ export class DatabaseSeedCommand {
     async handler(args) {
         const orm = await CLIHelper.getORM(args.contextName, args.config);
         const className = args.class ?? orm.config.get('seeder').defaultSeeder;
-        await orm.getSeeder().seedString(className);
+        await orm.seeder.seedString(className);
         CLIHelper.dump(colors.green(`Seeder ${className} successfully executed`));
         await orm.close(true);
     }

package/commands/DebugCommand.js

@@ -1,4 +1,5 @@
-import { ConfigurationLoader, Utils, colors } from '@mikro-orm/core';
+import { colors } from '@mikro-orm/core';
+import { fs } from '@mikro-orm/core/fs-utils';
 import { CLIHelper } from '../CLIHelper.js';
 export class DebugCommand {
     command = 'debug';
@@ -8,12 +9,13 @@ export class DebugCommand {
      */
     async handler(args) {
         CLIHelper.dump(`Current ${colors.cyan('MikroORM')} CLI configuration`);
-        await CLIHelper.dumpDependencies();
-        const settings = ConfigurationLoader.getSettings();
+        CLIHelper.dumpDependencies();
+        const settings = CLIHelper.getSettings();
         if (!process.versions.bun && settings.preferTs !== false) {
-            CLIHelper.dump(' - TypeScript support ' + colors.green('enabled'));
+            const loader = process.env.MIKRO_ORM_CLI_TS_LOADER ?? 'auto';
+            CLIHelper.dump(' - TypeScript support ' + colors.green(`enabled (${loader})`));
         }
-        const configPaths = args.config ?? CLIHelper.getConfigPaths();
+        const configPaths = args.config ?? (await CLIHelper.getConfigPaths());
         CLIHelper.dump(' - searched config paths:');
         await DebugCommand.checkPaths(configPaths, 'yellow');
         CLIHelper.dump(` - searched for config name: ${colors.green(args.contextName)}`);
@@ -23,7 +25,7 @@ export class DebugCommand {
             const drivers = CLIHelper.getDriverDependencies(config);
             CLIHelper.dump(' - driver dependencies:');
             for (const driver of drivers) {
-                CLIHelper.dump(`   - ${driver} ${await CLIHelper.getModuleVersion(driver)}`);
+                CLIHelper.dump(`   - ${driver} ${CLIHelper.getModuleVersion(driver)}`);
             }
             const isConnected = await CLIHelper.isDBConnected(config, true);
             if (isConnected === true) {
@@ -39,8 +41,8 @@ export class DebugCommand {
             }
             const entities = config.get('entities', []);
             if (entities.length > 0) {
-                const refs = entities.filter(p => !Utils.isString(p));
-                const paths = entities.filter(p => Utils.isString(p));
+                const refs = entities.filter(p => typeof p !== 'string');
+                const paths = entities.filter(p => typeof p === 'string');
                 const will = !config.get('preferTs') ? 'will' : 'could';
                 CLIHelper.dump(` - ${will} use \`entities\` array (contains ${refs.length} references and ${paths.length} paths)`);
                 if (paths.length > 0) {
@@ -49,8 +51,8 @@ export class DebugCommand {
             }
             const entitiesTs = config.get('entitiesTs', []);
             if (entitiesTs.length > 0) {
-                const refs = entitiesTs.filter(p => !Utils.isString(p));
-                const paths = entitiesTs.filter(p => Utils.isString(p));
+                const refs = entitiesTs.filter(p => typeof p !== 'string');
+                const paths = entitiesTs.filter(p => typeof p === 'string');
                 /* v8 ignore next */
                 const will = config.get('preferTs') ? 'will' : 'could';
                 CLIHelper.dump(` - ${will} use \`entitiesTs\` array (contains ${refs.length} references and ${paths.length} paths)`);
@@ -65,10 +67,9 @@ export class DebugCommand {
     }
     static async checkPaths(paths, failedColor, baseDir) {
         for (let path of paths) {
-            path = Utils.absolutePath(path, baseDir);
-            path = Utils.normalizePath(path);
-            const found = await Utils.pathExists(path);
-            if (found) {
+            path = fs.absolutePath(path, baseDir);
+            path = fs.normalizePath(path);
+            if (fs.pathExists(path)) {
                 CLIHelper.dump(`   - ${path} (${colors.green('found')})`);
             }
             else {

package/commands/GenerateCacheCommand.js

@@ -1,4 +1,5 @@
-import { MetadataDiscovery, MetadataStorage, colors, FileCacheAdapter } from '@mikro-orm/core';
+import { MetadataDiscovery, MetadataStorage, colors } from '@mikro-orm/core';
+import { FileCacheAdapter } from '@mikro-orm/core/fs-utils';
 import { CLIHelper } from '../CLIHelper.js';
 export class GenerateCacheCommand {
     command = 'cache:generate';
@@ -25,7 +26,7 @@ export class GenerateCacheCommand {
         await config.getMetadataCacheAdapter().clear();
         config.set('logger', CLIHelper.dump.bind(null));
         config.set('debug', true);
-        const discovery = new MetadataDiscovery(MetadataStorage.init(), config.getDriver().getPlatform(), config);
+        const discovery = new MetadataDiscovery(new MetadataStorage(), config.getDriver().getPlatform(), config);
         await discovery.discover(args.ts ?? false);
         const combined = args.combined && config.get('metadataCache').combined;
         CLIHelper.dump(colors.green(`${combined ? 'Combined ' : ''}${args.ts ? 'TS' : 'JS'} metadata cache was successfully generated${combined ? ' to ' + combined : ''}`));

package/commands/ImportCommand.js

@@ -1,3 +1,4 @@
+import { readFile } from 'node:fs/promises';
 import { colors } from '@mikro-orm/core';
 import { CLIHelper } from '../CLIHelper.js';
 export class ImportCommand {
@@ -8,7 +9,8 @@ export class ImportCommand {
      */
     async handler(args) {
         const orm = await CLIHelper.getORM(args.contextName, args.config, { multipleStatements: true });
-        await orm.em.getConnection().loadFile(args.file);
+        const buf = await readFile(args.file);
+        await orm.em.getConnection().executeDump(buf.toString());
         CLIHelper.dump(colors.green(`File ${args.file} successfully imported`));
         await orm.close(true);
     }

package/commands/MigrationCommandFactory.js

@@ -1,4 +1,4 @@
-import { Utils, colors } from '@mikro-orm/core';
+import { colors, Utils, } from '@mikro-orm/core';
 import { CLIHelper } from '../CLIHelper.js';
 export class MigrationCommandFactory {
     static DESCRIPTIONS = {
@@ -11,6 +11,7 @@ export class MigrationCommandFactory {
         fresh: 'Clear the database and rerun all migrations',
     };
     static create(command) {
+        // oxfmt-ignore
         return {
             command: `migration:${command}`,
             describe: MigrationCommandFactory.DESCRIPTIONS[command],
@@ -80,26 +81,25 @@ export class MigrationCommandFactory {
         // to be able to run have a master transaction, but run marked migrations outside of it, we need a second connection
         const options = { pool: { min: 1, max: 2 } };
         const orm = await CLIHelper.getORM(args.contextName, args.config, options);
-        const migrator = orm.getMigrator();
         switch (method) {
             case 'create':
-                await this.handleCreateCommand(migrator, args, orm.config);
+                await this.handleCreateCommand(orm.migrator, args, orm.config);
                 break;
             case 'check':
-                await this.handleCheckCommand(migrator, orm);
+                await this.handleCheckCommand(orm.migrator, orm);
                 break;
             case 'list':
-                await this.handleListCommand(migrator);
+                await this.handleListCommand(orm.migrator);
                 break;
             case 'pending':
-                await this.handlePendingCommand(migrator);
+                await this.handlePendingCommand(orm.migrator);
                 break;
             case 'up':
             case 'down':
-                await this.handleUpDownCommand(args, migrator, method);
+                await this.handleUpDownCommand(args, orm.migrator, method);
                 break;
             case 'fresh':
-                await this.handleFreshCommand(args, migrator, orm);
+                await this.handleFreshCommand(args, orm.migrator, orm);
         }
         await orm.close(true);
     }
@@ -121,7 +121,7 @@ export class MigrationCommandFactory {
         CLIHelper.dump(colors.green(message));
     }
     static async handlePendingCommand(migrator) {
-        const pending = await migrator.getPendingMigrations();
+        const pending = await migrator.getPending();
         CLIHelper.dumpTable({
             columns: ['Name'],
             rows: pending.map(row => [row.name]),
@@ -129,7 +129,7 @@ export class MigrationCommandFactory {
         });
     }
     static async handleListCommand(migrator) {
-        const executed = await migrator.getExecutedMigrations();
+        const executed = await migrator.getExecuted();
         CLIHelper.dumpTable({
             columns: ['Name', 'Executed at'],
             rows: executed.map(row => {
@@ -141,7 +141,7 @@ export class MigrationCommandFactory {
         });
     }
     static async handleCreateCommand(migrator, args, config) {
-        const ret = await migrator.createMigration(args.path, args.blank, args.initial, args.name);
+        const ret = await migrator.create(args.path, args.blank, args.initial, args.name);
         if (ret.diff.up.length === 0) {
             return CLIHelper.dump(colors.green(`No changes required, schema is up-to-date`));
         }
@@ -149,19 +149,20 @@ export class MigrationCommandFactory {
             CLIHelper.dump(colors.green('Creating migration with following queries:'));
             CLIHelper.dump(colors.green('up:'));
             CLIHelper.dump(ret.diff.up.map(sql => '  ' + sql).join('\n'), config);
-            /* v8 ignore next 3 */
+            /* v8 ignore if */
             if (config.getDriver().getPlatform().supportsDownMigrations()) {
                 CLIHelper.dump(colors.green('down:'));
                 CLIHelper.dump(ret.diff.down.map(sql => '  ' + sql).join('\n'), config);
             }
             else {
+                /* v8 ignore next */
                 CLIHelper.dump(colors.yellow(`(${config.getDriver().constructor.name} does not support automatic down migrations)`));
             }
         }
         CLIHelper.dump(colors.green(`${ret.fileName} successfully created`));
     }
     static async handleCheckCommand(migrator, orm) {
-        if (!(await migrator.checkMigrationNeeded())) {
+        if (!(await migrator.checkSchema())) {
             return CLIHelper.dump(colors.green(`No changes required, schema is up-to-date`));
         }
         await orm.close(true);
@@ -169,17 +170,15 @@ export class MigrationCommandFactory {
         process.exit(1);
     }
     static async handleFreshCommand(args, migrator, orm) {
-        const generator = orm.getSchemaGenerator();
-        await generator.dropSchema({ dropMigrationsTable: true, dropDb: args.dropDb });
+        await orm.schema.drop({ dropMigrationsTable: true, dropDb: args.dropDb });
         CLIHelper.dump(colors.green('Dropped schema successfully'));
         const opts = MigrationCommandFactory.getUpDownOptions(args);
         await migrator.up(opts);
         const message = this.getUpDownSuccessMessage('up', opts);
         CLIHelper.dump(colors.green(message));
         if (args.seed !== undefined) {
-            const seeder = orm.getSeeder();
             const seederClass = args.seed || orm.config.get('seeder').defaultSeeder;
-            await seeder.seedString(seederClass);
+            await orm.seeder.seedString(seederClass);
             CLIHelper.dump(colors.green(`Database seeded successfully with seeder class ${seederClass}`));
         }
     }
@@ -188,7 +187,7 @@ export class MigrationCommandFactory {
             return { migrations: flags.only.split(/[, ]+/) };
         }
         const ret = {};
-        ['from', 'to'].filter(k => flags[k]).forEach(k => ret[k] = flags[k] === '0' ? 0 : flags[k]);
+        ['from', 'to'].filter(k => flags[k]).forEach(k => (ret[k] = flags[k] === '0' ? 0 : flags[k]));
         return ret;
     }
     static getUpDownSuccessMessage(method, options) {
@@ -203,10 +202,10 @@ export class MigrationCommandFactory {
         if (method === 'up' && Utils.isEmpty(options)) {
             return msg + ' to the latest version';
         }
-        if (Utils.isString(options.to)) {
+        if (typeof options.to === 'string') {
             return msg + ' to version ' + options.to;
         }
-        if (options.migrations && options.migrations.length === 1) {
+        if (options.migrations?.length === 1) {
             return msg + ' to version ' + options.migrations[0];
         }
         return msg;

package/commands/SchemaCommandFactory.js

@@ -80,12 +80,11 @@ export class SchemaCommandFactory {
             return CLIHelper.showHelp();
         }
         const orm = await CLIHelper.getORM(args.contextName, args.config);
-        const generator = orm.getSchemaGenerator();
         const params = { wrap: args.fkChecks == null ? undefined : !args.fkChecks, ...args };
         if (args.dump) {
-            const m = `get${method.substr(0, 1).toUpperCase()}${method.substr(1)}SchemaSQL`;
-            const dump = await generator[m](params);
-            /* v8 ignore next 3 */
+            const m = `get${method.substring(0, 1).toUpperCase()}${method.substring(1)}SchemaSQL`;
+            const dump = await orm.schema[m](params);
+            /* v8 ignore if */
             if (dump) {
                 CLIHelper.dump(dump, orm.config);
                 successMessage = '';
@@ -95,16 +94,13 @@ export class SchemaCommandFactory {
             }
         }
         else if (method === 'fresh') {
-            await generator.dropSchema(params);
-            await generator.createSchema(params);
+            await orm.schema.refresh(params);
         }
         else {
-            const m = method + 'Schema';
-            await generator[m](params);
+            await orm.schema[method](params);
         }
         if (typeof args.seed !== 'undefined') {
-            const seeder = orm.getSeeder();
-            await seeder.seedString(args.seed || orm.config.get('seeder').defaultSeeder);
+            await orm.seeder.seedString(args.seed || orm.config.get('seeder').defaultSeeder);
         }
         CLIHelper.dump(colors.green(successMessage));
         await orm.close(true);

package/package.json

@@ -1,65 +1,60 @@
 {
   "name": "@mikro-orm/cli",
-  "type": "module",
-  "version": "7.0.0-dev.33",
+  "version": "7.0.0-dev.331",
   "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",
-    ".": "./index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
   "bin": {
     "mikro-orm": "./cli"
   },
-  "engines": {
-    "node": ">= 22.11.0"
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
-    "@mikro-orm/core": "7.0.0-dev.33",
-    "@mikro-orm/knex": "7.0.0-dev.33",
+    "@mikro-orm/core": "7.0.0-dev.331",
+    "mikro-orm": "7.0.0-dev.331",
     "yargs": "17.7.2"
   },
-  "devDependencies": {
-    "@mikro-orm/entity-generator": "^6.5.7",
-    "@mikro-orm/migrations": "^6.5.7",
-    "@mikro-orm/seeder": "^6.5.7"
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }