@mikro-orm/cli 7.0.4 → 7.0.5-dev.1

package/commands/DebugCommand.js

@@ -2,82 +2,79 @@ import { colors } from '@mikro-orm/core';
 import { fs } from '@mikro-orm/core/fs-utils';
 import { CLIHelper } from '../CLIHelper.js';
 export class DebugCommand {
-  command = 'debug';
-  describe = 'Debug CLI configuration';
-  /**
-   * @inheritDoc
-   */
-  async handler(args) {
-    CLIHelper.dump(`Current ${colors.cyan('MikroORM')} CLI configuration`);
-    CLIHelper.dumpDependencies();
-    const settings = CLIHelper.getSettings();
-    if (!process.versions.bun && settings.preferTs !== false) {
-      const loader = process.env.MIKRO_ORM_CLI_TS_LOADER ?? 'auto';
-      CLIHelper.dump(' - TypeScript support ' + colors.green(`enabled (${loader})`));
-    }
-    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)}`);
-    try {
-      const config = await CLIHelper.getConfiguration(args.contextName, configPaths);
-      CLIHelper.dump(` - configuration ${colors.green('found')}`);
-      const drivers = CLIHelper.getDriverDependencies(config);
-      CLIHelper.dump(' - driver dependencies:');
-      for (const driver of drivers) {
-        CLIHelper.dump(`   - ${driver} ${CLIHelper.getModuleVersion(driver)}`);
-      }
-      const isConnected = await CLIHelper.isDBConnected(config, true);
-      if (isConnected === true) {
-        CLIHelper.dump(` - ${colors.green('database connection successful')}`);
-      } else {
-        CLIHelper.dump(` - ${colors.yellow(`database connection failed (${isConnected})`)}`);
-      }
-      const preferTs = config.get('preferTs');
-      if ([true, false].includes(preferTs)) {
-        const warning = preferTs ? ' (this value should be set to `false` when running compiled code!)' : '';
-        CLIHelper.dump(
-          ` - \`preferTs\` flag explicitly set to ${preferTs}, will use \`entities${preferTs ? 'Ts' : ''}\` array${warning}`,
-        );
-      }
-      const entities = config.get('entities', []);
-      if (entities.length > 0) {
-        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) {
-          await DebugCommand.checkPaths(paths, 'red', config.get('baseDir'));
+    command = 'debug';
+    describe = 'Debug CLI configuration';
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        CLIHelper.dump(`Current ${colors.cyan('MikroORM')} CLI configuration`);
+        CLIHelper.dumpDependencies();
+        const settings = CLIHelper.getSettings();
+        if (!process.versions.bun && settings.preferTs !== false) {
+            const loader = process.env.MIKRO_ORM_CLI_TS_LOADER ?? 'auto';
+            CLIHelper.dump(' - TypeScript support ' + colors.green(`enabled (${loader})`));
+        }
+        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)}`);
+        try {
+            const config = await CLIHelper.getConfiguration(args.contextName, configPaths);
+            CLIHelper.dump(` - configuration ${colors.green('found')}`);
+            const drivers = CLIHelper.getDriverDependencies(config);
+            CLIHelper.dump(' - driver dependencies:');
+            for (const driver of drivers) {
+                CLIHelper.dump(`   - ${driver} ${CLIHelper.getModuleVersion(driver)}`);
+            }
+            const isConnected = await CLIHelper.isDBConnected(config, true);
+            if (isConnected === true) {
+                CLIHelper.dump(` - ${colors.green('database connection successful')}`);
+            }
+            else {
+                CLIHelper.dump(` - ${colors.yellow(`database connection failed (${isConnected})`)}`);
+            }
+            const preferTs = config.get('preferTs');
+            if ([true, false].includes(preferTs)) {
+                const warning = preferTs ? ' (this value should be set to `false` when running compiled code!)' : '';
+                CLIHelper.dump(` - \`preferTs\` flag explicitly set to ${preferTs}, will use \`entities${preferTs ? 'Ts' : ''}\` array${warning}`);
+            }
+            const entities = config.get('entities', []);
+            if (entities.length > 0) {
+                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) {
+                    await DebugCommand.checkPaths(paths, 'red', config.get('baseDir'));
+                }
+            }
+            const entitiesTs = config.get('entitiesTs', []);
+            if (entitiesTs.length > 0) {
+                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)`);
+                if (paths.length > 0) {
+                    await DebugCommand.checkPaths(paths, 'red', config.get('baseDir'));
+                }
+            }
         }
-      }
-      const entitiesTs = config.get('entitiesTs', []);
-      if (entitiesTs.length > 0) {
-        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)`,
-        );
-        if (paths.length > 0) {
-          await DebugCommand.checkPaths(paths, 'red', config.get('baseDir'));
+        catch (e) {
+            CLIHelper.dump(`- configuration ${colors.red('not found')} ${colors.red(`(${e.message})`)}`);
         }
-      }
-    } catch (e) {
-      CLIHelper.dump(`- configuration ${colors.red('not found')} ${colors.red(`(${e.message})`)}`);
     }
-  }
-  static async checkPaths(paths, failedColor, baseDir) {
-    for (let path of paths) {
-      path = fs.absolutePath(path, baseDir);
-      path = fs.normalizePath(path);
-      if (fs.pathExists(path)) {
-        CLIHelper.dump(`   - ${path} (${colors.green('found')})`);
-      } else {
-        CLIHelper.dump(`   - ${path} (${colors[failedColor]('not found')})`);
-      }
+    static async checkPaths(paths, failedColor, baseDir) {
+        for (let path of paths) {
+            path = fs.absolutePath(path, baseDir);
+            path = fs.normalizePath(path);
+            if (fs.pathExists(path)) {
+                CLIHelper.dump(`   - ${path} (${colors.green('found')})`);
+            }
+            else {
+                CLIHelper.dump(`   - ${path} (${colors[failedColor]('not found')})`);
+            }
+        }
     }
-  }
 }

package/commands/GenerateCacheCommand.d.ts

@@ -1,16 +1,16 @@
 import type { ArgumentsCamelCase, Argv } from 'yargs';
 import type { BaseArgs, BaseCommand } from '../CLIConfigurator.js';
 type CacheArgs = BaseArgs & {
-  ts?: boolean;
-  combined?: string;
+    ts?: boolean;
+    combined?: string;
 };
 export declare class GenerateCacheCommand implements BaseCommand<CacheArgs> {
-  command: string;
-  describe: string;
-  builder: (args: Argv<BaseArgs>) => Argv<CacheArgs>;
-  /**
-   * @inheritDoc
-   */
-  handler(args: ArgumentsCamelCase<CacheArgs>): Promise<void>;
+    command: string;
+    describe: string;
+    builder: (args: Argv<BaseArgs>) => Argv<CacheArgs>;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase<CacheArgs>): Promise<void>;
 }
 export {};

package/commands/GenerateCacheCommand.js

@@ -2,37 +2,33 @@ 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';
-  describe = 'Generate metadata cache';
-  builder = args => {
-    args.option('ts', {
-      type: 'boolean',
-      desc: `Generate development cache for '.ts' files`,
-    });
-    args.option('combined', {
-      alias: 'c',
-      desc: `Generate production cache into a single JSON file that can be used with the GeneratedCacheAdapter.`,
-    });
-    return args;
-  };
-  /**
-   * @inheritDoc
-   */
-  async handler(args) {
-    const options = args.combined ? { combined: './metadata.json' } : {};
-    const config = await CLIHelper.getConfiguration(args.contextName, args.config, {
-      metadataCache: { enabled: true, adapter: FileCacheAdapter, options },
-    });
-    await config.getMetadataCacheAdapter().clear();
-    config.set('logger', CLIHelper.dump.bind(null));
-    config.set('debug', true);
-    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 : ''}`,
-      ),
-    );
-  }
+    command = 'cache:generate';
+    describe = 'Generate metadata cache';
+    builder = (args) => {
+        args.option('ts', {
+            type: 'boolean',
+            desc: `Generate development cache for '.ts' files`,
+        });
+        args.option('combined', {
+            alias: 'c',
+            desc: `Generate production cache into a single JSON file that can be used with the GeneratedCacheAdapter.`,
+        });
+        return args;
+    };
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const options = args.combined ? { combined: './metadata.json' } : {};
+        const config = await CLIHelper.getConfiguration(args.contextName, args.config, {
+            metadataCache: { enabled: true, adapter: FileCacheAdapter, options },
+        });
+        await config.getMetadataCacheAdapter().clear();
+        config.set('logger', CLIHelper.dump.bind(null));
+        config.set('debug', true);
+        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/GenerateEntitiesCommand.d.ts

@@ -1,20 +1,20 @@
 import type { ArgumentsCamelCase, Argv } from 'yargs';
 import type { BaseArgs, BaseCommand } from '../CLIConfigurator.js';
 export type GenerateEntitiesArgs = BaseArgs & {
-  dump?: boolean;
-  save?: boolean;
-  path?: string;
-  schema?: string;
+    dump?: boolean;
+    save?: boolean;
+    path?: string;
+    schema?: string;
 };
 export declare class GenerateEntitiesCommand implements BaseCommand<GenerateEntitiesArgs> {
-  command: string;
-  describe: string;
-  /**
-   * @inheritDoc
-   */
-  builder(args: Argv): Argv<GenerateEntitiesArgs>;
-  /**
-   * @inheritDoc
-   */
-  handler(args: ArgumentsCamelCase<GenerateEntitiesArgs>): Promise<void>;
+    command: string;
+    describe: string;
+    /**
+     * @inheritDoc
+     */
+    builder(args: Argv): Argv<GenerateEntitiesArgs>;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase<GenerateEntitiesArgs>): Promise<void>;
 }

package/commands/GenerateEntitiesCommand.js

@@ -1,48 +1,48 @@
 import { CLIHelper } from '../CLIHelper.js';
 export class GenerateEntitiesCommand {
-  command = 'generate-entities';
-  describe = 'Generate entities based on current database schema';
-  /**
-   * @inheritDoc
-   */
-  builder(args) {
-    args.option('s', {
-      alias: 'save',
-      type: 'boolean',
-      desc: 'Saves entities to directory defined by --path',
-    });
-    args.option('d', {
-      alias: 'dump',
-      type: 'boolean',
-      desc: 'Dumps all entities to console',
-    });
-    args.option('p', {
-      alias: 'path',
-      type: 'string',
-      desc: 'Sets path to directory where to save entities',
-    });
-    args.option('schema', {
-      type: 'string',
-      desc: 'Generates entities only for given schema',
-    });
-    return args;
-  }
-  /**
-   * @inheritDoc
-   */
-  async handler(args) {
-    if (!args.save && !args.dump) {
-      return CLIHelper.showHelp();
+    command = 'generate-entities';
+    describe = 'Generate entities based on current database schema';
+    /**
+     * @inheritDoc
+     */
+    builder(args) {
+        args.option('s', {
+            alias: 'save',
+            type: 'boolean',
+            desc: 'Saves entities to directory defined by --path',
+        });
+        args.option('d', {
+            alias: 'dump',
+            type: 'boolean',
+            desc: 'Dumps all entities to console',
+        });
+        args.option('p', {
+            alias: 'path',
+            type: 'string',
+            desc: 'Sets path to directory where to save entities',
+        });
+        args.option('schema', {
+            type: 'string',
+            desc: 'Generates entities only for given schema',
+        });
+        return args;
     }
-    const orm = await CLIHelper.getORM(args.contextName, args.config, { discovery: { warnWhenNoEntities: false } });
-    const dump = await orm.entityGenerator.generate({
-      save: args.save,
-      path: args.path,
-      schema: args.schema,
-    });
-    if (args.dump) {
-      CLIHelper.dump(dump.join('\n\n'));
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        if (!args.save && !args.dump) {
+            return CLIHelper.showHelp();
+        }
+        const orm = await CLIHelper.getORM(args.contextName, args.config, { discovery: { warnWhenNoEntities: false } });
+        const dump = await orm.entityGenerator.generate({
+            save: args.save,
+            path: args.path,
+            schema: args.schema,
+        });
+        if (args.dump) {
+            CLIHelper.dump(dump.join('\n\n'));
+        }
+        await orm.close(true);
     }
-    await orm.close(true);
-  }
 }

package/commands/ImportCommand.d.ts

@@ -1,14 +1,14 @@
 import type { ArgumentsCamelCase } from 'yargs';
 import type { BaseArgs, BaseCommand } from '../CLIConfigurator.js';
 type ImportArgs = BaseArgs & {
-  file: string;
+    file: string;
 };
 export declare class ImportCommand implements BaseCommand<ImportArgs> {
-  command: string;
-  describe: string;
-  /**
-   * @inheritDoc
-   */
-  handler(args: ArgumentsCamelCase<ImportArgs>): Promise<void>;
+    command: string;
+    describe: string;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase<ImportArgs>): Promise<void>;
 }
 export {};

package/commands/ImportCommand.js

@@ -2,16 +2,16 @@ import { readFile } from 'node:fs/promises';
 import { colors } from '@mikro-orm/core';
 import { CLIHelper } from '../CLIHelper.js';
 export class ImportCommand {
-  command = 'database:import <file>';
-  describe = 'Imports the SQL file to the database';
-  /**
-   * @inheritDoc
-   */
-  async handler(args) {
-    const orm = await CLIHelper.getORM(args.contextName, args.config, { multipleStatements: true });
-    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);
-  }
+    command = 'database:import <file>';
+    describe = 'Imports the SQL file to the database';
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const orm = await CLIHelper.getORM(args.contextName, args.config, { multipleStatements: true });
+        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.d.ts

@@ -1,72 +1,67 @@
 import type { ArgumentsCamelCase, Argv } from 'yargs';
 import type { BaseArgs } from '../CLIConfigurator.js';
 export declare class MigrationCommandFactory {
-  static readonly DESCRIPTIONS: {
-    create: string;
-    up: string;
-    down: string;
-    list: string;
-    check: string;
-    pending: string;
-    fresh: string;
-  };
-  static create<const T extends MigratorMethod>(
-    command: T,
-  ): {
-    command: string;
-    describe: {
-      create: string;
-      up: string;
-      down: string;
-      list: string;
-      check: string;
-      pending: string;
-      fresh: string;
-    }[T];
-    builder: (args: Argv<BaseArgs>) => Argv<MigrationOptionsMap[T]>;
-    handler: (args: ArgumentsCamelCase<MigrationOptionsMap[T]>) => Promise<void>;
-  };
-  static configureMigrationCommand<const T extends MigratorMethod>(
-    args: Argv<BaseArgs>,
-    method: T,
-  ): Argv<MigrationOptionsMap[T]>;
-  private static configureUpDownCommand;
-  private static configureCreateCommand;
-  static handleMigrationCommand(args: ArgumentsCamelCase<Opts>, method: MigratorMethod): Promise<void>;
-  private static configureFreshCommand;
-  private static handleUpDownCommand;
-  private static handlePendingCommand;
-  private static handleListCommand;
-  private static handleCreateCommand;
-  private static handleCheckCommand;
-  private static handleFreshCommand;
-  private static getUpDownOptions;
-  private static getUpDownSuccessMessage;
+    static readonly DESCRIPTIONS: {
+        create: string;
+        up: string;
+        down: string;
+        list: string;
+        check: string;
+        pending: string;
+        fresh: string;
+    };
+    static create<const T extends MigratorMethod>(command: T): {
+        command: string;
+        describe: {
+            create: string;
+            up: string;
+            down: string;
+            list: string;
+            check: string;
+            pending: string;
+            fresh: string;
+        }[T];
+        builder: (args: Argv<BaseArgs>) => Argv<MigrationOptionsMap[T]>;
+        handler: (args: ArgumentsCamelCase<MigrationOptionsMap[T]>) => Promise<void>;
+    };
+    static configureMigrationCommand<const T extends MigratorMethod>(args: Argv<BaseArgs>, method: T): Argv<MigrationOptionsMap[T]>;
+    private static configureUpDownCommand;
+    private static configureCreateCommand;
+    static handleMigrationCommand(args: ArgumentsCamelCase<Opts>, method: MigratorMethod): Promise<void>;
+    private static configureFreshCommand;
+    private static handleUpDownCommand;
+    private static handlePendingCommand;
+    private static handleListCommand;
+    private static handleCreateCommand;
+    private static handleCheckCommand;
+    private static handleFreshCommand;
+    private static getUpDownOptions;
+    private static getUpDownSuccessMessage;
 }
 type CliUpDownOptions = BaseArgs & {
-  to?: string | number;
-  from?: string | number;
-  only?: string;
+    to?: string | number;
+    from?: string | number;
+    only?: string;
 };
 type MigratorFreshOptions = BaseArgs & {
-  dropDb?: boolean;
-  seed?: string;
+    dropDb?: boolean;
+    seed?: string;
 };
 type MigratorCreateOptions = BaseArgs & {
-  blank?: boolean;
-  initial?: boolean;
-  path?: string;
-  dump?: boolean;
-  name?: string;
+    blank?: boolean;
+    initial?: boolean;
+    path?: string;
+    dump?: boolean;
+    name?: string;
 };
 type MigrationOptionsMap = {
-  create: MigratorCreateOptions;
-  check: BaseArgs;
-  up: CliUpDownOptions;
-  down: CliUpDownOptions;
-  list: BaseArgs;
-  pending: BaseArgs;
-  fresh: MigratorFreshOptions;
+    create: MigratorCreateOptions;
+    check: BaseArgs;
+    up: CliUpDownOptions;
+    down: CliUpDownOptions;
+    list: BaseArgs;
+    pending: BaseArgs;
+    fresh: MigratorFreshOptions;
 };
 type MigratorMethod = keyof MigrationOptionsMap;
 type Opts = BaseArgs & MigratorCreateOptions & CliUpDownOptions & MigratorFreshOptions;