@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/utils/Configuration.js

@@ -1,280 +1,271 @@
-import { FileCacheAdapter } from '../cache/FileCacheAdapter.js';
 import { NullCacheAdapter } from '../cache/NullCacheAdapter.js';
 import { ObjectHydrator } from '../hydration/ObjectHydrator.js';
 import { NullHighlighter } from '../utils/NullHighlighter.js';
 import { DefaultLogger } from '../logging/DefaultLogger.js';
 import { colors } from '../logging/colors.js';
 import { Utils } from '../utils/Utils.js';
-import { ReflectMetadataProvider } from '../metadata/ReflectMetadataProvider.js';
+import { MetadataProvider } from '../metadata/MetadataProvider.js';
 import { NotFoundError } from '../errors.js';
 import { RequestContext } from './RequestContext.js';
 import { DataloaderType, FlushMode, LoadStrategy, PopulateHint } from '../enums.js';
 import { MemoryCacheAdapter } from '../cache/MemoryCacheAdapter.js';
 import { EntityComparator } from './EntityComparator.js';
+import { setEnv } from './env-vars.js';
+const DEFAULTS = {
+    pool: {},
+    entities: [],
+    entitiesTs: [],
+    extensions: [],
+    subscribers: [],
+    filters: {},
+    discovery: {
+        warnWhenNoEntities: true,
+        checkDuplicateTableNames: true,
+        checkDuplicateFieldNames: true,
+        checkDuplicateEntities: true,
+        checkNonPersistentCompositeProps: true,
+        inferDefaultValues: true,
+    },
+    validateRequired: true,
+    context: (name) => RequestContext.getEntityManager(name),
+    contextName: 'default',
+    allowGlobalContext: false,
+    // eslint-disable-next-line no-console
+    logger: console.log.bind(console),
+    colors: true,
+    findOneOrFailHandler: (entityName, where) => NotFoundError.findOneFailed(entityName, where),
+    findExactlyOneOrFailHandler: (entityName, where) => NotFoundError.findExactlyOneFailed(entityName, where),
+    baseDir: globalThis.process?.cwd?.(),
+    hydrator: ObjectHydrator,
+    flushMode: FlushMode.AUTO,
+    loadStrategy: LoadStrategy.BALANCED,
+    dataloader: DataloaderType.NONE,
+    populateWhere: PopulateHint.ALL,
+    ignoreUndefinedInQuery: false,
+    onQuery: (sql) => sql,
+    autoJoinOneToOneOwner: true,
+    autoJoinRefsForFilters: true,
+    filtersOnRelations: true,
+    propagationOnPrototype: true,
+    populateAfterFlush: true,
+    serialization: {
+        includePrimaryKeys: true,
+    },
+    assign: {
+        updateNestedEntities: true,
+        updateByPrimaryKey: true,
+        mergeObjectProperties: false,
+        mergeEmbeddedProperties: true,
+        ignoreUndefined: false,
+    },
+    persistOnCreate: true,
+    upsertManaged: true,
+    forceEntityConstructor: false,
+    forceUndefined: false,
+    forceUtcTimezone: true,
+    processOnCreateHooksEarly: true,
+    ensureDatabase: true,
+    ensureIndexes: false,
+    batchSize: 300,
+    debug: false,
+    ignoreDeprecations: false,
+    verbose: false,
+    driverOptions: {},
+    migrations: {
+        tableName: 'mikro_orm_migrations',
+        glob: '!(*.d).{js,ts,cjs}',
+        silent: false,
+        transactional: true,
+        allOrNothing: true,
+        dropTables: true,
+        safe: false,
+        snapshot: true,
+        emit: 'ts',
+        fileName: (timestamp, name) => `Migration${timestamp}${name ? '_' + name : ''}`,
+    },
+    schemaGenerator: {
+        createForeignKeyConstraints: true,
+        ignoreSchema: [],
+        skipTables: [],
+        skipViews: [],
+        skipColumns: {},
+    },
+    embeddables: {
+        prefixMode: 'relative',
+    },
+    entityGenerator: {
+        forceUndefined: true,
+        undefinedDefaults: false,
+        scalarTypeInDecorator: false,
+        bidirectionalRelations: true,
+        identifiedReferences: true,
+        scalarPropertiesForRelations: 'never',
+        entityDefinition: 'defineEntity',
+        decorators: 'legacy',
+        enumMode: 'dictionary',
+        /* v8 ignore next */
+        fileName: (className) => className,
+        onlyPurePivotTables: false,
+        outputPurePivotTables: false,
+        readOnlyPivotTables: false,
+        useCoreBaseEntity: false,
+    },
+    metadataCache: {},
+    resultCache: {
+        adapter: MemoryCacheAdapter,
+        expiration: 1000, // 1s
+        options: {},
+    },
+    metadataProvider: MetadataProvider,
+    highlighter: new NullHighlighter(),
+    seeder: {
+        defaultSeeder: 'DatabaseSeeder',
+        glob: '!(*.d).{js,ts}',
+        emit: 'ts',
+        fileName: (className) => className,
+    },
+    preferReadReplicas: true,
+    dynamicImportProvider: /* v8 ignore next */ (id) => import(id),
+};
 export class Configuration {
-    static DEFAULTS = {
-        pool: {},
-        entities: [],
-        entitiesTs: [],
-        extensions: [],
-        subscribers: [],
-        filters: {},
-        discovery: {
-            warnWhenNoEntities: true,
-            requireEntitiesArray: false,
-            checkDuplicateTableNames: true,
-            checkDuplicateFieldNames: true,
-            checkDuplicateEntities: true,
-            checkNonPersistentCompositeProps: true,
-            alwaysAnalyseProperties: true,
-            disableDynamicFileAccess: false,
-            inferDefaultValues: true,
-        },
-        strict: false,
-        validate: false,
-        validateRequired: true,
-        context: (name) => RequestContext.getEntityManager(name),
-        contextName: 'default',
-        allowGlobalContext: false,
-        // eslint-disable-next-line no-console
-        logger: console.log.bind(console),
-        colors: true,
-        findOneOrFailHandler: (entityName, where) => NotFoundError.findOneFailed(entityName, where),
-        findExactlyOneOrFailHandler: (entityName, where) => NotFoundError.findExactlyOneFailed(entityName, where),
-        baseDir: process.cwd(),
-        hydrator: ObjectHydrator,
-        flushMode: FlushMode.AUTO,
-        loadStrategy: LoadStrategy.BALANCED,
-        dataloader: DataloaderType.NONE,
-        populateWhere: PopulateHint.ALL,
-        connect: true,
-        ignoreUndefinedInQuery: false,
-        onQuery: sql => sql,
-        autoJoinOneToOneOwner: true,
-        autoJoinRefsForFilters: true,
-        propagationOnPrototype: true,
-        populateAfterFlush: true,
-        serialization: {
-            includePrimaryKeys: true,
-        },
-        assign: {
-            updateNestedEntities: true,
-            updateByPrimaryKey: true,
-            mergeObjectProperties: false,
-            mergeEmbeddedProperties: true,
-            ignoreUndefined: false,
-        },
-        persistOnCreate: true,
-        upsertManaged: true,
-        forceEntityConstructor: false,
-        forceUndefined: false,
-        processOnCreateHooksEarly: false,
-        ensureDatabase: true,
-        ensureIndexes: false,
-        batchSize: 300,
-        hashAlgorithm: 'md5',
-        debug: false,
-        ignoreDeprecations: false,
-        verbose: false,
-        driverOptions: {},
-        migrations: {
-            tableName: 'mikro_orm_migrations',
-            path: './migrations',
-            glob: '!(*.d).{js,ts,cjs}',
-            silent: false,
-            transactional: true,
-            disableForeignKeys: false,
-            allOrNothing: true,
-            dropTables: true,
-            safe: false,
-            snapshot: true,
-            emit: 'ts',
-            fileName: (timestamp, name) => `Migration${timestamp}${name ? '_' + name : ''}`,
-        },
-        schemaGenerator: {
-            disableForeignKeys: false,
-            createForeignKeyConstraints: true,
-            ignoreSchema: [],
-            skipTables: [],
-            skipColumns: {},
-        },
-        embeddables: {
-            prefixMode: 'relative',
-        },
-        entityGenerator: {
-            forceUndefined: true,
-            undefinedDefaults: false,
-            bidirectionalRelations: false,
-            identifiedReferences: false,
-            scalarTypeInDecorator: false,
-            scalarPropertiesForRelations: 'never',
-            fileName: (className) => className,
-            onlyPurePivotTables: false,
-            outputPurePivotTables: false,
-            readOnlyPivotTables: false,
-            useCoreBaseEntity: false,
-        },
-        metadataCache: {
-            pretty: false,
-            adapter: FileCacheAdapter,
-            options: { cacheDir: process.cwd() + '/temp' },
-        },
-        resultCache: {
-            adapter: MemoryCacheAdapter,
-            expiration: 1000, // 1s
-            options: {},
-        },
-        metadataProvider: ReflectMetadataProvider,
-        highlighter: new NullHighlighter(),
-        seeder: {
-            path: './seeders',
-            defaultSeeder: 'DatabaseSeeder',
-            glob: '!(*.d).{js,ts}',
-            emit: 'ts',
-            fileName: (className) => className,
-        },
-        preferReadReplicas: true,
-    };
-    options;
-    logger;
-    driver;
-    platform;
-    cache = new Map();
-    extensions = new Map();
+    #options;
+    #logger;
+    #driver;
+    #platform;
+    #cache = new Map();
+    #extensions = new Map();
     constructor(options, validate = true) {
-        this.options = Utils.mergeConfig({}, Configuration.DEFAULTS, options);
-        this.options.baseDir = Utils.absolutePath(this.options.baseDir);
-        this.options.preferTs ??= options.preferTs;
+        if (options.dynamicImportProvider) {
+            globalThis.dynamicImportProvider = options.dynamicImportProvider;
+        }
+        this.#options = Utils.mergeConfig({}, DEFAULTS, options);
         if (validate) {
             this.validateOptions();
         }
-        this.options.loggerFactory ??= DefaultLogger.create;
-        this.logger = this.options.loggerFactory({
-            debugMode: this.options.debug,
-            ignoreDeprecations: this.options.ignoreDeprecations,
-            usesReplicas: (this.options.replicas?.length ?? 0) > 0,
-            highlighter: this.options.highlighter,
-            writer: this.options.logger,
+        this.#options.loggerFactory ??= DefaultLogger.create;
+        this.#logger = this.#options.loggerFactory({
+            debugMode: this.#options.debug,
+            ignoreDeprecations: this.#options.ignoreDeprecations,
+            usesReplicas: (this.#options.replicas?.length ?? 0) > 0,
+            highlighter: this.#options.highlighter,
+            writer: this.#options.logger,
         });
-        if (this.options.driver) {
-            this.driver = new this.options.driver(this);
-            this.platform = this.driver.getPlatform();
-            this.platform.setConfig(this);
-            this.detectSourceFolder(options);
+        const cf = this.#options.compiledFunctions;
+        if (cf && cf.__version !== Utils.getORMVersion()) {
+            this.#logger.warn('discovery', `Compiled functions were generated with MikroORM v${cf.__version ?? 'unknown'}, but the current version is v${Utils.getORMVersion()}. Please regenerate with \`npx mikro-orm compile\`.`);
+        }
+        if (this.#options.driver) {
+            this.#driver = new this.#options.driver(this);
+            this.#platform = this.#driver.getPlatform();
+            this.#platform.setConfig(this);
             this.init(validate);
         }
     }
     getPlatform() {
-        return this.platform;
+        return this.#platform;
     }
     /**
      * Gets specific configuration option. Falls back to specified `defaultValue` if provided.
      */
     get(key, defaultValue) {
-        if (typeof this.options[key] !== 'undefined') {
-            return this.options[key];
+        if (typeof this.#options[key] !== 'undefined') {
+            return this.#options[key];
         }
         return defaultValue;
     }
     getAll() {
-        return this.options;
+        return this.#options;
     }
     /**
      * Overrides specified configuration value.
      */
     set(key, value) {
-        this.options[key] = value;
+        this.#options[key] = value;
         this.sync();
     }
     /**
      * Resets the configuration to its default value
      */
     reset(key) {
-        this.options[key] = Configuration.DEFAULTS[key];
+        this.#options[key] = DEFAULTS[key];
     }
     /**
      * Gets Logger instance.
      */
     getLogger() {
-        return this.logger;
+        return this.#logger;
     }
     getDataloaderType() {
-        if (typeof this.options.dataloader === 'boolean') {
-            return this.options.dataloader ? DataloaderType.ALL : DataloaderType.NONE;
-        }
-        return this.options.dataloader;
-    }
-    /**
-     * Gets current client URL (connection string).
-     */
-    getClientUrl(hidePassword = false) {
-        if (hidePassword) {
-            return this.options.clientUrl.replace(/\/\/([^:]+):(.+)@/, '//$1:*****@');
+        if (typeof this.#options.dataloader === 'boolean') {
+            return this.#options.dataloader ? DataloaderType.ALL : DataloaderType.NONE;
         }
-        return this.options.clientUrl;
+        return this.#options.dataloader;
     }
     getSchema(skipDefaultSchema = false) {
-        if (skipDefaultSchema && this.options.schema === this.platform.getDefaultSchemaName()) {
+        if (skipDefaultSchema && this.#options.schema === this.#platform.getDefaultSchemaName()) {
             return undefined;
         }
-        return this.options.schema;
+        return this.#options.schema;
     }
     /**
      * Gets current database driver instance.
      */
     getDriver() {
-        return this.driver;
+        return this.#driver;
     }
     registerExtension(name, cb) {
-        this.extensions.set(name, cb);
+        this.#extensions.set(name, cb);
     }
     getExtension(name) {
-        if (this.cache.has(name)) {
-            return this.cache.get(name);
+        if (this.#cache.has(name)) {
+            return this.#cache.get(name);
         }
-        const ext = this.extensions.get(name);
-        /* v8 ignore next 3 */
+        const ext = this.#extensions.get(name);
+        /* v8 ignore next */
         if (!ext) {
             return undefined;
         }
-        this.cache.set(name, ext());
-        return this.cache.get(name);
+        this.#cache.set(name, ext());
+        return this.#cache.get(name);
     }
     /**
      * Gets instance of NamingStrategy. (cached)
      */
     getNamingStrategy() {
-        return this.getCachedService(this.options.namingStrategy || this.platform.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);
+        return this.getCachedService(this.#options.hydrator, metadata, this.#platform, this);
     }
     /**
      * Gets instance of Comparator. (cached)
      */
     getComparator(metadata) {
-        return this.getCachedService(EntityComparator, metadata, this.platform);
+        return this.getCachedService(EntityComparator, metadata, this.#platform, this);
     }
     /**
      * Gets instance of MetadataProvider. (cached)
      */
     getMetadataProvider() {
-        return this.getCachedService(this.options.metadataProvider, this);
+        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, this.options.hashAlgorithm);
+        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 });
+        return this.getCachedService(this.#options.resultCache.adapter, {
+            expiration: this.#options.resultCache.expiration,
+            ...this.#options.resultCache.options,
+        });
     }
     /**
      * Gets EntityRepository class to be instantiated.
@@ -283,116 +274,88 @@ export class Configuration {
         if (repository) {
             return repository();
         }
-        if (this.options.entityRepository) {
-            return this.options.entityRepository;
+        if (this.#options.entityRepository) {
+            return this.#options.entityRepository;
         }
-        return this.platform.getRepositoryClass();
+        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));
+        if (!this.#cache.has(cls.name)) {
+            this.#cache.set(cls.name, new cls(...args));
         }
-        return this.cache.get(cls.name);
+        return this.#cache.get(cls.name);
     }
     resetServiceCache() {
-        this.cache.clear();
+        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();
+        const useCache = this.getMetadataProvider().useCache();
+        const metadataCache = this.#options.metadataCache;
+        if (!useCache) {
+            metadataCache.adapter = NullCacheAdapter;
         }
-        if (!this.options.clientUrl) {
-            this.options.clientUrl = this.platform.getDefaultClientUrl();
-        }
-        if (!('implicitTransactions' in this.options)) {
-            this.options.implicitTransactions = this.platform.usesImplicitTransactions();
+        metadataCache.enabled ??= useCache;
+        this.#options.clientUrl ??= this.#platform.getDefaultClientUrl();
+        this.#options.implicitTransactions ??= this.#platform.usesImplicitTransactions();
+        if (validate && 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.getClientUrl());
+            const url = new URL(this.#options.clientUrl);
             if (url.pathname) {
-                this.options.dbName = this.get('dbName', decodeURIComponent(url.pathname).substring(1));
+                this.#options.dbName = this.get('dbName', decodeURIComponent(url.pathname).substring(1));
             }
         }
         catch {
-            const url = this.getClientUrl().match(/:\/\/.*\/([^?]+)/);
+            const url = /:\/\/.*\/([^?]+)/.exec(this.#options.clientUrl);
             if (url) {
-                this.options.dbName = this.get('dbName', decodeURIComponent(url[1]));
+                this.#options.dbName = this.get('dbName', decodeURIComponent(url[1]));
             }
         }
-        if (validate && !this.options.dbName && this.options.clientUrl) {
+        if (validate && !this.#options.dbName && this.#options.clientUrl) {
             throw new Error("No database specified, `clientUrl` option provided but it's missing the pathname.");
         }
-        if (!this.options.schema) {
-            this.options.schema = this.platform.getDefaultSchemaName();
-        }
-        if (!this.options.charset) {
-            this.options.charset = this.platform.getDefaultCharset();
-        }
-        Object.keys(this.options.filters).forEach(key => {
-            this.options.filters[key].default ??= true;
+        this.#options.schema ??= this.#platform.getDefaultSchemaName();
+        this.#options.charset ??= this.#platform.getDefaultCharset();
+        Object.keys(this.#options.filters).forEach(key => {
+            this.#options.filters[key].default ??= true;
         });
-        this.options.subscribers = Utils.unique(this.options.subscribers).map(subscriber => {
+        if (!this.#options.filtersOnRelations) {
+            this.#options.autoJoinRefsForFilters ??= false;
+        }
+        this.#options.subscribers = [...this.#options.subscribers].map(subscriber => {
             return subscriber.constructor.name === 'Function' ? new subscriber() : subscriber;
         });
         this.sync();
         if (!colors.enabled()) {
-            this.options.highlighter = new NullHighlighter();
+            this.#options.highlighter = new 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 (!Utils.pathExistsSync(this.options.baseDir + '/src')) {
-            return;
-        }
-        const migrationsPathExists = Utils.pathExistsSync(this.options.baseDir + '/' + this.options.migrations.path);
-        const seedersPathExists = Utils.pathExistsSync(this.options.baseDir + '/' + this.options.seeder.path);
-        const distDir = Utils.pathExistsSync(this.options.baseDir + '/dist');
-        const buildDir = Utils.pathExistsSync(this.options.baseDir + '/build');
-        // 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';
-        }
+        setEnv('MIKRO_ORM_COLORS', this.#options.colors);
+        this.#logger.setDebugMode(this.#options.debug);
     }
     validateOptions() {
-        /* v8 ignore next 3 */
-        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({ ... })`).');
+        /* v8 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.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) {
+        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) {
+        if (this.#options.entities.length === 0 && this.#options.discovery.warnWhenNoEntities) {
             throw new Error('No entities found, please use `entities` option');
         }
+        if (typeof this.#options.driverOptions === 'function' &&
+            this.#options.driverOptions.constructor.name === 'AsyncFunction') {
+            throw new Error('`driverOptions` callback cannot be async');
+        }
     }
 }
 /**

package/utils/ConfigurationLoader.d.ts

@@ -1,52 +1 @@
-import type { EntityManager } from '../EntityManager.js';
-import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
-import type { Dictionary } from '../typings.js';
-import { Configuration, type Options } from './Configuration.js';
-/**
- * @internal
- */
-export declare class ConfigurationLoader {
-    /**
-     * Gets a named configuration
-     *
-     * @param contextName Load a config with the given `contextName` value. Used when config file exports array or factory function. Setting it to "default" matches also config objects without `contextName` set.
-     * @param paths Array of possible paths for a configuration file. Files will be checked in order, and the first existing one will be used. Defaults to the output of {@link ConfigurationLoader.getConfigPaths}.
-     * @param options Additional options to augment the final configuration with.
-     */
-    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = 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 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 loadEnvironmentVars<D extends IDatabaseDriver>(): Promise<Partial<Options<D>>>;
-    static loadEnvironmentVarsSync<D extends IDatabaseDriver>(): Partial<Options<D>>;
-    static getORMPackages(): Set<string>;
-    static getORMPackageVersion(name: string): string | undefined;
-    static checkPackageVersion(): string;
-}
-export interface Settings {
-    alwaysAllowTs?: boolean;
-    verbose?: boolean;
-    preferTs?: boolean;
-    tsConfigPath?: string;
-    configPaths?: string[];
-}
+export {};