@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/utils/Configuration.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = exports.Configuration = void 0;
+const fs_extra_1 = require("fs-extra");
+const cache_1 = require("../cache");
+const hydration_1 = require("../hydration");
+const NullHighlighter_1 = require("../utils/NullHighlighter");
+const logging_1 = require("../logging");
+const Utils_1 = require("../utils/Utils");
+const ReflectMetadataProvider_1 = require("../metadata/ReflectMetadataProvider");
+const errors_1 = require("../errors");
+const RequestContext_1 = require("./RequestContext");
+const enums_1 = require("../enums");
+const MemoryCacheAdapter_1 = require("../cache/MemoryCacheAdapter");
+const EntityComparator_1 = require("./EntityComparator");
+class Configuration {
+    static DEFAULTS = {
+        pool: {},
+        entities: [],
+        entitiesTs: [],
+        extensions: [],
+        subscribers: [],
+        filters: {},
+        discovery: {
+            warnWhenNoEntities: true,
+            requireEntitiesArray: false,
+            checkDuplicateTableNames: true,
+            checkDuplicateFieldNames: true,
+            alwaysAnalyseProperties: true,
+            disableDynamicFileAccess: false,
+            checkDuplicateEntities: true,
+            inferDefaultValues: true,
+        },
+        strict: false,
+        validate: false,
+        validateRequired: true,
+        context: (name) => RequestContext_1.RequestContext.getEntityManager(name),
+        contextName: 'default',
+        allowGlobalContext: false,
+        // eslint-disable-next-line no-console
+        logger: console.log.bind(console),
+        colors: true,
+        findOneOrFailHandler: (entityName, where) => errors_1.NotFoundError.findOneFailed(entityName, where),
+        findExactlyOneOrFailHandler: (entityName, where) => errors_1.NotFoundError.findExactlyOneFailed(entityName, where),
+        baseDir: process.cwd(),
+        hydrator: hydration_1.ObjectHydrator,
+        flushMode: enums_1.FlushMode.AUTO,
+        loadStrategy: enums_1.LoadStrategy.JOINED,
+        dataloader: enums_1.DataloaderType.NONE,
+        populateWhere: enums_1.PopulateHint.ALL,
+        connect: true,
+        ignoreUndefinedInQuery: false,
+        autoJoinOneToOneOwner: true,
+        autoJoinRefsForFilters: true,
+        propagationOnPrototype: true,
+        populateAfterFlush: true,
+        serialization: {
+            includePrimaryKeys: true,
+        },
+        persistOnCreate: true,
+        forceEntityConstructor: false,
+        forceUndefined: false,
+        forceUtcTimezone: false,
+        ensureDatabase: true,
+        ensureIndexes: false,
+        batchSize: 300,
+        debug: false,
+        verbose: false,
+        driverOptions: {},
+        migrations: {
+            tableName: 'mikro_orm_migrations',
+            path: './migrations',
+            glob: '!(*.d).{js,ts,cjs}',
+            silent: false,
+            transactional: true,
+            disableForeignKeys: true,
+            allOrNothing: true,
+            dropTables: true,
+            safe: false,
+            snapshot: true,
+            emit: 'ts',
+            fileName: (timestamp, name) => `Migration${timestamp}${name ? '_' + name : ''}`,
+        },
+        schemaGenerator: {
+            disableForeignKeys: true,
+            createForeignKeyConstraints: true,
+            ignoreSchema: [],
+        },
+        entityGenerator: {
+            bidirectionalRelations: false,
+            identifiedReferences: false,
+            scalarTypeInDecorator: false,
+            scalarPropertiesForRelations: 'never',
+            fileName: (className) => className,
+            onlyPurePivotTables: false,
+            readOnlyPivotTables: false,
+            useCoreBaseEntity: false,
+        },
+        metadataCache: {
+            pretty: false,
+            adapter: cache_1.FileCacheAdapter,
+            options: { cacheDir: process.cwd() + '/temp' },
+        },
+        resultCache: {
+            adapter: MemoryCacheAdapter_1.MemoryCacheAdapter,
+            expiration: 1000, // 1s
+            options: {},
+        },
+        metadataProvider: ReflectMetadataProvider_1.ReflectMetadataProvider,
+        highlighter: new NullHighlighter_1.NullHighlighter(),
+        seeder: {
+            path: './seeders',
+            defaultSeeder: 'DatabaseSeeder',
+            glob: '!(*.d).{js,ts}',
+            emit: 'ts',
+            fileName: (className) => className,
+        },
+        preferReadReplicas: true,
+        dynamicImportProvider: /* istanbul ignore next */ (id) => import(id),
+    };
+    options;
+    logger;
+    driver;
+    platform;
+    cache = new Map();
+    extensions = new Map();
+    constructor(options, validate = true) {
+        if (options.dynamicImportProvider) {
+            Utils_1.Utils.setDynamicImportProvider(options.dynamicImportProvider);
+        }
+        this.options = Utils_1.Utils.mergeConfig({}, Configuration.DEFAULTS, options);
+        this.options.baseDir = Utils_1.Utils.absolutePath(this.options.baseDir);
+        if (validate) {
+            this.validateOptions();
+        }
+        this.options.loggerFactory ??= (options) => new logging_1.DefaultLogger(options);
+        this.logger = this.options.loggerFactory({
+            debugMode: this.options.debug,
+            usesReplicas: (this.options.replicas?.length ?? 0) > 0,
+            highlighter: this.options.highlighter,
+            writer: this.options.logger,
+        });
+        this.driver = new this.options.driver(this);
+        this.platform = this.driver.getPlatform();
+        this.platform.setConfig(this);
+        this.detectSourceFolder(options);
+        this.init();
+    }
+    /**
+     * Gets specific configuration option. Falls back to specified `defaultValue` if provided.
+     */
+    get(key, defaultValue) {
+        if (typeof this.options[key] !== 'undefined') {
+            return this.options[key];
+        }
+        return defaultValue;
+    }
+    getAll() {
+        return this.options;
+    }
+    /**
+     * Overrides specified configuration value.
+     */
+    set(key, value) {
+        this.options[key] = value;
+        this.sync();
+    }
+    /**
+     * Resets the configuration to its default value
+     */
+    reset(key) {
+        this.options[key] = Configuration.DEFAULTS[key];
+    }
+    /**
+     * Gets Logger instance.
+     */
+    getLogger() {
+        return this.logger;
+    }
+    /**
+     * Gets current client URL (connection string).
+     */
+    getClientUrl(hidePassword = false) {
+        if (hidePassword) {
+            return this.options.clientUrl.replace(/\/\/([^:]+):(.+)@/, '//$1:*****@');
+        }
+        return this.options.clientUrl;
+    }
+    /**
+     * Gets current database driver instance.
+     */
+    getDriver() {
+        return this.driver;
+    }
+    registerExtension(name, cb) {
+        this.extensions.set(name, cb);
+    }
+    getExtension(name) {
+        if (this.cache.has(name)) {
+            return this.cache.get(name);
+        }
+        const ext = this.extensions.get(name);
+        if (ext) {
+            this.cache.set(name, ext());
+            return this.cache.get(name);
+        }
+        return undefined;
+    }
+    /**
+     * Gets instance of NamingStrategy. (cached)
+     */
+    getNamingStrategy() {
+        return this.getCachedService(this.options.namingStrategy || this.platform.getNamingStrategy());
+    }
+    /**
+     * Gets instance of Hydrator. (cached)
+     */
+    getHydrator(metadata) {
+        return this.getCachedService(this.options.hydrator, metadata, this.platform, this);
+    }
+    /**
+     * Gets instance of Comparator. (cached)
+     */
+    getComparator(metadata) {
+        return this.getCachedService(EntityComparator_1.EntityComparator, metadata, this.platform);
+    }
+    /**
+     * Gets instance of MetadataProvider. (cached)
+     */
+    getMetadataProvider() {
+        return this.getCachedService(this.options.metadataProvider, this);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Gets instance of CacheAdapter for result cache. (cached)
+     */
+    getResultCacheAdapter() {
+        return this.getCachedService(this.options.resultCache.adapter, { expiration: this.options.resultCache.expiration, ...this.options.resultCache.options });
+    }
+    /**
+     * Gets EntityRepository class to be instantiated.
+     */
+    getRepositoryClass(repository) {
+        if (repository) {
+            return repository();
+        }
+        if (this.options.entityRepository) {
+            return this.options.entityRepository;
+        }
+        return this.platform.getRepositoryClass();
+    }
+    /**
+     * Creates instance of given service and caches it.
+     */
+    getCachedService(cls, ...args) {
+        if (!this.cache.has(cls.name)) {
+            const Class = cls;
+            this.cache.set(cls.name, new Class(...args));
+        }
+        return this.cache.get(cls.name);
+    }
+    resetServiceCache() {
+        this.cache.clear();
+    }
+    init() {
+        if (!this.getMetadataProvider().useCache()) {
+            this.options.metadataCache.adapter = cache_1.NullCacheAdapter;
+        }
+        if (!('enabled' in this.options.metadataCache)) {
+            this.options.metadataCache.enabled = this.getMetadataProvider().useCache();
+        }
+        if (!this.options.clientUrl) {
+            this.options.clientUrl = this.driver.getConnection().getDefaultClientUrl();
+        }
+        if (!('implicitTransactions' in this.options)) {
+            this.options.implicitTransactions = this.platform.usesImplicitTransactions();
+        }
+        const url = this.getClientUrl().match(/:\/\/.*\/([^?]+)/);
+        if (url) {
+            this.options.dbName = this.get('dbName', decodeURIComponent(url[1]));
+        }
+        if (!this.options.charset) {
+            this.options.charset = this.platform.getDefaultCharset();
+        }
+        Object.keys(this.options.filters).forEach(key => {
+            this.options.filters[key].default ??= true;
+        });
+        this.options.subscribers = Utils_1.Utils.unique(this.options.subscribers).map(subscriber => {
+            return subscriber.constructor.name === 'Function' ? new subscriber() : subscriber;
+        });
+        this.sync();
+        if (!logging_1.colors.enabled()) {
+            this.options.highlighter = new NullHighlighter_1.NullHighlighter();
+        }
+    }
+    sync() {
+        process.env.MIKRO_ORM_COLORS = '' + this.options.colors;
+        this.logger.setDebugMode(this.options.debug);
+    }
+    /**
+     * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
+     * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
+     * used for the TS variant (`pathTs` option).
+     *
+     * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
+     * break existing projects, only help with the new ones.
+     */
+    detectSourceFolder(options) {
+        if (!(0, fs_extra_1.pathExistsSync)(this.options.baseDir + '/src')) {
+            return;
+        }
+        const migrationsPathExists = (0, fs_extra_1.pathExistsSync)(this.options.baseDir + '/' + this.options.migrations.path);
+        const seedersPathExists = (0, fs_extra_1.pathExistsSync)(this.options.baseDir + '/' + this.options.seeder.path);
+        const distDir = (0, fs_extra_1.pathExistsSync)(this.options.baseDir + '/dist');
+        const buildDir = (0, fs_extra_1.pathExistsSync)(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
+        if (!options.migrations?.path && !options.migrations?.pathTs && !migrationsPathExists) {
+            this.options.migrations.path = `${path}/migrations`;
+            this.options.migrations.pathTs = './src/migrations';
+        }
+        // only if the user did not provide any values and if the default path does not exist
+        if (!options.seeder?.path && !options.seeder?.pathTs && !seedersPathExists) {
+            this.options.seeder.path = `${path}/seeders`;
+            this.options.seeder.pathTs = './src/seeders';
+        }
+    }
+    validateOptions() {
+        /* istanbul ignore next */
+        if ('type' in this.options) {
+            throw new Error('The `type` option has been removed in v6, please fill in the `driver` option instead or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from \'@mikro-orm/mysql\'; export default defineConfig({ ... })`).');
+        }
+        if (!this.options.driver) {
+            throw new Error('No driver specified, please fill in the `driver` option or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from \'@mikro-orm/mysql\'; export defineConfig({ ... })`).');
+        }
+        if (!this.options.dbName && !this.options.clientUrl) {
+            throw new Error('No database specified, please fill in `dbName` or `clientUrl` option');
+        }
+        if (this.options.entities.length === 0 && this.options.discovery.warnWhenNoEntities) {
+            throw new Error('No entities found, please use `entities` option');
+        }
+    }
+}
+exports.Configuration = Configuration;
+/**
+ * Type helper to make it easier to use `mikro-orm.config.js`.
+ */
+function defineConfig(options) {
+    return options;
+}
+exports.defineConfig = defineConfig;

package/utils/ConfigurationLoader.d.ts

@@ -0,0 +1,29 @@
+import type { EntityManagerType, IDatabaseDriver } from '../drivers';
+import { Configuration, type Options } from './Configuration';
+import type { Dictionary } from '../typings';
+import type { EntityManager } from '../EntityManager';
+/**
+ * @internal
+ */
+export declare class ConfigurationLoader {
+    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = EntityManager>(validate?: boolean, options?: Partial<Options>): Promise<Configuration<D, EM>>;
+    static getPackageConfig(basePath?: string): Promise<Dictionary>;
+    static getSettings(): Promise<Settings>;
+    static getConfigPaths(): Promise<string[]>;
+    static isESM(): Promise<boolean>;
+    static registerTsNode(configPath?: string): Promise<boolean>;
+    static registerDotenv<D extends IDatabaseDriver>(options?: Options<D> | Configuration<D>): void;
+    static loadEnvironmentVars<D extends IDatabaseDriver>(): Partial<Options<D>>;
+    static getORMPackages(): Promise<Set<string>>;
+    /** @internal */
+    static commonJSCompat(options: Partial<Options>): Promise<void>;
+    static getORMPackageVersion(name: string): Promise<string | undefined>;
+    static checkPackageVersion(): Promise<string>;
+}
+export interface Settings {
+    alwaysAllowTs?: boolean;
+    verbose?: boolean;
+    useTsNode?: boolean;
+    tsConfigPath?: string;
+    configPaths?: string[];
+}

package/utils/ConfigurationLoader.js

@@ -0,0 +1,282 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationLoader = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const os_1 = require("os");
+const url_1 = require("url");
+const Configuration_1 = require("./Configuration");
+const Utils_1 = require("./Utils");
+const colors_1 = require("../logging/colors");
+/**
+ * @internal
+ */
+class ConfigurationLoader {
+    static async getConfiguration(validate = true, options = {}) {
+        await this.commonJSCompat(options);
+        this.registerDotenv(options);
+        const paths = await this.getConfigPaths();
+        const env = this.loadEnvironmentVars();
+        for (let path of paths) {
+            path = Utils_1.Utils.absolutePath(path);
+            path = Utils_1.Utils.normalizePath(path);
+            if (await (0, fs_extra_1.pathExists)(path)) {
+                const config = await Utils_1.Utils.dynamicImport(path);
+                /* istanbul ignore next */
+                let tmp = config.default ?? config;
+                if (tmp instanceof Function) {
+                    tmp = tmp();
+                }
+                if (tmp instanceof Promise) {
+                    tmp = await tmp;
+                }
+                const esmConfigOptions = await this.isESM() ? { entityGenerator: { esmImport: true } } : {};
+                return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig({}, esmConfigOptions, tmp, options, env), validate);
+            }
+        }
+        if (Utils_1.Utils.hasObjectKeys(env)) {
+            return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig({}, options, env), validate);
+        }
+        throw new Error(`MikroORM config file not found in ['${paths.join(`', '`)}']`);
+    }
+    static async getPackageConfig(basePath = process.cwd()) {
+        if (await (0, fs_extra_1.pathExists)(`${basePath}/package.json`)) {
+            /* istanbul ignore next */
+            try {
+                return await Utils_1.Utils.dynamicImport(`${basePath}/package.json`);
+            }
+            catch {
+                return {};
+            }
+        }
+        const parentFolder = await (0, fs_extra_1.realpath)(`${basePath}/..`);
+        // we reached the root folder
+        if (basePath === parentFolder) {
+            return {};
+        }
+        return this.getPackageConfig(parentFolder);
+    }
+    static async getSettings() {
+        const config = await ConfigurationLoader.getPackageConfig();
+        const settings = { ...config['mikro-orm'] };
+        const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
+        settings.useTsNode = process.env.MIKRO_ORM_CLI_USE_TS_NODE != null ? bool(process.env.MIKRO_ORM_CLI_USE_TS_NODE) : settings.useTsNode;
+        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.useTsNode = true;
+        }
+        return settings;
+    }
+    static async getConfigPaths() {
+        const options = Utils_1.Utils.parseArgs();
+        if (options.config) {
+            return [options.config];
+        }
+        const paths = [];
+        const settings = await ConfigurationLoader.getSettings();
+        if (process.env.MIKRO_ORM_CLI_CONFIG) {
+            paths.push(process.env.MIKRO_ORM_CLI_CONFIG);
+        }
+        paths.push(...(settings.configPaths || []));
+        if (settings.useTsNode || settings.alwaysAllowTs) {
+            paths.push('./src/mikro-orm.config.ts');
+            paths.push('./mikro-orm.config.ts');
+        }
+        const distDir = (0, fs_extra_1.pathExistsSync)(process.cwd() + '/dist');
+        const buildDir = (0, fs_extra_1.pathExistsSync)(process.cwd() + '/build');
+        /* istanbul ignore next */
+        const path = distDir ? 'dist' : (buildDir ? 'build' : 'src');
+        paths.push(`./${path}/mikro-orm.config.js`);
+        paths.push('./mikro-orm.config.js');
+        const tsNode = Utils_1.Utils.detectTsNode();
+        return Utils_1.Utils.unique(paths).filter(p => p.endsWith('.js') || tsNode || settings.alwaysAllowTs);
+    }
+    static async isESM() {
+        const config = await ConfigurationLoader.getPackageConfig();
+        const type = config?.type ?? '';
+        return type === 'module';
+    }
+    static async registerTsNode(configPath = 'tsconfig.json') {
+        const tsConfigPath = (0, path_1.isAbsolute)(configPath) ? configPath : (0, path_1.join)(process.cwd(), configPath);
+        const tsNode = Utils_1.Utils.tryRequire({
+            module: 'ts-node',
+            from: tsConfigPath,
+            warning: 'ts-node not installed, support for working with TS files might not work',
+        });
+        /* istanbul ignore next */
+        if (!tsNode) {
+            return false;
+        }
+        const { options } = tsNode.register({
+            project: tsConfigPath,
+            transpileOnly: true,
+            // compilerOptions: {
+            //   module: 'commonjs',
+            // },
+        }).config;
+        if (Object.entries(options?.paths ?? {}).length > 0) {
+            Utils_1.Utils.requireFrom('tsconfig-paths', tsConfigPath).register({
+                baseUrl: options.baseUrl ?? '.',
+                paths: options.paths,
+            });
+        }
+        return true;
+    }
+    static registerDotenv(options) {
+        const baseDir = options instanceof Configuration_1.Configuration ? options.get('baseDir') : options?.baseDir;
+        const path = process.env.MIKRO_ORM_ENV ?? ((baseDir ?? process.cwd()) + '/.env');
+        const env = {};
+        dotenv_1.default.config({ path, processEnv: env });
+        // only propagate known env vars
+        for (const key of Object.keys(env)) {
+            if (key.startsWith('MIKRO_ORM_')) {
+                process.env[key] ??= env[key]; // respect user provided values
+            }
+        }
+    }
+    static loadEnvironmentVars() {
+        const ret = {};
+        // 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' },
+            'mariadb': { className: 'MariaDbDriver', module: '@mikro-orm/mariadb' },
+            'postgresql': { className: 'PostgreSqlDriver', module: '@mikro-orm/postgresql' },
+            'sqlite': { className: 'SqliteDriver', module: '@mikro-orm/sqlite' },
+            'better-sqlite': { className: 'BetterSqliteDriver', module: '@mikro-orm/better-sqlite' },
+        };
+        const array = (v) => v.split(',').map(vv => vv.trim());
+        const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
+        const num = (v) => +v;
+        const driver = (v) => Utils_1.Utils.requireFrom(PLATFORMS[v].module)[PLATFORMS[v].className];
+        const read = (o, envKey, key, mapper = v => v) => {
+            if (!(envKey in process.env)) {
+                return;
+            }
+            const val = process.env[envKey];
+            o[key] = mapper(val);
+        };
+        const cleanup = (o, k) => Utils_1.Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
+        read(ret, 'MIKRO_ORM_BASE_DIR', 'baseDir');
+        read(ret, 'MIKRO_ORM_TYPE', 'driver', driver);
+        read(ret, 'MIKRO_ORM_ENTITIES', 'entities', array);
+        read(ret, 'MIKRO_ORM_ENTITIES_TS', 'entitiesTs', array);
+        read(ret, 'MIKRO_ORM_CLIENT_URL', 'clientUrl');
+        read(ret, 'MIKRO_ORM_HOST', 'host');
+        read(ret, 'MIKRO_ORM_PORT', 'port', num);
+        read(ret, 'MIKRO_ORM_USER', 'user');
+        read(ret, 'MIKRO_ORM_PASSWORD', 'password');
+        read(ret, 'MIKRO_ORM_DB_NAME', 'dbName');
+        read(ret, 'MIKRO_ORM_SCHEMA', 'schema');
+        read(ret, 'MIKRO_ORM_LOAD_STRATEGY', 'loadStrategy');
+        read(ret, 'MIKRO_ORM_BATCH_SIZE', 'batchSize', num);
+        read(ret, 'MIKRO_ORM_USE_BATCH_INSERTS', 'useBatchInserts', bool);
+        read(ret, 'MIKRO_ORM_USE_BATCH_UPDATES', 'useBatchUpdates', bool);
+        read(ret, 'MIKRO_ORM_STRICT', 'strict', bool);
+        read(ret, 'MIKRO_ORM_VALIDATE', 'validate', bool);
+        read(ret, 'MIKRO_ORM_ALLOW_GLOBAL_CONTEXT', 'allowGlobalContext', bool);
+        read(ret, 'MIKRO_ORM_AUTO_JOIN_ONE_TO_ONE_OWNER', 'autoJoinOneToOneOwner', bool);
+        read(ret, 'MIKRO_ORM_POPULATE_AFTER_FLUSH', 'populateAfterFlush', bool);
+        read(ret, 'MIKRO_ORM_FORCE_ENTITY_CONSTRUCTOR', 'forceEntityConstructor', bool);
+        read(ret, 'MIKRO_ORM_FORCE_UNDEFINED', 'forceUndefined', bool);
+        read(ret, 'MIKRO_ORM_FORCE_UTC_TIMEZONE', 'forceUtcTimezone', bool);
+        read(ret, 'MIKRO_ORM_TIMEZONE', 'timezone');
+        read(ret, 'MIKRO_ORM_ENSURE_INDEXES', 'ensureIndexes', bool);
+        read(ret, 'MIKRO_ORM_IMPLICIT_TRANSACTIONS', 'implicitTransactions', bool);
+        read(ret, 'MIKRO_ORM_DEBUG', 'debug', bool);
+        read(ret, 'MIKRO_ORM_COLORS', 'colors', bool);
+        ret.discovery = {};
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_WARN_WHEN_NO_ENTITIES', 'warnWhenNoEntities', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_REQUIRE_ENTITIES_ARRAY', 'requireEntitiesArray', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_ALWAYS_ANALYSE_PROPERTIES', 'alwaysAnalyseProperties', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_DISABLE_DYNAMIC_FILE_ACCESS', 'disableDynamicFileAccess', bool);
+        cleanup(ret, 'discovery');
+        ret.migrations = {};
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_TABLE_NAME', 'tableName');
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_PATH', 'path');
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_PATH_TS', 'pathTs');
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_GLOB', 'glob');
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_TRANSACTIONAL', 'transactional', bool);
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_DISABLE_FOREIGN_KEYS', 'disableForeignKeys', bool);
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_ALL_OR_NOTHING', 'allOrNothing', bool);
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_DROP_TABLES', 'dropTables', bool);
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SAFE', 'safe', bool);
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_EMIT', 'emit');
+        cleanup(ret, 'migrations');
+        ret.schemaGenerator = {};
+        read(ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_DISABLE_FOREIGN_KEYS', 'disableForeignKeys', bool);
+        read(ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_CREATE_FOREIGN_KEY_CONSTRAINTS', 'createForeignKeyConstraints', bool);
+        cleanup(ret, 'schemaGenerator');
+        ret.seeder = {};
+        read(ret.seeder, 'MIKRO_ORM_SEEDER_PATH', 'path');
+        read(ret.seeder, 'MIKRO_ORM_SEEDER_PATH_TS', 'pathTs');
+        read(ret.seeder, 'MIKRO_ORM_SEEDER_GLOB', 'glob');
+        read(ret.seeder, 'MIKRO_ORM_SEEDER_EMIT', 'emit');
+        read(ret.seeder, 'MIKRO_ORM_SEEDER_DEFAULT_SEEDER', 'defaultSeeder');
+        cleanup(ret, 'seeder');
+        return ret;
+    }
+    static async getORMPackages() {
+        const pkg = await this.getPackageConfig();
+        return new Set([
+            ...Object.keys(pkg.dependencies ?? {}),
+            ...Object.keys(pkg.devDependencies ?? {}),
+        ]);
+    }
+    /** @internal */
+    static async commonJSCompat(options) {
+        if (await this.isESM()) {
+            return;
+        }
+        /* istanbul ignore next */
+        options.dynamicImportProvider ??= id => {
+            if ((0, os_1.platform)() === 'win32') {
+                try {
+                    id = (0, url_1.fileURLToPath)(id);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            return Utils_1.Utils.requireFrom(id);
+        };
+        Utils_1.Utils.setDynamicImportProvider(options.dynamicImportProvider);
+    }
+    static async getORMPackageVersion(name) {
+        /* istanbul ignore next */
+        try {
+            const pkg = Utils_1.Utils.requireFrom(`${name}/package.json`);
+            return pkg?.version;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    // inspired by https://github.com/facebook/mikro-orm/pull/3386
+    static async checkPackageVersion() {
+        const coreVersion = Utils_1.Utils.getORMVersion();
+        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH) {
+            return coreVersion;
+        }
+        const deps = await this.getORMPackages();
+        const exceptions = new Set(['nestjs', 'sql-highlighter', 'mongo-highlighter']);
+        const ormPackages = [...deps].filter(d => d.startsWith('@mikro-orm/') && d !== '@mikro-orm/core' && !exceptions.has(d.substring('@mikro-orm/'.length)));
+        for (const ormPackage of ormPackages) {
+            const version = await this.getORMPackageVersion(ormPackage);
+            if (version != null && version !== coreVersion) {
+                throw new Error(`Bad ${colors_1.colors.cyan(ormPackage)} version ${colors_1.colors.yellow('' + version)}.\n` +
+                    `All official @mikro-orm/* packages need to have the exact same version as @mikro-orm/core (${colors_1.colors.green(coreVersion)}).\n` +
+                    `Only exceptions are packages that don't live in the 'mikro-orm' repository: ${[...exceptions].join(', ')}.\n` +
+                    `Maybe you want to check, or regenerate your yarn.lock or package-lock.json file?`);
+            }
+        }
+        return coreVersion;
+    }
+}
+exports.ConfigurationLoader = ConfigurationLoader;