@mikro-orm/cli 7.0.0-dev.32 → 7.0.0-dev.321

package/commands/CompileCommand.d.ts

@@ -0,0 +1,21 @@
+import type { ArgumentsCamelCase, Argv } from 'yargs';
+import { MetadataStorage, type Configuration } from '@mikro-orm/core';
+import type { BaseArgs, BaseCommand } from '../CLIConfigurator.js';
+type CompileArgs = BaseArgs & {
+    out?: string;
+};
+export declare class CompileCommand implements BaseCommand<CompileArgs> {
+    command: string;
+    describe: string;
+    builder: (args: Argv<BaseArgs>) => Argv<CompileArgs>;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase<CompileArgs>): Promise<void>;
+    static capture(metadata: MetadataStorage, config: Configuration): {
+        key: string;
+        contextKeys: string[];
+        code: string;
+    }[];
+}
+export {};

package/commands/CompileCommand.js

@@ -0,0 +1,94 @@
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { MetadataDiscovery, MetadataStorage, Utils, EntityComparator, ObjectHydrator, colors, } from '@mikro-orm/core';
+import { fs } from '@mikro-orm/core/fs-utils';
+import { CLIHelper } from '../CLIHelper.js';
+export class CompileCommand {
+    command = 'compile';
+    describe = 'Pre-compile optimized entity functions for runtimes that prohibit eval (e.g. Cloudflare Workers)';
+    builder = (args) => {
+        args.option('out', {
+            type: 'string',
+            desc: 'Output path for the generated file (defaults to next to your ORM config)',
+        });
+        return args;
+    };
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const config = await CLIHelper.getConfiguration(args.contextName, args.config);
+        const settings = CLIHelper.getSettings();
+        config.set('debug', !!settings.verbose);
+        const metadata = await new MetadataDiscovery(new MetadataStorage(), config.getDriver().getPlatform(), config).discover(false);
+        // Default output path to next to the ORM config file
+        if (!args.out) {
+            const configPaths = args.config ?? (await CLIHelper.getConfigPaths());
+            for (const configPath of configPaths) {
+                const absPath = fs.absolutePath(configPath);
+                if (fs.pathExists(absPath)) {
+                    args.out = resolve(dirname(absPath), 'compiled-functions.js');
+                    break;
+                }
+            }
+        }
+        const captured = CompileCommand.capture(metadata, config);
+        const entries = captured.map(({ key, contextKeys, code }) => {
+            const params = contextKeys.join(', ');
+            const indentedCode = code.replace(/\n/g, '\n    ');
+            return `  '${key}': function(${params}) {\n    ${indentedCode}\n  }`;
+        });
+        const esm = CLIHelper.isESM();
+        const version = Utils.getORMVersion();
+        const output = esm
+            ? `export default {\n  __version: '${version}',\n${entries.join(',\n')}\n};\n`
+            : `'use strict';\nmodule.exports = {\n  __version: '${version}',\n${entries.join(',\n')}\n};\n`;
+        const outPath = args.out ?? resolve(process.cwd(), 'compiled-functions.js');
+        const dtsPath = outPath.replace(/\.js$/, '.d.ts');
+        const dts = esm
+            ? `import type { CompiledFunctions } from '@mikro-orm/core';\ndeclare const compiledFunctions: CompiledFunctions;\nexport default compiledFunctions;\n`
+            : `import type { CompiledFunctions } from '@mikro-orm/core';\ndeclare const compiledFunctions: CompiledFunctions;\nexport = compiledFunctions;\n`;
+        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`);
+        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`);
+    }
+    static capture(metadata, config) {
+        const captured = [];
+        const original = Utils.createFunction;
+        Utils.createFunction = (context, code, _compiledFunctions, key) => {
+            captured.push({ key: key, contextKeys: [...context.keys()], code });
+            return original.call(Utils, context, code);
+        };
+        try {
+            const platform = config.getDriver().getPlatform();
+            const hydrator = new ObjectHydrator(metadata, platform, config);
+            const comparator = new EntityComparator(metadata, platform, config);
+            for (const meta of metadata) {
+                hydrator.getEntityHydrator(meta, 'full', false);
+                hydrator.getEntityHydrator(meta, 'full', true);
+                comparator.getEntityComparator(meta.class);
+                comparator.getSnapshotGenerator(meta.class);
+                comparator.getResultMapper(meta);
+                if (!meta.embeddable && !meta.virtual) {
+                    hydrator.getEntityHydrator(meta, 'reference', false);
+                    hydrator.getEntityHydrator(meta, 'reference', true);
+                }
+                if (meta.primaryKeys.length > 0) {
+                    comparator.getPkGetter(meta);
+                    comparator.getPkGetterConverted(meta);
+                    comparator.getPkSerializer(meta);
+                }
+            }
+        }
+        finally {
+            Utils.createFunction = original;
+        }
+        return captured;
+    }
+}

package/commands/CreateDatabaseCommand.js

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

package/commands/CreateSeederCommand.js

@@ -16,8 +16,7 @@ export class CreateSeederCommand {
     async handler(args) {
         const className = CreateSeederCommand.getSeederClassName(args.seeder);
         const orm = await CLIHelper.getORM(args.contextName, args.config);
-        const seeder = orm.getSeeder();
-        const path = await seeder.createSeeder(className);
+        const path = await orm.seeder.create(className);
         CLIHelper.dump(colors.green(`Seeder ${args.seeder} successfully created at ${path}`));
         await orm.close(true);
     }
@@ -25,7 +24,7 @@ export class CreateSeederCommand {
      * Will return a seeder name that is formatted like this EntitySeeder
      */
     static getSeederClassName(name) {
-        name = name.match(/(.+)seeder/i)?.[1] ?? name;
+        name = /(.+)seeder/i.exec(name)?.[1] ?? name;
         const parts = name.split('-');
         return parts.map(name => name.charAt(0).toUpperCase() + name.slice(1)).join('') + 'Seeder';
     }

package/commands/DatabaseSeedCommand.js

@@ -17,7 +17,7 @@ export class DatabaseSeedCommand {
     async handler(args) {
         const orm = await CLIHelper.getORM(args.contextName, args.config);
         const className = args.class ?? orm.config.get('seeder').defaultSeeder;
-        await orm.getSeeder().seedString(className);
+        await orm.seeder.seedString(className);
         CLIHelper.dump(colors.green(`Seeder ${className} successfully executed`));
         await orm.close(true);
     }

package/commands/DebugCommand.js

@@ -1,4 +1,5 @@
-import { ConfigurationLoader, Utils, colors } from '@mikro-orm/core';
+import { colors } from '@mikro-orm/core';
+import { fs } from '@mikro-orm/core/fs-utils';
 import { CLIHelper } from '../CLIHelper.js';
 export class DebugCommand {
     command = 'debug';
@@ -8,12 +9,13 @@ export class DebugCommand {
      */
     async handler(args) {
         CLIHelper.dump(`Current ${colors.cyan('MikroORM')} CLI configuration`);
-        await CLIHelper.dumpDependencies();
-        const settings = ConfigurationLoader.getSettings();
+        CLIHelper.dumpDependencies();
+        const settings = CLIHelper.getSettings();
         if (!process.versions.bun && settings.preferTs !== false) {
-            CLIHelper.dump(' - TypeScript support ' + colors.green('enabled'));
+            const loader = process.env.MIKRO_ORM_CLI_TS_LOADER ?? 'auto';
+            CLIHelper.dump(' - TypeScript support ' + colors.green(`enabled (${loader})`));
         }
-        const configPaths = args.config ?? CLIHelper.getConfigPaths();
+        const configPaths = args.config ?? (await CLIHelper.getConfigPaths());
         CLIHelper.dump(' - searched config paths:');
         await DebugCommand.checkPaths(configPaths, 'yellow');
         CLIHelper.dump(` - searched for config name: ${colors.green(args.contextName)}`);
@@ -23,7 +25,7 @@ export class DebugCommand {
             const drivers = CLIHelper.getDriverDependencies(config);
             CLIHelper.dump(' - driver dependencies:');
             for (const driver of drivers) {
-                CLIHelper.dump(`   - ${driver} ${await CLIHelper.getModuleVersion(driver)}`);
+                CLIHelper.dump(`   - ${driver} ${CLIHelper.getModuleVersion(driver)}`);
             }
             const isConnected = await CLIHelper.isDBConnected(config, true);
             if (isConnected === true) {
@@ -39,8 +41,8 @@ export class DebugCommand {
             }
             const entities = config.get('entities', []);
             if (entities.length > 0) {
-                const refs = entities.filter(p => !Utils.isString(p));
-                const paths = entities.filter(p => Utils.isString(p));
+                const refs = entities.filter(p => typeof p !== 'string');
+                const paths = entities.filter(p => typeof p === 'string');
                 const will = !config.get('preferTs') ? 'will' : 'could';
                 CLIHelper.dump(` - ${will} use \`entities\` array (contains ${refs.length} references and ${paths.length} paths)`);
                 if (paths.length > 0) {
@@ -49,8 +51,8 @@ export class DebugCommand {
             }
             const entitiesTs = config.get('entitiesTs', []);
             if (entitiesTs.length > 0) {
-                const refs = entitiesTs.filter(p => !Utils.isString(p));
-                const paths = entitiesTs.filter(p => Utils.isString(p));
+                const refs = entitiesTs.filter(p => typeof p !== 'string');
+                const paths = entitiesTs.filter(p => typeof p === 'string');
                 /* v8 ignore next */
                 const will = config.get('preferTs') ? 'will' : 'could';
                 CLIHelper.dump(` - ${will} use \`entitiesTs\` array (contains ${refs.length} references and ${paths.length} paths)`);
@@ -65,10 +67,9 @@ export class DebugCommand {
     }
     static async checkPaths(paths, failedColor, baseDir) {
         for (let path of paths) {
-            path = Utils.absolutePath(path, baseDir);
-            path = Utils.normalizePath(path);
-            const found = await Utils.pathExists(path);
-            if (found) {
+            path = fs.absolutePath(path, baseDir);
+            path = fs.normalizePath(path);
+            if (fs.pathExists(path)) {
                 CLIHelper.dump(`   - ${path} (${colors.green('found')})`);
             }
             else {

package/commands/GenerateCacheCommand.js

@@ -1,4 +1,5 @@
-import { MetadataDiscovery, MetadataStorage, colors, FileCacheAdapter } from '@mikro-orm/core';
+import { MetadataDiscovery, MetadataStorage, colors } from '@mikro-orm/core';
+import { FileCacheAdapter } from '@mikro-orm/core/fs-utils';
 import { CLIHelper } from '../CLIHelper.js';
 export class GenerateCacheCommand {
     command = 'cache:generate';
@@ -25,7 +26,7 @@ export class GenerateCacheCommand {
         await config.getMetadataCacheAdapter().clear();
         config.set('logger', CLIHelper.dump.bind(null));
         config.set('debug', true);
-        const discovery = new MetadataDiscovery(MetadataStorage.init(), config.getDriver().getPlatform(), config);
+        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 : ''}`));

package/commands/ImportCommand.js

@@ -1,3 +1,4 @@
+import { readFile } from 'node:fs/promises';
 import { colors } from '@mikro-orm/core';
 import { CLIHelper } from '../CLIHelper.js';
 export class ImportCommand {
@@ -8,7 +9,8 @@ export class ImportCommand {
      */
     async handler(args) {
         const orm = await CLIHelper.getORM(args.contextName, args.config, { multipleStatements: true });
-        await orm.em.getConnection().loadFile(args.file);
+        const buf = await readFile(args.file);
+        await orm.em.getConnection().executeDump(buf.toString());
         CLIHelper.dump(colors.green(`File ${args.file} successfully imported`));
         await orm.close(true);
     }

package/commands/MigrationCommandFactory.js

@@ -1,4 +1,4 @@
-import { Utils, colors } from '@mikro-orm/core';
+import { colors, Utils, } from '@mikro-orm/core';
 import { CLIHelper } from '../CLIHelper.js';
 export class MigrationCommandFactory {
     static DESCRIPTIONS = {
@@ -11,6 +11,7 @@ export class MigrationCommandFactory {
         fresh: 'Clear the database and rerun all migrations',
     };
     static create(command) {
+        // oxfmt-ignore
         return {
             command: `migration:${command}`,
             describe: MigrationCommandFactory.DESCRIPTIONS[command],
@@ -80,26 +81,25 @@ export class MigrationCommandFactory {
         // 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);
-        const migrator = orm.getMigrator();
         switch (method) {
             case 'create':
-                await this.handleCreateCommand(migrator, args, orm.config);
+                await this.handleCreateCommand(orm.migrator, args, orm.config);
                 break;
             case 'check':
-                await this.handleCheckCommand(migrator, orm);
+                await this.handleCheckCommand(orm.migrator, orm);
                 break;
             case 'list':
-                await this.handleListCommand(migrator);
+                await this.handleListCommand(orm.migrator);
                 break;
             case 'pending':
-                await this.handlePendingCommand(migrator);
+                await this.handlePendingCommand(orm.migrator);
                 break;
             case 'up':
             case 'down':
-                await this.handleUpDownCommand(args, migrator, method);
+                await this.handleUpDownCommand(args, orm.migrator, method);
                 break;
             case 'fresh':
-                await this.handleFreshCommand(args, migrator, orm);
+                await this.handleFreshCommand(args, orm.migrator, orm);
         }
         await orm.close(true);
     }
@@ -121,7 +121,7 @@ export class MigrationCommandFactory {
         CLIHelper.dump(colors.green(message));
     }
     static async handlePendingCommand(migrator) {
-        const pending = await migrator.getPendingMigrations();
+        const pending = await migrator.getPending();
         CLIHelper.dumpTable({
             columns: ['Name'],
             rows: pending.map(row => [row.name]),
@@ -129,7 +129,7 @@ export class MigrationCommandFactory {
         });
     }
     static async handleListCommand(migrator) {
-        const executed = await migrator.getExecutedMigrations();
+        const executed = await migrator.getExecuted();
         CLIHelper.dumpTable({
             columns: ['Name', 'Executed at'],
             rows: executed.map(row => {
@@ -141,7 +141,7 @@ export class MigrationCommandFactory {
         });
     }
     static async handleCreateCommand(migrator, args, config) {
-        const ret = await migrator.createMigration(args.path, args.blank, args.initial, args.name);
+        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`));
         }
@@ -149,19 +149,20 @@ export class MigrationCommandFactory {
             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 next 3 */
+            /* 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`));
     }
     static async handleCheckCommand(migrator, orm) {
-        if (!(await migrator.checkMigrationNeeded())) {
+        if (!(await migrator.checkSchema())) {
             return CLIHelper.dump(colors.green(`No changes required, schema is up-to-date`));
         }
         await orm.close(true);
@@ -169,17 +170,15 @@ export class MigrationCommandFactory {
         process.exit(1);
     }
     static async handleFreshCommand(args, migrator, orm) {
-        const generator = orm.getSchemaGenerator();
-        await generator.dropSchema({ dropMigrationsTable: true, dropDb: args.dropDb });
+        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 seeder = orm.getSeeder();
             const seederClass = args.seed || orm.config.get('seeder').defaultSeeder;
-            await seeder.seedString(seederClass);
+            await orm.seeder.seedString(seederClass);
             CLIHelper.dump(colors.green(`Database seeded successfully with seeder class ${seederClass}`));
         }
     }
@@ -188,7 +187,7 @@ export class MigrationCommandFactory {
             return { migrations: flags.only.split(/[, ]+/) };
         }
         const ret = {};
-        ['from', 'to'].filter(k => flags[k]).forEach(k => ret[k] = flags[k] === '0' ? 0 : flags[k]);
+        ['from', 'to'].filter(k => flags[k]).forEach(k => (ret[k] = flags[k] === '0' ? 0 : flags[k]));
         return ret;
     }
     static getUpDownSuccessMessage(method, options) {
@@ -203,10 +202,10 @@ export class MigrationCommandFactory {
         if (method === 'up' && Utils.isEmpty(options)) {
             return msg + ' to the latest version';
         }
-        if (Utils.isString(options.to)) {
+        if (typeof options.to === 'string') {
             return msg + ' to version ' + options.to;
         }
-        if (options.migrations && options.migrations.length === 1) {
+        if (options.migrations?.length === 1) {
             return msg + ' to version ' + options.migrations[0];
         }
         return msg;

package/commands/SchemaCommandFactory.js

@@ -80,12 +80,11 @@ export class SchemaCommandFactory {
             return CLIHelper.showHelp();
         }
         const orm = await CLIHelper.getORM(args.contextName, args.config);
-        const generator = orm.getSchemaGenerator();
         const params = { wrap: args.fkChecks == null ? undefined : !args.fkChecks, ...args };
         if (args.dump) {
             const m = `get${method.substr(0, 1).toUpperCase()}${method.substr(1)}SchemaSQL`;
-            const dump = await generator[m](params);
-            /* v8 ignore next 3 */
+            const dump = await orm.schema[m](params);
+            /* v8 ignore if */
             if (dump) {
                 CLIHelper.dump(dump, orm.config);
                 successMessage = '';
@@ -95,16 +94,13 @@ export class SchemaCommandFactory {
             }
         }
         else if (method === 'fresh') {
-            await generator.dropSchema(params);
-            await generator.createSchema(params);
+            await orm.schema.refresh(params);
         }
         else {
-            const m = method + 'Schema';
-            await generator[m](params);
+            await orm.schema[method](params);
         }
         if (typeof args.seed !== 'undefined') {
-            const seeder = orm.getSeeder();
-            await seeder.seedString(args.seed || orm.config.get('seeder').defaultSeeder);
+            await orm.seeder.seedString(args.seed || orm.config.get('seeder').defaultSeeder);
         }
         CLIHelper.dump(colors.green(successMessage));
         await orm.close(true);

package/package.json

@@ -1,65 +1,60 @@
 {
   "name": "@mikro-orm/cli",
-  "type": "module",
-  "version": "7.0.0-dev.32",
+  "version": "7.0.0-dev.321",
   "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.",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": "./index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
   "bin": {
     "mikro-orm": "./cli"
   },
-  "engines": {
-    "node": ">= 22.11.0"
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
-    "@mikro-orm/core": "7.0.0-dev.32",
-    "@mikro-orm/knex": "7.0.0-dev.32",
+    "@mikro-orm/core": "7.0.0-dev.321",
+    "mikro-orm": "7.0.0-dev.321",
     "yargs": "17.7.2"
   },
-  "devDependencies": {
-    "@mikro-orm/entity-generator": "^6.5.7",
-    "@mikro-orm/migrations": "^6.5.7",
-    "@mikro-orm/seeder": "^6.5.7"
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }