@mikro-orm/cli 7.0.0-dev.31 → 7.0.0-dev.310

package/CLIConfigurator.d.ts

@@ -2,20 +2,20 @@ import { 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(): import("yargs").Argv<{
+    config: string[] | undefined;
+} & {
+    contextName: string;
+}>;
+export declare function configure(): Promise<import("yargs").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,94 @@ 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;
+        }
+        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 +237,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 +275,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

@@ -6,10 +6,10 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 
 > 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)
 
@@ -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/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 {};