@mikro-orm/core 7.0.0-dev.77 → 7.0.0-dev.78

package/MikroORM.js

@@ -1,7 +1,7 @@
 import { MetadataDiscovery } from './metadata/MetadataDiscovery.js';
 import { MetadataStorage } from './metadata/MetadataStorage.js';
 import { Configuration } from './utils/Configuration.js';
-import { ConfigurationLoader } from './utils/ConfigurationLoader.js';
+import { loadEnvironmentVars } from './utils/env-vars.js';
 import { Utils } from './utils/Utils.js';
 import { colors } from './logging/colors.js';
 async function registerExtension(name, mod, extensions) {
@@ -31,6 +31,11 @@ export async function lookupExtensions(options) {
         await registerExtension('EntityGenerator', import('@mikro-orm/entity-generator' + ''), extensions);
     }
     options.extensions = extensions;
+    const metadataCacheEnabled = options.metadataCache?.enabled || options.metadataProvider?.useCache?.();
+    if (metadataCacheEnabled) {
+        options.metadataCache ??= {};
+        options.metadataCache.adapter ??= await import('@mikro-orm/core/fs-utils').then(m => m.FileCacheAdapter);
+    }
 }
 /**
  * The main class used to configure and bootstrap the ORM.
@@ -94,7 +99,7 @@ export class MikroORM {
      * - no support for folder based discovery
      */
     constructor(options) {
-        const env = ConfigurationLoader.loadEnvironmentVars();
+        const env = loadEnvironmentVars();
         options = Utils.merge(options, env);
         this.config = new Configuration(options);
         const discovery = this.config.get('discovery');

package/cache/FileCacheAdapter.d.ts

@@ -8,7 +8,7 @@ export declare class FileCacheAdapter implements SyncCacheAdapter {
     constructor(options: {
         cacheDir: string;
         combined?: boolean | string;
-    }, baseDir: string, pretty?: boolean);
+    } | undefined, baseDir: string, pretty?: boolean);
     /**
      * @inheritDoc
      */

package/cache/FileCacheAdapter.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { fs } from '../utils/fs-utils.js';
 import { Utils } from '../utils/Utils.js';
 export class FileCacheAdapter {
     options;
@@ -6,10 +7,11 @@ export class FileCacheAdapter {
     pretty;
     VERSION = Utils.getORMVersion();
     cache = {};
-    constructor(options, baseDir, pretty = false) {
+    constructor(options = {}, baseDir, pretty = false) {
         this.options = options;
         this.baseDir = baseDir;
         this.pretty = pretty;
+        this.options.cacheDir ??= process.cwd() + '/temp';
     }
     /**
      * @inheritDoc
@@ -19,7 +21,7 @@ export class FileCacheAdapter {
         if (!existsSync(path)) {
             return null;
         }
-        const payload = Utils.readJSONSync(path);
+        const payload = fs.readJSONSync(path);
         const hash = this.getHash(payload.origin);
         if (!hash || payload.hash !== hash) {
             return null;
@@ -50,7 +52,7 @@ export class FileCacheAdapter {
      */
     clear() {
         const path = this.path('*');
-        const files = Utils.glob(path);
+        const files = fs.glob(path);
         files.forEach(file => unlinkSync(file));
         this.cache = {};
     }
@@ -67,7 +69,7 @@ export class FileCacheAdapter {
         return path;
     }
     path(name) {
-        Utils.ensureDir(this.options.cacheDir);
+        fs.ensureDir(this.options.cacheDir);
         return `${this.options.cacheDir}/${name}.json`;
     }
     getHash(origin) {

package/cache/GeneratedCacheAdapter.d.ts

@@ -1,7 +1,6 @@
 import type { CacheAdapter } from './CacheAdapter.js';
 import type { Dictionary } from '../typings.js';
 export declare class GeneratedCacheAdapter implements CacheAdapter {
-    private readonly options;
     private readonly data;
     constructor(options: {
         data: Dictionary;

package/cache/GeneratedCacheAdapter.js

@@ -1,8 +1,6 @@
 export class GeneratedCacheAdapter {
-    options;
     data = new Map();
     constructor(options) {
-        this.options = options;
         this.data = new Map(Object.entries(options.data));
     }
     /**

package/cache/index.d.ts

@@ -1,5 +1,4 @@
 export * from './CacheAdapter.js';
 export * from './NullCacheAdapter.js';
-export * from './FileCacheAdapter.js';
 export * from './MemoryCacheAdapter.js';
 export * from './GeneratedCacheAdapter.js';

package/cache/index.js

@@ -1,5 +1,4 @@
 export * from './CacheAdapter.js';
 export * from './NullCacheAdapter.js';
-export * from './FileCacheAdapter.js';
 export * from './MemoryCacheAdapter.js';
 export * from './GeneratedCacheAdapter.js';

package/metadata/MetadataDiscovery.d.ts

@@ -9,7 +9,6 @@ export declare class MetadataDiscovery {
     private readonly config;
     private readonly namingStrategy;
     private readonly metadataProvider;
-    private readonly cache;
     private readonly logger;
     private readonly schemaHelper;
     private readonly validator;
@@ -29,7 +28,6 @@ export declare class MetadataDiscovery {
     private getSchema;
     private getRootEntity;
     private discoverEntity;
-    private saveToCache;
     private initNullability;
     private applyNamingStrategy;
     private initOwnColumns;

package/metadata/MetadataDiscovery.js

@@ -1,4 +1,3 @@
-import { extname } from 'node:path';
 import { EntityMetadata, } from '../typings.js';
 import { Utils } from '../utils/Utils.js';
 import { MetadataValidator } from './MetadataValidator.js';
@@ -15,7 +14,6 @@ export class MetadataDiscovery {
     config;
     namingStrategy;
     metadataProvider;
-    cache;
     logger;
     schemaHelper;
     validator = new MetadataValidator();
@@ -26,7 +24,6 @@ export class MetadataDiscovery {
         this.config = config;
         this.namingStrategy = this.config.getNamingStrategy();
         this.metadataProvider = this.config.getMetadataProvider();
-        this.cache = this.config.getMetadataCacheAdapter();
         this.logger = this.config.getLogger();
         this.schemaHelper = this.platform.getSchemaHelper();
     }
@@ -145,11 +142,7 @@ export class MetadataDiscovery {
             discovered.push(...this.processEntity(meta));
         }
         discovered.forEach(meta => meta.sync(true));
-        const combinedCachePath = this.cache.combine?.();
-        // override the path in the options, so we can log it from the CLI in `cache:generate` command
-        if (combinedCachePath) {
-            this.config.get('metadataCache').combined = combinedCachePath;
-        }
+        this.metadataProvider.combineCache();
         return discovered.map(meta => {
             meta = this.metadata.get(meta.className);
             meta.sync(true);
@@ -287,11 +280,9 @@ export class MetadataDiscovery {
         this.logger.log('discovery', `- processing entity ${colors.cyan(meta.className)}${colors.grey(path ? ` (${path})` : '')}`);
         const root = this.getRootEntity(meta);
         schema.meta.path = Utils.relativePath(meta.path, this.config.get('baseDir'));
-        const cache = this.metadataProvider.useCache() && meta.path && this.cache.get(meta.className + extname(meta.path));
+        const cache = this.metadataProvider.getCachedMetadata(meta, root);
         if (cache) {
             this.logger.log('discovery', `- using cached metadata for entity ${colors.cyan(meta.className)}`);
-            this.metadataProvider.loadFromCache(meta, cache);
-            meta.root = root;
             this.discovered.push(meta);
             return;
         }
@@ -305,39 +296,10 @@ export class MetadataDiscovery {
             const entityName = root.discriminatorColumn ? root.name : meta.name;
             meta.collection = this.namingStrategy.classToTableName(entityName);
         }
-        delete meta.root; // to allow caching (as root can contain cycles)
-        this.saveToCache(meta);
+        this.metadataProvider.saveToCache(meta);
         meta.root = root;
         this.discovered.push(meta);
     }
-    saveToCache(meta) {
-        if (!this.metadataProvider.useCache()) {
-            return;
-        }
-        const copy = Utils.copy(meta, false);
-        for (const prop of copy.props) {
-            if (Type.isMappedType(prop.type)) {
-                Reflect.deleteProperty(prop, 'type');
-                Reflect.deleteProperty(prop, 'customType');
-            }
-            if (prop.default) {
-                const raw = RawQueryFragment.getKnownFragment(prop.default);
-                if (raw) {
-                    prop.defaultRaw ??= this.platform.formatQuery(raw.sql, raw.params);
-                    Reflect.deleteProperty(prop, 'default');
-                }
-            }
-            Reflect.deleteProperty(prop, 'targetMeta');
-        }
-        [
-            'prototype', 'props', 'referencingProperties', 'propertyOrder', 'relations',
-            'concurrencyCheckKeys', 'checks',
-        ].forEach(key => delete copy[key]);
-        // base entity without properties might not have path, but nothing to cache there
-        if (meta.path) {
-            this.cache.set(meta.className + extname(meta.path), copy, meta.path);
-        }
-    }
     initNullability(prop) {
         if (prop.kind === ReferenceKind.ONE_TO_ONE) {
             return Utils.defaultValue(prop, 'nullable', prop.optional || !prop.owner);

package/metadata/MetadataProvider.d.ts

@@ -1,13 +1,22 @@
 import type { EntityMetadata } from '../typings.js';
 import type { Logger } from '../logging/Logger.js';
+import type { SyncCacheAdapter } from '../cache/CacheAdapter.js';
+import type { Platform } from '../platforms/Platform.js';
 export interface IConfiguration {
     get(key: string, defaultValue?: any): any;
     getLogger(): Logger;
+    getMetadataCacheAdapter(): SyncCacheAdapter;
+    getPlatform(): Platform;
 }
 export declare class MetadataProvider {
     protected readonly config: IConfiguration;
     constructor(config: IConfiguration);
     loadEntityMetadata(meta: EntityMetadata): void;
     loadFromCache(meta: EntityMetadata, cache: EntityMetadata): void;
+    static useCache(): boolean;
     useCache(): boolean;
+    saveToCache(meta: EntityMetadata): void;
+    getCachedMetadata<T>(meta: Pick<EntityMetadata<T>, 'className' | 'path' | 'root'>, root: EntityMetadata<T>): EntityMetadata<T> | undefined;
+    combineCache(): void;
+    getCacheKey(meta: Pick<EntityMetadata, 'className' | 'path'>): string;
 }

package/metadata/MetadataProvider.js

@@ -29,7 +29,34 @@ export class MetadataProvider {
         });
         Utils.mergeConfig(meta, cache);
     }
+    static useCache() {
+        return false;
+    }
     useCache() {
-        return this.config.get('metadataCache').enabled ?? false;
+        return this.config.get('metadataCache').enabled ?? MetadataProvider.useCache();
+    }
+    saveToCache(meta) {
+        //
+    }
+    getCachedMetadata(meta, root) {
+        if (!this.useCache()) {
+            return undefined;
+        }
+        const cache = meta.path && this.config.getMetadataCacheAdapter().get(this.getCacheKey(meta));
+        if (cache) {
+            this.loadFromCache(meta, cache);
+            meta.root = root;
+        }
+        return cache;
+    }
+    combineCache() {
+        const path = this.config.getMetadataCacheAdapter().combine?.();
+        // override the path in the options, so we can log it from the CLI in `cache:generate` command
+        if (path) {
+            this.config.get('metadataCache').combined = path;
+        }
+    }
+    getCacheKey(meta) {
+        return meta.className;
     }
 }

package/metadata/discover-entities.js

@@ -1,4 +1,5 @@
 import { basename } from 'node:path';
+import { fs } from '../utils/fs-utils.js';
 import { Utils } from '../utils/Utils.js';
 import { MetadataStorage } from './MetadataStorage.js';
 import { EntitySchema } from './EntitySchema.js';
@@ -26,7 +27,7 @@ async function getEntityClassOrSchema(filepath, allTargets, baseDir) {
 export async function discoverEntities(paths, options) {
     paths = Utils.asArray(paths).map(path => Utils.normalizePath(path));
     const baseDir = options?.baseDir ?? process.cwd();
-    const files = Utils.glob(paths, Utils.normalizePath(baseDir));
+    const files = fs.glob(paths, Utils.normalizePath(baseDir));
     const found = new Map();
     for (const filepath of files) {
         const filename = basename(filepath);

package/not-supported.d.ts

@@ -1 +1,2 @@
 export declare function discoverEntities(): void;
+export declare const fs: {};

package/not-supported.js

@@ -1,3 +1,4 @@
 export function discoverEntities() {
-    throw new Error('File discovery is not supported in this environment.');
+    throw new Error('Folder-based discovery is not supported in this environment.');
 }
+export const fs = new Proxy({}, { get: () => { throw new Error('File system is not supported in this environment.'); } });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.77",
+  "version": "7.0.0-dev.78",
   "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",
@@ -9,6 +9,10 @@
     "./file-discovery": {
       "node": "./metadata/discover-entities.js",
       "browser": "./not-supported.js"
+    },
+    "./fs-utils": {
+      "node": "./utils/fs-utils.js",
+      "browser": "./not-supported.js"
     }
   },
   "repository": {

package/utils/Configuration.d.ts

@@ -1,5 +1,4 @@
 import type { NamingStrategy } from '../naming-strategy/NamingStrategy.js';
-import { FileCacheAdapter } from '../cache/FileCacheAdapter.js';
 import { type CacheAdapter, type SyncCacheAdapter } from '../cache/CacheAdapter.js';
 import type { EntityRepository } from '../entity/EntityRepository.js';
 import type { AnyEntity, Constructor, Dictionary, EnsureDatabaseOptions, EntityClass, EntityMetadata, FilterDef, GenerateOptions, Highlighter, HydratorConstructor, IHydrator, IMigrationGenerator, IPrimaryKey, MaybePromise, Migration, MigrationObject } from '../typings.js';
@@ -80,7 +79,6 @@ declare const DEFAULTS: {
     readonly driverOptions: {};
     readonly migrations: {
         readonly tableName: "mikro_orm_migrations";
-        readonly path: "./migrations";
         readonly glob: "!(*.d).{js,ts,cjs}";
         readonly silent: false;
         readonly transactional: true;
@@ -118,13 +116,7 @@ declare const DEFAULTS: {
         readonly readOnlyPivotTables: false;
         readonly useCoreBaseEntity: false;
     };
-    readonly metadataCache: {
-        readonly pretty: false;
-        readonly adapter: typeof FileCacheAdapter;
-        readonly options: {
-            readonly cacheDir: string;
-        };
-    };
+    readonly metadataCache: {};
     readonly resultCache: {
         readonly adapter: typeof MemoryCacheAdapter;
         readonly expiration: 1000;
@@ -133,7 +125,6 @@ declare const DEFAULTS: {
     readonly metadataProvider: typeof MetadataProvider;
     readonly highlighter: NullHighlighter;
     readonly seeder: {
-        readonly path: "./seeders";
         readonly defaultSeeder: "DatabaseSeeder";
         readonly glob: "!(*.d).{js,ts}";
         readonly emit: "ts";
@@ -213,15 +204,6 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
     resetServiceCache(): void;
     private init;
     private sync;
-    /**
-     * 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.
-     */
-    private detectSourceFolder;
     private validateOptions;
 }
 /**
@@ -903,8 +885,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
          */
         pretty?: boolean;
         /**
-         * Cache adapter class to use.
-         * @default FileCacheAdapter
+         * Cache adapter class to use. When cache is enabled, and no adapter is provided explicitly, {@link FileCacheAdapter} is used automatically - but only if you use the async `MikroORM.init()` method.
          */
         adapter?: {
             new (...params: any[]): SyncCacheAdapter;
@@ -950,6 +931,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      */
     metadataProvider?: {
         new (config: Configuration): MetadataProvider;
+        useCache?: MetadataProvider['useCache'];
     };
     /**
      * Seeder configuration options.

package/utils/Configuration.js

@@ -1,4 +1,3 @@
-import { FileCacheAdapter } from '../cache/FileCacheAdapter.js';
 import { NullCacheAdapter } from '../cache/NullCacheAdapter.js';
 import { ObjectHydrator } from '../hydration/ObjectHydrator.js';
 import { NullHighlighter } from '../utils/NullHighlighter.js';
@@ -72,7 +71,6 @@ const DEFAULTS = {
     driverOptions: {},
     migrations: {
         tableName: 'mikro_orm_migrations',
-        path: './migrations',
         glob: '!(*.d).{js,ts,cjs}',
         silent: false,
         transactional: true,
@@ -104,17 +102,14 @@ const DEFAULTS = {
         entityDefinition: 'defineEntity',
         decorators: 'legacy',
         enumMode: 'dictionary',
+        /* v8 ignore next */
         fileName: (className) => className,
         onlyPurePivotTables: false,
         outputPurePivotTables: false,
         readOnlyPivotTables: false,
         useCoreBaseEntity: false,
     },
-    metadataCache: {
-        pretty: false,
-        adapter: FileCacheAdapter,
-        options: { cacheDir: process.cwd() + '/temp' },
-    },
+    metadataCache: {},
     resultCache: {
         adapter: MemoryCacheAdapter,
         expiration: 1000, // 1s
@@ -123,7 +118,6 @@ const DEFAULTS = {
     metadataProvider: MetadataProvider,
     highlighter: new NullHighlighter(),
     seeder: {
-        path: './seeders',
         defaultSeeder: 'DatabaseSeeder',
         glob: '!(*.d).{js,ts}',
         emit: 'ts',
@@ -160,7 +154,6 @@ export class Configuration {
             this.driver = new this.options.driver(this);
             this.platform = this.driver.getPlatform();
             this.platform.setConfig(this);
-            this.detectSourceFolder(options);
             this.init(validate);
         }
     }
@@ -292,16 +285,17 @@ export class Configuration {
         this.cache.clear();
     }
     init(validate) {
-        if (!this.getMetadataProvider().useCache()) {
-            this.options.metadataCache.adapter = NullCacheAdapter;
-        }
-        if (!('enabled' in this.options.metadataCache)) {
-            this.options.metadataCache.enabled = this.getMetadataProvider().useCache();
-        }
-        if (!this.options.clientUrl) {
-            this.options.clientUrl = this.platform.getDefaultClientUrl();
+        const useCache = this.getMetadataProvider().useCache();
+        const metadataCache = this.options.metadataCache;
+        if (!useCache) {
+            metadataCache.adapter = NullCacheAdapter;
         }
+        metadataCache.enabled ??= useCache;
+        this.options.clientUrl ??= this.platform.getDefaultClientUrl();
         this.options.implicitTransactions ??= this.platform.usesImplicitTransactions();
+        if (metadataCache.enabled && !metadataCache.adapter) {
+            throw new Error('No metadata cache adapter specified, please fill in `metadataCache.adapter` option or use the async MikroORM.init() method which can autoload it.');
+        }
         try {
             const url = new URL(this.options.clientUrl);
             if (url.pathname) {
@@ -337,35 +331,6 @@ export class Configuration {
         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 (!Utils.pathExists(this.options.baseDir + '/src')) {
-            return;
-        }
-        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
-        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() {
         /* v8 ignore next */
         if ('type' in this.options) {

package/utils/ConfigurationLoader.d.ts

@@ -1,13 +1 @@
-import type { IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
-import type { Dictionary } from '../typings.js';
-import { type Options } from './Configuration.js';
-/**
- * @internal
- */
-export declare class ConfigurationLoader {
-    static loadEnvironmentVars<D extends IDatabaseDriver>(): Partial<Options<D>>;
-    static getPackageConfig<T extends Dictionary>(basePath?: string): Promise<T>;
-    static getORMPackages(): Promise<Set<string>>;
-    static getORMPackageVersion(name: string): string | undefined;
-    static checkPackageVersion(): Promise<string>;
-}
+export {};

package/utils/ConfigurationLoader.js

@@ -1,151 +1 @@
-import { realpathSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { Utils } from './Utils.js';
-import { colors } from '../logging/colors.js';
-/**
- * @internal
- */
-export class ConfigurationLoader {
-    static loadEnvironmentVars() {
-        const ret = {};
-        const getEnvKey = (key, envPrefix = 'MIKRO_ORM_') => {
-            return envPrefix + key
-                .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-                .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
-                .toUpperCase();
-        };
-        const array = (v) => v.split(',').map(vv => vv.trim());
-        const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
-        const num = (v) => +v;
-        const read = (o, envPrefix, key, mapper = v => v) => {
-            const envKey = getEnvKey(key, envPrefix);
-            if (envKey in process.env) {
-                o[key] = mapper(process.env[envKey]);
-            }
-        };
-        const cleanup = (o, k) => Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
-        const read0 = read.bind(null, ret, 'MIKRO_ORM_');
-        read0('baseDir');
-        read0('entities', array);
-        read0('entitiesTs', array);
-        read0('clientUrl');
-        read0('host');
-        read0('port', num);
-        read0('user');
-        read0('password');
-        read0('dbName');
-        read0('schema');
-        read0('loadStrategy');
-        read0('batchSize', num);
-        read0('useBatchInserts', bool);
-        read0('useBatchUpdates', bool);
-        read0('strict', bool);
-        read0('validate', bool);
-        read0('allowGlobalContext', bool);
-        read0('autoJoinOneToOneOwner', bool);
-        read0('populateAfterFlush', bool);
-        read0('forceEntityConstructor', bool);
-        read0('forceUndefined', bool);
-        read0('forceUtcTimezone', bool);
-        read0('timezone');
-        read0('ensureIndexes', bool);
-        read0('implicitTransactions', bool);
-        read0('debug', bool);
-        read0('colors', bool);
-        ret.discovery = {};
-        const read1 = read.bind(null, ret.discovery, 'MIKRO_ORM_DISCOVERY_');
-        read1('warnWhenNoEntities', bool);
-        read1('checkDuplicateTableNames', bool);
-        read1('checkDuplicateFieldNames', bool);
-        read1('checkDuplicateEntities', bool);
-        read1('checkNonPersistentCompositeProps', bool);
-        read1('inferDefaultValues', bool);
-        read1('tsConfigPath');
-        cleanup(ret, 'discovery');
-        ret.migrations = {};
-        const read2 = read.bind(null, ret.migrations, 'MIKRO_ORM_MIGRATIONS_');
-        read2('tableName');
-        read2('path');
-        read2('pathTs');
-        read2('glob');
-        read2('transactional', bool);
-        read2('disableForeignKeys', bool);
-        read2('allOrNothing', bool);
-        read2('dropTables', bool);
-        read2('safe', bool);
-        read2('silent', bool);
-        read2('emit');
-        read2('snapshot', bool);
-        read2('snapshotName');
-        cleanup(ret, 'migrations');
-        ret.schemaGenerator = {};
-        const read3 = read.bind(null, ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_');
-        read3('disableForeignKeys', bool);
-        read3('createForeignKeyConstraints', bool);
-        cleanup(ret, 'schemaGenerator');
-        ret.seeder = {};
-        const read4 = read.bind(null, ret.seeder, 'MIKRO_ORM_SEEDER_');
-        read4('path');
-        read4('pathTs');
-        read4('glob');
-        read4('emit');
-        read4('defaultSeeder');
-        cleanup(ret, 'seeder');
-        return ret;
-    }
-    static async getPackageConfig(basePath = process.cwd()) {
-        if (Utils.pathExists(`${basePath}/package.json`)) {
-            try {
-                return await Utils.dynamicImport(`${basePath}/package.json`);
-            }
-            catch (e) {
-                /* v8 ignore next */
-                return {};
-            }
-        }
-        const parentFolder = realpathSync(`${basePath}/..`);
-        // we reached the root folder
-        if (basePath === parentFolder) {
-            return {};
-        }
-        return this.getPackageConfig(parentFolder);
-    }
-    static async getORMPackages() {
-        const pkg = await this.getPackageConfig();
-        return new Set([
-            ...Object.keys(pkg.dependencies ?? {}),
-            ...Object.keys(pkg.devDependencies ?? {}),
-        ]);
-    }
-    static getORMPackageVersion(name) {
-        try {
-            const path = import.meta.resolve(`${name}/package.json`);
-            const pkg = Utils.readJSONSync(fileURLToPath(path));
-            /* v8 ignore next */
-            return pkg?.version;
-        }
-        catch (e) {
-            return undefined;
-        }
-    }
-    // inspired by https://github.com/facebook/docusaurus/pull/3386
-    static async checkPackageVersion() {
-        const coreVersion = Utils.getORMVersion();
-        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH || coreVersion === 'N/A') {
-            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 = this.getORMPackageVersion(ormPackage);
-            if (version != null && version !== coreVersion) {
-                throw new Error(`Bad ${colors.cyan(ormPackage)} version ${colors.yellow('' + version)}.\n` +
-                    `All official @mikro-orm/* packages need to have the exact same version as @mikro-orm/core (${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;
-    }
-}
+export {};

package/utils/Utils.d.ts

@@ -153,8 +153,6 @@ export declare class Utils {
     static findDuplicates<T>(items: T[]): T[];
     static removeDuplicates<T>(items: T[]): T[];
     static randomInt(min: number, max: number): number;
-    static glob(input: string | string[], cwd?: string): string[];
-    static pathExists(path: string): boolean;
     /**
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
      */
@@ -163,8 +161,6 @@ export declare class Utils {
     static isOperator(key: PropertyKey, includeGroupOperators?: boolean): boolean;
     static hasNestedKey(object: unknown, key: string): boolean;
     static dynamicImport<T = any>(id: string): Promise<T>;
-    static ensureDir(path: string): void;
-    static readJSONSync(path: string): Dictionary;
     static getORMVersion(): string;
     static createFunction(context: Map<string, any>, code: string): any;
     static callCompiledFunction<T extends unknown[], R>(fn: (...args: T) => R, ...args: T): R;

package/utils/Utils.js

@@ -1,6 +1,5 @@
-import { isAbsolute, join, normalize, relative } from 'node:path';
+import { isAbsolute, normalize, relative } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { existsSync, globSync, statSync, mkdirSync, readFileSync } from 'node:fs';
 import { clone } from './clone.js';
 import { GroupOperator, PlainObject, QueryOperator, ReferenceKind } from '../enums.js';
 import { helper } from '../entity/wrap.js';
@@ -686,33 +685,6 @@ export class Utils {
     static randomInt(min, max) {
         return Math.round(Math.random() * (max - min)) + min;
     }
-    static glob(input, cwd) {
-        if (Array.isArray(input)) {
-            return input.flatMap(paths => this.glob(paths, cwd));
-        }
-        const hasGlobChars = /[*?[\]]/.test(input);
-        if (!hasGlobChars) {
-            try {
-                const s = statSync(cwd ? Utils.normalizePath(cwd, input) : input);
-                if (s.isDirectory()) {
-                    const files = globSync(join(input, '**'), { cwd, withFileTypes: true });
-                    return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
-                }
-            }
-            catch {
-                // ignore
-            }
-        }
-        const files = globSync(input, { cwd, withFileTypes: true });
-        return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
-    }
-    static pathExists(path) {
-        if (/[*?[\]]/.test(path)) {
-            const found = globSync(path);
-            return found.length > 0;
-        }
-        return existsSync(path);
-    }
     /**
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
      */
@@ -755,15 +727,6 @@ export class Utils {
         const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
         return this.dynamicImportProvider(specifier);
     }
-    static ensureDir(path) {
-        if (!existsSync(path)) {
-            mkdirSync(path, { recursive: true });
-        }
-    }
-    static readJSONSync(path) {
-        const file = readFileSync(path);
-        return JSON.parse(file.toString());
-    }
     static getORMVersion() {
         return '6.6.1';
     }

package/utils/env-vars.d.ts

@@ -0,0 +1,3 @@
+import { type Options } from './Configuration.js';
+/** @internal */
+export declare function loadEnvironmentVars(): Partial<Options>;

package/utils/env-vars.js

@@ -0,0 +1,87 @@
+import { Utils } from './Utils.js';
+/** @internal */
+export function loadEnvironmentVars() {
+    const ret = {};
+    const getEnvKey = (key, envPrefix = 'MIKRO_ORM_') => {
+        return envPrefix + key
+            .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+            .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+            .toUpperCase();
+    };
+    const array = (v) => v.split(',').map(vv => vv.trim());
+    const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
+    const num = (v) => +v;
+    const read = (o, envPrefix, key, mapper = v => v) => {
+        const envKey = getEnvKey(key, envPrefix);
+        if (envKey in process.env) {
+            o[key] = mapper(process.env[envKey]);
+        }
+    };
+    const cleanup = (o, k) => Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
+    const read0 = read.bind(null, ret, 'MIKRO_ORM_');
+    read0('baseDir');
+    read0('entities', array);
+    read0('entitiesTs', array);
+    read0('clientUrl');
+    read0('host');
+    read0('port', num);
+    read0('user');
+    read0('password');
+    read0('dbName');
+    read0('schema');
+    read0('loadStrategy');
+    read0('batchSize', num);
+    read0('useBatchInserts', bool);
+    read0('useBatchUpdates', bool);
+    read0('allowGlobalContext', bool);
+    read0('autoJoinOneToOneOwner', bool);
+    read0('populateAfterFlush', bool);
+    read0('forceEntityConstructor', bool);
+    read0('forceUndefined', bool);
+    read0('forceUtcTimezone', bool);
+    read0('timezone');
+    read0('ensureIndexes', bool);
+    read0('implicitTransactions', bool);
+    read0('debug', bool);
+    read0('colors', bool);
+    ret.discovery = {};
+    const read1 = read.bind(null, ret.discovery, 'MIKRO_ORM_DISCOVERY_');
+    read1('warnWhenNoEntities', bool);
+    read1('checkDuplicateTableNames', bool);
+    read1('checkDuplicateFieldNames', bool);
+    read1('checkDuplicateEntities', bool);
+    read1('checkNonPersistentCompositeProps', bool);
+    read1('inferDefaultValues', bool);
+    read1('tsConfigPath');
+    cleanup(ret, 'discovery');
+    ret.migrations = {};
+    const read2 = read.bind(null, ret.migrations, 'MIKRO_ORM_MIGRATIONS_');
+    read2('tableName');
+    read2('path');
+    read2('pathTs');
+    read2('glob');
+    read2('transactional', bool);
+    read2('disableForeignKeys', bool);
+    read2('allOrNothing', bool);
+    read2('dropTables', bool);
+    read2('safe', bool);
+    read2('silent', bool);
+    read2('emit');
+    read2('snapshot', bool);
+    read2('snapshotName');
+    cleanup(ret, 'migrations');
+    ret.schemaGenerator = {};
+    const read3 = read.bind(null, ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_');
+    read3('disableForeignKeys', bool);
+    read3('createForeignKeyConstraints', bool);
+    cleanup(ret, 'schemaGenerator');
+    ret.seeder = {};
+    const read4 = read.bind(null, ret.seeder, 'MIKRO_ORM_SEEDER_');
+    read4('path');
+    read4('pathTs');
+    read4('glob');
+    read4('emit');
+    read4('defaultSeeder');
+    cleanup(ret, 'seeder');
+    return ret;
+}

package/utils/fs-utils.d.ts

@@ -0,0 +1,12 @@
+import { type Dictionary } from '../typings.js';
+export declare const fs: {
+    pathExists(path: string): boolean;
+    ensureDir(path: string): void;
+    readJSONSync<T = Dictionary>(path: string): T;
+    glob(input: string | string[], cwd?: string): string[];
+    getPackageConfig<T extends Dictionary>(basePath?: string): Promise<T>;
+    getORMPackages(): Promise<Set<string>>;
+    getORMPackageVersion(name: string): string | undefined;
+    checkPackageVersion(): Promise<void>;
+};
+export * from '../cache/FileCacheAdapter.js';

package/utils/fs-utils.js

@@ -0,0 +1,96 @@
+import { existsSync, globSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Utils } from './Utils.js';
+import { colors } from '../logging/colors.js';
+export const fs = {
+    pathExists(path) {
+        if (/[*?[\]]/.test(path)) {
+            return globSync(path).length > 0;
+        }
+        return existsSync(path);
+    },
+    ensureDir(path) {
+        if (!existsSync(path)) {
+            mkdirSync(path, { recursive: true });
+        }
+    },
+    readJSONSync(path) {
+        const file = readFileSync(path);
+        return JSON.parse(file.toString());
+    },
+    glob(input, cwd) {
+        if (Array.isArray(input)) {
+            return input.flatMap(paths => this.glob(paths, cwd));
+        }
+        const hasGlobChars = /[*?[\]]/.test(input);
+        if (!hasGlobChars) {
+            try {
+                const s = statSync(cwd ? Utils.normalizePath(cwd, input) : input);
+                if (s.isDirectory()) {
+                    const files = globSync(join(input, '**'), { cwd, withFileTypes: true });
+                    return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        const files = globSync(input, { cwd, withFileTypes: true });
+        return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+    },
+    async getPackageConfig(basePath = process.cwd()) {
+        if (this.pathExists(`${basePath}/package.json`)) {
+            try {
+                return await Utils.dynamicImport(`${basePath}/package.json`);
+            }
+            catch (e) {
+                /* v8 ignore next */
+                return {};
+            }
+        }
+        const parentFolder = realpathSync(`${basePath}/..`);
+        // we reached the root folder
+        if (basePath === parentFolder) {
+            return {};
+        }
+        return this.getPackageConfig(parentFolder);
+    },
+    async getORMPackages() {
+        const pkg = await this.getPackageConfig();
+        return new Set([
+            ...Object.keys(pkg.dependencies ?? {}),
+            ...Object.keys(pkg.devDependencies ?? {}),
+        ]);
+    },
+    getORMPackageVersion(name) {
+        try {
+            const path = import.meta.resolve(`${name}/package.json`);
+            const pkg = this.readJSONSync(fileURLToPath(path));
+            return pkg?.version;
+        }
+        catch (e) {
+            return undefined;
+        }
+    },
+    // inspired by https://github.com/facebook/docusaurus/pull/3386
+    async checkPackageVersion() {
+        const coreVersion = Utils.getORMVersion();
+        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH || coreVersion === '[[MIKRO_ORM_VERSION]]') {
+            return;
+        }
+        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 = this.getORMPackageVersion(ormPackage);
+            if (version != null && version !== coreVersion) {
+                throw new Error(`Bad ${colors.cyan(ormPackage)} version ${colors.yellow('' + version)}.\n` +
+                    `All official @mikro-orm/* packages need to have the exact same version as @mikro-orm/core (${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?`);
+            }
+        }
+    },
+};
+export * from '../cache/FileCacheAdapter.js';

package/utils/index.d.ts

@@ -1,5 +1,4 @@
 export * from './Configuration.js';
-export * from './ConfigurationLoader.js';
 export * from './Cursor.js';
 export * from './DataloaderUtils.js';
 export * from './Utils.js';
@@ -11,4 +10,5 @@ export * from './NullHighlighter.js';
 export * from './EntityComparator.js';
 export * from './AbstractSchemaGenerator.js';
 export * from './RawQueryFragment.js';
+export * from './env-vars.js';
 export * from './upsert-utils.js';

package/utils/index.js

@@ -1,5 +1,4 @@
 export * from './Configuration.js';
-export * from './ConfigurationLoader.js';
 export * from './Cursor.js';
 export * from './DataloaderUtils.js';
 export * from './Utils.js';
@@ -11,4 +10,5 @@ export * from './NullHighlighter.js';
 export * from './EntityComparator.js';
 export * from './AbstractSchemaGenerator.js';
 export * from './RawQueryFragment.js';
+export * from './env-vars.js';
 export * from './upsert-utils.js';