@mikro-orm/cli 7.2.0-dev.2 → 7.2.0-dev.21

package/CLIConfigurator.d.ts

@@ -11,9 +11,11 @@ export interface BaseCommand<CommandArgs extends BaseArgs = BaseArgs> extends Co
 declare function createBasicConfig(): Argv<{
     config: string[] | undefined;
     contextName: string;
+    quiet: boolean;
 }>;
 export declare function configure(): Promise<Argv<{
     config: string[] | undefined;
     contextName: string;
+    quiet: boolean;
 }>>;
 export {};

package/CLIConfigurator.js

@@ -30,6 +30,12 @@ function createBasicConfig() {
         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',
+    })
+        .option('quiet', {
+        alias: 'q',
+        type: 'boolean',
+        desc: 'Do not show any auxiliary output.',
+        default: false,
     })
         .alias('v', 'version')
         .alias('h', 'help')

package/CLIHelper.d.ts

@@ -3,6 +3,7 @@ import { Configuration, type EntityManager, type EntityManagerType, type IDataba
  * @internal
  */
 export declare class CLIHelper {
+    static quiet: boolean;
     /**
      * Gets a named configuration
      *
@@ -16,6 +17,7 @@ export declare class CLIHelper {
     static isDBConnected(config: Configuration, reason?: false): Promise<boolean>;
     static isDBConnected(config: Configuration, reason: true): Promise<true | string>;
     static getDriverDependencies(config: Configuration): string[];
+    static info(text: string): void;
     static dump(text: string, config?: Configuration): void;
     static getSettings(): Settings;
     static getConfigPaths(): Promise<string[]>;
@@ -35,18 +37,19 @@ export declare class CLIHelper {
         empty: string;
     }): void;
     /**
-     * Tries to register TS support in the following order: oxc, swc, tsx, jiti, tsimp
+     * Tries to register TS support in the following order: oxc, swc, tsx, jiti, tsimp, nub
      * Use `MIKRO_ORM_CLI_TS_LOADER` env var to set the loader explicitly.
+     * `nub` is skipped when a custom tsconfig path is used, and it supports only the legacy decorators.
      * This method is used only in CLI context.
      */
-    static registerTypeScriptSupport(configPath?: string, tsLoader?: 'oxc' | 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto'): Promise<boolean>;
+    static registerTypeScriptSupport(configPath?: string, tsLoader?: 'oxc' | 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'nub' | 'auto'): Promise<boolean>;
     static isESM(): boolean;
     static showHelp(): void;
 }
 export interface Settings {
     verbose?: boolean;
     preferTs?: boolean;
-    tsLoader?: 'oxc' | 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto';
+    tsLoader?: 'oxc' | 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'nub' | 'auto';
     tsConfigPath?: string;
     configPaths?: string[];
 }

package/CLIHelper.js

@@ -9,6 +9,7 @@ import { searchConfiguration } from './searchConfiguration.js';
  * @internal
  */
 export class CLIHelper {
+    static quiet = false;
     /**
      * Gets a named configuration
      *
@@ -88,6 +89,13 @@ export class CLIHelper {
             return [];
         }
     }
+    static info(text) {
+        if (CLIHelper.quiet) {
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.log(text);
+    }
     static dump(text, config) {
         if (config?.get('highlighter')) {
             text = config.get('highlighter').highlight(text);
@@ -257,8 +265,9 @@ export class CLIHelper {
         CLIHelper.dump(ret);
     }
     /**
-     * Tries to register TS support in the following order: oxc, swc, tsx, jiti, tsimp
+     * Tries to register TS support in the following order: oxc, swc, tsx, jiti, tsimp, nub
      * Use `MIKRO_ORM_CLI_TS_LOADER` env var to set the loader explicitly.
+     * `nub` is skipped when a custom tsconfig path is used, and it supports only the legacy decorators.
      * This method is used only in CLI context.
      */
     static async registerTypeScriptSupport(configPath = 'tsconfig.json', tsLoader) {
@@ -270,32 +279,62 @@ export class CLIHelper {
         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 usesDefaultTsConfig = fs.absolutePath(configPath) === fs.absolutePath('tsconfig.json');
         const setEsmImportProvider = () => {
             return (globalThis.dynamicImportProvider = (id) => import(id).then(mod => mod?.default ?? mod));
         };
+        if (explicitLoader === 'nub' && !usesDefaultTsConfig) {
+            throw new Error('The `nub` loader does not support a custom tsconfig path. Use the project tsconfig.json or select another loader.');
+        }
         const loaders = {
             oxc: { esm: '@oxc-node/core/register', cjs: '@oxc-node/core/register' },
             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: { cjs: 'jiti/register', cb: setEsmImportProvider },
             tsimp: { cjs: 'tsimp/import', cb: setEsmImportProvider },
+            nub: { esm: '@nubjs/loader', cjs: '@nubjs/loader' },
         };
+        const errors = [];
         for (const loader of Utils.keys(loaders)) {
+            if (loader === 'nub' && !usesDefaultTsConfig) {
+                continue;
+            }
             if (explicitLoader !== 'auto' && loader !== explicitLoader) {
                 continue;
             }
             const { esm, cjs, cb } = loaders[loader];
             const isEsm = this.isESM();
             const module = isEsm && esm ? esm : cjs;
-            const mod = await Utils.tryImport({ module });
+            let mod;
+            try {
+                mod = await Utils.tryImport({ module });
+            }
+            catch (e) {
+                const error = new Error(`Failed to load TypeScript loader \`${loader}\` (${module}): ${e.message}`, {
+                    cause: e,
+                });
+                if (explicitLoader !== 'auto') {
+                    throw error;
+                }
+                errors.push(error);
+                continue;
+            }
             if (mod) {
                 cb?.(mod);
                 process.env.MIKRO_ORM_CLI_TS_LOADER = loader;
                 return true;
             }
         }
+        // a loader that is installed but broken is a real problem, not a missing dependency
+        if (errors.length > 0) {
+            throw new Error(errors.map(e => e.message).join('\n'), { cause: errors[0] });
+        }
+        const loadersMessage = usesDefaultTsConfig
+            ? '`oxc`, `swc`, `tsx`, `jiti`, `tsimp` nor `nub`'
+            : '`oxc`, `swc`, `tsx`, `jiti` nor `tsimp`';
+        const nubHint = usesDefaultTsConfig ? '' : ' The `nub` loader was skipped as a custom tsconfig path is configured.';
         // eslint-disable-next-line no-console
-        console.warn('Neither `oxc`, `swc`, `tsx`, `jiti` nor `tsimp` found in the project dependencies, support for working with TypeScript files might not work. To use `oxc`, install `@oxc-node/core`. To use `swc`, install both `@swc-node/register` and `@swc/core`.');
+        console.warn(`Neither ${loadersMessage} found in the project dependencies, support for working with TypeScript files might not work.${nubHint} To use \`oxc\`, install \`@oxc-node/core\`. To use \`swc\`, install both \`@swc-node/register\` and \`@swc/core\`.`);
         return false;
     }
     static isESM() {

package/commands/ClearCacheCommand.js

@@ -7,6 +7,7 @@ export class ClearCacheCommand {
      * @inheritDoc
      */
     async handler(args) {
+        CLIHelper.quiet = args.quiet;
         const config = await CLIHelper.getConfiguration(args.contextName, args.config);
         if (!config.get('metadataCache').enabled) {
             CLIHelper.dump(colors.red('Metadata cache is disabled in your configuration. Set cache.enabled to true to use this command.'));
@@ -14,6 +15,6 @@ export class ClearCacheCommand {
         }
         const cache = config.getMetadataCacheAdapter();
         await cache.clear();
-        CLIHelper.dump(colors.green('Metadata cache was successfully cleared'));
+        CLIHelper.info(colors.green('Metadata cache was successfully cleared'));
     }
 }

package/commands/CompileCommand.js

@@ -17,6 +17,7 @@ export class CompileCommand {
      * @inheritDoc
      */
     async handler(args) {
+        CLIHelper.quiet = args.quiet;
         const config = await CLIHelper.getConfiguration(args.contextName, args.config);
         const settings = CLIHelper.getSettings();
         config.set('debug', !!settings.verbose);
@@ -51,12 +52,15 @@ export class CompileCommand {
         mkdirSync(dirname(outPath), { recursive: true });
         writeFileSync(outPath, output);
         writeFileSync(dtsPath, dts);
-        CLIHelper.dump(colors.green(`Compiled functions generated to ${outPath} (${captured.length} functions)`));
-        CLIHelper.dump(`\nExample usage in your ORM config:\n`);
+        if (args.quiet) {
+            return;
+        }
+        CLIHelper.info(colors.green(`Compiled functions generated to ${outPath} (${captured.length} functions)`));
+        CLIHelper.info(`\nExample usage in your ORM config:\n`);
         const importPath = esm ? './compiled-functions.js' : './compiled-functions';
-        CLIHelper.dump(`  ${esm ? 'import' : 'const'} compiledFunctions ${esm ? 'from ' : '= require('}${colors.cyan(`'${importPath}'`)}${esm ? '' : ')'};`);
-        CLIHelper.dump('');
-        CLIHelper.dump(`  export default defineConfig({ compiledFunctions });\n`);
+        CLIHelper.info(`  ${esm ? 'import' : 'const'} compiledFunctions ${esm ? 'from ' : '= require('}${colors.cyan(`'${importPath}'`)}${esm ? '' : ')'};`);
+        CLIHelper.info('');
+        CLIHelper.info(`  export default defineConfig({ compiledFunctions });\n`);
     }
     static capture(metadata, config) {
         const captured = [];

package/commands/CreateDatabaseCommand.js

@@ -6,6 +6,7 @@ export class CreateDatabaseCommand {
      * @inheritDoc
      */
     async handler(args) {
+        CLIHelper.quiet = args.quiet;
         const orm = await CLIHelper.getORM(args.contextName, args.config);
         await orm.schema.ensureDatabase();
         await orm.close(true);

package/commands/CreateSeederCommand.js

@@ -14,10 +14,11 @@ export class CreateSeederCommand {
      * @inheritDoc
      */
     async handler(args) {
+        CLIHelper.quiet = args.quiet;
         const className = CreateSeederCommand.getSeederClassName(args.seeder);
         const orm = await CLIHelper.getORM(args.contextName, args.config);
         const path = await orm.seeder.create(className);
-        CLIHelper.dump(colors.green(`Seeder ${args.seeder} successfully created at ${path}`));
+        CLIHelper.info(colors.green(`Seeder ${args.seeder} successfully created at ${path}`));
         await orm.close(true);
     }
     /**

package/commands/DatabaseSeedCommand.js

@@ -15,10 +15,11 @@ export class DatabaseSeedCommand {
      * @inheritDoc
      */
     async handler(args) {
+        CLIHelper.quiet = args.quiet;
         const orm = await CLIHelper.getORM(args.contextName, args.config);
         const className = args.class ?? orm.config.get('seeder').defaultSeeder;
         await orm.seeder.seedString(className);
-        CLIHelper.dump(colors.green(`Seeder ${className} successfully executed`));
+        CLIHelper.info(colors.green(`Seeder ${className} successfully executed`));
         await orm.close(true);
     }
 }

package/commands/DebugCommand.js

@@ -8,6 +8,7 @@ export class DebugCommand {
      * @inheritDoc
      */
     async handler(args) {
+        CLIHelper.quiet = args.quiet;
         CLIHelper.dump(`Current ${colors.cyan('MikroORM')} CLI configuration`);
         CLIHelper.dumpDependencies();
         const settings = CLIHelper.getSettings();

package/commands/DiscoveryExportCommand.d.ts

@@ -4,6 +4,7 @@ type DiscoveryExportArgs = BaseArgs & {
     path?: string[];
     out?: string;
     dump?: boolean;
+    quiet?: boolean;
 };
 export declare class DiscoveryExportCommand implements BaseCommand<DiscoveryExportArgs> {
     command: string;

package/commands/DiscoveryExportCommand.js

@@ -41,6 +41,7 @@ export class DiscoveryExportCommand {
      * @inheritDoc
      */
     handler = async (args) => {
+        CLIHelper.quiet = args.quiet;
         const config = await CLIHelper.getConfiguration(args.contextName, args.config);
         const paths = this.resolvePaths(args, config);
         const baseDir = fs.absolutePath(config.get('baseDir') ?? process.cwd());
@@ -60,13 +61,16 @@ export class DiscoveryExportCommand {
         const output = this.generateFile(discovered, outPath, esm, driverPackage);
         mkdirSync(dirname(outPath), { recursive: true });
         writeFileSync(outPath, output);
-        CLIHelper.dump(colors.green(`Entity exports generated to ${outPath} (${discovered.length} entities)`));
-        CLIHelper.dump(`\nExample usage in your ORM config:\n`);
+        if (args.quiet) {
+            return;
+        }
+        CLIHelper.info(colors.green(`Entity exports generated to ${outPath} (${discovered.length} entities)`));
+        CLIHelper.info(`\nExample usage in your ORM config:\n`);
         const importExt = esm ? '.js' : '';
         const importPath = `./${basename(outPath).replace(/\.ts$/, importExt)}`;
-        CLIHelper.dump(`  import { entities } from ${colors.cyan(`'${importPath}'`)};`);
-        CLIHelper.dump('');
-        CLIHelper.dump('  export default defineConfig({ entities });\n');
+        CLIHelper.info(`  import { entities } from ${colors.cyan(`'${importPath}'`)};`);
+        CLIHelper.info('');
+        CLIHelper.info('  export default defineConfig({ entities });\n');
     };
     resolvePaths(args, config) {
         if (args.path && args.path.length > 0) {

package/commands/GenerateCacheCommand.js

@@ -10,6 +10,7 @@ export class GenerateCacheCommand {
             desc: `Generate development cache for '.ts' files`,
         });
         args.option('combined', {
+            type: 'string',
             alias: 'c',
             desc: `Generate production cache into a single JSON file that can be used with the GeneratedCacheAdapter.`,
         });
@@ -19,7 +20,10 @@ export class GenerateCacheCommand {
      * @inheritDoc
      */
     async handler(args) {
-        const options = args.combined ? { combined: './metadata.json' } : {};
+        CLIHelper.quiet = args.quiet;
+        const options = typeof args.combined !== 'undefined'
+            ? { combined: args.combined === '' ? './metadata.json' : args.combined }
+            : {};
         const config = await CLIHelper.getConfiguration(args.contextName, args.config, {
             metadataCache: { enabled: true, adapter: FileCacheAdapter, options },
         });
@@ -29,6 +33,6 @@ export class GenerateCacheCommand {
         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 : ''}`));
+        CLIHelper.info(colors.green(`${combined ? 'Combined ' : ''}${args.ts ? 'TS' : 'JS'} metadata cache was successfully generated${combined ? ' to ' + combined : ''}`));
     }
 }

package/commands/GenerateEntitiesCommand.js

@@ -1,4 +1,5 @@
 import { CLIHelper } from '../CLIHelper.js';
+import { colors } from '@mikro-orm/core';
 export class GenerateEntitiesCommand {
     command = 'generate-entities';
     describe = 'Generate entities based on current database schema';
@@ -31,6 +32,7 @@ export class GenerateEntitiesCommand {
      * @inheritDoc
      */
     async handler(args) {
+        CLIHelper.quiet = args.quiet;
         if (!args.save && !args.dump) {
             return CLIHelper.showHelp();
         }
@@ -43,6 +45,9 @@ export class GenerateEntitiesCommand {
         if (args.dump) {
             CLIHelper.dump(dump.join('\n\n'));
         }
+        else {
+            CLIHelper.info(colors.green(`Entities generated successfully`));
+        }
         await orm.close(true);
     }
 }

package/commands/ImportCommand.js

@@ -8,10 +8,11 @@ export class ImportCommand {
      * @inheritDoc
      */
     async handler(args) {
+        CLIHelper.quiet = args.quiet;
         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`));
+        CLIHelper.info(colors.green(`File ${args.file} successfully imported`));
         await orm.close(true);
     }
 }

package/commands/MigrationCommandFactory.js

@@ -98,6 +98,7 @@ export class MigrationCommandFactory {
         return args;
     }
     static async handleMigrationCommand(args, method) {
+        CLIHelper.quiet = args.quiet;
         // 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);
@@ -146,7 +147,7 @@ export class MigrationCommandFactory {
         const opts = MigrationCommandFactory.getUpDownOptions(args);
         await migrator[method](opts);
         const message = this.getUpDownSuccessMessage(method, opts);
-        CLIHelper.dump(colors.green(message));
+        CLIHelper.info(colors.green(message));
     }
     static async handlePendingCommand(migrator) {
         const pending = await migrator.getPending();
@@ -171,10 +172,10 @@ export class MigrationCommandFactory {
     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`));
+            return CLIHelper.info(colors.green(`No changes required, schema is up-to-date`));
         }
         if (args.dump) {
-            CLIHelper.dump(colors.green('Creating migration with following queries:'));
+            CLIHelper.info(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 */
@@ -187,11 +188,11 @@ export class MigrationCommandFactory {
                 CLIHelper.dump(colors.yellow(`(${config.getDriver().constructor.name} does not support automatic down migrations)`));
             }
         }
-        CLIHelper.dump(colors.green(`${ret.fileName} successfully created`));
+        CLIHelper.info(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`));
+            return CLIHelper.info(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.`));
@@ -199,25 +200,25 @@ export class MigrationCommandFactory {
     }
     static async handleFreshCommand(args, migrator, orm) {
         await orm.schema.drop({ dropMigrationsTable: true, dropDb: args.dropDb });
-        CLIHelper.dump(colors.green('Dropped schema successfully'));
+        CLIHelper.info(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));
+        CLIHelper.info(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}`));
+            CLIHelper.info(colors.green(`Database seeded successfully with seeder class ${seederClass}`));
         }
     }
     static async handleLogUnlogCommand(args, migrator, method) {
         await migrator[`${method}Migration`](args.name);
         const action = method === 'log' ? 'logged' : 'unlogged';
-        CLIHelper.dump(colors.green(`Successfully ${action} migration '${args.name}'`));
+        CLIHelper.info(colors.green(`Successfully ${action} migration '${args.name}'`));
     }
     static async handleRollupCommand(migrator) {
         const ret = await migrator.rollup();
-        CLIHelper.dump(colors.green(`${ret.fileName} successfully created (rollup)`));
+        CLIHelper.info(colors.green(`${ret.fileName} successfully created (rollup)`));
     }
     static getUpDownOptions(flags) {
         const ret = !flags.to && !flags.from && flags.only ? { migrations: flags.only.split(/[, ]+/) } : {};

package/commands/SchemaCommandFactory.js

@@ -76,6 +76,7 @@ export class SchemaCommandFactory {
         return args;
     }
     static async handleSchemaCommand(args, method, successMessage) {
+        CLIHelper.quiet = args.quiet;
         if (!args.run && !args.dump) {
             return CLIHelper.showHelp();
         }
@@ -102,7 +103,7 @@ export class SchemaCommandFactory {
         if (typeof args.seed !== 'undefined') {
             await orm.seeder.seedString(args.seed || orm.config.get('seeder').defaultSeeder);
         }
-        CLIHelper.dump(colors.green(successMessage));
+        CLIHelper.info(colors.green(successMessage));
         await orm.close(true);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/cli",
-  "version": "7.2.0-dev.2",
+  "version": "7.2.0-dev.21",
   "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.",
   "keywords": [
     "data-mapper",
@@ -50,8 +50,8 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/core": "7.2.0-dev.2",
-    "mikro-orm": "7.2.0-dev.2",
+    "@mikro-orm/core": "7.2.0-dev.21",
+    "mikro-orm": "7.2.0-dev.21",
     "yargs": "17.7.2"
   },
   "engines": {