@mikro-orm/core 7.0.0-dev.64 → 7.0.0-dev.65

package/MikroORM.js

@@ -37,7 +37,7 @@ export class MikroORM {
      * - no support for folder based discovery
      */
     constructor(options) {
-        const env = ConfigurationLoader.loadEnvironmentVarsSync();
+        const env = ConfigurationLoader.loadEnvironmentVars();
         const coreVersion = ConfigurationLoader.checkPackageVersion();
         options = Utils.merge(options, env);
         this.config = new Configuration(options);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.64",
+  "version": "7.0.0-dev.65",
   "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",
@@ -52,7 +52,7 @@
     "access": "public"
   },
   "dependencies": {
-    "mikro-orm": "7.0.0-dev.64"
+    "mikro-orm": "7.0.0-dev.65"
   },
   "peerDependencies": {
     "dataloader": "2.2.3"

package/utils/ConfigurationLoader.d.ts

@@ -1,40 +1,13 @@
-import type { EntityManager } from '../EntityManager.js';
-import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
+import type { IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
 import type { Dictionary } from '../typings.js';
-import { Configuration, type Options } from './Configuration.js';
+import { type Options } from './Configuration.js';
 /**
  * @internal
  */
 export declare 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 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 loadEnvironmentVars<D extends IDatabaseDriver>(): Partial<Options<D>>;
     static getPackageConfig(basePath?: string): Dictionary;
-    static getSettings(): Settings;
-    static getConfigPaths(): string[];
-    static isESM(): boolean;
-    /**
-     * 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 loadEnvironmentVars<D extends IDatabaseDriver>(): Promise<Partial<Options<D>>>;
-    static loadEnvironmentVarsSync<D extends IDatabaseDriver>(): Partial<Options<D>>;
     static getORMPackages(): Set<string>;
     static getORMPackageVersion(name: string): string | undefined;
     static checkPackageVersion(): string;
 }
-export interface Settings {
-    verbose?: boolean;
-    preferTs?: boolean;
-    tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto';
-    tsConfigPath?: string;
-    configPaths?: string[];
-}

package/utils/ConfigurationLoader.js

@@ -1,209 +1,11 @@
 import { realpathSync } from 'node:fs';
-import { colors } from '../logging/colors.js';
-import { Configuration } from './Configuration.js';
 import { Utils } from './Utils.js';
+import { colors } from '../logging/colors.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 = {}) {
-        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 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 getPackageConfig(basePath = process.cwd()) {
-        if (Utils.pathExists(`${basePath}/package.json`)) {
-            /* v8 ignore next 5 */
-            try {
-                return Utils.readJSONSync(`${basePath}/package.json`);
-            }
-            catch {
-                return {};
-            }
-        }
-        const parentFolder = realpathSync(`${basePath}/..`);
-        // we reached the root folder
-        if (basePath === parentFolder) {
-            return {};
-        }
-        return this.getPackageConfig(parentFolder);
-    }
-    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() {
-        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 || []));
-        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 isESM() {
-        const config = ConfigurationLoader.getPackageConfig();
-        const type = config?.type ?? '';
-        return type === 'module';
-    }
-    /**
-     * 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.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 async loadEnvironmentVars() {
-        const ret = this.loadEnvironmentVarsSync();
-        // 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 loadEnvironmentVarsSync() {
+    static loadEnvironmentVars() {
         const ret = {};
         const array = (v) => v.split(',').map(vv => vv.trim());
         const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
@@ -280,6 +82,23 @@ export class ConfigurationLoader {
         cleanup(ret, 'seeder');
         return ret;
     }
+    static getPackageConfig(basePath = process.cwd()) {
+        if (Utils.pathExists(`${basePath}/package.json`)) {
+            /* v8 ignore next 5 */
+            try {
+                return Utils.readJSONSync(`${basePath}/package.json`);
+            }
+            catch {
+                return {};
+            }
+        }
+        const parentFolder = realpathSync(`${basePath}/..`);
+        // we reached the root folder
+        if (basePath === parentFolder) {
+            return {};
+        }
+        return this.getPackageConfig(parentFolder);
+    }
     static getORMPackages() {
         const pkg = this.getPackageConfig();
         return new Set([