@mikro-orm/core 7.0.0-dev.50 → 7.0.0-dev.51

package/MikroORM.d.ts

@@ -7,7 +7,7 @@ import type { AnyEntity, Constructor, EntityClass, EntityMetadata, EntityName, I
 /**
  * Helper class for bootstrapping the MikroORM.
  */
-export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = Driver[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> {
+export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends Driver[typeof EntityManagerType] & EntityManager<Driver> = Driver[typeof EntityManagerType] & EntityManager<Driver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> {
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
     em: EM & {
         '~entities'?: Entities;
@@ -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> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
+    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<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)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.50",
+  "version": "7.0.0-dev.51",
   "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.50",
+    "mikro-orm": "7.0.0-dev.51",
     "reflect-metadata": "0.2.2",
     "tinyglobby": "0.2.13"
   }

package/utils/Configuration.d.ts

@@ -22,134 +22,134 @@ import { MemoryCacheAdapter } from '../cache/MemoryCacheAdapter.js';
 import { EntityComparator } from './EntityComparator.js';
 import type { Type } from '../types/Type.js';
 import type { MikroORM } from '../MikroORM.js';
-export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager> {
-    static readonly DEFAULTS: {
-        pool: {};
-        entities: never[];
-        entitiesTs: never[];
-        extensions: never[];
-        subscribers: never[];
-        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: string) => EntityManager<IDatabaseDriver<import("../index.js").Connection>> | undefined;
-        contextName: string;
-        allowGlobalContext: false;
-        logger: (message?: any, ...optionalParams: any[]) => void;
-        colors: true;
-        findOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => NotFoundError<Partial<any>>;
-        findExactlyOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => NotFoundError<Partial<any>>;
-        baseDir: string;
-        hydrator: typeof ObjectHydrator;
-        flushMode: FlushMode.AUTO;
-        loadStrategy: LoadStrategy.BALANCED;
-        dataloader: DataloaderType.NONE;
-        populateWhere: PopulateHint.ALL;
-        ignoreUndefinedInQuery: false;
-        onQuery: (sql: string) => string;
-        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;
-        processOnCreateHooksEarly: false;
-        ensureDatabase: true;
-        ensureIndexes: false;
-        batchSize: number;
-        hashAlgorithm: "md5";
-        debug: false;
-        ignoreDeprecations: false;
-        verbose: false;
-        driverOptions: {};
-        migrations: {
-            tableName: string;
-            path: string;
-            glob: string;
-            silent: false;
-            transactional: true;
-            disableForeignKeys: false;
-            allOrNothing: true;
-            dropTables: true;
-            safe: false;
-            snapshot: true;
-            emit: "ts";
-            fileName: (timestamp: string, name?: string) => string;
-        };
-        schemaGenerator: {
-            disableForeignKeys: false;
-            createForeignKeyConstraints: true;
-            ignoreSchema: never[];
-            skipTables: never[];
-            skipColumns: {};
-        };
-        embeddables: {
-            prefixMode: "relative";
-        };
-        entityGenerator: {
-            forceUndefined: true;
-            undefinedDefaults: false;
-            scalarTypeInDecorator: false;
-            bidirectionalRelations: true;
-            identifiedReferences: true;
-            scalarPropertiesForRelations: "never";
-            entityDefinition: "defineEntity";
-            enumMode: "dictionary";
-            fileName: (className: string) => string;
-            onlyPurePivotTables: false;
-            outputPurePivotTables: false;
-            readOnlyPivotTables: false;
-            useCoreBaseEntity: false;
-        };
-        metadataCache: {
-            pretty: false;
-            adapter: typeof FileCacheAdapter;
-            options: {
-                cacheDir: string;
-            };
-        };
-        resultCache: {
-            adapter: typeof MemoryCacheAdapter;
-            expiration: number;
-            options: {};
-        };
-        metadataProvider: typeof ReflectMetadataProvider;
-        highlighter: NullHighlighter;
-        seeder: {
-            path: string;
-            defaultSeeder: string;
-            glob: string;
-            emit: "ts";
-            fileName: (className: string) => string;
+declare const DEFAULTS: {
+    readonly pool: {};
+    readonly entities: readonly [];
+    readonly entitiesTs: readonly [];
+    readonly extensions: readonly [];
+    readonly subscribers: readonly [];
+    readonly filters: {};
+    readonly discovery: {
+        readonly warnWhenNoEntities: true;
+        readonly requireEntitiesArray: false;
+        readonly checkDuplicateTableNames: true;
+        readonly checkDuplicateFieldNames: true;
+        readonly checkDuplicateEntities: true;
+        readonly checkNonPersistentCompositeProps: true;
+        readonly alwaysAnalyseProperties: true;
+        readonly disableDynamicFileAccess: false;
+        readonly inferDefaultValues: true;
+    };
+    readonly strict: false;
+    readonly validate: false;
+    readonly validateRequired: true;
+    readonly context: (name: string) => EntityManager<IDatabaseDriver<import("../index.js").Connection>> | undefined;
+    readonly contextName: "default";
+    readonly allowGlobalContext: false;
+    readonly logger: (message?: any, ...optionalParams: any[]) => void;
+    readonly colors: true;
+    readonly findOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => NotFoundError<Partial<any>>;
+    readonly findExactlyOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => NotFoundError<Partial<any>>;
+    readonly baseDir: string;
+    readonly hydrator: typeof ObjectHydrator;
+    readonly flushMode: FlushMode.AUTO;
+    readonly loadStrategy: LoadStrategy.BALANCED;
+    readonly dataloader: DataloaderType.NONE;
+    readonly populateWhere: PopulateHint.ALL;
+    readonly ignoreUndefinedInQuery: false;
+    readonly onQuery: (sql: string) => string;
+    readonly autoJoinOneToOneOwner: true;
+    readonly autoJoinRefsForFilters: true;
+    readonly filtersOnRelations: true;
+    readonly propagationOnPrototype: true;
+    readonly populateAfterFlush: true;
+    readonly serialization: {
+        readonly includePrimaryKeys: true;
+    };
+    readonly assign: {
+        readonly updateNestedEntities: true;
+        readonly updateByPrimaryKey: true;
+        readonly mergeObjectProperties: false;
+        readonly mergeEmbeddedProperties: true;
+        readonly ignoreUndefined: false;
+    };
+    readonly persistOnCreate: true;
+    readonly upsertManaged: true;
+    readonly forceEntityConstructor: false;
+    readonly forceUndefined: false;
+    readonly processOnCreateHooksEarly: false;
+    readonly ensureDatabase: true;
+    readonly ensureIndexes: false;
+    readonly batchSize: 300;
+    readonly hashAlgorithm: "md5";
+    readonly debug: false;
+    readonly ignoreDeprecations: false;
+    readonly verbose: false;
+    readonly driverOptions: {};
+    readonly migrations: {
+        readonly tableName: "mikro_orm_migrations";
+        readonly path: "./migrations";
+        readonly glob: "!(*.d).{js,ts,cjs}";
+        readonly silent: false;
+        readonly transactional: true;
+        readonly disableForeignKeys: false;
+        readonly allOrNothing: true;
+        readonly dropTables: true;
+        readonly safe: false;
+        readonly snapshot: true;
+        readonly emit: "ts";
+        readonly fileName: (timestamp: string, name?: string) => string;
+    };
+    readonly schemaGenerator: {
+        readonly disableForeignKeys: false;
+        readonly createForeignKeyConstraints: true;
+        readonly ignoreSchema: readonly [];
+        readonly skipTables: readonly [];
+        readonly skipColumns: {};
+    };
+    readonly embeddables: {
+        readonly prefixMode: "relative";
+    };
+    readonly entityGenerator: {
+        readonly forceUndefined: true;
+        readonly undefinedDefaults: false;
+        readonly scalarTypeInDecorator: false;
+        readonly bidirectionalRelations: true;
+        readonly identifiedReferences: true;
+        readonly scalarPropertiesForRelations: "never";
+        readonly entityDefinition: "defineEntity";
+        readonly enumMode: "dictionary";
+        readonly fileName: (className: string) => string;
+        readonly onlyPurePivotTables: false;
+        readonly outputPurePivotTables: false;
+        readonly readOnlyPivotTables: false;
+        readonly useCoreBaseEntity: false;
+    };
+    readonly metadataCache: {
+        readonly pretty: false;
+        readonly adapter: typeof FileCacheAdapter;
+        readonly options: {
+            readonly cacheDir: string;
         };
-        preferReadReplicas: true;
-        dynamicImportProvider: (id: string) => Promise<any>;
     };
+    readonly resultCache: {
+        readonly adapter: typeof MemoryCacheAdapter;
+        readonly expiration: 1000;
+        readonly options: {};
+    };
+    readonly metadataProvider: typeof ReflectMetadataProvider;
+    readonly highlighter: NullHighlighter;
+    readonly seeder: {
+        readonly path: "./seeders";
+        readonly defaultSeeder: "DatabaseSeeder";
+        readonly glob: "!(*.d).{js,ts}";
+        readonly emit: "ts";
+        readonly fileName: (className: string) => string;
+    };
+    readonly preferReadReplicas: true;
+    readonly dynamicImportProvider: (id: string) => Promise<any>;
+};
+export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>> {
     private readonly options;
     private readonly logger;
     private readonly driver;
@@ -161,16 +161,16 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
     /**
      * Gets specific configuration option. Falls back to specified `defaultValue` if provided.
      */
-    get<T extends keyof MikroORMOptions<D, EM>, U extends MikroORMOptions<D, EM>[T]>(key: T, defaultValue?: U): U;
-    getAll(): MikroORMOptions<D, EM>;
+    get<T extends keyof Options<D, EM>, U extends RequiredOptions<D, EM>[T]>(key: T, defaultValue?: U): U;
+    getAll(): RequiredOptions<D, EM>;
     /**
      * Overrides specified configuration value.
      */
-    set<T extends keyof MikroORMOptions<D, EM>, U extends MikroORMOptions<D, EM>[T]>(key: T, value: U): void;
+    set<T extends keyof Options<D, EM>, U extends RequiredOptions<D, EM>[T]>(key: T, value: U): void;
     /**
      * Resets the configuration to its default value
      */
-    reset<T extends keyof MikroORMOptions<D, EM>>(key: T): void;
+    reset<T extends keyof RequiredOptions<D, EM>>(key: T): void;
     /**
      * Gets Logger instance.
      */
@@ -210,7 +210,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
     /**
      * Gets EntityRepository class to be instantiated.
      */
-    getRepositoryClass(repository: () => EntityClass<EntityRepository<AnyEntity>>): MikroORMOptions<D, EM>['entityRepository'];
+    getRepositoryClass(repository: () => EntityClass<EntityRepository<AnyEntity>>): Options<D, EM>['entityRepository'];
     /**
      * Creates instance of given service and caches it.
      */
@@ -298,87 +298,87 @@ export interface MetadataDiscoveryOptions {
     tsConfigPath?: string;
     skipSyncDiscovery?: boolean;
 }
-export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = EntityManager> extends ConnectionOptions {
-    entities: (string | EntityClass<AnyEntity> | EntitySchema)[];
-    entitiesTs: (string | EntityClass<AnyEntity> | EntitySchema)[];
-    extensions: {
+export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<Driver> & Driver[typeof EntityManagerType] = EntityManager<Driver> & Driver[typeof EntityManagerType], Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends ConnectionOptions {
+    entities?: Entities;
+    entitiesTs?: (string | EntityClass<AnyEntity> | EntitySchema)[];
+    extensions?: {
         register: (orm: MikroORM) => void;
     }[];
-    subscribers: (EventSubscriber | Constructor<EventSubscriber>)[];
-    filters: Dictionary<{
+    subscribers?: (EventSubscriber | Constructor<EventSubscriber>)[];
+    filters?: Dictionary<{
         name?: string;
     } & Omit<FilterDef, 'name'>>;
-    discovery: MetadataDiscoveryOptions;
+    discovery?: MetadataDiscoveryOptions;
     driver?: {
-        new (config: Configuration): D;
+        new (config: Configuration): Driver;
     };
     namingStrategy?: {
         new (): NamingStrategy;
     };
     implicitTransactions?: boolean;
     disableTransactions?: boolean;
-    verbose: boolean;
+    verbose?: boolean;
     ignoreUndefinedInQuery?: boolean;
-    onQuery: (sql: string, params: readonly unknown[]) => string;
-    autoJoinOneToOneOwner: boolean;
-    autoJoinRefsForFilters: boolean;
-    filtersOnRelations: boolean;
-    propagationOnPrototype: boolean;
-    populateAfterFlush: boolean;
-    serialization: {
+    onQuery?: (sql: string, params: readonly unknown[]) => string;
+    autoJoinOneToOneOwner?: boolean;
+    autoJoinRefsForFilters?: boolean;
+    filtersOnRelations?: boolean;
+    propagationOnPrototype?: boolean;
+    populateAfterFlush?: boolean;
+    serialization?: {
         includePrimaryKeys?: boolean;
         /** Enforce unpopulated references to be returned as objects, e.g. `{ author: { id: 1 } }` instead of `{ author: 1 }`. */
         forceObject?: boolean;
     };
-    assign: AssignOptions<boolean>;
-    persistOnCreate: boolean;
-    upsertManaged: boolean;
-    forceEntityConstructor: boolean | (Constructor<AnyEntity> | string)[];
-    forceUndefined: boolean;
+    assign?: AssignOptions<boolean>;
+    persistOnCreate?: boolean;
+    upsertManaged?: boolean;
+    forceEntityConstructor?: boolean | (Constructor<AnyEntity> | string)[];
+    forceUndefined?: boolean;
     /**
      * Property `onCreate` hooks are normally executed during `flush` operation.
      * With this option, they will be processed early inside `em.create()` method.
      */
-    processOnCreateHooksEarly: boolean;
+    processOnCreateHooksEarly?: boolean;
     forceUtcTimezone?: boolean;
     timezone?: string;
-    ensureDatabase: boolean | EnsureDatabaseOptions;
-    ensureIndexes: boolean;
+    ensureDatabase?: boolean | EnsureDatabaseOptions;
+    ensureIndexes?: boolean;
     useBatchInserts?: boolean;
     useBatchUpdates?: boolean;
-    batchSize: number;
-    hydrator: HydratorConstructor;
-    loadStrategy: LoadStrategy | `${LoadStrategy}`;
-    dataloader: DataloaderType | boolean;
+    batchSize?: number;
+    hydrator?: HydratorConstructor;
+    loadStrategy?: LoadStrategy | `${LoadStrategy}`;
+    dataloader?: DataloaderType | boolean;
     populateWhere?: PopulateHint | `${PopulateHint}`;
-    flushMode: FlushMode | 'commit' | 'auto' | 'always';
+    flushMode?: FlushMode | `${FlushMode}`;
     entityRepository?: EntityClass<EntityRepository<any>>;
     entityManager?: Constructor<EM>;
     replicas?: ConnectionOptions[];
-    strict: boolean;
-    validate: boolean;
-    validateRequired: boolean;
-    context: (name: string) => EntityManager | undefined;
-    contextName: string;
-    allowGlobalContext: boolean;
+    strict?: boolean;
+    validate?: boolean;
+    validateRequired?: boolean;
+    context?: (name: string) => EntityManager | undefined;
+    contextName?: string;
+    allowGlobalContext?: boolean;
     disableIdentityMap?: boolean;
-    logger: (message: string) => void;
+    logger?: (message: string) => void;
     colors?: boolean;
     loggerFactory?: (options: LoggerOptions) => Logger;
-    findOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => Error;
-    findExactlyOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => Error;
-    debug: boolean | LoggerNamespace[];
-    ignoreDeprecations: boolean | string[];
-    highlighter: Highlighter;
+    findOneOrFailHandler?: (entityName: string, where: Dictionary | IPrimaryKey) => Error;
+    findExactlyOneOrFailHandler?: (entityName: string, where: Dictionary | IPrimaryKey) => Error;
+    debug?: boolean | LoggerNamespace[];
+    ignoreDeprecations?: boolean | string[];
+    highlighter?: Highlighter;
     /**
      * Using this option, you can force the ORM to use the TS options regardless of whether the TypeScript support
      * is detected or not. This effectively means using `entitiesTs` for discovery and `pathTs` for migrations and
      * seeders. Should be used only for tests and stay disabled for production builds.
      */
     preferTs?: boolean;
-    baseDir: string;
-    migrations: MigrationsOptions;
-    schemaGenerator: {
+    baseDir?: string;
+    migrations?: MigrationsOptions;
+    schemaGenerator?: {
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
@@ -386,11 +386,11 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
         skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
     };
-    embeddables: {
+    embeddables?: {
         prefixMode: EmbeddedPrefixMode;
     };
-    entityGenerator: GenerateOptions;
-    metadataCache: {
+    entityGenerator?: GenerateOptions;
+    metadataCache?: {
         enabled?: boolean;
         combined?: boolean | string;
         pretty?: boolean;
@@ -399,7 +399,7 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
         };
         options?: Dictionary;
     };
-    resultCache: {
+    resultCache?: {
         expiration?: number;
         adapter?: {
             new (...params: any[]): CacheAdapter;
@@ -407,14 +407,18 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
         options?: Dictionary;
         global?: boolean | number | [string, number];
     };
-    metadataProvider: {
+    metadataProvider?: {
         new (config: Configuration): MetadataProvider;
     };
-    seeder: SeederOptions;
-    preferReadReplicas: boolean;
-    dynamicImportProvider: (id: string) => Promise<unknown>;
-    hashAlgorithm: 'md5' | 'sha256';
-}
-export interface Options<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends Pick<MikroORMOptions<D, EM>, Exclude<keyof MikroORMOptions, keyof typeof Configuration.DEFAULTS>>, Partial<MikroORMOptions<D, EM>> {
-    entities?: Entities;
+    seeder?: SeederOptions;
+    preferReadReplicas?: boolean;
+    dynamicImportProvider?: (id: string) => Promise<unknown>;
+    hashAlgorithm?: 'md5' | 'sha256';
 }
+type MarkRequired<T, D> = {
+    [K in keyof T as Extract<K, keyof D>]-?: T[K];
+} & {
+    [K in keyof T as Exclude<K, keyof D>]?: T[K];
+};
+export type RequiredOptions<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = MarkRequired<Options<D, EM, Entities>, typeof DEFAULTS>;
+export {};

package/utils/Configuration.js

@@ -11,133 +11,133 @@ import { RequestContext } from './RequestContext.js';
 import { DataloaderType, FlushMode, LoadStrategy, PopulateHint } from '../enums.js';
 import { MemoryCacheAdapter } from '../cache/MemoryCacheAdapter.js';
 import { EntityComparator } from './EntityComparator.js';
+const 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,
+    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,
+    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,
+        scalarTypeInDecorator: false,
+        bidirectionalRelations: true,
+        identifiedReferences: true,
+        scalarPropertiesForRelations: 'never',
+        entityDefinition: 'defineEntity',
+        enumMode: 'dictionary',
+        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,
+    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,
-        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,
-        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,
-            scalarTypeInDecorator: false,
-            bidirectionalRelations: true,
-            identifiedReferences: true,
-            scalarPropertiesForRelations: 'never',
-            entityDefinition: 'defineEntity',
-            enumMode: 'dictionary',
-            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,
-        dynamicImportProvider: /* v8 ignore next */ (id) => import(id),
-    };
     options;
     logger;
     driver;
@@ -148,7 +148,7 @@ export class Configuration {
         if (options.dynamicImportProvider) {
             Utils.setDynamicImportProvider(options.dynamicImportProvider);
         }
-        this.options = Utils.mergeConfig({}, Configuration.DEFAULTS, options);
+        this.options = Utils.mergeConfig({}, DEFAULTS, options);
         this.options.baseDir = Utils.absolutePath(this.options.baseDir);
         if (validate) {
             this.validateOptions();
@@ -195,7 +195,7 @@ export class Configuration {
      * Resets the configuration to its default value
      */
     reset(key) {
-        this.options[key] = Configuration.DEFAULTS[key];
+        this.options[key] = DEFAULTS[key];
     }
     /**
      * Gets Logger instance.
@@ -307,9 +307,7 @@ export class Configuration {
         if (!this.options.clientUrl) {
             this.options.clientUrl = this.platform.getDefaultClientUrl();
         }
-        if (!('implicitTransactions' in this.options)) {
-            this.options.implicitTransactions = this.platform.usesImplicitTransactions();
-        }
+        this.options.implicitTransactions ??= this.platform.usesImplicitTransactions();
         try {
             const url = new URL(this.options.clientUrl);
             if (url.pathname) {
@@ -325,12 +323,8 @@ export class Configuration {
         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();
-        }
+        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;
         });

package/utils/ConfigurationLoader.d.ts

@@ -13,7 +13,7 @@ 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>>;
+    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>>(contextName?: string, paths?: string[], options?: Partial<Options>): Promise<Configuration<D, EM>>;
     static getConfigFile(paths: string[]): Promise<[string, unknown] | []>;
     static getPackageConfig(basePath?: string): Dictionary;
     static getSettings(): Settings;