@mikro-orm/core 7.0.0-dev.41 → 7.0.0-dev.43

package/MikroORM.d.ts

@@ -21,7 +21,7 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
      * If you omit the `options` parameter, your CLI config will be used.
      */
-    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options?: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
+    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * Synchronous variant of the `init` method with some limitations:
      * - database connection will be established when you first interact with the database (or you can use `orm.connect()` explicitly)
@@ -29,7 +29,6 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * - no support for folder based discovery
      * - no check for mismatched package versions
      */
-    static initSync<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): MikroORM<D, EM, Entities>;
     constructor(options: Options<Driver, EM>);
     /**
      * Connects to the database.

package/MikroORM.js

@@ -23,22 +23,14 @@ export class MikroORM {
      * If you omit the `options` parameter, your CLI config will be used.
      */
     static async init(options) {
-        ConfigurationLoader.registerDotenv(options);
-        const coreVersion = ConfigurationLoader.checkPackageVersion();
-        const env = await ConfigurationLoader.loadEnvironmentVars();
+        /* v8 ignore next 3 */
         if (!options) {
-            const configPathFromArg = ConfigurationLoader.configPathsFromArg();
-            const config = (await ConfigurationLoader.getConfiguration(process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default', configPathFromArg ?? ConfigurationLoader.getConfigPaths()));
-            options = config.getAll();
-            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' });
-            }
-        }
-        options = Utils.mergeConfig(options, env);
-        if ('DRIVER' in this && !options.driver) {
-            options.driver = this.DRIVER;
+            throw new Error(`options parameter is required`);
         }
-        const orm = new MikroORM(options);
+        const coreVersion = ConfigurationLoader.checkPackageVersion();
+        options.discovery ??= {};
+        options.discovery.skipSyncDiscovery ??= true;
+        const orm = new this(options);
         orm.logger.log('info', `MikroORM version: ${colors.green(coreVersion)}`);
         // we need to allow global context here as we are not in a scope of requests yet
         const allowGlobalContext = orm.config.get('allowGlobalContext');
@@ -46,15 +38,6 @@ export class MikroORM {
         await orm.discoverEntities();
         orm.config.set('allowGlobalContext', allowGlobalContext);
         orm.driver.getPlatform().init(orm);
-        if (orm.config.get('connect')) {
-            await orm.connect();
-        }
-        for (const extension of orm.config.get('extensions')) {
-            extension.register(orm);
-        }
-        if (orm.config.get('connect') && orm.config.get('ensureIndexes')) {
-            await orm.getSchemaGenerator().ensureIndexes();
-        }
         return orm;
     }
     /**
@@ -64,26 +47,10 @@ export class MikroORM {
      * - no support for folder based discovery
      * - no check for mismatched package versions
      */
-    static initSync(options) {
+    constructor(options) {
         ConfigurationLoader.registerDotenv(options);
         const env = ConfigurationLoader.loadEnvironmentVarsSync();
         options = Utils.merge(options, env);
-        if ('DRIVER' in this && !options.driver) {
-            options.driver = this.DRIVER;
-        }
-        const orm = new MikroORM(options);
-        // we need to allow global context here as we are not in a scope of requests yet
-        const allowGlobalContext = orm.config.get('allowGlobalContext');
-        orm.config.set('allowGlobalContext', true);
-        orm.discoverEntitiesSync();
-        orm.config.set('allowGlobalContext', allowGlobalContext);
-        orm.driver.getPlatform().init(orm);
-        for (const extension of orm.config.get('extensions')) {
-            extension.register(orm);
-        }
-        return orm;
-    }
-    constructor(options) {
         this.config = new Configuration(options);
         const discovery = this.config.get('discovery');
         if (discovery.disableDynamicFileAccess) {
@@ -94,25 +61,23 @@ export class MikroORM {
         this.driver = this.config.getDriver();
         this.logger = this.config.getLogger();
         this.discovery = new MetadataDiscovery(new MetadataStorage(), this.driver.getPlatform(), this.config);
+        if (!discovery.skipSyncDiscovery) {
+            // we need to allow global context here as we are not in a scope of requests yet
+            const allowGlobalContext = this.config.get('allowGlobalContext');
+            this.config.set('allowGlobalContext', true);
+            this.discoverEntitiesSync();
+            this.config.set('allowGlobalContext', allowGlobalContext);
+            this.driver.getPlatform().init(this);
+        }
+        for (const extension of this.config.get('extensions')) {
+            extension.register(this);
+        }
     }
     /**
      * Connects to the database.
      */
     async connect() {
-        const connection = await this.driver.connect();
-        const clientUrl = connection.getClientUrl();
-        const dbName = this.config.get('dbName');
-        const db = dbName + (clientUrl ? ' on ' + clientUrl : '');
-        if (this.config.get('ensureDatabase')) {
-            const options = this.config.get('ensureDatabase');
-            await this.schema.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
-        }
-        if (await this.isConnected()) {
-            this.logger.log('info', `MikroORM successfully connected to database ${colors.green(db)}`);
-        }
-        else {
-            this.logger.error('info', `MikroORM failed to connect to database ${db}`);
-        }
+        await this.driver.connect();
         return this.driver;
     }
     /**
@@ -141,9 +106,7 @@ export class MikroORM {
      * Closes the database connection.
      */
     async close(force = false) {
-        if (await this.isConnected()) {
-            await this.driver.close(force);
-        }
+        await this.driver.close(force);
         if (this.config.getMetadataCacheAdapter()?.close) {
             await this.config.getMetadataCacheAdapter().close();
         }
@@ -166,7 +129,7 @@ export class MikroORM {
         this.createEntityManager();
     }
     discoverEntitiesSync() {
-        this.metadata = this.discovery.discoverSync(this.config.get('preferTs'));
+        this.metadata = this.discovery.discoverSync();
         this.createEntityManager();
     }
     createEntityManager() {

package/connections/Connection.d.ts

@@ -17,7 +17,9 @@ export declare abstract class Connection {
     /**
      * Establishes connection to database
      */
-    abstract connect(): void | Promise<void>;
+    abstract connect(options?: {
+        skipOnConnect?: boolean;
+    }): void | Promise<void>;
     /**
      * Are we connected to the database
      */
@@ -37,9 +39,10 @@ export declare abstract class Connection {
      */
     close(force?: boolean): Promise<void>;
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     ensureConnection(): Promise<void>;
+    protected onConnect(): Promise<void>;
     transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
@@ -58,7 +61,6 @@ export declare abstract class Connection {
     rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
     abstract execute<T>(query: string, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<QueryResult<T> | any | any[]>;
     getConnectionOptions(): ConnectionConfig;
-    getClientUrl(): string;
     setMetadata(metadata: MetadataStorage): void;
     setPlatform(platform: Platform): void;
     getPlatform(): Platform;

package/connections/Connection.js

@@ -33,13 +33,25 @@ export class Connection {
             .forEach(k => delete this.options[k]);
     }
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     async ensureConnection() {
         if (!this.connected) {
             await this.connect();
         }
     }
+    async onConnect() {
+        const schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
+        if (this.type === 'write' && schemaGenerator) {
+            if (this.config.get('ensureDatabase')) {
+                const options = this.config.get('ensureDatabase');
+                await schemaGenerator.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
+            }
+            if (this.config.get('ensureIndexes')) {
+                await schemaGenerator.ensureIndexes();
+            }
+        }
+    }
     async transactional(cb, options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
@@ -67,7 +79,7 @@ export class Connection {
             }
         }
         else {
-            const url = new URL(this.config.getClientUrl());
+            const url = new URL(this.config.get('clientUrl'));
             this.options.host = ret.host = this.options.host ?? this.config.get('host', decodeURIComponent(url.hostname));
             this.options.port = ret.port = this.options.port ?? this.config.get('port', +url.port);
             this.options.user = ret.user = this.options.user ?? this.config.get('user', decodeURIComponent(url.username));
@@ -76,15 +88,6 @@ export class Connection {
         }
         return ret;
     }
-    getClientUrl() {
-        const options = this.getConnectionOptions();
-        const url = new URL(this.config.getClientUrl(true));
-        const password = options.password ? ':*****' : '';
-        const schema = options.schema && options.schema !== this.platform.getDefaultSchemaName()
-            ? `?schema=${options.schema}`
-            : '';
-        return `${url.protocol}//${options.user}${password}@${options.host}:${options.port}${schema}`;
-    }
     setMetadata(metadata) {
         this.metadata = metadata;
     }

package/drivers/DatabaseDriver.d.ts

@@ -36,8 +36,12 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     mapResult<T extends object>(result: EntityDictionary<T>, meta?: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
-    connect(): Promise<C>;
-    reconnect(): Promise<C>;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
+    reconnect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     getConnection(type?: ConnectionType): C;
     close(force?: boolean): Promise<void>;
     getPlatform(): Platform;

package/drivers/DatabaseDriver.js

@@ -65,14 +65,14 @@ export class DatabaseDriver {
         }
         return this.comparator.mapResult(meta.className, result);
     }
-    async connect() {
-        await this.connection.connect();
+    async connect(options) {
+        await this.connection.connect(options);
         await Promise.all(this.replicas.map(replica => replica.connect()));
         return this.connection;
     }
-    async reconnect() {
+    async reconnect(options) {
         await this.close(true);
-        await this.connect();
+        await this.connect(options);
         return this.connection;
     }
     getConnection(type = 'write') {

package/drivers/IDatabaseDriver.d.ts

@@ -14,9 +14,13 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
     [EntityManagerType]: EntityManager<this>;
     readonly config: Configuration;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    connect(): Promise<C>;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     close(force?: boolean): Promise<void>;
-    reconnect(): Promise<C>;
+    reconnect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     getConnection(type?: ConnectionType): C;
     /**
      * Finds selection of entities

package/metadata/MetadataDiscovery.d.ts

@@ -16,7 +16,7 @@ export declare class MetadataDiscovery {
     private readonly discovered;
     constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
     discover(preferTs?: boolean): Promise<MetadataStorage>;
-    discoverSync(preferTs?: boolean): MetadataStorage;
+    discoverSync(): MetadataStorage;
     private mapDiscoveredEntities;
     private initAccessors;
     processDiscoveredEntities(discovered: EntityMetadata[]): EntityMetadata[];

package/metadata/MetadataDiscovery.js

@@ -47,10 +47,10 @@ export class MetadataDiscovery {
         await this.config.get('discovery').afterDiscovered?.(storage, this.platform);
         return storage;
     }
-    discoverSync(preferTs = true) {
+    discoverSync() {
         const startTime = Date.now();
         this.logger.log('discovery', `ORM entity discovery started, using ${colors.cyan(this.metadataProvider.constructor.name)} in sync mode`);
-        this.findEntities(preferTs, true);
+        this.findEntities();
         for (const meta of this.discovered) {
             /* v8 ignore next */
             void this.config.get('discovery').onMetadata?.(meta, this.platform);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.41",
+  "version": "7.0.0-dev.43",
   "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",
@@ -54,7 +54,7 @@
     "dataloader": "2.2.3",
     "dotenv": "17.2.3",
     "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.41",
+    "mikro-orm": "7.0.0-dev.43",
     "reflect-metadata": "0.2.2",
     "tinyglobby": "0.2.13"
   }

package/typings.d.ts

@@ -527,6 +527,7 @@ export interface CreateSchemaOptions {
 export interface ClearDatabaseOptions {
     schema?: string;
     truncate?: boolean;
+    clearIdentityMap?: boolean;
 }
 export interface EnsureDatabaseOptions extends CreateSchemaOptions, ClearDatabaseOptions {
     clear?: boolean;

package/utils/AbstractSchemaGenerator.js

@@ -42,7 +42,9 @@ export class AbstractSchemaGenerator {
         for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
             await this.driver.nativeDelete(meta.className, {}, options);
         }
-        this.clearIdentityMap();
+        if (options?.clearIdentityMap ?? true) {
+            this.clearIdentityMap();
+        }
     }
     clearIdentityMap() {
         /* v8 ignore next 3 */

package/utils/Configuration.d.ts

@@ -57,7 +57,6 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
         loadStrategy: LoadStrategy.BALANCED;
         dataloader: DataloaderType.NONE;
         populateWhere: PopulateHint.ALL;
-        connect: true;
         ignoreUndefinedInQuery: false;
         onQuery: (sql: string) => string;
         autoJoinOneToOneOwner: true;
@@ -177,10 +176,6 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
      */
     getLogger(): Logger;
     getDataloaderType(): DataloaderType;
-    /**
-     * Gets current client URL (connection string).
-     */
-    getClientUrl(hidePassword?: boolean): string;
     getSchema(skipDefaultSchema?: boolean): string | undefined;
     /**
      * Gets current database driver instance.
@@ -239,7 +234,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
 /**
  * Type helper to make it easier to use `mikro-orm.config.js`.
  */
-export declare function defineConfig<D extends IDatabaseDriver>(options: Options<D>): Options<D, D[typeof EntityManagerType] & EntityManager<IDatabaseDriver<import("../index.js").Connection>>, (string | EntityClass<Partial<any>> | EntityClassGroup<Partial<any>> | EntitySchema<any, never>)[]>;
+export declare function defineConfig<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Options<D, EM, Entities>;
 export interface ConnectionOptions {
     dbName?: string;
     schema?: string;
@@ -301,6 +296,7 @@ export interface MetadataDiscoveryOptions {
     onMetadata?: (meta: EntityMetadata, platform: Platform) => MaybePromise<void>;
     afterDiscovered?: (storage: MetadataStorage, platform: Platform) => MaybePromise<void>;
     tsConfigPath?: string;
+    skipSyncDiscovery?: boolean;
 }
 export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = EntityManager> extends ConnectionOptions {
     entities: (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[];
@@ -321,7 +317,6 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     };
     implicitTransactions?: boolean;
     disableTransactions?: boolean;
-    connect: boolean;
     verbose: boolean;
     ignoreUndefinedInQuery?: boolean;
     onQuery: (sql: string, params: readonly unknown[]) => string;

package/utils/Configuration.js

@@ -47,7 +47,6 @@ export class Configuration {
         loadStrategy: LoadStrategy.BALANCED,
         dataloader: DataloaderType.NONE,
         populateWhere: PopulateHint.ALL,
-        connect: true,
         ignoreUndefinedInQuery: false,
         onQuery: sql => sql,
         autoJoinOneToOneOwner: true,
@@ -211,15 +210,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;
@@ -322,13 +312,13 @@ export class Configuration {
             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]));
             }

package/utils/ConfigurationLoader.d.ts

@@ -13,30 +13,14 @@ 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 = EntityManager>(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;
+    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>;

package/utils/ConfigurationLoader.js

@@ -7,30 +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.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'));
@@ -134,14 +118,6 @@ export class ConfigurationLoader {
         }
         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();
@@ -187,7 +163,7 @@ export class ConfigurationLoader {
         return !!supported;
     }
     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, quiet: true });
         // only propagate known env vars

package/utils/Utils.d.ts

@@ -261,10 +261,6 @@ export declare class Utils {
         warning: string;
     }): Promise<T | undefined>;
     static stripRelativePath(str: string): string;
-    /**
-     * simple process.argv parser, supports only properties with long names, prefixed with `--`
-     */
-    static parseArgs<T extends Dictionary = Dictionary>(): T;
     static xor(a: boolean, b: boolean): boolean;
     static keys<T extends object>(obj: T): (keyof T)[];
     static values<T extends object>(obj: T): T[keyof T][];

package/utils/Utils.js

@@ -1098,26 +1098,6 @@ export class Utils {
     static stripRelativePath(str) {
         return str.replace(/^(?:\.\.\/|\.\/)+/, '/');
     }
-    /**
-     * simple process.argv parser, supports only properties with long names, prefixed with `--`
-     */
-    static parseArgs() {
-        let lastKey;
-        return process.argv.slice(2).reduce((args, arg) => {
-            if (arg.includes('=')) {
-                const [key, value] = arg.split('=');
-                args[key.substring(2)] = value;
-            }
-            else if (lastKey) {
-                args[lastKey] = arg;
-                lastKey = undefined;
-            }
-            else if (arg.startsWith('--')) {
-                lastKey = arg.substring(2);
-            }
-            return args;
-        }, {});
-    }
     static xor(a, b) {
         return (a || b) && !(a && b);
     }