@mikro-orm/cli 6.3.14-dev.1 → 6.3.14-dev.11

package/CLIConfigurator.d.ts

@@ -1,7 +1,19 @@
-import { type Argv } from 'yargs';
+import yargs, { type CommandModule } from 'yargs';
+/**
+ * @internal
+ */
+export type BaseArgs = Awaited<ReturnType<typeof CLIConfigurator['createBasicConfig']>['argv']>;
+/**
+ * @internal
+ */
+export interface BaseCommand<CommandArgs extends BaseArgs = BaseArgs> extends CommandModule<BaseArgs, CommandArgs> {
+}
 /**
  * @internal
  */
 export declare class CLIConfigurator {
-    static configure(): Promise<Argv>;
+    private static createBasicConfig;
+    static configure(): yargs.Argv<{
+        config: string | undefined;
+    }>;
 }

package/CLIConfigurator.js

@@ -4,9 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLIConfigurator = void 0;
-const yargs_1 = __importDefault(require("yargs"));
 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");
@@ -14,13 +16,25 @@ const GenerateEntitiesCommand_1 = require("./commands/GenerateEntitiesCommand");
 const ImportCommand_1 = require("./commands/ImportCommand");
 const MigrationCommandFactory_1 = require("./commands/MigrationCommandFactory");
 const SchemaCommandFactory_1 = require("./commands/SchemaCommandFactory");
-const CreateSeederCommand_1 = require("./commands/CreateSeederCommand");
-const CreateDatabaseCommand_1 = require("./commands/CreateDatabaseCommand");
 /**
  * @internal
  */
 class CLIConfigurator {
-    static async configure() {
+    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',
+            desc: `Set path to the ORM configuration file`,
+        })
+            .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();
@@ -31,17 +45,8 @@ class CLIConfigurator {
                 process.env.MIKRO_ORM_CLI_USE_TS_NODE ??= '0';
             }
         }
-        return yargs_1.default
-            .scriptName('mikro-orm')
+        return CLIConfigurator.createBasicConfig()
             .version(version)
-            .usage('Usage: $0 <command> [options]')
-            .example('$0 schema:update --run', 'Runs schema synchronization')
-            .option('config', {
-            type: 'string',
-            desc: `Set path to the ORM configuration file`,
-        })
-            .alias('v', 'version')
-            .alias('h', 'help')
             .command(new ClearCacheCommand_1.ClearCacheCommand())
             .command(new GenerateCacheCommand_1.GenerateCacheCommand())
             .command(new GenerateEntitiesCommand_1.GenerateEntitiesCommand())
@@ -60,9 +65,7 @@ class CLIConfigurator {
             .command(MigrationCommandFactory_1.MigrationCommandFactory.create('check'))
             .command(MigrationCommandFactory_1.MigrationCommandFactory.create('pending'))
             .command(MigrationCommandFactory_1.MigrationCommandFactory.create('fresh'))
-            .command(new DebugCommand_1.DebugCommand())
-            .recommendCommands()
-            .strict();
+            .command(new DebugCommand_1.DebugCommand());
     }
 }
 exports.CLIConfigurator = CLIConfigurator;

package/cli

@@ -10,7 +10,7 @@ require('@jercle/yargonaut')
 const CLIHelper_1 = require("./CLIHelper");
 const CLIConfigurator_1 = require("./CLIConfigurator");
 (async () => {
-    const argv = await CLIConfigurator_1.CLIConfigurator.configure();
+    const argv = CLIConfigurator_1.CLIConfigurator.configure();
     const args = await argv.parse(process.argv.slice(2));
     if (args._.length === 0) {
         CLIHelper_1.CLIHelper.showHelp();

package/cli.js

@@ -10,7 +10,7 @@ require('@jercle/yargonaut')
 const CLIHelper_1 = require("./CLIHelper");
 const CLIConfigurator_1 = require("./CLIConfigurator");
 (async () => {
-    const argv = await CLIConfigurator_1.CLIConfigurator.configure();
+    const argv = CLIConfigurator_1.CLIConfigurator.configure();
     const args = await argv.parse(process.argv.slice(2));
     if (args._.length === 0) {
         CLIHelper_1.CLIHelper.showHelp();

package/commands/ClearCacheCommand.d.ts

@@ -1,9 +1,10 @@
-import type { ArgumentsCamelCase, CommandModule } from 'yargs';
-export declare class ClearCacheCommand implements CommandModule {
+import type { ArgumentsCamelCase } from 'yargs';
+import type { BaseArgs, BaseCommand } from '../CLIConfigurator';
+export declare class ClearCacheCommand implements BaseCommand {
     command: string;
     describe: string;
     /**
      * @inheritDoc
      */
-    handler(args: ArgumentsCamelCase): Promise<void>;
+    handler(args: ArgumentsCamelCase<BaseArgs>): Promise<void>;
 }

package/commands/CreateDatabaseCommand.d.ts

@@ -1,9 +1,10 @@
-import type { ArgumentsCamelCase, CommandModule } from 'yargs';
-export declare class CreateDatabaseCommand implements CommandModule {
+import type { ArgumentsCamelCase } from 'yargs';
+import type { BaseArgs, BaseCommand } from '../CLIConfigurator';
+export declare class CreateDatabaseCommand implements BaseCommand {
     command: string;
     describe: string;
     /**
      * @inheritDoc
      */
-    handler(args: ArgumentsCamelCase): Promise<void>;
+    handler(args: ArgumentsCamelCase<BaseArgs>): Promise<void>;
 }

package/commands/CreateSeederCommand.d.ts

@@ -1,20 +1,19 @@
-import type { ArgumentsCamelCase, Argv, CommandModule } from 'yargs';
-export declare class CreateSeederCommand<T> implements CommandModule<T, {
+import type { ArgumentsCamelCase, Argv } from 'yargs';
+import type { BaseArgs, BaseCommand } from '../CLIConfigurator';
+type CreateSeederCommandArgs = BaseArgs & {
     seeder: string;
-}> {
+};
+export declare class CreateSeederCommand implements BaseCommand<CreateSeederCommandArgs> {
     command: string;
     describe: string;
-    builder: (args: Argv<T>) => Argv<{
-        seeder: string;
-    }>;
+    builder: (args: Argv<BaseArgs>) => Argv<CreateSeederCommandArgs>;
     /**
      * @inheritDoc
      */
-    handler(args: ArgumentsCamelCase<{
-        seeder?: string;
-    }>): Promise<void>;
+    handler(args: ArgumentsCamelCase<CreateSeederCommandArgs>): Promise<void>;
     /**
      * Will return a seeder name that is formatted like this EntitySeeder
      */
     private static getSeederClassName;
 }
+export {};

package/commands/DatabaseSeedCommand.d.ts

@@ -1,16 +1,15 @@
-import type { ArgumentsCamelCase, Argv, CommandModule } from 'yargs';
-export declare class DatabaseSeedCommand<T> implements CommandModule<T, {
-    class: string;
-}> {
+import type { ArgumentsCamelCase, Argv } from 'yargs';
+import type { BaseArgs, BaseCommand } from '../CLIConfigurator';
+type DatabaseSeedArgs = BaseArgs & {
+    class?: string;
+};
+export declare class DatabaseSeedCommand implements BaseCommand<DatabaseSeedArgs> {
     command: string;
     describe: string;
-    builder: (args: Argv<T>) => Argv<{
-        class: string;
-    }>;
+    builder: (args: Argv<BaseArgs>) => Argv<DatabaseSeedArgs>;
     /**
      * @inheritDoc
      */
-    handler(args: ArgumentsCamelCase<{
-        class?: string;
-    }>): Promise<void>;
+    handler(args: ArgumentsCamelCase<DatabaseSeedArgs>): Promise<void>;
 }
+export {};

package/commands/DebugCommand.d.ts

@@ -1,10 +1,11 @@
-import type { CommandModule } from 'yargs';
-export declare class DebugCommand implements CommandModule {
+import type { ArgumentsCamelCase } from 'yargs';
+import type { BaseArgs, BaseCommand } from '../CLIConfigurator';
+export declare class DebugCommand implements BaseCommand {
     command: string;
     describe: string;
     /**
      * @inheritDoc
      */
-    handler(): Promise<void>;
+    handler(args: ArgumentsCamelCase<BaseArgs>): Promise<void>;
     private static checkPaths;
 }

package/commands/DebugCommand.js

@@ -9,7 +9,7 @@ class DebugCommand {
     /**
      * @inheritDoc
      */
-    async handler() {
+    async handler(args) {
         CLIHelper_1.CLIHelper.dump(`Current ${core_1.colors.cyan('MikroORM')} CLI configuration`);
         await CLIHelper_1.CLIHelper.dumpDependencies();
         const settings = core_1.ConfigurationLoader.getSettings();

package/commands/GenerateCacheCommand.d.ts

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

package/commands/GenerateEntitiesCommand.d.ts

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

package/commands/ImportCommand.d.ts

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

package/commands/MigrationCommandFactory.d.ts

@@ -1,4 +1,5 @@
-import type { ArgumentsCamelCase, Argv, CommandModule } from 'yargs';
+import type { ArgumentsCamelCase, Argv } from 'yargs';
+import type { BaseArgs } from '../CLIConfigurator';
 export declare class MigrationCommandFactory {
     static readonly DESCRIPTIONS: {
         create: string;
@@ -9,11 +10,21 @@ export declare class MigrationCommandFactory {
         pending: string;
         fresh: string;
     };
-    static create<U extends Opts = Opts>(command: MigratorMethod): CommandModule<unknown, U> & {
-        builder: (args: Argv) => Argv<U>;
-        handler: (args: ArgumentsCamelCase<U>) => Promise<void>;
+    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(args: Argv, method: MigratorMethod): Argv<{}>;
+    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>;
@@ -27,22 +38,31 @@ export declare class MigrationCommandFactory {
     private static getUpDownOptions;
     private static getUpDownSuccessMessage;
 }
-type MigratorMethod = 'create' | 'check' | 'up' | 'down' | 'list' | 'pending' | 'fresh';
-type CliUpDownOptions = {
+type CliUpDownOptions = BaseArgs & {
     to?: string | number;
     from?: string | number;
     only?: string;
 };
-type GenerateOptions = {
-    dump?: boolean;
+type MigratorFreshOptions = BaseArgs & {
+    dropDb?: boolean;
+    seed?: string;
+};
+type MigratorCreateOptions = BaseArgs & {
     blank?: boolean;
     initial?: boolean;
     path?: string;
-    disableFkChecks?: boolean;
-    seed: string;
+    dump?: boolean;
     name?: string;
 };
-type Opts = GenerateOptions & CliUpDownOptions & {
-    dropDb?: boolean;
+type MigrationOptionsMap = {
+    create: MigratorCreateOptions;
+    check: BaseArgs;
+    up: CliUpDownOptions;
+    down: CliUpDownOptions;
+    list: BaseArgs;
+    pending: BaseArgs;
+    fresh: MigratorFreshOptions;
 };
+type MigratorMethod = keyof MigrationOptionsMap;
+type Opts = BaseArgs & MigratorCreateOptions & CliUpDownOptions & MigratorFreshOptions;
 export {};

package/commands/MigrationCommandFactory.js

@@ -23,13 +23,13 @@ class MigrationCommandFactory {
     }
     static configureMigrationCommand(args, method) {
         if (method === 'create') {
-            this.configureCreateCommand(args);
+            return this.configureCreateCommand(args);
         }
-        if (['up', 'down'].includes(method)) {
-            this.configureUpDownCommand(args, method);
+        if (method === 'up' || method === 'down') {
+            return this.configureUpDownCommand(args, method);
         }
         if (method === 'fresh') {
-            this.configureFreshCommand(args);
+            return this.configureFreshCommand(args);
         }
         return args;
     }
@@ -49,6 +49,7 @@ class MigrationCommandFactory {
             type: 'string',
             desc: 'Migrate only specified versions',
         });
+        return args;
     }
     static configureCreateCommand(args) {
         args.option('b', {
@@ -76,6 +77,7 @@ class MigrationCommandFactory {
             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
@@ -113,6 +115,7 @@ class MigrationCommandFactory {
             type: 'boolean',
             desc: 'Drop the whole database',
         });
+        return args;
     }
     static async handleUpDownCommand(args, migrator, method) {
         const opts = MigrationCommandFactory.getUpDownOptions(args);

package/commands/SchemaCommandFactory.d.ts

@@ -1,34 +1,52 @@
-import type { ArgumentsCamelCase, Argv, CommandModule } from 'yargs';
+import type { ArgumentsCamelCase, Argv } from 'yargs';
+import type { BaseArgs } from '../CLIConfigurator';
 export declare class SchemaCommandFactory {
     static readonly DESCRIPTIONS: {
-        create: string;
-        update: string;
-        drop: string;
-        fresh: string;
+        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: {
-        create: string;
-        update: string;
-        drop: string;
-        fresh: string;
+        readonly create: "Schema successfully created";
+        readonly update: "Schema successfully updated";
+        readonly drop: "Schema successfully dropped";
+        readonly fresh: "Schema successfully dropped and recreated";
     };
-    static create<U extends Options = Options>(command: SchemaMethod): CommandModule<unknown, U> & {
-        builder: (args: Argv) => Argv<U>;
-        handler: (args: ArgumentsCamelCase<U>) => Promise<void>;
+    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(args: Argv, command: SchemaMethod): Argv<{}>;
+    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 SchemaMethod = 'create' | 'update' | 'drop' | 'fresh';
-export type Options = {
-    dump: boolean;
-    run: boolean;
-    fkChecks: boolean;
-    dropMigrationsTable: boolean;
-    dropDb: boolean;
-    dropTables: boolean;
-    safe: boolean;
-    seed: string;
-    schema: string;
+type SchemaOptions = BaseArgs & {
+    run?: boolean;
+    schema?: string;
 };
+type NonFreshOptions = SchemaOptions & {
+    dump?: boolean;
+    fkChecks?: boolean;
+};
+export type SchemaCreateOptions = NonFreshOptions & {
+    seed?: string;
+};
+export type SchemaUpdateOptions = NonFreshOptions & {
+    safe?: boolean;
+    dropTables?: boolean;
+};
+export type SchemaDropOptions = NonFreshOptions & {
+    dropDb?: boolean;
+};
+export type SchemaFreshOptions = SchemaOptions & Omit<SchemaCreateOptions & SchemaDropOptions, keyof NonFreshOptions>;
+type OptionsMap = {
+    create: SchemaCreateOptions;
+    update: SchemaUpdateOptions;
+    drop: SchemaDropOptions;
+    fresh: SchemaFreshOptions;
+};
+type SchemaMethod = keyof OptionsMap;
+export type Options = SchemaCreateOptions & SchemaUpdateOptions & SchemaDropOptions & SchemaFreshOptions;
 export {};

package/commands/SchemaCommandFactory.js

@@ -105,7 +105,7 @@ class SchemaCommandFactory {
             const m = method + 'Schema';
             await generator[m](params);
         }
-        if (args.seed !== undefined) {
+        if (typeof args.seed !== 'undefined') {
             const seeder = orm.getSeeder();
             await seeder.seedString(args.seed || orm.config.get('seeder').defaultSeeder);
         }

package/esm

@@ -10,7 +10,7 @@ require('@jercle/yargonaut')
 const CLIHelper_1 = require("./CLIHelper");
 const CLIConfigurator_1 = require("./CLIConfigurator");
 (async () => {
-    const argv = await CLIConfigurator_1.CLIConfigurator.configure();
+    const argv = CLIConfigurator_1.CLIConfigurator.configure();
     const args = await argv.parse(process.argv.slice(2));
     if (args._.length === 0) {
         CLIHelper_1.CLIHelper.showHelp();

package/esm.js

@@ -10,7 +10,7 @@ require('@jercle/yargonaut')
 const CLIHelper_1 = require("./CLIHelper");
 const CLIConfigurator_1 = require("./CLIConfigurator");
 (async () => {
-    const argv = await CLIConfigurator_1.CLIConfigurator.configure();
+    const argv = CLIConfigurator_1.CLIConfigurator.configure();
     const args = await argv.parse(process.argv.slice(2));
     if (args._.length === 0) {
         CLIHelper_1.CLIHelper.showHelp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/cli",
-  "version": "6.3.14-dev.1",
+  "version": "6.3.14-dev.11",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -63,8 +63,8 @@
   },
   "dependencies": {
     "@jercle/yargonaut": "1.1.5",
-    "@mikro-orm/core": "6.3.14-dev.1",
-    "@mikro-orm/knex": "6.3.14-dev.1",
+    "@mikro-orm/core": "6.3.14-dev.11",
+    "@mikro-orm/knex": "6.3.14-dev.11",
     "fs-extra": "11.2.0",
     "tsconfig-paths": "4.2.0",
     "yargs": "17.7.2"