@mikro-orm/cli 7.0.0-dev.64 → 7.0.0-dev.66

package/CLIConfigurator.d.ts

@@ -2,20 +2,20 @@ import { type CommandModule } from 'yargs';
 /**
  * @internal
  */
-export type BaseArgs = Awaited<ReturnType<typeof CLIConfigurator['createBasicConfig']>['argv']>;
+export type BaseArgs = Awaited<ReturnType<typeof createBasicConfig>['argv']>;
 /**
  * @internal
  */
 export interface BaseCommand<CommandArgs extends BaseArgs = BaseArgs> extends CommandModule<BaseArgs, CommandArgs> {
 }
-/**
- * @internal
- */
-export declare class CLIConfigurator {
-    private static createBasicConfig;
-    static configure(): Promise<import("yargs").Argv<{
-        config: string[] | undefined;
-    } & {
-        contextName: string;
-    }>>;
-}
+declare function createBasicConfig(): import("yargs").Argv<{
+    config: string[] | undefined;
+} & {
+    contextName: string;
+}>;
+export declare function configure(): Promise<import("yargs").Argv<{
+    config: string[] | undefined;
+} & {
+    contextName: string;
+}>>;
+export {};

package/CLIConfigurator.js

@@ -10,65 +10,61 @@ import { GenerateEntitiesCommand } from './commands/GenerateEntitiesCommand.js';
 import { ImportCommand } from './commands/ImportCommand.js';
 import { MigrationCommandFactory } from './commands/MigrationCommandFactory.js';
 import { SchemaCommandFactory } from './commands/SchemaCommandFactory.js';
-/**
- * @internal
- */
-export class CLIConfigurator {
-    static createBasicConfig() {
-        return yargs()
-            .scriptName('mikro-orm')
-            .usage('Usage: $0 <command> [options]')
-            .example('$0 debug', 'Show debugging information')
-            .example('$0 schema:update --run', 'Runs schema synchronization')
-            .option('config', {
-            type: 'string',
-            array: true,
-            desc: `Set path to the ORM configuration file`,
-        })
-            .option('contextName', {
-            alias: 'context',
-            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',
-        })
-            .alias('v', 'version')
-            .alias('h', 'help')
-            .recommendCommands()
-            .showHelpOnFail(true)
-            .demandCommand(1, '')
-            .strict();
-    }
-    static async configure() {
-        ConfigurationLoader.checkPackageVersion();
-        const settings = ConfigurationLoader.getSettings();
-        const version = Utils.getORMVersion();
-        if (settings.preferTs !== false) {
-            const preferTs = await ConfigurationLoader.registerTypeScriptSupport(settings.tsConfigPath, settings.tsLoader);
-            /* v8 ignore next 3 */
-            if (!preferTs) {
-                process.env.MIKRO_ORM_CLI_PREFER_TS ??= '0';
-            }
+import { CLIHelper } from './CLIHelper.js';
+function createBasicConfig() {
+    return yargs()
+        .scriptName('mikro-orm')
+        .usage('Usage: $0 <command> [options]')
+        .example('$0 debug', 'Show debugging information')
+        .example('$0 schema:update --run', 'Runs schema synchronization')
+        .option('config', {
+        type: 'string',
+        array: true,
+        desc: `Set path to the ORM configuration file`,
+    })
+        .option('contextName', {
+        alias: 'context',
+        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',
+    })
+        .alias('v', 'version')
+        .alias('h', 'help')
+        .recommendCommands()
+        .showHelpOnFail(true)
+        .demandCommand(1, '')
+        .strict();
+}
+export async function configure() {
+    ConfigurationLoader.checkPackageVersion();
+    const settings = CLIHelper.getSettings();
+    const version = Utils.getORMVersion();
+    if (settings.preferTs !== false) {
+        const preferTs = await CLIHelper.registerTypeScriptSupport(settings.tsConfigPath, settings.tsLoader);
+        /* v8 ignore next 3 */
+        if (!preferTs) {
+            process.env.MIKRO_ORM_CLI_PREFER_TS ??= '0';
         }
-        return CLIConfigurator.createBasicConfig()
-            .version(version)
-            .command(new ClearCacheCommand())
-            .command(new GenerateCacheCommand())
-            .command(new GenerateEntitiesCommand())
-            .command(new CreateDatabaseCommand())
-            .command(new ImportCommand())
-            .command(new DatabaseSeedCommand())
-            .command(new CreateSeederCommand())
-            .command(SchemaCommandFactory.create('create'))
-            .command(SchemaCommandFactory.create('drop'))
-            .command(SchemaCommandFactory.create('update'))
-            .command(SchemaCommandFactory.create('fresh'))
-            .command(MigrationCommandFactory.create('create'))
-            .command(MigrationCommandFactory.create('up'))
-            .command(MigrationCommandFactory.create('down'))
-            .command(MigrationCommandFactory.create('list'))
-            .command(MigrationCommandFactory.create('check'))
-            .command(MigrationCommandFactory.create('pending'))
-            .command(MigrationCommandFactory.create('fresh'))
-            .command(new DebugCommand());
     }
+    return createBasicConfig()
+        .version(version)
+        .command(new ClearCacheCommand())
+        .command(new GenerateCacheCommand())
+        .command(new GenerateEntitiesCommand())
+        .command(new CreateDatabaseCommand())
+        .command(new ImportCommand())
+        .command(new DatabaseSeedCommand())
+        .command(new CreateSeederCommand())
+        .command(SchemaCommandFactory.create('create'))
+        .command(SchemaCommandFactory.create('drop'))
+        .command(SchemaCommandFactory.create('update'))
+        .command(SchemaCommandFactory.create('fresh'))
+        .command(MigrationCommandFactory.create('create'))
+        .command(MigrationCommandFactory.create('up'))
+        .command(MigrationCommandFactory.create('down'))
+        .command(MigrationCommandFactory.create('list'))
+        .command(MigrationCommandFactory.create('check'))
+        .command(MigrationCommandFactory.create('pending'))
+        .command(MigrationCommandFactory.create('fresh'))
+        .command(new DebugCommand());
 }

package/CLIHelper.d.ts

@@ -1,16 +1,26 @@
-import { MikroORM, type Configuration, type IDatabaseDriver, type Options } from '@mikro-orm/core';
+import { type EntityManagerType, type EntityManager, MikroORM, Configuration, type IDatabaseDriver, type Options } from '@mikro-orm/core';
 /**
  * @internal
  */
 export declare class CLIHelper {
-    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver>(contextName?: string, configPaths?: string[], options?: Partial<Options<D>>): Promise<Configuration<D>>;
+    /**
+     * Gets a named configuration
+     *
+     * @param contextName Load a config with the given `contextName` value. Used when config file exports array or factory function. Setting it to "default" matches also config objects without `contextName` set.
+     * @param paths Array of possible paths for a configuration file. Files will be checked in order, and the first existing one will be used. Defaults to the output of {@link ConfigurationLoader.getConfigPaths}.
+     * @param options Additional options to augment the final configuration with.
+     */
+    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>>(contextName?: string, paths?: string[], options?: Partial<Options<D>>): Promise<Configuration<D, EM>>;
     static getORM<D extends IDatabaseDriver = IDatabaseDriver>(contextName?: string, configPaths?: string[], opts?: Partial<Options<D>>): Promise<MikroORM<D>>;
     static isDBConnected(config: Configuration, reason?: false): Promise<boolean>;
     static isDBConnected(config: Configuration, reason: true): Promise<true | string>;
     static getNodeVersion(): string;
     static getDriverDependencies(config: Configuration): string[];
     static dump(text: string, config?: Configuration): void;
+    static getSettings(): Settings;
     static getConfigPaths(): string[];
+    private static getConfigFile;
+    private static loadEnvironmentVars;
     static dumpDependencies(): Promise<void>;
     static getModuleVersion(name: string): Promise<string>;
     static dumpTable(options: {
@@ -18,5 +28,19 @@ export declare class CLIHelper {
         rows: string[][];
         empty: string;
     }): void;
+    /**
+     * Tries to register TS support in the following order: swc, tsx, jiti, tsimp
+     * Use `MIKRO_ORM_CLI_TS_LOADER` env var to set the loader explicitly.
+     * This method is used only in CLI context.
+     */
+    static registerTypeScriptSupport(configPath?: string, tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto'): Promise<boolean>;
+    static isESM(): boolean;
     static showHelp(): void;
 }
+export interface Settings {
+    verbose?: boolean;
+    preferTs?: boolean;
+    tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto';
+    tsConfigPath?: string;
+    configPaths?: string[];
+}

package/CLIHelper.js

@@ -1,22 +1,87 @@
 import { readFile } from 'node:fs/promises';
 import yargs from 'yargs';
-import { colors, ConfigurationLoader, MikroORM, Utils } from '@mikro-orm/core';
+import { colors, ConfigurationLoader, MikroORM, Utils, Configuration, } from '@mikro-orm/core';
 /**
  * @internal
  */
 export class CLIHelper {
-    static async getConfiguration(contextName, configPaths, options = {}) {
+    /**
+     * Gets a named configuration
+     *
+     * @param contextName Load a config with the given `contextName` value. Used when config file exports array or factory function. Setting it to "default" matches also config objects without `contextName` set.
+     * @param paths Array of possible paths for a configuration file. Files will be checked in order, and the first existing one will be used. Defaults to the output of {@link ConfigurationLoader.getConfigPaths}.
+     * @param options Additional options to augment the final configuration with.
+     */
+    static async getConfiguration(contextName, paths = this.getConfigPaths(), options = {}) {
         const deps = ConfigurationLoader.getORMPackages();
         if (!deps.has('@mikro-orm/cli') && !process.env.MIKRO_ORM_ALLOW_GLOBAL_CLI) {
             throw new Error('@mikro-orm/cli needs to be installed as a local dependency!');
         }
-        configPaths ??= ConfigurationLoader.getConfigPaths();
         contextName ??= process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default';
-        return ConfigurationLoader.getConfiguration(contextName, configPaths, options);
+        const env = await this.loadEnvironmentVars();
+        const configFinder = (cfg) => {
+            return typeof cfg === 'object' && cfg !== null && ('contextName' in cfg ? cfg.contextName === contextName : (contextName === 'default'));
+        };
+        const isValidConfigFactoryResult = (cfg) => {
+            return typeof cfg === 'object' && cfg !== null && (!('contextName' in cfg) || cfg.contextName === contextName);
+        };
+        const result = await this.getConfigFile(paths);
+        if (!result[0]) {
+            if (Utils.hasObjectKeys(env)) {
+                return new Configuration(Utils.mergeConfig({ contextName }, options, env));
+            }
+            throw new Error(`MikroORM config file not found in ['${paths.join(`', '`)}']`);
+        }
+        const path = result[0];
+        let tmp = result[1];
+        if (Array.isArray(tmp)) {
+            const tmpFirstIndex = tmp.findIndex(configFinder);
+            if (tmpFirstIndex === -1) {
+                // Static config not found. Try factory functions
+                let configCandidate;
+                for (let i = 0, l = tmp.length; i < l; ++i) {
+                    const f = tmp[i];
+                    if (typeof f !== 'function') {
+                        continue;
+                    }
+                    configCandidate = await f(contextName);
+                    if (!isValidConfigFactoryResult(configCandidate)) {
+                        continue;
+                    }
+                    tmp = configCandidate;
+                    break;
+                }
+                if (Array.isArray(tmp)) {
+                    throw new Error(`MikroORM config '${contextName}' was not found within the config file '${path}'. Either add a config with this name to the array, or add a function that when given this name will return a configuration object without a name, or with name set to this name.`);
+                }
+            }
+            else {
+                const tmpLastIndex = tmp.findLastIndex(configFinder);
+                if (tmpLastIndex !== tmpFirstIndex) {
+                    throw new Error(`MikroORM config '${contextName}' is not unique within the array exported by '${path}' (first occurrence index: ${tmpFirstIndex}; last occurrence index: ${tmpLastIndex})`);
+                }
+                tmp = tmp[tmpFirstIndex];
+            }
+        }
+        else {
+            if (tmp instanceof Function) {
+                tmp = await tmp(contextName);
+                if (!isValidConfigFactoryResult(tmp)) {
+                    throw new Error(`MikroORM config '${contextName}' was not what the function exported from '${path}' provided. Ensure it returns a config object with no name, or name matching the requested one.`);
+                }
+            }
+            else {
+                if (!configFinder(tmp)) {
+                    throw new Error(`MikroORM config '${contextName}' was not what the default export from '${path}' provided.`);
+                }
+            }
+        }
+        const esmConfigOptions = this.isESM() ? { entityGenerator: { esmImport: true } } : {};
+        return new Configuration(Utils.mergeConfig({}, esmConfigOptions, tmp, options, env));
     }
     static async getORM(contextName, configPaths, opts = {}) {
-        const options = await CLIHelper.getConfiguration(contextName, configPaths, opts);
-        const settings = ConfigurationLoader.getSettings();
+        const options = await this.getConfiguration(contextName, configPaths, opts);
+        const settings = this.getSettings();
         options.set('allowGlobalContext', true);
         options.set('debug', !!settings.verbose);
         options.getLogger().setDebugMode(!!settings.verbose);
@@ -59,8 +124,70 @@ export class CLIHelper {
         // eslint-disable-next-line no-console
         console.log(text);
     }
+    static getSettings() {
+        const config = ConfigurationLoader.getPackageConfig();
+        const settings = { ...config['mikro-orm'] };
+        const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
+        settings.preferTs = process.env.MIKRO_ORM_CLI_PREFER_TS != null ? bool(process.env.MIKRO_ORM_CLI_PREFER_TS) : settings.preferTs;
+        settings.tsLoader = process.env.MIKRO_ORM_CLI_TS_LOADER ?? settings.tsLoader;
+        settings.tsConfigPath = process.env.MIKRO_ORM_CLI_TS_CONFIG_PATH ?? settings.tsConfigPath;
+        settings.verbose = process.env.MIKRO_ORM_CLI_VERBOSE != null ? bool(process.env.MIKRO_ORM_CLI_VERBOSE) : settings.verbose;
+        if (process.env.MIKRO_ORM_CLI_CONFIG?.endsWith('.ts')) {
+            settings.preferTs = true;
+        }
+        return settings;
+    }
     static getConfigPaths() {
-        return ConfigurationLoader.getConfigPaths();
+        const settings = this.getSettings();
+        const typeScriptSupport = settings.preferTs ?? Utils.detectTypeScriptSupport();
+        const paths = [];
+        if (process.env.MIKRO_ORM_CLI_CONFIG) {
+            paths.push(process.env.MIKRO_ORM_CLI_CONFIG);
+        }
+        paths.push(...(settings.configPaths || []));
+        if (typeScriptSupport) {
+            paths.push('./src/mikro-orm.config.ts');
+            paths.push('./mikro-orm.config.ts');
+        }
+        const distDir = Utils.pathExists(process.cwd() + '/dist');
+        const buildDir = Utils.pathExists(process.cwd() + '/build');
+        /* v8 ignore next */
+        const path = distDir ? 'dist' : (buildDir ? 'build' : 'src');
+        paths.push(`./${path}/mikro-orm.config.js`);
+        paths.push('./mikro-orm.config.js');
+        /* v8 ignore next */
+        return Utils.unique(paths).filter(p => !p.match(/\.[mc]?ts$/) || typeScriptSupport);
+    }
+    static async getConfigFile(paths) {
+        for (let path of paths) {
+            path = Utils.absolutePath(path);
+            path = Utils.normalizePath(path);
+            if (Utils.pathExists(path)) {
+                const config = await Utils.dynamicImport(path);
+                /* v8 ignore next */
+                return [path, await (config.default ?? config)];
+            }
+        }
+        return [];
+    }
+    static async loadEnvironmentVars() {
+        const ret = ConfigurationLoader.loadEnvironmentVars();
+        // only to keep some sort of back compatibility with those using env vars only, to support `MIKRO_ORM_TYPE`
+        const PLATFORMS = {
+            mongo: { className: 'MongoDriver', module: '@mikro-orm/mongodb' },
+            mysql: { className: 'MySqlDriver', module: '@mikro-orm/mysql' },
+            mssql: { className: 'MsSqlDriver', module: '@mikro-orm/mssql' },
+            mariadb: { className: 'MariaDbDriver', module: '@mikro-orm/mariadb' },
+            postgresql: { className: 'PostgreSqlDriver', module: '@mikro-orm/postgresql' },
+            sqlite: { className: 'SqliteDriver', module: '@mikro-orm/sqlite' },
+            libsql: { className: 'LibSqlDriver', module: '@mikro-orm/libsql' },
+        };
+        if (process.env.MIKRO_ORM_TYPE) {
+            const val = process.env.MIKRO_ORM_TYPE;
+            const driver = await import(PLATFORMS[val].module);
+            ret.driver = driver[PLATFORMS[val].className];
+        }
+        return ret;
     }
     static async dumpDependencies() {
         const version = Utils.getORMVersion();
@@ -118,6 +245,52 @@ export class CLIHelper {
         ret += colors.grey('└' + lengths.map(length => '─'.repeat(length)).join('┴') + '┘');
         CLIHelper.dump(ret);
     }
+    /**
+     * Tries to register TS support in the following order: swc, tsx, jiti, tsimp
+     * Use `MIKRO_ORM_CLI_TS_LOADER` env var to set the loader explicitly.
+     * This method is used only in CLI context.
+     */
+    static async registerTypeScriptSupport(configPath = 'tsconfig.json', tsLoader) {
+        /* v8 ignore next 3 */
+        if (process.versions.bun) {
+            return true;
+        }
+        process.env.SWC_NODE_PROJECT ??= configPath;
+        process.env.TSIMP_PROJECT ??= configPath;
+        process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS ??= '1';
+        const isEsm = this.isESM();
+        /* v8 ignore next */
+        const importMethod = isEsm ? 'tryImport' : 'tryRequire';
+        const explicitLoader = tsLoader ?? process.env.MIKRO_ORM_CLI_TS_LOADER ?? 'auto';
+        const loaders = {
+            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: { esm: 'jiti/register', cjs: 'jiti/register', cb: () => Utils.dynamicImportProvider = id => import(id).then(mod => mod?.default ?? mod) },
+            tsimp: { esm: 'tsimp/import', cjs: 'tsimp/import' },
+        };
+        for (const loader of Utils.keys(loaders)) {
+            if (explicitLoader !== 'auto' && loader !== explicitLoader) {
+                continue;
+            }
+            const { esm, cjs, cb } = loaders[loader];
+            /* v8 ignore next */
+            const module = isEsm ? esm : cjs;
+            const mod = await Utils[importMethod]({ module });
+            if (mod) {
+                cb?.(mod);
+                process.env.MIKRO_ORM_CLI_TS_LOADER = loader;
+                return true;
+            }
+        }
+        // eslint-disable-next-line no-console
+        console.warn('Neither `swc`, `tsx`, `jiti` nor `tsimp` found in the project dependencies, support for working with TypeScript files might not work. To use `swc`, you need to install both `@swc-node/register` and `@swc/core`.');
+        return false;
+    }
+    static isESM() {
+        const config = ConfigurationLoader.getPackageConfig();
+        const type = config?.type ?? '';
+        return type === 'module';
+    }
     /* v8 ignore next 3 */
     static showHelp() {
         yargs(process.argv.slice(2)).showHelp();

package/cli

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { CLIHelper } from './CLIHelper.js';
-import { CLIConfigurator } from './CLIConfigurator.js';
-const argv = await CLIConfigurator.configure();
+import { configure } from './CLIConfigurator.js';
+const argv = await configure();
 const args = await argv.parse(process.argv.slice(2));
 if (args._.length === 0) {
     CLIHelper.showHelp();

package/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { CLIHelper } from './CLIHelper.js';
-import { CLIConfigurator } from './CLIConfigurator.js';
-const argv = await CLIConfigurator.configure();
+import { configure } from './CLIConfigurator.js';
+const argv = await configure();
 const args = await argv.parse(process.argv.slice(2));
 if (args._.length === 0) {
     CLIHelper.showHelp();

package/commands/DebugCommand.js

@@ -1,4 +1,4 @@
-import { colors, ConfigurationLoader, Utils } from '@mikro-orm/core';
+import { colors, Utils } from '@mikro-orm/core';
 import { CLIHelper } from '../CLIHelper.js';
 export class DebugCommand {
     command = 'debug';
@@ -9,7 +9,7 @@ export class DebugCommand {
     async handler(args) {
         CLIHelper.dump(`Current ${colors.cyan('MikroORM')} CLI configuration`);
         await CLIHelper.dumpDependencies();
-        const settings = ConfigurationLoader.getSettings();
+        const settings = CLIHelper.getSettings();
         if (!process.versions.bun && settings.preferTs !== false) {
             const loader = process.env.MIKRO_ORM_CLI_TS_LOADER ?? 'auto';
             CLIHelper.dump(' - TypeScript support ' + colors.green(`enabled (${loader})`));
@@ -40,8 +40,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) {
@@ -50,8 +50,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)`);

package/commands/GenerateCacheCommand.js

@@ -25,7 +25,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/MigrationCommandFactory.js

@@ -203,7 +203,7 @@ 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?.length === 1) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/cli",
   "type": "module",
-  "version": "7.0.0-dev.64",
+  "version": "7.0.0-dev.66",
   "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.64",
-    "@mikro-orm/knex": "7.0.0-dev.64",
+    "@mikro-orm/core": "7.0.0-dev.66",
+    "@mikro-orm/knex": "7.0.0-dev.66",
     "yargs": "17.7.2"
   },
   "devDependencies": {