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

package/commands/MigrationCommandFactory.js

@@ -1,214 +1,213 @@
-import { colors, Utils } from '@mikro-orm/core';
+import { colors, Utils, } from '@mikro-orm/core';
 import { CLIHelper } from '../CLIHelper.js';
 export class MigrationCommandFactory {
-  static DESCRIPTIONS = {
-    create: 'Create new migration with current schema diff',
-    up: 'Migrate up to the latest version',
-    down: 'Migrate one step down',
-    list: 'List all executed migrations',
-    check: 'Check if migrations are needed. Useful for bash scripts.',
-    pending: 'List all pending migrations',
-    fresh: 'Clear the database and rerun all migrations',
-  };
-  static create(command) {
-    // oxfmt-ignore
-    return {
+    static DESCRIPTIONS = {
+        create: 'Create new migration with current schema diff',
+        up: 'Migrate up to the latest version',
+        down: 'Migrate one step down',
+        list: 'List all executed migrations',
+        check: 'Check if migrations are needed. Useful for bash scripts.',
+        pending: 'List all pending migrations',
+        fresh: 'Clear the database and rerun all migrations',
+    };
+    static create(command) {
+        // oxfmt-ignore
+        return {
             command: `migration:${command}`,
             describe: MigrationCommandFactory.DESCRIPTIONS[command],
             builder: (args) => MigrationCommandFactory.configureMigrationCommand(args, command),
             handler: (args) => MigrationCommandFactory.handleMigrationCommand(args, command),
         };
-  }
-  static configureMigrationCommand(args, method) {
-    if (method === 'create') {
-      return this.configureCreateCommand(args);
     }
-    if (method === 'up' || method === 'down') {
-      return this.configureUpDownCommand(args, method);
+    static configureMigrationCommand(args, method) {
+        if (method === 'create') {
+            return this.configureCreateCommand(args);
+        }
+        if (method === 'up' || method === 'down') {
+            return this.configureUpDownCommand(args, method);
+        }
+        if (method === 'fresh') {
+            return this.configureFreshCommand(args);
+        }
+        return args;
     }
-    if (method === 'fresh') {
-      return this.configureFreshCommand(args);
+    static configureUpDownCommand(args, method) {
+        args.option('t', {
+            alias: 'to',
+            type: 'string',
+            desc: `Migrate ${method} to specific version`,
+        });
+        args.option('f', {
+            alias: 'from',
+            type: 'string',
+            desc: 'Start migration from specific version',
+        });
+        args.option('o', {
+            alias: 'only',
+            type: 'string',
+            desc: 'Migrate only specified versions',
+        });
+        return args;
     }
-    return args;
-  }
-  static configureUpDownCommand(args, method) {
-    args.option('t', {
-      alias: 'to',
-      type: 'string',
-      desc: `Migrate ${method} to specific version`,
-    });
-    args.option('f', {
-      alias: 'from',
-      type: 'string',
-      desc: 'Start migration from specific version',
-    });
-    args.option('o', {
-      alias: 'only',
-      type: 'string',
-      desc: 'Migrate only specified versions',
-    });
-    return args;
-  }
-  static configureCreateCommand(args) {
-    args.option('b', {
-      alias: 'blank',
-      type: 'boolean',
-      desc: 'Create blank migration',
-    });
-    args.option('i', {
-      alias: 'initial',
-      type: 'boolean',
-      desc: 'Create initial migration',
-    });
-    args.option('d', {
-      alias: 'dump',
-      type: 'boolean',
-      desc: 'Dumps all queries to console',
-    });
-    args.option('p', {
-      alias: 'path',
-      type: 'string',
-      desc: 'Sets path to directory where to save entities',
-    });
-    args.option('n', {
-      alias: 'name',
-      type: 'string',
-      desc: 'Specify custom name for the file',
-    });
-    return args;
-  }
-  static async handleMigrationCommand(args, method) {
-    // 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);
-    switch (method) {
-      case 'create':
-        await this.handleCreateCommand(orm.migrator, args, orm.config);
-        break;
-      case 'check':
-        await this.handleCheckCommand(orm.migrator, orm);
-        break;
-      case 'list':
-        await this.handleListCommand(orm.migrator);
-        break;
-      case 'pending':
-        await this.handlePendingCommand(orm.migrator);
-        break;
-      case 'up':
-      case 'down':
-        await this.handleUpDownCommand(args, orm.migrator, method);
-        break;
-      case 'fresh':
-        await this.handleFreshCommand(args, orm.migrator, orm);
+    static configureCreateCommand(args) {
+        args.option('b', {
+            alias: 'blank',
+            type: 'boolean',
+            desc: 'Create blank migration',
+        });
+        args.option('i', {
+            alias: 'initial',
+            type: 'boolean',
+            desc: 'Create initial migration',
+        });
+        args.option('d', {
+            alias: 'dump',
+            type: 'boolean',
+            desc: 'Dumps all queries to console',
+        });
+        args.option('p', {
+            alias: 'path',
+            type: 'string',
+            desc: 'Sets path to directory where to save entities',
+        });
+        args.option('n', {
+            alias: 'name',
+            type: 'string',
+            desc: 'Specify custom name for the file',
+        });
+        return args;
     }
-    await orm.close(true);
-  }
-  static configureFreshCommand(args) {
-    args.option('seed', {
-      type: 'string',
-      desc: 'Allows to seed the database after dropping it and rerunning all migrations',
-    });
-    args.option('drop-db', {
-      type: 'boolean',
-      desc: 'Drop the whole database',
-    });
-    return args;
-  }
-  static async handleUpDownCommand(args, migrator, method) {
-    const opts = MigrationCommandFactory.getUpDownOptions(args);
-    await migrator[method](opts);
-    const message = this.getUpDownSuccessMessage(method, opts);
-    CLIHelper.dump(colors.green(message));
-  }
-  static async handlePendingCommand(migrator) {
-    const pending = await migrator.getPending();
-    CLIHelper.dumpTable({
-      columns: ['Name'],
-      rows: pending.map(row => [row.name]),
-      empty: 'No pending migrations',
-    });
-  }
-  static async handleListCommand(migrator) {
-    const executed = await migrator.getExecuted();
-    CLIHelper.dumpTable({
-      columns: ['Name', 'Executed at'],
-      rows: executed.map(row => {
-        /* v8 ignore next */
-        const executedAt = (row.executed_at ?? row.created_at)?.toISOString() ?? '';
-        return [row.name.replace(/\.[jt]s$/, ''), executedAt];
-      }),
-      empty: 'No migrations executed yet',
-    });
-  }
-  static async handleCreateCommand(migrator, args, config) {
-    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`));
+    static async handleMigrationCommand(args, method) {
+        // 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);
+        switch (method) {
+            case 'create':
+                await this.handleCreateCommand(orm.migrator, args, orm.config);
+                break;
+            case 'check':
+                await this.handleCheckCommand(orm.migrator, orm);
+                break;
+            case 'list':
+                await this.handleListCommand(orm.migrator);
+                break;
+            case 'pending':
+                await this.handlePendingCommand(orm.migrator);
+                break;
+            case 'up':
+            case 'down':
+                await this.handleUpDownCommand(args, orm.migrator, method);
+                break;
+            case 'fresh':
+                await this.handleFreshCommand(args, orm.migrator, orm);
+        }
+        await orm.close(true);
     }
-    if (args.dump) {
-      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 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)`),
-        );
-      }
+    static configureFreshCommand(args) {
+        args.option('seed', {
+            type: 'string',
+            desc: 'Allows to seed the database after dropping it and rerunning all migrations',
+        });
+        args.option('drop-db', {
+            type: 'boolean',
+            desc: 'Drop the whole database',
+        });
+        return args;
     }
-    CLIHelper.dump(colors.green(`${ret.fileName} successfully created`));
-  }
-  static async handleCheckCommand(migrator, orm) {
-    if (!(await migrator.checkSchema())) {
-      return CLIHelper.dump(colors.green(`No changes required, schema is up-to-date`));
+    static async handleUpDownCommand(args, migrator, method) {
+        const opts = MigrationCommandFactory.getUpDownOptions(args);
+        await migrator[method](opts);
+        const message = this.getUpDownSuccessMessage(method, opts);
+        CLIHelper.dump(colors.green(message));
     }
-    await orm.close(true);
-    CLIHelper.dump(colors.yellow(`Changes detected. Please create migration to update schema.`));
-    process.exit(1);
-  }
-  static async handleFreshCommand(args, migrator, orm) {
-    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 seederClass = args.seed || orm.config.get('seeder').defaultSeeder;
-      await orm.seeder.seedString(seederClass);
-      CLIHelper.dump(colors.green(`Database seeded successfully with seeder class ${seederClass}`));
+    static async handlePendingCommand(migrator) {
+        const pending = await migrator.getPending();
+        CLIHelper.dumpTable({
+            columns: ['Name'],
+            rows: pending.map(row => [row.name]),
+            empty: 'No pending migrations',
+        });
     }
-  }
-  static getUpDownOptions(flags) {
-    if (!flags.to && !flags.from && flags.only) {
-      return { migrations: flags.only.split(/[, ]+/) };
+    static async handleListCommand(migrator) {
+        const executed = await migrator.getExecuted();
+        CLIHelper.dumpTable({
+            columns: ['Name', 'Executed at'],
+            rows: executed.map(row => {
+                /* v8 ignore next */
+                const executedAt = (row.executed_at ?? row.created_at)?.toISOString() ?? '';
+                return [row.name.replace(/\.[jt]s$/, ''), executedAt];
+            }),
+            empty: 'No migrations executed yet',
+        });
     }
-    const ret = {};
-    ['from', 'to'].filter(k => flags[k]).forEach(k => (ret[k] = flags[k] === '0' ? 0 : flags[k]));
-    return ret;
-  }
-  static getUpDownSuccessMessage(method, options) {
-    const msg = `Successfully migrated ${method}`;
-    if (method === 'down' && Utils.isEmpty(options)) {
-      return msg + ' to previous version';
+    static async handleCreateCommand(migrator, args, config) {
+        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`));
+        }
+        if (args.dump) {
+            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 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`));
     }
-    if (options.to === 0) {
-      const v = { down: 'first', up: 'latest' }[method];
-      return `${msg} to the ${v} version`;
+    static async handleCheckCommand(migrator, orm) {
+        if (!(await migrator.checkSchema())) {
+            return CLIHelper.dump(colors.green(`No changes required, schema is up-to-date`));
+        }
+        await orm.close(true);
+        CLIHelper.dump(colors.yellow(`Changes detected. Please create migration to update schema.`));
+        process.exit(1);
     }
-    if (method === 'up' && Utils.isEmpty(options)) {
-      return msg + ' to the latest version';
+    static async handleFreshCommand(args, migrator, orm) {
+        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 seederClass = args.seed || orm.config.get('seeder').defaultSeeder;
+            await orm.seeder.seedString(seederClass);
+            CLIHelper.dump(colors.green(`Database seeded successfully with seeder class ${seederClass}`));
+        }
     }
-    if (typeof options.to === 'string') {
-      return msg + ' to version ' + options.to;
+    static getUpDownOptions(flags) {
+        if (!flags.to && !flags.from && flags.only) {
+            return { migrations: flags.only.split(/[, ]+/) };
+        }
+        const ret = {};
+        ['from', 'to'].filter(k => flags[k]).forEach(k => (ret[k] = flags[k] === '0' ? 0 : flags[k]));
+        return ret;
     }
-    if (options.migrations?.length === 1) {
-      return msg + ' to version ' + options.migrations[0];
+    static getUpDownSuccessMessage(method, options) {
+        const msg = `Successfully migrated ${method}`;
+        if (method === 'down' && Utils.isEmpty(options)) {
+            return msg + ' to previous version';
+        }
+        if (options.to === 0) {
+            const v = { down: 'first', up: 'latest' }[method];
+            return `${msg} to the ${v} version`;
+        }
+        if (method === 'up' && Utils.isEmpty(options)) {
+            return msg + ' to the latest version';
+        }
+        if (typeof options.to === 'string') {
+            return msg + ' to version ' + options.to;
+        }
+        if (options.migrations?.length === 1) {
+            return msg + ' to version ' + options.migrations[0];
+        }
+        return msg;
     }
-    return msg;
-  }
 }

package/commands/SchemaCommandFactory.d.ts

@@ -1,61 +1,51 @@
 import type { ArgumentsCamelCase, Argv } from 'yargs';
 import type { BaseArgs } from '../CLIConfigurator.js';
 export declare class SchemaCommandFactory {
-  static readonly DESCRIPTIONS: {
-    readonly create: 'Create database schema based on current metadata';
-    readonly update: 'Update database schema based on current metadata';
-    readonly drop: 'Drop database schema based on current metadata';
-    readonly fresh: 'Drop and recreate database schema based on current metadata';
-  };
-  static readonly SUCCESS_MESSAGES: {
-    readonly create: 'Schema successfully created';
-    readonly update: 'Schema successfully updated';
-    readonly drop: 'Schema successfully dropped';
-    readonly fresh: 'Schema successfully dropped and recreated';
-  };
-  static create<const T extends SchemaMethod>(
-    command: T,
-  ): {
-    command: string;
-    describe:
-      | 'Create database schema based on current metadata'
-      | 'Update database schema based on current metadata'
-      | 'Drop database schema based on current metadata'
-      | 'Drop and recreate database schema based on current metadata';
-    builder: (args: Argv<BaseArgs>) => Argv<OptionsMap[T]>;
-    handler: (args: ArgumentsCamelCase<OptionsMap[T]>) => Promise<void>;
-  };
-  static configureSchemaCommand<const T extends SchemaMethod>(args: Argv<BaseArgs>, command: T): Argv<OptionsMap[T]>;
-  static handleSchemaCommand(
-    args: ArgumentsCamelCase<Options>,
-    method: SchemaMethod,
-    successMessage: string,
-  ): Promise<void>;
+    static readonly DESCRIPTIONS: {
+        readonly create: "Create database schema based on current metadata";
+        readonly update: "Update database schema based on current metadata";
+        readonly drop: "Drop database schema based on current metadata";
+        readonly fresh: "Drop and recreate database schema based on current metadata";
+    };
+    static readonly SUCCESS_MESSAGES: {
+        readonly create: "Schema successfully created";
+        readonly update: "Schema successfully updated";
+        readonly drop: "Schema successfully dropped";
+        readonly fresh: "Schema successfully dropped and recreated";
+    };
+    static create<const T extends SchemaMethod>(command: T): {
+        command: string;
+        describe: "Create database schema based on current metadata" | "Update database schema based on current metadata" | "Drop database schema based on current metadata" | "Drop and recreate database schema based on current metadata";
+        builder: (args: Argv<BaseArgs>) => Argv<OptionsMap[T]>;
+        handler: (args: ArgumentsCamelCase<OptionsMap[T]>) => Promise<void>;
+    };
+    static configureSchemaCommand<const T extends SchemaMethod>(args: Argv<BaseArgs>, command: T): Argv<OptionsMap[T]>;
+    static handleSchemaCommand(args: ArgumentsCamelCase<Options>, method: SchemaMethod, successMessage: string): Promise<void>;
 }
 type SchemaOptions = BaseArgs & {
-  run?: boolean;
-  schema?: string;
+    run?: boolean;
+    schema?: string;
 };
 type NonFreshOptions = SchemaOptions & {
-  dump?: boolean;
-  fkChecks?: boolean;
+    dump?: boolean;
+    fkChecks?: boolean;
 };
 export type SchemaCreateOptions = NonFreshOptions & {
-  seed?: string;
+    seed?: string;
 };
 export type SchemaUpdateOptions = NonFreshOptions & {
-  safe?: boolean;
-  dropTables?: boolean;
+    safe?: boolean;
+    dropTables?: boolean;
 };
 export type SchemaDropOptions = NonFreshOptions & {
-  dropDb?: boolean;
+    dropDb?: boolean;
 };
 export type SchemaFreshOptions = SchemaOptions & Omit<SchemaCreateOptions & SchemaDropOptions, keyof NonFreshOptions>;
 type OptionsMap = {
-  create: SchemaCreateOptions;
-  update: SchemaUpdateOptions;
-  drop: SchemaDropOptions;
-  fresh: SchemaFreshOptions;
+    create: SchemaCreateOptions;
+    update: SchemaUpdateOptions;
+    drop: SchemaDropOptions;
+    fresh: SchemaFreshOptions;
 };
 type SchemaMethod = keyof OptionsMap;
 export type Options = SchemaCreateOptions & SchemaUpdateOptions & SchemaDropOptions & SchemaFreshOptions;