@mikro-orm/cli 7.0.0-dev.220 → 7.0.0-dev.222

package/CLIConfigurator.js

@@ -7,6 +7,7 @@ import { CreateSeederCommand } from './commands/CreateSeederCommand.js';
 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 { GenerateEntitiesCommand } from './commands/GenerateEntitiesCommand.js';
 import { ImportCommand } from './commands/ImportCommand.js';
 import { MigrationCommandFactory } from './commands/MigrationCommandFactory.js';
@@ -51,6 +52,7 @@ export async function configure() {
         .version(version)
         .command(new ClearCacheCommand())
         .command(new GenerateCacheCommand())
+        .command(new CompileCommand())
         .command(new GenerateEntitiesCommand())
         .command(new CreateDatabaseCommand())
         .command(new ImportCommand())

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/cli",
   "type": "module",
-  "version": "7.0.0-dev.220",
+  "version": "7.0.0-dev.222",
   "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",
@@ -53,8 +53,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/core": "7.0.0-dev.220",
-    "mikro-orm": "7.0.0-dev.220",
+    "@mikro-orm/core": "7.0.0-dev.222",
+    "mikro-orm": "7.0.0-dev.222",
     "yargs": "17.7.2"
   }
 }