@mikro-orm/core 7.0.0-dev.6 → 7.0.0-dev.61

package/utils/Configuration.js

@@ -11,127 +11,133 @@ import { RequestContext } from './RequestContext.js';
 import { DataloaderType, FlushMode, LoadStrategy, PopulateHint } from '../enums.js';
 import { MemoryCacheAdapter } from '../cache/MemoryCacheAdapter.js';
 import { EntityComparator } from './EntityComparator.js';
+const DEFAULTS = {
+    pool: {},
+    entities: [],
+    entitiesTs: [],
+    extensions: [],
+    subscribers: [],
+    filters: {},
+    discovery: {
+        warnWhenNoEntities: true,
+        requireEntitiesArray: false,
+        checkDuplicateTableNames: true,
+        checkDuplicateFieldNames: true,
+        checkDuplicateEntities: true,
+        checkNonPersistentCompositeProps: true,
+        alwaysAnalyseProperties: true,
+        disableDynamicFileAccess: false,
+        inferDefaultValues: true,
+    },
+    strict: false,
+    validate: false,
+    validateRequired: true,
+    context: (name) => RequestContext.getEntityManager(name),
+    contextName: 'default',
+    allowGlobalContext: false,
+    // eslint-disable-next-line no-console
+    logger: console.log.bind(console),
+    colors: true,
+    findOneOrFailHandler: (entityName, where) => NotFoundError.findOneFailed(entityName, where),
+    findExactlyOneOrFailHandler: (entityName, where) => NotFoundError.findExactlyOneFailed(entityName, where),
+    baseDir: process.cwd(),
+    hydrator: ObjectHydrator,
+    flushMode: FlushMode.AUTO,
+    loadStrategy: LoadStrategy.BALANCED,
+    dataloader: DataloaderType.NONE,
+    populateWhere: PopulateHint.ALL,
+    ignoreUndefinedInQuery: false,
+    onQuery: (sql) => sql,
+    autoJoinOneToOneOwner: true,
+    autoJoinRefsForFilters: true,
+    filtersOnRelations: true,
+    propagationOnPrototype: true,
+    populateAfterFlush: true,
+    serialization: {
+        includePrimaryKeys: true,
+    },
+    assign: {
+        updateNestedEntities: true,
+        updateByPrimaryKey: true,
+        mergeObjectProperties: false,
+        mergeEmbeddedProperties: true,
+        ignoreUndefined: false,
+    },
+    persistOnCreate: true,
+    upsertManaged: true,
+    forceEntityConstructor: false,
+    forceUndefined: false,
+    processOnCreateHooksEarly: false,
+    ensureDatabase: true,
+    ensureIndexes: false,
+    batchSize: 300,
+    hashAlgorithm: 'md5',
+    debug: false,
+    ignoreDeprecations: false,
+    verbose: false,
+    driverOptions: {},
+    migrations: {
+        tableName: 'mikro_orm_migrations',
+        path: './migrations',
+        glob: '!(*.d).{js,ts,cjs}',
+        silent: false,
+        transactional: true,
+        disableForeignKeys: false,
+        allOrNothing: true,
+        dropTables: true,
+        safe: false,
+        snapshot: true,
+        emit: 'ts',
+        fileName: (timestamp, name) => `Migration${timestamp}${name ? '_' + name : ''}`,
+    },
+    schemaGenerator: {
+        disableForeignKeys: false,
+        createForeignKeyConstraints: true,
+        ignoreSchema: [],
+        skipTables: [],
+        skipColumns: {},
+    },
+    embeddables: {
+        prefixMode: 'relative',
+    },
+    entityGenerator: {
+        forceUndefined: true,
+        undefinedDefaults: false,
+        scalarTypeInDecorator: false,
+        bidirectionalRelations: true,
+        identifiedReferences: true,
+        scalarPropertiesForRelations: 'never',
+        entityDefinition: 'defineEntity',
+        enumMode: 'dictionary',
+        fileName: (className) => className,
+        onlyPurePivotTables: false,
+        outputPurePivotTables: false,
+        readOnlyPivotTables: false,
+        useCoreBaseEntity: false,
+    },
+    metadataCache: {
+        pretty: false,
+        adapter: FileCacheAdapter,
+        options: { cacheDir: process.cwd() + '/temp' },
+    },
+    resultCache: {
+        adapter: MemoryCacheAdapter,
+        expiration: 1000, // 1s
+        options: {},
+    },
+    metadataProvider: ReflectMetadataProvider,
+    highlighter: new NullHighlighter(),
+    seeder: {
+        path: './seeders',
+        defaultSeeder: 'DatabaseSeeder',
+        glob: '!(*.d).{js,ts}',
+        emit: 'ts',
+        fileName: (className) => className,
+    },
+    preferReadReplicas: true,
+    dynamicImportProvider: /* v8 ignore next */ (id) => import(id),
+};
 export class Configuration {
-    static DEFAULTS = {
-        pool: {},
-        entities: [],
-        entitiesTs: [],
-        extensions: [],
-        subscribers: [],
-        filters: {},
-        discovery: {
-            warnWhenNoEntities: true,
-            requireEntitiesArray: false,
-            checkDuplicateTableNames: true,
-            checkDuplicateFieldNames: true,
-            checkDuplicateEntities: true,
-            checkNonPersistentCompositeProps: true,
-            alwaysAnalyseProperties: true,
-            disableDynamicFileAccess: false,
-            inferDefaultValues: true,
-        },
-        strict: false,
-        validate: false,
-        validateRequired: true,
-        context: (name) => RequestContext.getEntityManager(name),
-        contextName: 'default',
-        allowGlobalContext: false,
-        // eslint-disable-next-line no-console
-        logger: console.log.bind(console),
-        colors: true,
-        findOneOrFailHandler: (entityName, where) => NotFoundError.findOneFailed(entityName, where),
-        findExactlyOneOrFailHandler: (entityName, where) => NotFoundError.findExactlyOneFailed(entityName, where),
-        baseDir: process.cwd(),
-        hydrator: ObjectHydrator,
-        flushMode: FlushMode.AUTO,
-        loadStrategy: LoadStrategy.JOINED,
-        dataloader: DataloaderType.NONE,
-        populateWhere: PopulateHint.ALL,
-        connect: true,
-        ignoreUndefinedInQuery: false,
-        onQuery: sql => sql,
-        autoJoinOneToOneOwner: true,
-        autoJoinRefsForFilters: true,
-        propagationOnPrototype: true,
-        populateAfterFlush: true,
-        serialization: {
-            includePrimaryKeys: true,
-        },
-        assign: {
-            updateNestedEntities: true,
-            updateByPrimaryKey: true,
-            mergeObjectProperties: false,
-            mergeEmbeddedProperties: true,
-            ignoreUndefined: false,
-        },
-        persistOnCreate: true,
-        upsertManaged: true,
-        forceEntityConstructor: false,
-        forceUndefined: false,
-        ensureDatabase: true,
-        ensureIndexes: false,
-        batchSize: 300,
-        debug: false,
-        ignoreDeprecations: false,
-        verbose: false,
-        driverOptions: {},
-        migrations: {
-            tableName: 'mikro_orm_migrations',
-            path: './migrations',
-            glob: '!(*.d).{js,ts,cjs}',
-            silent: false,
-            transactional: true,
-            disableForeignKeys: false,
-            allOrNothing: true,
-            dropTables: true,
-            safe: false,
-            snapshot: true,
-            emit: 'ts',
-            fileName: (timestamp, name) => `Migration${timestamp}${name ? '_' + name : ''}`,
-        },
-        schemaGenerator: {
-            disableForeignKeys: false,
-            createForeignKeyConstraints: true,
-            ignoreSchema: [],
-        },
-        embeddables: {
-            prefixMode: 'absolute',
-        },
-        entityGenerator: {
-            forceUndefined: true,
-            undefinedDefaults: false,
-            bidirectionalRelations: false,
-            identifiedReferences: false,
-            scalarTypeInDecorator: false,
-            scalarPropertiesForRelations: 'never',
-            fileName: (className) => className,
-            onlyPurePivotTables: false,
-            outputPurePivotTables: false,
-            readOnlyPivotTables: false,
-            useCoreBaseEntity: false,
-        },
-        metadataCache: {
-            pretty: false,
-            adapter: FileCacheAdapter,
-            options: { cacheDir: process.cwd() + '/temp' },
-        },
-        resultCache: {
-            adapter: MemoryCacheAdapter,
-            expiration: 1000, // 1s
-            options: {},
-        },
-        metadataProvider: ReflectMetadataProvider,
-        highlighter: new NullHighlighter(),
-        seeder: {
-            path: './seeders',
-            defaultSeeder: 'DatabaseSeeder',
-            glob: '!(*.d).{js,ts}',
-            emit: 'ts',
-            fileName: (className) => className,
-        },
-        preferReadReplicas: true,
-        dynamicImportProvider: /* v8 ignore next */ (id) => import(id),
-    };
     options;
     logger;
     driver;
@@ -142,9 +148,8 @@ export class Configuration {
         if (options.dynamicImportProvider) {
             Utils.setDynamicImportProvider(options.dynamicImportProvider);
         }
-        this.options = Utils.mergeConfig({}, Configuration.DEFAULTS, options);
+        this.options = Utils.mergeConfig({}, DEFAULTS, options);
         this.options.baseDir = Utils.absolutePath(this.options.baseDir);
-        this.options.preferTs ??= options.preferTs;
         if (validate) {
             this.validateOptions();
         }
@@ -190,7 +195,7 @@ export class Configuration {
      * Resets the configuration to its default value
      */
     reset(key) {
-        this.options[key] = Configuration.DEFAULTS[key];
+        this.options[key] = DEFAULTS[key];
     }
     /**
      * Gets Logger instance.
@@ -204,15 +209,6 @@ export class Configuration {
         }
         return this.options.dataloader;
     }
-    /**
-     * Gets current client URL (connection string).
-     */
-    getClientUrl(hidePassword = false) {
-        if (hidePassword) {
-            return this.options.clientUrl.replace(/\/\/([^:]+):(.+)@/, '//$1:*****@');
-        }
-        return this.options.clientUrl;
-    }
     getSchema(skipDefaultSchema = false) {
         if (skipDefaultSchema && this.options.schema === this.platform.getDefaultSchemaName()) {
             return undefined;
@@ -268,7 +264,7 @@ export class Configuration {
      * Gets instance of metadata CacheAdapter. (cached)
      */
     getMetadataCacheAdapter() {
-        return this.getCachedService(this.options.metadataCache.adapter, this.options.metadataCache.options, this.options.baseDir, this.options.metadataCache.pretty);
+        return this.getCachedService(this.options.metadataCache.adapter, this.options.metadataCache.options, this.options.baseDir, this.options.metadataCache.pretty, this.options.hashAlgorithm);
     }
     /**
      * Gets instance of CacheAdapter for result cache. (cached)
@@ -293,8 +289,7 @@ export class Configuration {
      */
     getCachedService(cls, ...args) {
         if (!this.cache.has(cls.name)) {
-            const Class = cls;
-            this.cache.set(cls.name, new Class(...args));
+            this.cache.set(cls.name, new cls(...args));
         }
         return this.cache.get(cls.name);
     }
@@ -311,17 +306,15 @@ export class Configuration {
         if (!this.options.clientUrl) {
             this.options.clientUrl = this.platform.getDefaultClientUrl();
         }
-        if (!('implicitTransactions' in this.options)) {
-            this.options.implicitTransactions = this.platform.usesImplicitTransactions();
-        }
+        this.options.implicitTransactions ??= this.platform.usesImplicitTransactions();
         try {
-            const url = new URL(this.getClientUrl());
+            const url = new URL(this.options.clientUrl);
             if (url.pathname) {
                 this.options.dbName = this.get('dbName', decodeURIComponent(url.pathname).substring(1));
             }
         }
         catch {
-            const url = this.getClientUrl().match(/:\/\/.*\/([^?]+)/);
+            const url = this.options.clientUrl.match(/:\/\/.*\/([^?]+)/);
             if (url) {
                 this.options.dbName = this.get('dbName', decodeURIComponent(url[1]));
             }
@@ -329,15 +322,14 @@ export class Configuration {
         if (validate && !this.options.dbName && this.options.clientUrl) {
             throw new Error("No database specified, `clientUrl` option provided but it's missing the pathname.");
         }
-        if (!this.options.schema) {
-            this.options.schema = this.platform.getDefaultSchemaName();
-        }
-        if (!this.options.charset) {
-            this.options.charset = this.platform.getDefaultCharset();
-        }
+        this.options.schema ??= this.platform.getDefaultSchemaName();
+        this.options.charset ??= this.platform.getDefaultCharset();
         Object.keys(this.options.filters).forEach(key => {
             this.options.filters[key].default ??= true;
         });
+        if (!this.options.filtersOnRelations) {
+            this.options.autoJoinRefsForFilters ??= false;
+        }
         this.options.subscribers = Utils.unique(this.options.subscribers).map(subscriber => {
             return subscriber.constructor.name === 'Function' ? new subscriber() : subscriber;
         });
@@ -359,13 +351,13 @@ export class Configuration {
      * break existing projects, only help with the new ones.
      */
     detectSourceFolder(options) {
-        if (!Utils.pathExistsSync(this.options.baseDir + '/src')) {
+        if (!Utils.pathExists(this.options.baseDir + '/src')) {
             return;
         }
-        const migrationsPathExists = Utils.pathExistsSync(this.options.baseDir + '/' + this.options.migrations.path);
-        const seedersPathExists = Utils.pathExistsSync(this.options.baseDir + '/' + this.options.seeder.path);
-        const distDir = Utils.pathExistsSync(this.options.baseDir + '/dist');
-        const buildDir = Utils.pathExistsSync(this.options.baseDir + '/build');
+        const migrationsPathExists = Utils.pathExists(this.options.baseDir + '/' + this.options.migrations.path);
+        const seedersPathExists = Utils.pathExists(this.options.baseDir + '/' + this.options.seeder.path);
+        const distDir = Utils.pathExists(this.options.baseDir + '/dist');
+        const buildDir = Utils.pathExists(this.options.baseDir + '/build');
         // if neither `dist` nor `build` exist, we use the `src` folder as it might be a JS project without building, but with `src` folder
         const path = distDir ? './dist' : (buildDir ? './build' : './src');
         // only if the user did not provide any values and if the default path does not exist

package/utils/ConfigurationLoader.d.ts

@@ -13,42 +13,29 @@ export declare class ConfigurationLoader {
      * @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 = EntityManager>(contextName: string, paths?: string[], options?: Partial<Options>): Promise<Configuration<D, EM>>;
-    /**
-     * Gets the default config from the default paths
-     *
-     * @deprecated Prefer to explicitly set the `contextName` at the first argument. This signature is available for backwards compatibility, and may be removed in v7.
-     */
-    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = EntityManager>(): Promise<Configuration<D, EM>>;
-    /**
-     * Gets default configuration out of the default paths, and possibly from `process.argv`
-     *
-     * @param validate Whether to validate the final configuration.
-     * @param options Additional options to augment the final configuration with (just before validation).
-     *
-     * @deprecated Use the other overloads of this method. This signature will be removed in v7.
-     */
-    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = EntityManager>(validate: boolean, options?: Partial<Options>): Promise<Configuration<D, EM>>;
+    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>): Promise<Configuration<D, EM>>;
     static getConfigFile(paths: string[]): Promise<[string, unknown] | []>;
     static getPackageConfig(basePath?: string): Dictionary;
     static getSettings(): Settings;
-    static configPathsFromArg(): string[] | undefined;
     static getConfigPaths(): string[];
     static isESM(): boolean;
-    static registerTypeScriptSupport(configPath?: string): Promise<boolean>;
-    static registerDotenv<D extends IDatabaseDriver>(options?: Options<D>): 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 registerDotenv<D extends IDatabaseDriver>(options: Options<D>): void;
     static loadEnvironmentVars<D extends IDatabaseDriver>(): Promise<Partial<Options<D>>>;
     static loadEnvironmentVarsSync<D extends IDatabaseDriver>(): Partial<Options<D>>;
     static getORMPackages(): Set<string>;
-    /** @internal */
-    static commonJSCompat(options: Partial<Options>): void;
     static getORMPackageVersion(name: string): string | undefined;
     static checkPackageVersion(): string;
 }
 export interface Settings {
-    alwaysAllowTs?: boolean;
     verbose?: boolean;
     preferTs?: boolean;
+    tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto';
     tsConfigPath?: string;
     configPaths?: string[];
 }

package/utils/ConfigurationLoader.js

@@ -1,7 +1,5 @@
 import dotenv from 'dotenv';
 import { realpathSync } from 'node:fs';
-import { platform } from 'node:os';
-import { fileURLToPath } from 'node:url';
 import { colors } from '../logging/colors.js';
 import { Configuration } from './Configuration.js';
 import { Utils } from './Utils.js';
@@ -9,31 +7,14 @@ import { Utils } from './Utils.js';
  * @internal
  */
 export class ConfigurationLoader {
+    /**
+     * 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 = 'default', paths = ConfigurationLoader.getConfigPaths(), options = {}) {
-        // Backwards compatibility layer
-        if (typeof contextName === 'boolean' || !Array.isArray(paths)) {
-            this.commonJSCompat(options);
-            this.registerDotenv(options);
-            const configPathFromArg = ConfigurationLoader.configPathsFromArg();
-            const configPaths = configPathFromArg ?? (Array.isArray(paths) ? paths : ConfigurationLoader.getConfigPaths());
-            const config = contextName
-                ? (await ConfigurationLoader.getConfiguration(process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default', configPaths, Array.isArray(paths) ? {} : paths))
-                : await (async () => {
-                    const env = await this.loadEnvironmentVars();
-                    const [path, tmp] = await this.getConfigFile(configPaths);
-                    if (!path) {
-                        if (Utils.hasObjectKeys(env)) {
-                            return new Configuration(Utils.mergeConfig({}, options, env), false);
-                        }
-                        throw new Error(`MikroORM config file not found in ['${configPaths.join(`', '`)}']`);
-                    }
-                    return new Configuration(Utils.mergeConfig(tmp, options, env), false);
-                })();
-            if (configPathFromArg) {
-                config.getLogger().warn('deprecated', 'Path for config file was inferred from the command line arguments. Instead, you should set the MIKRO_ORM_CLI_CONFIG environment variable to specify the path, or if you really must use the command line arguments, import the config manually based on them, and pass it to init.', { label: 'D0001' });
-            }
-            return config;
-        }
         const env = await this.loadEnvironmentVars();
         const configFinder = (cfg) => {
             return typeof cfg === 'object' && cfg !== null && ('contextName' in cfg ? cfg.contextName === contextName : (contextName === 'default'));
@@ -99,7 +80,7 @@ export class ConfigurationLoader {
         for (let path of paths) {
             path = Utils.absolutePath(path);
             path = Utils.normalizePath(path);
-            if (Utils.pathExistsSync(path)) {
+            if (Utils.pathExists(path)) {
                 const config = await Utils.dynamicImport(path);
                 /* v8 ignore next */
                 return [path, await (config.default ?? config)];
@@ -108,7 +89,7 @@ export class ConfigurationLoader {
         return [];
     }
     static getPackageConfig(basePath = process.cwd()) {
-        if (Utils.pathExistsSync(`${basePath}/package.json`)) {
+        if (Utils.pathExists(`${basePath}/package.json`)) {
             /* v8 ignore next 5 */
             try {
                 return Utils.readJSONSync(`${basePath}/package.json`);
@@ -129,70 +110,85 @@ export class ConfigurationLoader {
         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.alwaysAllowTs = process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS != null ? bool(process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS) : settings.alwaysAllowTs;
         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 configPathsFromArg() {
-        const options = Utils.parseArgs();
-        const configArgName = process.env.MIKRO_ORM_CONFIG_ARG_NAME ?? 'config';
-        if (options[configArgName]) {
-            return [options[configArgName]];
-        }
-        return undefined;
-    }
     static getConfigPaths() {
-        const paths = [];
         const settings = ConfigurationLoader.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 || []));
-        const alwaysAllowTs = settings.alwaysAllowTs ?? process.versions.bun;
-        if (settings.preferTs !== false || alwaysAllowTs) {
+        if (typeScriptSupport) {
             paths.push('./src/mikro-orm.config.ts');
             paths.push('./mikro-orm.config.ts');
         }
-        const distDir = Utils.pathExistsSync(process.cwd() + '/dist');
-        const buildDir = Utils.pathExistsSync(process.cwd() + '/build');
+        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');
-        const typeScriptSupport = Utils.detectTypeScriptSupport();
         /* v8 ignore next */
-        return Utils.unique(paths).filter(p => p.endsWith('.js') || typeScriptSupport || alwaysAllowTs);
+        return Utils.unique(paths).filter(p => !p.match(/\.[mc]?ts$/) || typeScriptSupport);
     }
     static isESM() {
         const config = ConfigurationLoader.getPackageConfig();
         const type = config?.type ?? '';
         return type === 'module';
     }
-    static async registerTypeScriptSupport(configPath = 'tsconfig.json') {
+    /**
+     * 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 esm = this.isESM();
-        /* v8 ignore next 2 */
-        const importMethod = esm ? 'tryImport' : 'tryRequire';
-        const module = esm ? '@swc-node/register/esm-register' : '@swc-node/register';
-        const supported = await Utils[importMethod]({
-            module,
-            warning: '@swc-node/register and @swc/core are not installed, support for working with TypeScript files might not work',
-        });
-        return !!supported;
+        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.setDynamicImportProvider(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 registerDotenv(options) {
-        const path = process.env.MIKRO_ORM_ENV ?? ((options?.baseDir ?? process.cwd()) + '/.env');
+        const path = process.env.MIKRO_ORM_ENV ?? ((options.baseDir ?? process.cwd()) + '/.env');
         const env = {};
-        dotenv.config({ path, processEnv: env });
+        dotenv.config({ path, processEnv: env, quiet: true });
         // only propagate known env vars
         for (const key of Object.keys(env)) {
             if (key.startsWith('MIKRO_ORM_')) {
@@ -300,25 +296,6 @@ export class ConfigurationLoader {
             ...Object.keys(pkg.devDependencies ?? {}),
         ]);
     }
-    /** @internal */
-    static commonJSCompat(options) {
-        if (this.isESM()) {
-            return;
-        }
-        /* v8 ignore next 11 */
-        options.dynamicImportProvider ??= id => {
-            if (platform() === 'win32') {
-                try {
-                    id = fileURLToPath(id);
-                }
-                catch {
-                    // ignore
-                }
-            }
-            return Utils.requireFrom(id);
-        };
-        Utils.setDynamicImportProvider(options.dynamicImportProvider);
-    }
     static getORMPackageVersion(name) {
         try {
             const pkg = Utils.requireFrom(`${name}/package.json`);
@@ -332,7 +309,7 @@ export class ConfigurationLoader {
     // inspired by https://github.com/facebook/docusaurus/pull/3386
     static checkPackageVersion() {
         const coreVersion = Utils.getORMVersion();
-        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH) {
+        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH || coreVersion === 'N/A') {
             return coreVersion;
         }
         const deps = this.getORMPackages();

package/utils/Cursor.d.ts

@@ -49,13 +49,13 @@ import { type QueryOrder } from '../enums.js';
  * }
  * ```
  */
-export declare class Cursor<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never> {
+export declare class Cursor<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true> {
     readonly items: Loaded<Entity, Hint, Fields, Excludes>[];
-    readonly totalCount: number;
+    readonly totalCount: IncludeCount extends true ? number : undefined;
     readonly hasPrevPage: boolean;
     readonly hasNextPage: boolean;
     private readonly definition;
-    constructor(items: Loaded<Entity, Hint, Fields, Excludes>[], totalCount: number, options: FindByCursorOptions<Entity, Hint, Fields, Excludes>, meta: EntityMetadata<Entity>);
+    constructor(items: Loaded<Entity, Hint, Fields, Excludes>[], totalCount: IncludeCount extends true ? number : undefined, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>, meta: EntityMetadata<Entity>);
     get startCursor(): string | null;
     get endCursor(): string | null;
     /**

package/utils/Cursor.js

@@ -107,6 +107,9 @@ export class Cursor {
             if (Utils.isEntity(value, true)) {
                 value = helper(value).getPrimaryKey();
             }
+            if (Utils.isScalarReference(value)) {
+                value = value.unwrap();
+            }
             if (object) {
                 return ({ [prop]: value });
             }