@mikro-orm/cli 7.0.0-dev.1 → 7.0.0-dev.100

package/CLIConfigurator.d.ts

@@ -1,21 +1,21 @@
-import yargs, { type CommandModule } from 'yargs';
+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(): 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,78 +1,71 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLIConfigurator = void 0;
-const core_1 = require("@mikro-orm/core");
-const yargs_1 = __importDefault(require("yargs"));
-const ClearCacheCommand_1 = require("./commands/ClearCacheCommand");
-const CreateDatabaseCommand_1 = require("./commands/CreateDatabaseCommand");
-const CreateSeederCommand_1 = require("./commands/CreateSeederCommand");
-const DatabaseSeedCommand_1 = require("./commands/DatabaseSeedCommand");
-const DebugCommand_1 = require("./commands/DebugCommand");
-const GenerateCacheCommand_1 = require("./commands/GenerateCacheCommand");
-const GenerateEntitiesCommand_1 = require("./commands/GenerateEntitiesCommand");
-const ImportCommand_1 = require("./commands/ImportCommand");
-const MigrationCommandFactory_1 = require("./commands/MigrationCommandFactory");
-const SchemaCommandFactory_1 = require("./commands/SchemaCommandFactory");
-/**
- * @internal
- */
-class CLIConfigurator {
-    static createBasicConfig() {
-        return yargs_1.default
-            .scriptName('mikro-orm')
-            .usage('Usage: $0 <command> [options]')
-            .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()
-            .strict();
-    }
-    static configure() {
-        core_1.ConfigurationLoader.checkPackageVersion();
-        const settings = core_1.ConfigurationLoader.getSettings();
-        const version = core_1.Utils.getORMVersion();
-        if (settings.useTsNode !== false) {
-            const preferTs = core_1.ConfigurationLoader.registerTsNode(settings.tsConfigPath);
-            /* istanbul ignore if */
-            if (!preferTs) {
-                process.env.MIKRO_ORM_CLI_USE_TS_NODE ??= '0';
-            }
+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';
+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 { GenerateEntitiesCommand } from './commands/GenerateEntitiesCommand.js';
+import { ImportCommand } from './commands/ImportCommand.js';
+import { MigrationCommandFactory } from './commands/MigrationCommandFactory.js';
+import { SchemaCommandFactory } from './commands/SchemaCommandFactory.js';
+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_1.ClearCacheCommand())
-            .command(new GenerateCacheCommand_1.GenerateCacheCommand())
-            .command(new GenerateEntitiesCommand_1.GenerateEntitiesCommand())
-            .command(new CreateDatabaseCommand_1.CreateDatabaseCommand())
-            .command(new ImportCommand_1.ImportCommand())
-            .command(new DatabaseSeedCommand_1.DatabaseSeedCommand())
-            .command(new CreateSeederCommand_1.CreateSeederCommand())
-            .command(SchemaCommandFactory_1.SchemaCommandFactory.create('create'))
-            .command(SchemaCommandFactory_1.SchemaCommandFactory.create('drop'))
-            .command(SchemaCommandFactory_1.SchemaCommandFactory.create('update'))
-            .command(SchemaCommandFactory_1.SchemaCommandFactory.create('fresh'))
-            .command(MigrationCommandFactory_1.MigrationCommandFactory.create('create'))
-            .command(MigrationCommandFactory_1.MigrationCommandFactory.create('up'))
-            .command(MigrationCommandFactory_1.MigrationCommandFactory.create('down'))
-            .command(MigrationCommandFactory_1.MigrationCommandFactory.create('list'))
-            .command(MigrationCommandFactory_1.MigrationCommandFactory.create('check'))
-            .command(MigrationCommandFactory_1.MigrationCommandFactory.create('pending'))
-            .command(MigrationCommandFactory_1.MigrationCommandFactory.create('fresh'))
-            .command(new DebugCommand_1.DebugCommand());
     }
+    return 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());
 }
-exports.CLIConfigurator = CLIConfigurator;

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,35 +1,108 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLIHelper = void 0;
-const fs_extra_1 = require("fs-extra");
-const yargs_1 = __importDefault(require("yargs"));
-const core_1 = require("@mikro-orm/core");
+import { extname, join } from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import yargs from 'yargs';
+import { colors, Configuration, loadEnvironmentVars, lookupExtensions, MikroORM, Utils, } from '@mikro-orm/core';
+import { fs } from '@mikro-orm/core/fs-utils';
 /**
  * @internal
  */
-class CLIHelper {
-    static async getConfiguration(contextName, configPaths, options = {}) {
-        const deps = core_1.ConfigurationLoader.getORMPackages();
+export class CLIHelper {
+    /**
+     * 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!');
         }
-        core_1.ConfigurationLoader.commonJSCompat(options);
-        core_1.ConfigurationLoader.registerDotenv(options);
-        configPaths ??= core_1.ConfigurationLoader.getConfigPaths();
         contextName ??= process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default';
-        return core_1.ConfigurationLoader.getConfiguration(contextName, configPaths, options);
+        const env = await this.loadEnvironmentVars();
+        await lookupExtensions(options);
+        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, env));
+            }
+            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 lookupExtensions(tmp);
+        return new Configuration(Utils.mergeConfig({}, esmConfigOptions, tmp, options, env));
+    }
+    static commonJSCompat(options) {
+        if (this.isESM()) {
+            return;
+        }
+        /* v8 ignore next */
+        Utils.dynamicImportProvider = options.dynamicImportProvider ??= id => {
+            id = fileURLToPath(id);
+            return createRequire(process.cwd())(id);
+        };
     }
     static async getORM(contextName, configPaths, opts = {}) {
-        const options = await CLIHelper.getConfiguration(contextName, configPaths, opts);
-        const settings = core_1.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.useTsNode !== false) {
+        if (settings.preferTs !== false) {
             options.set('preferTs', true);
         }
         // The only times when we don't care to have a warning about no entities is also the time when we ignore entities.
@@ -37,7 +110,7 @@ class CLIHelper {
             options.set('entities', []);
             options.set('entitiesTs', []);
         }
-        return core_1.MikroORM.init(options.getAll());
+        return MikroORM.init(options.getAll());
     }
     static async isDBConnected(config, reason = false) {
         try {
@@ -50,9 +123,6 @@ class CLIHelper {
             return false;
         }
     }
-    static getNodeVersion() {
-        return process.versions.node;
-    }
     static getDriverDependencies(config) {
         try {
             return config.getDriver().getDependencies();
@@ -68,36 +138,123 @@ class CLIHelper {
         // eslint-disable-next-line no-console
         console.log(text);
     }
-    static getConfigPaths() {
-        return core_1.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 => !p.match(/\.[mc]?ts$/) || typeScriptSupport);
+    }
+    static async getConfigFile(paths) {
+        for (let path of paths) {
+            path = Utils.absolutePath(path);
+            path = Utils.normalizePath(path);
+            if (fs.pathExists(path)) {
+                const config = await Utils.dynamicImport(path);
+                /* v8 ignore next */
+                return [path, await (config.default ?? config)];
+            }
+        }
+        return [];
+    }
+    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 async dumpDependencies() {
-        const version = core_1.Utils.getORMVersion();
+    static dumpDependencies() {
+        const version = Utils.getORMVersion();
         CLIHelper.dump(' - dependencies:');
-        CLIHelper.dump(`   - mikro-orm ${core_1.colors.green(version)}`);
-        CLIHelper.dump(`   - node ${core_1.colors.green(CLIHelper.getNodeVersion())}`);
-        if ((0, fs_extra_1.pathExistsSync)(process.cwd() + '/package.json')) {
-            /* istanbul ignore next */
+        CLIHelper.dump(`   - mikro-orm ${colors.green(version)}`);
+        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 ' + core_1.colors.green('found'));
+            CLIHelper.dump(' - package.json ' + colors.green('found'));
         }
         else {
-            CLIHelper.dump(' - package.json ' + core_1.colors.red('not found'));
+            CLIHelper.dump(' - package.json ' + colors.red('not found'));
         }
     }
-    static async getModuleVersion(name) {
+    static getModuleVersion(name) {
         try {
-            const pkg = core_1.Utils.requireFrom(`${name}/package.json`);
-            return core_1.colors.green(pkg.version);
+            const path = `${this.resolveModulePath(name)}/package.json`;
+            const pkg = fs.readJSONSync(path);
+            return colors.green(pkg.version);
         }
         catch {
-            return core_1.colors.red('not-found');
+            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 = Utils.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) {
@@ -111,18 +268,61 @@ class CLIHelper {
             });
         });
         let ret = '';
-        ret += core_1.colors.grey('┌' + lengths.map(length => '─'.repeat(length)).join('┬') + '┐\n');
-        ret += core_1.colors.grey('│') + lengths.map((length, idx) => ' ' + core_1.colors.red(options.columns[idx]) + ' '.repeat(length - options.columns[idx].length - 1)).join(core_1.colors.grey('│')) + core_1.colors.grey('│\n');
-        ret += core_1.colors.grey('├' + lengths.map(length => '─'.repeat(length)).join('┼') + '┤\n');
+        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 => '─'.repeat(length)).join('┼') + '┤\n');
         options.rows.forEach(row => {
-            ret += core_1.colors.grey('│') + lengths.map((length, idx) => ' ' + row[idx] + ' '.repeat(length - row[idx].length - 1)).join(core_1.colors.grey('│')) + core_1.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 += core_1.colors.grey('└' + lengths.map(length => '─'.repeat(length)).join('┴') + '┘');
+        ret += colors.grey('└' + lengths.map(length => '─'.repeat(length)).join('┴') + '┘');
         CLIHelper.dump(ret);
     }
-    /* istanbul ignore next */
+    /**
+     * 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 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: { esm: 'jiti/register', cjs: 'jiti/register', cb: () => Utils.dynamicImportProvider = id => import(id).then(mod => mod?.default ?? mod) },
+            tsimp: { esm: 'tsimp/import', cjs: 'tsimp/import' },
+        };
+        for (const loader of Utils.keys(loaders)) {
+            if (explicitLoader !== 'auto' && loader !== explicitLoader) {
+                continue;
+            }
+            const { esm, cjs, cb } = loaders[loader];
+            const isEsm = this.isESM();
+            /* v8 ignore next */
+            const module = isEsm ? 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_1.default.showHelp();
+        yargs(process.argv.slice(2)).showHelp();
     }
 }
-exports.CLIHelper = CLIHelper;

package/README.md

@@ -11,7 +11,6 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 [![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)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
-[![Maintainability](https://api.codeclimate.com/v1/badges/27999651d3adc47cfa40/maintainability)](https://codeclimate.com/github/mikro-orm/mikro-orm/maintainability)
 [![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)
 
 ## 🤔 Unit of What?
@@ -141,7 +140,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
 - [Filters](https://mikro-orm.io/docs/filters)
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
-- [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
+- [Populating relations](https://mikro-orm.io/docs/populating-relations)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
 - [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)
@@ -382,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).