@mikro-orm/cli 7.1.0-dev.0 → 7.1.0-dev.10

package/CLIConfigurator.js

@@ -8,6 +8,7 @@ import { DatabaseSeedCommand } from './commands/DatabaseSeedCommand.js';
 import { DebugCommand } from './commands/DebugCommand.js';
 import { GenerateCacheCommand } from './commands/GenerateCacheCommand.js';
 import { CompileCommand } from './commands/CompileCommand.js';
+import { DiscoveryExportCommand } from './commands/DiscoveryExportCommand.js';
 import { GenerateEntitiesCommand } from './commands/GenerateEntitiesCommand.js';
 import { ImportCommand } from './commands/ImportCommand.js';
 import { MigrationCommandFactory } from './commands/MigrationCommandFactory.js';
@@ -53,6 +54,7 @@ export async function configure() {
         .command(new ClearCacheCommand())
         .command(new GenerateCacheCommand())
         .command(new CompileCommand())
+        .command(new DiscoveryExportCommand())
         .command(new GenerateEntitiesCommand())
         .command(new CreateDatabaseCommand())
         .command(new ImportCommand())
@@ -69,5 +71,8 @@ export async function configure() {
         .command(MigrationCommandFactory.create('check'))
         .command(MigrationCommandFactory.create('pending'))
         .command(MigrationCommandFactory.create('fresh'))
+        .command(MigrationCommandFactory.create('log'))
+        .command(MigrationCommandFactory.create('unlog'))
+        .command(MigrationCommandFactory.create('rollup'))
         .command(new DebugCommand());
 }

package/commands/DiscoveryExportCommand.d.ts

@@ -0,0 +1,23 @@
+import type { ArgumentsCamelCase, Argv } from 'yargs';
+import type { BaseArgs, BaseCommand } from '../CLIConfigurator.js';
+type DiscoveryExportArgs = BaseArgs & {
+    path?: string[];
+    out?: string;
+    dump?: boolean;
+};
+export declare class DiscoveryExportCommand implements BaseCommand<DiscoveryExportArgs> {
+    command: string;
+    describe: string;
+    builder: (args: Argv<BaseArgs>) => Argv<DiscoveryExportArgs>;
+    /**
+     * @inheritDoc
+     */
+    handler: (args: ArgumentsCamelCase<DiscoveryExportArgs>) => Promise<void>;
+    private resolvePaths;
+    private discoverExports;
+    private inferNameFromDefault;
+    private resolveOutputPath;
+    private resolveDriverPackage;
+    private generateFile;
+}
+export {};

package/commands/DiscoveryExportCommand.js

@@ -0,0 +1,219 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { colors, EntitySchema, MetadataStorage } from '@mikro-orm/core';
+import { fs } from '@mikro-orm/core/fs-utils';
+import { CLIHelper } from '../CLIHelper.js';
+const driverPackageMap = {
+    PostgreSqlDriver: '@mikro-orm/postgresql',
+    MySqlDriver: '@mikro-orm/mysql',
+    MariaDbDriver: '@mikro-orm/mariadb',
+    SqliteDriver: '@mikro-orm/sqlite',
+    LibSqlDriver: '@mikro-orm/libsql',
+    MsSqlDriver: '@mikro-orm/mssql',
+    OracleDriver: '@mikro-orm/oracledb',
+    MongoDriver: '@mikro-orm/mongodb',
+};
+export class DiscoveryExportCommand {
+    command = 'discovery:export';
+    describe = 'Generate a TypeScript barrel file with entity exports for typed Kysely and ORM config';
+    builder = (args) => {
+        args.option('path', {
+            alias: 'p',
+            type: 'string',
+            array: true,
+            desc: 'Glob patterns for entity source files',
+        });
+        args.option('out', {
+            alias: 'o',
+            type: 'string',
+            desc: 'Output file path (defaults to next to ORM config)',
+        });
+        args.option('dump', {
+            alias: 'd',
+            type: 'boolean',
+            desc: 'Print to stdout instead of writing a file',
+            default: false,
+        });
+        return args;
+    };
+    /**
+     * @inheritDoc
+     */
+    handler = async (args) => {
+        const config = await CLIHelper.getConfiguration(args.contextName, args.config);
+        const paths = this.resolvePaths(args, config);
+        const baseDir = fs.absolutePath(config.get('baseDir') ?? process.cwd());
+        const discovered = await this.discoverExports(paths, baseDir);
+        if (discovered.length === 0) {
+            CLIHelper.dump(colors.yellow('No entities found in the specified paths.'));
+            return;
+        }
+        const esm = CLIHelper.isESM();
+        const driverPackage = this.resolveDriverPackage(config);
+        if (args.dump) {
+            const output = this.generateFile(discovered, join(process.cwd(), 'entities.generated.ts'), esm, driverPackage);
+            CLIHelper.dump(output);
+            return;
+        }
+        const outPath = await this.resolveOutputPath(args);
+        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`);
+        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');
+    };
+    resolvePaths(args, config) {
+        if (args.path && args.path.length > 0) {
+            return args.path;
+        }
+        const entitiesTs = config.get('entitiesTs', []);
+        const stringPathsTs = entitiesTs.filter((p) => typeof p === 'string');
+        if (stringPathsTs.length > 0) {
+            return stringPathsTs;
+        }
+        const entities = config.get('entities', []);
+        const stringPaths = entities.filter((p) => typeof p === 'string');
+        if (stringPaths.length > 0) {
+            return stringPaths;
+        }
+        throw new Error('No entity paths found in config. Use --path to specify entity source locations.');
+    }
+    async discoverExports(paths, baseDir) {
+        const normalizedPaths = paths.map(path => fs.normalizePath(path));
+        const normalizedBaseDir = fs.normalizePath(baseDir);
+        const files = fs.glob(normalizedPaths, normalizedBaseDir);
+        const discovered = [];
+        for (const filepath of files) {
+            const filename = basename(filepath);
+            if (!/\.[cm]?[jt]s$/.exec(filename) || /\.d\.[cm]?ts/.exec(filename)) {
+                continue;
+            }
+            // fs.glob returns paths relative to normalizedBaseDir
+            const path = fs.normalizePath(baseDir, filepath);
+            const exports = await fs.dynamicImport(path);
+            const entries = Object.entries(exports);
+            // Collect entity schemas and their linked classes for dedup
+            const schemaClasses = new Set();
+            for (const [, value] of entries) {
+                if (EntitySchema.is(value) && value.meta.class) {
+                    schemaClasses.add(value.meta.class);
+                }
+            }
+            for (const [key, value] of entries) {
+                if (key === '__esModule') {
+                    continue;
+                }
+                const isSchema = EntitySchema.is(value);
+                // Skip class implementations that are linked from an EntitySchema
+                if (!isSchema && schemaClasses.has(value)) {
+                    continue;
+                }
+                const validTarget = isSchema || (value instanceof Function && MetadataStorage.isKnownEntity(value.name));
+                if (!validTarget) {
+                    continue;
+                }
+                const exportName = key === 'default' ? this.inferNameFromDefault(value, isSchema) : key;
+                // Avoid duplicates (e.g., default + named export of same thing)
+                if (discovered.some(d => d.filePath === path && d.exportName === exportName)) {
+                    continue;
+                }
+                discovered.push({
+                    exportName,
+                    filePath: path,
+                    isDefault: key === 'default',
+                });
+            }
+        }
+        discovered.sort((a, b) => a.exportName.localeCompare(b.exportName));
+        return discovered;
+    }
+    inferNameFromDefault(value, isSchema) {
+        if (isSchema) {
+            return value.meta.className ?? value.meta.name ?? 'DefaultEntity';
+        }
+        return value.name ?? 'DefaultEntity';
+    }
+    async resolveOutputPath(args) {
+        if (args.out) {
+            return resolve(args.out);
+        }
+        const configPaths = args.config ?? (await CLIHelper.getConfigPaths());
+        for (const configPath of configPaths) {
+            const absPath = fs.absolutePath(configPath);
+            if (fs.pathExists(absPath)) {
+                return resolve(dirname(absPath), 'entities.generated.ts');
+            }
+        }
+        return resolve(process.cwd(), 'entities.generated.ts');
+    }
+    resolveDriverPackage(config) {
+        try {
+            const driverName = config.getDriver().constructor.name;
+            return driverPackageMap[driverName] ?? '@mikro-orm/sql';
+        }
+        catch {
+            return '@mikro-orm/sql';
+        }
+    }
+    generateFile(discovered, outPath, esm, driverPackage) {
+        const outDir = dirname(outPath);
+        const lines = [
+            '// This file was generated by MikroORM CLI. Do not edit manually.',
+            '// Re-run `mikro-orm discovery:export` to update.',
+            '',
+        ];
+        // Group by file path for imports
+        const byFile = new Map();
+        for (const item of discovered) {
+            const list = byFile.get(item.filePath) ?? [];
+            list.push(item);
+            byFile.set(item.filePath, list);
+        }
+        // Generate import lines
+        for (const [filePath, items] of byFile) {
+            let rel = relative(outDir, filePath);
+            if (!rel.startsWith('.')) {
+                rel = './' + rel;
+            }
+            // Remove .ts extension and optionally add .js for ESM
+            rel = rel.replace(/\.[cm]?[jt]s$/, '');
+            if (esm) {
+                rel += '.js';
+            }
+            const defaults = items.filter(i => i.isDefault);
+            const named = items.filter(i => !i.isDefault);
+            for (const d of defaults) {
+                lines.push(`import ${d.exportName} from '${rel}';`);
+            }
+            if (named.length > 0) {
+                const names = named.map(n => n.exportName).join(', ');
+                lines.push(`import { ${names} } from '${rel}';`);
+            }
+        }
+        const isMongo = driverPackage === '@mikro-orm/mongodb';
+        // Type imports (Kysely types are not available for MongoDB)
+        if (!isMongo) {
+            lines.push(`import type { EntitySchemaWithMeta, InferKyselyDB, InferClassEntityDB } from '${driverPackage}';`);
+        }
+        lines.push('');
+        // entities array
+        lines.push('export const entities = [');
+        for (const item of discovered) {
+            lines.push(`  ${item.exportName},`);
+        }
+        lines.push('] as const;');
+        // Database type (Kysely is SQL-only, skip for MongoDB)
+        if (!isMongo) {
+            lines.push('');
+            lines.push('export type Database = InferKyselyDB<Extract<(typeof entities)[number], EntitySchemaWithMeta>>');
+            lines.push('  & InferClassEntityDB<(typeof entities)[number]>;');
+        }
+        lines.push('');
+        return lines.join('\n');
+    }
+}

package/commands/MigrationCommandFactory.d.ts

@@ -9,6 +9,9 @@ export declare class MigrationCommandFactory {
         check: string;
         pending: string;
         fresh: string;
+        log: string;
+        unlog: string;
+        rollup: string;
     };
     static create<const T extends MigratorMethod>(command: T): {
         command: string;
@@ -20,11 +23,15 @@ export declare class MigrationCommandFactory {
             check: string;
             pending: string;
             fresh: string;
+            log: string;
+            unlog: string;
+            rollup: 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 configureLogUnlogCommand;
     private static configureUpDownCommand;
     private static configureCreateCommand;
     static handleMigrationCommand(args: ArgumentsCamelCase<Opts>, method: MigratorMethod): Promise<void>;
@@ -35,6 +42,8 @@ export declare class MigrationCommandFactory {
     private static handleCreateCommand;
     private static handleCheckCommand;
     private static handleFreshCommand;
+    private static handleLogUnlogCommand;
+    private static handleRollupCommand;
     private static getUpDownOptions;
     private static getUpDownSuccessMessage;
 }
@@ -54,6 +63,9 @@ type MigratorCreateOptions = BaseArgs & {
     dump?: boolean;
     name?: string;
 };
+type MigratorLogUnlogOptions = BaseArgs & {
+    name?: string;
+};
 type MigrationOptionsMap = {
     create: MigratorCreateOptions;
     check: BaseArgs;
@@ -62,7 +74,10 @@ type MigrationOptionsMap = {
     list: BaseArgs;
     pending: BaseArgs;
     fresh: MigratorFreshOptions;
+    log: MigratorLogUnlogOptions;
+    unlog: MigratorLogUnlogOptions;
+    rollup: BaseArgs;
 };
 type MigratorMethod = keyof MigrationOptionsMap;
-type Opts = BaseArgs & MigratorCreateOptions & CliUpDownOptions & MigratorFreshOptions;
+type Opts = BaseArgs & MigratorCreateOptions & CliUpDownOptions & MigratorFreshOptions & MigratorLogUnlogOptions;
 export {};

package/commands/MigrationCommandFactory.js

@@ -9,6 +9,9 @@ export class MigrationCommandFactory {
         check: 'Check if migrations are needed. Useful for bash scripts.',
         pending: 'List all pending migrations',
         fresh: 'Clear the database and rerun all migrations',
+        log: 'Mark a migration as executed without running it',
+        unlog: 'Remove a migration from the executed list without reverting it',
+        rollup: 'Combine multiple migrations into a single migration',
     };
     static create(command) {
         // oxfmt-ignore
@@ -29,6 +32,18 @@ export class MigrationCommandFactory {
         if (method === 'fresh') {
             return this.configureFreshCommand(args);
         }
+        if (method === 'log' || method === 'unlog') {
+            return this.configureLogUnlogCommand(args);
+        }
+        return args;
+    }
+    static configureLogUnlogCommand(args) {
+        args.option('n', {
+            alias: 'name',
+            type: 'string',
+            desc: 'Name of the migration to log/unlog',
+            demandOption: true,
+        });
         return args;
     }
     static configureUpDownCommand(args, method) {
@@ -100,6 +115,14 @@ export class MigrationCommandFactory {
                 break;
             case 'fresh':
                 await this.handleFreshCommand(args, orm.migrator, orm);
+                break;
+            case 'log':
+            case 'unlog':
+                await this.handleLogUnlogCommand(args, orm.migrator, method);
+                break;
+            case 'rollup':
+                await this.handleRollupCommand(orm.migrator);
+                break;
         }
         await orm.close(true);
     }
@@ -182,6 +205,15 @@ export class MigrationCommandFactory {
             CLIHelper.dump(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}'`));
+    }
+    static async handleRollupCommand(migrator) {
+        const ret = await migrator.rollup();
+        CLIHelper.dump(colors.green(`${ret.fileName} successfully created (rollup)`));
+    }
     static getUpDownOptions(flags) {
         if (!flags.to && !flags.from && flags.only) {
             return { migrations: flags.only.split(/[, ]+/) };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/cli",
-  "version": "7.1.0-dev.0",
+  "version": "7.1.0-dev.10",
   "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.1.0-dev.0",
-    "mikro-orm": "7.1.0-dev.0",
+    "@mikro-orm/core": "7.1.0-dev.10",
+    "mikro-orm": "7.1.0-dev.10",
     "yargs": "17.7.2"
   },
   "engines": {