@mikro-orm/cli 7.0.4-dev.9 → 7.0.4

package/commands/MigrationCommandFactory.js

@@ -1,213 +1,214 @@
-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);
     }
-    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 === 'up' || method === 'down') {
+      return this.configureUpDownCommand(args, method);
     }
-    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;
+    if (method === 'fresh') {
+      return this.configureFreshCommand(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;
+    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 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);
+    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 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;
+    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 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));
+    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 handlePendingCommand(migrator) {
-        const pending = await migrator.getPending();
-        CLIHelper.dumpTable({
-            columns: ['Name'],
-            rows: pending.map(row => [row.name]),
-            empty: 'No pending migrations',
-        });
+    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 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 getUpDownOptions(flags) {
+    if (!flags.to && !flags.from && flags.only) {
+      return { migrations: flags.only.split(/[, ]+/) };
     }
-    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`));
+    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 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 (options.to === 0) {
+      const v = { down: 'first', up: 'latest' }[method];
+      return `${msg} to the ${v} 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 (method === 'up' && Utils.isEmpty(options)) {
+      return msg + ' to the latest version';
     }
-    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 (typeof options.to === 'string') {
+      return msg + ' to version ' + options.to;
     }
-    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;
+    if (options.migrations?.length === 1) {
+      return msg + ' to version ' + options.migrations[0];
     }
+    return msg;
+  }
 }

package/commands/SchemaCommandFactory.d.ts

@@ -1,51 +1,61 @@
 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;