@mikro-orm/cli 7.0.4 → 7.0.5-dev.1

package/README.md

@@ -133,7 +133,7 @@ const author = await em.findOneOrFail(Author, 1, {
   populate: ['books'],
 });
 author.name = 'Jon Snow II';
-author.books.getItems().forEach(book => (book.title += ' (2nd ed.)'));
+author.books.getItems().forEach(book => book.title += ' (2nd ed.)');
 author.books.add(orm.em.create(Book, { title: 'New Book', author }));
 
 // Flush computes change sets and executes them in a single transaction

package/cli.js

@@ -4,5 +4,5 @@ import { configure } from './CLIConfigurator.js';
 const argv = await configure();
 const args = await argv.parse(process.argv.slice(2));
 if (args._.length === 0) {
-  CLIHelper.showHelp();
+    CLIHelper.showHelp();
 }

package/commands/ClearCacheCommand.d.ts

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

package/commands/ClearCacheCommand.js

@@ -1,21 +1,19 @@
 import { colors } from '@mikro-orm/core';
 import { CLIHelper } from '../CLIHelper.js';
 export class ClearCacheCommand {
-  command = 'cache:clear';
-  describe = 'Clear metadata cache';
-  /**
-   * @inheritDoc
-   */
-  async handler(args) {
-    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.'),
-      );
-      return;
+    command = 'cache:clear';
+    describe = 'Clear metadata cache';
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        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.'));
+            return;
+        }
+        const cache = config.getMetadataCacheAdapter();
+        await cache.clear();
+        CLIHelper.dump(colors.green('Metadata cache was successfully cleared'));
     }
-    const cache = config.getMetadataCacheAdapter();
-    await cache.clear();
-    CLIHelper.dump(colors.green('Metadata cache was successfully cleared'));
-  }
 }

package/commands/CompileCommand.d.ts

@@ -2,23 +2,20 @@ 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;
+    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;
-  }[];
+    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

@@ -1,99 +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 { 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;
+    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`);
     }
-    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);
+    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);
+                }
+            }
         }
-        if (meta.primaryKeys.length > 0) {
-          comparator.getPkGetter(meta);
-          comparator.getPkGetterConverted(meta);
-          comparator.getPkSerializer(meta);
+        finally {
+            Utils.createFunction = original;
         }
-      }
-    } finally {
-      Utils.createFunction = original;
+        return captured;
     }
-    return captured;
-  }
 }

package/commands/CreateDatabaseCommand.d.ts

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

package/commands/CreateDatabaseCommand.js

@@ -1,13 +1,13 @@
 import { CLIHelper } from '../CLIHelper.js';
 export class CreateDatabaseCommand {
-  command = 'database:create';
-  describe = 'Create your database if it does not exist';
-  /**
-   * @inheritDoc
-   */
-  async handler(args) {
-    const orm = await CLIHelper.getORM(args.contextName, args.config);
-    await orm.schema.ensureDatabase();
-    await orm.close(true);
-  }
+    command = 'database:create';
+    describe = 'Create your database if it does not exist';
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const orm = await CLIHelper.getORM(args.contextName, args.config);
+        await orm.schema.ensureDatabase();
+        await orm.close(true);
+    }
 }

package/commands/CreateSeederCommand.d.ts

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

package/commands/CreateSeederCommand.js

@@ -1,32 +1,31 @@
 import { colors } from '@mikro-orm/core';
 import { CLIHelper } from '../CLIHelper.js';
 export class CreateSeederCommand {
-  command = 'seeder:create <seeder>';
-  describe = 'Create a new seeder class';
-  builder = args => {
-    args.positional('seeder', {
-      describe:
-        'Name for the seeder class. (e.g. "test" will generate "TestSeeder" or "TestSeeder" will generate "TestSeeder")',
-      demandOption: true,
-    });
-    return args;
-  };
-  /**
-   * @inheritDoc
-   */
-  async handler(args) {
-    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}`));
-    await orm.close(true);
-  }
-  /**
-   * Will return a seeder name that is formatted like this EntitySeeder
-   */
-  static getSeederClassName(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';
-  }
+    command = 'seeder:create <seeder>';
+    describe = 'Create a new seeder class';
+    builder = (args) => {
+        args.positional('seeder', {
+            describe: 'Name for the seeder class. (e.g. "test" will generate "TestSeeder" or "TestSeeder" will generate "TestSeeder")',
+            demandOption: true,
+        });
+        return args;
+    };
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        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}`));
+        await orm.close(true);
+    }
+    /**
+     * Will return a seeder name that is formatted like this EntitySeeder
+     */
+    static getSeederClassName(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.d.ts

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

package/commands/DatabaseSeedCommand.js

@@ -1,24 +1,24 @@
 import { colors } from '@mikro-orm/core';
 import { CLIHelper } from '../CLIHelper.js';
 export class DatabaseSeedCommand {
-  command = 'seeder:run';
-  describe = 'Seed the database using the seeder class';
-  builder = args => {
-    args.option('c', {
-      alias: 'class',
-      type: 'string',
-      desc: 'Seeder class to run',
-    });
-    return args;
-  };
-  /**
-   * @inheritDoc
-   */
-  async handler(args) {
-    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`));
-    await orm.close(true);
-  }
+    command = 'seeder:run';
+    describe = 'Seed the database using the seeder class';
+    builder = (args) => {
+        args.option('c', {
+            alias: 'class',
+            type: 'string',
+            desc: 'Seeder class to run',
+        });
+        return args;
+    };
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        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`));
+        await orm.close(true);
+    }
 }

package/commands/DebugCommand.d.ts

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