@mikro-orm/core 6.3.14-dev.8 → 6.4.0

package/EntityManager.js

@@ -623,7 +623,7 @@ class EntityManager {
         const convertCustomTypes = !utils_1.Utils.isEntity(data);
         if (utils_1.Utils.isEntity(data)) {
             entity = data;
-            if ((0, entity_1.helper)(entity).__managed && (0, entity_1.helper)(entity).__em === em) {
+            if ((0, entity_1.helper)(entity).__managed && (0, entity_1.helper)(entity).__em === em && !this.config.get('upsertManaged')) {
                 em.entityFactory.mergeData(meta, entity, data, { initialized: true });
                 return entity;
             }
@@ -633,7 +633,7 @@ class EntityManager {
         else {
             data = utils_1.Utils.copy(utils_1.QueryHelper.processParams(data));
             where = utils_1.Utils.extractPK(data, meta);
-            if (where) {
+            if (where && !this.config.get('upsertManaged')) {
                 const exists = em.unitOfWork.getById(entityName, where, options.schema);
                 if (exists) {
                     return em.assign(exists, data);
@@ -763,7 +763,7 @@ class EntityManager {
             let where;
             if (utils_1.Utils.isEntity(row)) {
                 const entity = row;
-                if ((0, entity_1.helper)(entity).__managed && (0, entity_1.helper)(entity).__em === em) {
+                if ((0, entity_1.helper)(entity).__managed && (0, entity_1.helper)(entity).__em === em && !this.config.get('upsertManaged')) {
                     em.entityFactory.mergeData(meta, entity, row, { initialized: true });
                     entities.set(entity, row);
                     entitiesByData.set(row, entity);
@@ -775,7 +775,7 @@ class EntityManager {
             else {
                 row = data[i] = utils_1.Utils.copy(utils_1.QueryHelper.processParams(row));
                 where = utils_1.Utils.extractPK(row, meta);
-                if (where) {
+                if (where && !this.config.get('upsertManaged')) {
                     const exists = em.unitOfWork.getById(entityName, where, options.schema);
                     if (exists) {
                         em.assign(exists, row);
@@ -1103,7 +1103,7 @@ class EntityManager {
         em.prepareOptions(options);
         entityName = utils_1.Utils.className(entityName);
         data = utils_1.QueryHelper.processObjectParams(data);
-        where = await em.processWhere(entityName, where, options, 'update');
+        where = await em.processWhere(entityName, where, { ...options, convertCustomTypes: false }, 'update');
         em.validator.validateParams(data, 'update data');
         em.validator.validateParams(where, 'update condition');
         const res = await em.driver.nativeUpdate(entityName, where, data, { ctx: em.transactionContext, ...options });

package/MikroORM.d.ts

@@ -44,8 +44,10 @@ export declare class MikroORM<D extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Checks whether the database connection is active, returns .
      */
     checkConnection(): Promise<{
-        ok: boolean;
-        reason?: string;
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
         error?: Error;
     }>;
     /**

package/MikroORM.js

@@ -29,7 +29,12 @@ class MikroORM {
         const coreVersion = await utils_1.ConfigurationLoader.checkPackageVersion();
         const env = utils_1.ConfigurationLoader.loadEnvironmentVars();
         if (!options) {
-            options = (await utils_1.ConfigurationLoader.getConfiguration()).getAll();
+            const configPathFromArg = utils_1.ConfigurationLoader.configPathsFromArg();
+            const config = (await utils_1.ConfigurationLoader.getConfiguration(process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default', configPathFromArg ?? utils_1.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_1.Utils.mergeConfig(options, env);
         await utils_1.ConfigurationLoader.commonJSCompat(options);
@@ -169,11 +174,11 @@ class MikroORM {
         return this.metadata;
     }
     async discoverEntities() {
-        this.metadata = await this.discovery.discover(this.config.get('tsNode'));
+        this.metadata = await this.discovery.discover(this.config.get('preferTs'));
         this.createEntityManager();
     }
     discoverEntitiesSync() {
-        this.metadata = this.discovery.discoverSync(this.config.get('tsNode'));
+        this.metadata = this.discovery.discoverSync(this.config.get('preferTs'));
         this.createEntityManager();
     }
     createEntityManager() {

package/connections/Connection.d.ts

@@ -26,8 +26,10 @@ export declare abstract class Connection {
      * Are we connected to the database
      */
     abstract checkConnection(): Promise<{
-        ok: boolean;
-        reason?: string;
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
         error?: Error;
     }>;
     /**

package/decorators/CreateRequestContext.d.ts

@@ -1,9 +1,3 @@
-import { MikroORM } from '../MikroORM';
-import { EntityManager } from '../EntityManager';
-import { EntityRepository } from '../entity/EntityRepository';
-export declare function CreateRequestContext<T>(getContext?: MikroORM | Promise<MikroORM> | ((type: T) => MikroORM | Promise<MikroORM> | EntityManager | EntityRepository<any> | {
-    getEntityManager(): EntityManager;
-}), respectExistingContext?: boolean): MethodDecorator;
-export declare function EnsureRequestContext<T>(getContext?: MikroORM | Promise<MikroORM> | ((type: T) => MikroORM | Promise<MikroORM> | EntityManager | EntityRepository<any> | {
-    getEntityManager(): EntityManager;
-})): MethodDecorator;
+import type { ContextProvider } from '../typings';
+export declare function CreateRequestContext<T extends object>(context?: ContextProvider<T>, respectExistingContext?: boolean): MethodDecorator;
+export declare function EnsureRequestContext<T extends object>(context?: ContextProvider<T>): MethodDecorator;

package/decorators/CreateRequestContext.js

@@ -2,59 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateRequestContext = CreateRequestContext;
 exports.EnsureRequestContext = EnsureRequestContext;
-const MikroORM_1 = require("../MikroORM");
 const RequestContext_1 = require("../utils/RequestContext");
-const EntityManager_1 = require("../EntityManager");
-const EntityRepository_1 = require("../entity/EntityRepository");
+const resolveContextProvider_1 = require("../utils/resolveContextProvider");
 const TransactionContext_1 = require("../utils/TransactionContext");
-function CreateRequestContext(getContext, respectExistingContext = false) {
+function CreateRequestContext(context, respectExistingContext = false) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = async function (...args) {
-            // Otherwise, the outer tx context would be preferred.
-            const txContext = TransactionContext_1.TransactionContext.currentTransactionContext();
-            const provider = txContext ? TransactionContext_1.TransactionContext : RequestContext_1.RequestContext;
-            let orm;
-            let em;
-            if (typeof getContext === 'function') {
-                const context = await getContext(this);
-                orm = context ?? await this.orm;
-                em = context ?? await this.em;
-            }
-            else if (getContext) {
-                orm = em = await getContext;
-            }
-            else {
-                orm = await this.orm;
-                em = await this.em;
-            }
-            const create = async (em) => {
-                // reuse existing context if available for given respect `contextName`
-                if (respectExistingContext && RequestContext_1.RequestContext.getEntityManager(em.name)) {
-                    return originalMethod.apply(this, args);
-                }
-                if (txContext) {
-                    em = em.fork({ useContext: true });
-                }
-                return await provider.create(em, () => {
-                    return originalMethod.apply(this, args);
-                });
-            };
-            if (em instanceof EntityManager_1.EntityManager) {
-                return await create(em);
-            }
-            if (orm instanceof EntityRepository_1.EntityRepository) {
-                return await create(orm.getEntityManager());
-            }
-            if (!(orm instanceof MikroORM_1.MikroORM)) {
+            const em = await (0, resolveContextProvider_1.resolveContextProvider)(this, context);
+            if (!em) {
                 const name = respectExistingContext ? 'EnsureRequestContext' : 'CreateRequestContext';
                 throw new Error(`@${name}() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@${name}(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
             }
-            return await create(orm.em);
+            // reuse existing context if available for given respect `contextName`
+            if (respectExistingContext && RequestContext_1.RequestContext.getEntityManager(em.name)) {
+                return originalMethod.apply(this, args);
+            }
+            // Otherwise, the outer tx context would be preferred.
+            const txContext = TransactionContext_1.TransactionContext.currentTransactionContext();
+            const provider = txContext ? TransactionContext_1.TransactionContext : RequestContext_1.RequestContext;
+            return txContext
+                ? provider.create(em.fork({ useContext: true }), () => originalMethod.apply(this, args))
+                : provider.create(em, () => originalMethod.apply(this, args));
         };
         return descriptor;
     };
 }
-function EnsureRequestContext(getContext) {
-    return CreateRequestContext(getContext, true);
+function EnsureRequestContext(context) {
+    return CreateRequestContext(context, true);
 }

package/decorators/ManyToOne.d.ts

@@ -15,6 +15,8 @@ export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner,
     joinColumn?: string;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
     joinColumns?: string[];
+    /** When a part of a composite column is shared in other properties, use this option to specify what columns are considered as owned by this property. This is useful when your composite property is nullable, but parts of it are not. */
+    ownColumns?: string[];
     /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     referenceColumnName?: string;
     /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */

package/decorators/Property.d.ts

@@ -177,6 +177,19 @@ export interface PropertyOptions<Owner> {
      * ```
      */
     getter?: boolean;
+    /**
+     * When defining a property over a method (not a getter, a regular function), you can use this option to point
+     * to the method name.
+     *
+     * @example
+     * ```
+     * @Property({ getter: true })
+     * getFullName() {
+     *   return this.firstName + this.lastName;
+     * }
+     * ```
+     */
+    getterName?: keyof Owner;
     /**
      * Set to define serialized primary key for MongoDB. (virtual)
      * Alias for `@SerializedPrimaryKey()` decorator.

package/decorators/Transactional.d.ts

@@ -0,0 +1,13 @@
+import type { TransactionOptions } from '../enums';
+import type { ContextProvider } from '../typings';
+type TransactionalOptions<T> = TransactionOptions & {
+    context?: ContextProvider<T>;
+};
+/**
+ * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.
+ * The difference is that you can specify the context in which the transaction begins by providing `context` option,
+ * and if omitted, the transaction will begin in the current context implicitly.
+ * It works on async functions and can be nested with `em.transactional()`.
+ */
+export declare function Transactional<T extends object>(options?: TransactionalOptions<T>): MethodDecorator;
+export {};

package/decorators/Transactional.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transactional = Transactional;
+const RequestContext_1 = require("../utils/RequestContext");
+const resolveContextProvider_1 = require("../utils/resolveContextProvider");
+const TransactionContext_1 = require("../utils/TransactionContext");
+/**
+ * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.
+ * The difference is that you can specify the context in which the transaction begins by providing `context` option,
+ * and if omitted, the transaction will begin in the current context implicitly.
+ * It works on async functions and can be nested with `em.transactional()`.
+ */
+function Transactional(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        if (originalMethod.constructor.name !== 'AsyncFunction') {
+            throw new Error('@Transactional() should be use with async functions');
+        }
+        descriptor.value = async function (...args) {
+            const { context, ...txOptions } = options;
+            const em = await (0, resolveContextProvider_1.resolveContextProvider)(this, context)
+                || TransactionContext_1.TransactionContext.getEntityManager()
+                || RequestContext_1.RequestContext.getEntityManager();
+            if (!em) {
+                throw new Error(`@Transactional() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@Transactional(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
+            }
+            return em.transactional(() => originalMethod.apply(this, args), txOptions);
+        };
+        return descriptor;
+    };
+}

package/decorators/index.d.ts

@@ -14,3 +14,4 @@ export * from './Embedded';
 export * from './Filter';
 export * from './CreateRequestContext';
 export * from './hooks';
+export * from './Transactional';

package/decorators/index.js

@@ -33,3 +33,4 @@ __exportStar(require("./Embedded"), exports);
 __exportStar(require("./Filter"), exports);
 __exportStar(require("./CreateRequestContext"), exports);
 __exportStar(require("./hooks"), exports);
+__exportStar(require("./Transactional"), exports);

package/drivers/DatabaseDriver.js

@@ -223,7 +223,7 @@ class DatabaseDriver {
             }
             if (prop.joinColumns?.length > 1 && data[k] == null) {
                 delete data[k];
-                prop.joinColumns.forEach((joinColumn, idx) => data[joinColumn] = null);
+                prop.ownColumns.forEach(joinColumn => data[joinColumn] = null);
                 return;
             }
             if (prop.customType && convertCustomTypes && !(prop.customType instanceof JsonType_1.JsonType && object) && !this.platform.isRaw(data[k])) {
@@ -354,16 +354,11 @@ class DatabaseDriver {
      */
     getTableName(meta, options, quote = true) {
         const schema = this.getSchemaName(meta, options);
-        if (schema) {
-            if (quote) {
-                return this.platform.quoteIdentifier(schema + '.' + meta.tableName);
-            }
-            return schema + '.' + meta.tableName;
-        }
+        const tableName = schema ? `${schema}.${meta.tableName}` : meta.tableName;
         if (quote) {
-            return this.platform.quoteIdentifier(meta.tableName);
+            return this.platform.quoteIdentifier(tableName);
         }
-        return meta.tableName;
+        return tableName;
     }
     /**
      * @internal

package/entity/BaseEntity.d.ts

@@ -14,7 +14,7 @@ export declare abstract class BaseEntity {
     toObject<Entity extends this = this>(ignoreFields: never[]): EntityDTO<Entity>;
     toObject<Entity extends this = this, Ignored extends EntityKey<Entity> = never>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
     toPOJO<Entity extends this = this>(): EntityDTO<Entity>;
-    serialize<Entity extends this = this, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): EntityDTO<Loaded<Entity, Hint>>;
+    serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): EntityDTO<Loaded<Naked, Hint>>;
     assign<Entity extends this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     init<Entity extends this = this, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
     getSchema(): string | undefined;

package/entity/EntityFactory.js

@@ -69,6 +69,12 @@ class EntityFactory {
             if (options.convertCustomTypes) {
                 for (const prop of meta.props) {
                     if (prop.customType?.ensureComparable(meta, prop) && data[prop.name]) {
+                        if ([enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                            continue;
+                        }
+                        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
+                            data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                        }
                         data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
                     }
                 }
@@ -244,7 +250,7 @@ class EntityFactory {
         if (!Array.isArray(data) && meta.primaryKeys.some(pk => data[pk] == null)) {
             return undefined;
         }
-        const pks = Utils_1.Utils.getOrderedPrimaryKeys(data, meta, this.platform, options.convertCustomTypes);
+        const pks = Utils_1.Utils.getOrderedPrimaryKeys(data, meta, this.platform);
         return this.unitOfWork.getById(meta.className, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {

package/entity/EntityHelper.js

@@ -176,10 +176,15 @@ class EntityHelper {
                 inverse.addWithoutPropagation(owner);
                 (0, wrap_1.helper)(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);
             }
-            if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && entity && (!prop.owner || (0, wrap_1.helper)(entity).__initialized)) {
+            if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE) {
                 if ((value != null && Reference_1.Reference.unwrapReference(inverse) !== owner) ||
-                    (value == null && entity[prop2.name] != null)) {
-                    EntityHelper.propagateOneToOne(entity, owner, prop, prop2, value, old);
+                    (value == null && entity?.[prop2.name] != null)) {
+                    if (entity && (!prop.owner || (0, wrap_1.helper)(entity).__initialized)) {
+                        EntityHelper.propagateOneToOne(entity, owner, prop, prop2, value, old);
+                    }
+                    if (old && prop.orphanRemoval) {
+                        (0, wrap_1.helper)(old).__em?.getUnitOfWork().scheduleOrphanRemoval(old);
+                    }
                 }
             }
         }
@@ -203,9 +208,6 @@ class EntityHelper {
         else {
             entity[prop2.name] = Reference_1.Reference.wrapReference(owner, prop);
         }
-        if (old && prop.orphanRemoval) {
-            (0, wrap_1.helper)(old).__em?.getUnitOfWork().scheduleOrphanRemoval(old);
-        }
         if (old?.[prop2.name] != null) {
             delete (0, wrap_1.helper)(old).__data[prop2.name];
         }

package/errors.d.ts

@@ -55,6 +55,7 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError<Partial<any>>;
     static invalidManyToManyWithPivotEntity(meta1: EntityMetadata, prop1: EntityProperty, meta2: EntityMetadata, prop2: EntityProperty): MetadataError<Partial<any>>;
     static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
+    static nonPersistentCompositeProp(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
     static propertyTargetsEntityType(meta: EntityMetadata, prop: EntityProperty, target: EntityMetadata): MetadataError<Partial<any>>;
     static fromMissingOption(meta: EntityMetadata, prop: EntityProperty, option: string): MetadataError<Partial<any>>;
     private static fromMessage;

package/errors.js

@@ -198,6 +198,9 @@ class MetadataError extends ValidationError {
     static targetIsAbstract(meta, prop) {
         return this.fromMessage(meta, prop, `targets abstract entity ${prop.type}. Maybe you forgot to put @Entity() decorator on the ${prop.type} class?`);
     }
+    static nonPersistentCompositeProp(meta, prop) {
+        return this.fromMessage(meta, prop, `is non-persistent relation which targets composite primary key. This is not supported and will cause issues, 'persist: false' should be added to the properties representing single columns instead.`);
+    }
     static propertyTargetsEntityType(meta, prop, target) {
         /* istanbul ignore next */
         const suggestion = target.embeddable ? 'Embedded' : 'ManyToOne';

package/index.d.ts

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { Constructor, ConnectionType, Dictionary, PrimaryKeyProp, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, AnyEntity, EntityClass, EntityProperty, EntityMetadata, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, GetRepository, EntityRepositoryType, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, OptionalProps, EagerProps, HiddenProps, RequiredEntityData, CheckCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, FilterKey, Opt, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, Hidden, FilterValue, MergeLoaded, MergeSelected, Config, DefineConfig, TypeConfig, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, } from './typings';
+export { Constructor, ConnectionType, Dictionary, PrimaryKeyProp, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, EntityMetadata, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, EntityRepositoryType, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, OptionalProps, EagerProps, HiddenProps, RequiredEntityData, CheckCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, FilterKey, Opt, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, Hidden, FilterValue, MergeLoaded, MergeSelected, Config, DefineConfig, TypeConfig, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, } from './typings';
 export * from './enums';
 export * from './errors';
 export * from './exceptions';

package/index.mjs

@@ -162,6 +162,7 @@ export const TimeType = mod.TimeType;
 export const TinyIntType = mod.TinyIntType;
 export const TransactionContext = mod.TransactionContext;
 export const TransactionEventBroadcaster = mod.TransactionEventBroadcaster;
+export const Transactional = mod.Transactional;
 export const Type = mod.Type;
 export const Uint8ArrayType = mod.Uint8ArrayType;
 export const UnderscoreNamingStrategy = mod.UnderscoreNamingStrategy;

package/logging/DefaultLogger.js

@@ -60,6 +60,12 @@ class DefaultLogger {
             return context.enabled;
         }
         const debugMode = context?.debugMode ?? this.debugMode;
+        if (namespace === 'deprecated') {
+            const { ignoreDeprecations = false } = this.options;
+            return Array.isArray(ignoreDeprecations)
+                ? !ignoreDeprecations.includes(context?.label ?? '')
+                : !ignoreDeprecations;
+        }
         return !!debugMode && (!Array.isArray(debugMode) || debugMode.includes(namespace));
     }
     /**

package/logging/Logger.d.ts

@@ -22,7 +22,7 @@ export interface Logger {
     setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
     isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
 }
-export type LoggerNamespace = 'query' | 'query-params' | 'schema' | 'discovery' | 'info';
+export type LoggerNamespace = 'query' | 'query-params' | 'schema' | 'discovery' | 'info' | 'deprecated';
 export interface LogContext extends Dictionary {
     query?: string;
     label?: string;
@@ -41,6 +41,7 @@ export interface LogContext extends Dictionary {
 export interface LoggerOptions {
     writer: (message: string) => void;
     debugMode?: boolean | LoggerNamespace[];
+    ignoreDeprecations?: boolean | string[];
     highlighter?: Highlighter;
     usesReplicas?: boolean;
 }

package/metadata/MetadataDiscovery.d.ts

@@ -31,6 +31,7 @@ export declare class MetadataDiscovery {
     private saveToCache;
     private initNullability;
     private applyNamingStrategy;
+    private initOwnColumns;
     private initFieldName;
     private initManyToOneFieldName;
     private initManyToManyFieldName;

package/metadata/MetadataDiscovery.js

@@ -127,10 +127,10 @@ class MetadataDiscovery {
             return meta;
         });
     }
-    findEntities(preferTsNode, sync = false) {
+    findEntities(preferTs, sync = false) {
         this.discovered.length = 0;
         const options = this.config.get('discovery');
-        const key = (preferTsNode && this.config.get('tsNode', Utils_1.Utils.detectTsNode()) && this.config.get('entitiesTs').length > 0) ? 'entitiesTs' : 'entities';
+        const key = (preferTs && this.config.get('preferTs', Utils_1.Utils.detectTsNode()) && this.config.get('entitiesTs').length > 0) ? 'entitiesTs' : 'entities';
         const paths = this.config.get(key).filter(item => Utils_1.Utils.isString(item));
         const refs = this.config.get(key).filter(item => !Utils_1.Utils.isString(item));
         if (paths.length > 0) {
@@ -361,6 +361,22 @@ class MetadataDiscovery {
             this.initOneToManyFields(prop);
         }
     }
+    initOwnColumns(meta) {
+        meta.sync();
+        for (const prop of meta.props) {
+            if (!prop.joinColumns || prop.ownColumns) {
+                continue;
+            }
+            if (prop.joinColumns.length > 1) {
+                prop.ownColumns = prop.joinColumns.filter(col => {
+                    return !meta.props.find(p => p.name !== prop.name && (!p.fieldNames || p.fieldNames.includes(col)));
+                });
+            }
+            if (!prop.ownColumns || prop.ownColumns.length === 0) {
+                prop.ownColumns = prop.joinColumns;
+            }
+        }
+    }
     initFieldName(prop, object = false) {
         if (prop.fieldNames && prop.fieldNames.length > 0) {
             return;
@@ -469,6 +485,7 @@ class MetadataDiscovery {
             this.initColumnType(prop);
             this.initRelation(prop);
         }
+        this.initOwnColumns(meta);
         meta.simplePK = pks.length === 1 && pks[0].kind === enums_1.ReferenceKind.SCALAR && !pks[0].customType && pks[0].runtimeType !== 'Date';
         meta.serializedPrimaryKey = this.platform.getSerializedPrimaryKeyField(meta.primaryKeys[0]);
         const serializedPKProp = meta.properties[meta.serializedPrimaryKey];

package/metadata/MetadataValidator.js

@@ -41,7 +41,7 @@ class MetadataValidator {
         this.validateIndexes(meta, meta.uniques ?? [], 'unique');
         for (const prop of utils_1.Utils.values(meta.properties)) {
             if (prop.kind !== enums_1.ReferenceKind.SCALAR) {
-                this.validateReference(meta, prop, metadata);
+                this.validateReference(meta, prop, metadata, options);
                 this.validateBidirectional(meta, prop, metadata);
             }
             else if (metadata.has(prop.type)) {
@@ -98,7 +98,7 @@ class MetadataValidator {
             }
         });
     }
-    validateReference(meta, prop, metadata) {
+    validateReference(meta, prop, metadata, options) {
         // references do have types
         if (!prop.type) {
             throw errors_1.MetadataError.fromWrongTypeDefinition(meta, prop);
@@ -110,6 +110,9 @@ class MetadataValidator {
         if (metadata.find(prop.type).abstract && !metadata.find(prop.type).discriminatorColumn) {
             throw errors_1.MetadataError.targetIsAbstract(meta, prop);
         }
+        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.persist === false && metadata.find(prop.type).compositePK && options.checkNonPersistentCompositeProps) {
+            throw errors_1.MetadataError.nonPersistentCompositeProp(meta, prop);
+        }
     }
     validateBidirectional(meta, prop, metadata) {
         if (prop.inversedBy) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.14-dev.8",
+  "version": "6.4.0",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.3.14-dev.8",
+    "mikro-orm": "6.4.0",
     "reflect-metadata": "0.2.2"
   }
 }

package/serialization/EntitySerializer.js

@@ -111,7 +111,7 @@ class EntitySerializer {
         const parts = prop.split('.');
         prop = parts[0];
         const wrapped = (0, wrap_1.helper)(entity);
-        const property = wrapped.__meta.properties[prop];
+        const property = wrapped.__meta.properties[prop] ?? { name: prop };
         const serializer = property?.serializer;
         const value = entity[prop];
         // getter method
@@ -127,10 +127,10 @@ class EntitySerializer {
             return serializer(value);
         }
         if (Utils_1.Utils.isCollection(value)) {
-            return this.processCollection(prop, entity, options);
+            return this.processCollection(property, entity, options);
         }
         if (Utils_1.Utils.isEntity(value, true)) {
-            return this.processEntity(prop, entity, wrapped.__platform, options);
+            return this.processEntity(property, entity, wrapped.__platform, options);
         }
         if (Utils_1.Utils.isScalarReference(value)) {
             return value.unwrap();
@@ -158,17 +158,20 @@ class EntitySerializer {
         };
     }
     static processEntity(prop, entity, platform, options) {
-        const child = Reference_1.Reference.unwrapReference(entity[prop]);
+        const child = Reference_1.Reference.unwrapReference(entity[prop.name]);
         const wrapped = (0, wrap_1.helper)(child);
-        const populated = isPopulated(prop, options) && wrapped.isInitialized();
+        const populated = isPopulated(prop.name, options) && wrapped.isInitialized();
         const expand = populated || !wrapped.__managed;
         const meta = wrapped.__meta;
-        const childOptions = this.extractChildOptions(options, prop);
+        const childOptions = this.extractChildOptions(options, prop.name);
         const visible = meta.primaryKeys.filter(prop => isVisible(meta, prop, childOptions));
         if (expand) {
             return this.serialize(child, childOptions);
         }
-        const pk = wrapped.getPrimaryKey(true);
+        let pk = wrapped.getPrimaryKey();
+        if (prop.customType) {
+            pk = prop.customType.toJSON(pk, wrapped.__platform);
+        }
         if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
             return Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
         }
@@ -182,20 +185,24 @@ class EntitySerializer {
         return platform.normalizePrimaryKey(pk);
     }
     static processCollection(prop, entity, options) {
-        const col = entity[prop];
+        const col = entity[prop.name];
         if (!col.isInitialized()) {
             return undefined;
         }
         return col.getItems(false).map(item => {
-            const populated = isPopulated(prop, options);
+            const populated = isPopulated(prop.name, options);
             const wrapped = (0, wrap_1.helper)(item);
             if (populated || !wrapped.__managed) {
-                return this.serialize(item, this.extractChildOptions(options, prop));
+                return this.serialize(item, this.extractChildOptions(options, prop.name));
+            }
+            let pk = wrapped.getPrimaryKey();
+            if (prop.customType) {
+                pk = prop.customType.toJSON(pk, wrapped.__platform);
             }
             if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
-                return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, wrapped.getPrimaryKey(true));
+                return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, pk);
             }
-            return (0, wrap_1.helper)(item).getPrimaryKey();
+            return pk;
         });
     }
 }

package/serialization/EntityTransformer.js

@@ -18,6 +18,9 @@ class EntityTransformer {
         }
         const wrapped = (0, wrap_1.helper)(entity);
         let contextCreated = false;
+        if (!wrapped) {
+            return entity;
+        }
         if (!wrapped.__serializationContext.root) {
             const root = new SerializationContext_1.SerializationContext(wrapped.__config, wrapped.__serializationContext.populate, wrapped.__serializationContext.fields, wrapped.__serializationContext.exclude);
             SerializationContext_1.SerializationContext.propagate(root, entity, isVisible);
@@ -108,7 +111,7 @@ class EntityTransformer {
     }
     static processProperty(prop, entity, raw, populated) {
         const wrapped = (0, wrap_1.helper)(entity);
-        const property = wrapped.__meta.properties[prop];
+        const property = wrapped.__meta.properties[prop] ?? { name: prop };
         const serializer = property?.serializer;
         const value = entity[prop];
         // getter method
@@ -123,10 +126,10 @@ class EntityTransformer {
             return serializer(value);
         }
         if (Utils_1.Utils.isCollection(value)) {
-            return EntityTransformer.processCollection(prop, entity, raw, populated);
+            return EntityTransformer.processCollection(property, entity, raw, populated);
         }
         if (Utils_1.Utils.isEntity(value, true)) {
-            return EntityTransformer.processEntity(prop, entity, wrapped.__platform, raw, populated);
+            return EntityTransformer.processEntity(property, entity, wrapped.__platform, raw, populated);
         }
         if (Utils_1.Utils.isScalarReference(value)) {
             return value.unwrap();
@@ -151,7 +154,7 @@ class EntityTransformer {
         return value;
     }
     static processEntity(prop, entity, platform, raw, populated) {
-        const child = entity[prop];
+        const child = entity[prop.name];
         const wrapped = (0, wrap_1.helper)(child);
         const meta = wrapped.__meta;
         const visible = meta.primaryKeys.filter(prop => isVisible(meta, prop));
@@ -170,7 +173,10 @@ class EntityTransformer {
         if (wrapped.isInitialized() && isPopulated() && child !== entity) {
             return (0, wrap_1.wrap)(child).toJSON();
         }
-        const pk = wrapped.getPrimaryKey(true);
+        let pk = wrapped.getPrimaryKey();
+        if (prop.customType) {
+            pk = prop.customType.toJSON(pk, wrapped.__platform);
+        }
         if (wrapped.__config.get('serialization').forceObject) {
             return Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
         }
@@ -184,7 +190,7 @@ class EntityTransformer {
         return platform.normalizePrimaryKey(pk);
     }
     static processCollection(prop, entity, raw, populated) {
-        const col = entity[prop];
+        const col = entity[prop.name];
         if (raw && col.isInitialized(true)) {
             return col.map(item => (0, wrap_1.helper)(item).toPOJO());
         }
@@ -193,13 +199,18 @@ class EntityTransformer {
         }
         if (col.isInitialized()) {
             const wrapped = (0, wrap_1.helper)(entity);
-            if (wrapped.__config.get('serialization').forceObject) {
-                return col.map(item => {
-                    const wrapped = (0, wrap_1.helper)(item);
-                    return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, wrapped.getPrimaryKey(true));
-                });
-            }
-            return col.map(i => (0, wrap_1.helper)(i).getPrimaryKey(true));
+            const forceObject = wrapped.__config.get('serialization').forceObject;
+            return col.map(item => {
+                const wrapped = (0, wrap_1.helper)(item);
+                const pk = wrapped.getPrimaryKey();
+                if (prop.customType) {
+                    return prop.customType.toJSON(pk, wrapped.__platform);
+                }
+                if (forceObject) {
+                    return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, pk);
+                }
+                return pk;
+            });
         }
         return undefined;
     }

package/types/DecimalType.d.ts

@@ -8,6 +8,8 @@ export declare class DecimalType extends Type<string | number, string> {
     mode?: ("number" | "string") | undefined;
     constructor(mode?: ("number" | "string") | undefined);
     convertToJSValue(value: string): number | string;
+    compareValues(a: string, b: string): boolean;
+    private format;
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
 }

package/types/DecimalType.js

@@ -17,6 +17,17 @@ class DecimalType extends Type_1.Type {
         }
         return value;
     }
+    compareValues(a, b) {
+        return this.format(a) === this.format(b);
+    }
+    format(val) {
+        /* istanbul ignore next */
+        if (this.prop?.scale == null) {
+            return +val;
+        }
+        const base = Math.pow(10, this.prop.scale);
+        return Math.round((+val + Number.EPSILON) * base) / base;
+    }
     getColumnType(prop, platform) {
         return platform.getDecimalTypeDeclarationSQL(prop);
     }

package/typings.d.ts

@@ -1,6 +1,7 @@
 import type { Transaction } from './connections';
 import { type Cascade, type DeferMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind } from './enums';
 import { type AssignOptions, type Collection, type EntityFactory, type EntityIdentifier, type EntityLoaderOptions, type EntityRepository, Reference, type ScalarReference } from './entity';
+import type { MikroORM } from './MikroORM';
 import type { SerializationContext, SerializeOptions } from './serialization';
 import type { EntitySchema, MetadataStorage } from './metadata';
 import type { Type, types } from './types';
@@ -143,7 +144,7 @@ export interface IWrappedEntity<Entity extends object> {
     toObject<Ignored extends EntityKey<Entity>>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
     toJSON(...args: any[]): EntityDTO<Entity>;
     toPOJO(): EntityDTO<Entity>;
-    serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): EntityDTO<Loaded<Entity, Hint>>;
+    serialize<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): EntityDTO<Loaded<Naked, Hint>>;
     setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
     assign<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked, Convert>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     getSchema(): string | undefined;
@@ -364,6 +365,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     pivotTable: string;
     pivotEntity: string;
     joinColumns: string[];
+    ownColumns: string[];
     inverseJoinColumns: string[];
     referencedColumnNames: string[];
     referencedTableName: string;
@@ -626,11 +628,20 @@ export interface IMigrator {
      * Executes down migrations to the given point. Without parameter it will migrate one version down.
      */
     down(options?: string | string[] | MigrateOptions): Promise<UmzugMigration[]>;
+    /**
+     * Registers event handler.
+     */
+    on(event: MigratorEvent, listener: (event: UmzugMigration) => MaybePromise<void>): IMigrator;
+    /**
+     * Removes event handler.
+     */
+    off(event: MigratorEvent, listener: (event: UmzugMigration) => MaybePromise<void>): IMigrator;
     /**
      * @internal
      */
     getStorage(): IMigratorStorage;
 }
+export type MigratorEvent = 'migrating' | 'migrated' | 'reverting' | 'reverted';
 export interface MigrationDiff {
     up: string[];
     down: string[];
@@ -786,4 +797,10 @@ export interface Seeder<T extends Dictionary = Dictionary> {
 }
 export type ConnectionType = 'read' | 'write';
 export type MetadataProcessor = (metadata: EntityMetadata[], platform: Platform) => MaybePromise<void>;
+/**
+ * The type of context that the user intends to inject.
+ */
+export type ContextProvider<T> = MaybePromise<MikroORM> | ((type: T) => MaybePromise<MikroORM | EntityManager | EntityRepository<any> | {
+    getEntityManager(): EntityManager;
+}>);
 export {};

package/utils/Configuration.d.ts

@@ -34,9 +34,10 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
             requireEntitiesArray: false;
             checkDuplicateTableNames: true;
             checkDuplicateFieldNames: true;
+            checkDuplicateEntities: true;
+            checkNonPersistentCompositeProps: true;
             alwaysAnalyseProperties: true;
             disableDynamicFileAccess: false;
-            checkDuplicateEntities: true;
             inferDefaultValues: true;
         };
         strict: false;
@@ -57,6 +58,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
         populateWhere: PopulateHint.ALL;
         connect: true;
         ignoreUndefinedInQuery: false;
+        onQuery: (sql: string) => string;
         autoJoinOneToOneOwner: true;
         autoJoinRefsForFilters: true;
         propagationOnPrototype: true;
@@ -71,12 +73,14 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
             mergeEmbeddedProperties: true;
         };
         persistOnCreate: true;
+        upsertManaged: true;
         forceEntityConstructor: false;
         forceUndefined: false;
         ensureDatabase: true;
         ensureIndexes: false;
         batchSize: number;
         debug: false;
+        ignoreDeprecations: false;
         verbose: false;
         driverOptions: {};
         migrations: {
@@ -291,11 +295,12 @@ export interface MetadataDiscoveryOptions {
     requireEntitiesArray?: boolean;
     checkDuplicateTableNames?: boolean;
     checkDuplicateFieldNames?: boolean;
+    checkDuplicateEntities?: boolean;
+    checkNonPersistentCompositeProps?: boolean;
     alwaysAnalyseProperties?: boolean;
     disableDynamicFileAccess?: boolean;
     inferDefaultValues?: boolean;
     getMappedType?: (type: string, platform: Platform) => Type<unknown> | undefined;
-    checkDuplicateEntities?: boolean;
     onMetadata?: (meta: EntityMetadata, platform: Platform) => MaybePromise<void>;
     afterDiscovered?: (storage: MetadataStorage, platform: Platform) => MaybePromise<void>;
     tsConfigPath?: string;
@@ -322,6 +327,7 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     connect: boolean;
     verbose: boolean;
     ignoreUndefinedInQuery?: boolean;
+    onQuery: (sql: string, params: unknown[]) => string;
     autoJoinOneToOneOwner: boolean;
     autoJoinRefsForFilters: boolean;
     propagationOnPrototype: boolean;
@@ -333,6 +339,7 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     };
     assign: AssignOptions<boolean>;
     persistOnCreate: boolean;
+    upsertManaged: boolean;
     forceEntityConstructor: boolean | (Constructor<AnyEntity> | string)[];
     forceUndefined: boolean;
     forceUtcTimezone?: boolean;
@@ -363,7 +370,15 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     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;
+    /** @deprecated use `preferTs` instead */
     tsNode?: boolean;
     baseDir: string;
     migrations: MigrationsOptions;

package/utils/Configuration.js

@@ -27,9 +27,10 @@ class Configuration {
             requireEntitiesArray: false,
             checkDuplicateTableNames: true,
             checkDuplicateFieldNames: true,
+            checkDuplicateEntities: true,
+            checkNonPersistentCompositeProps: true,
             alwaysAnalyseProperties: true,
             disableDynamicFileAccess: false,
-            checkDuplicateEntities: true,
             inferDefaultValues: true,
         },
         strict: false,
@@ -51,6 +52,7 @@ class Configuration {
         populateWhere: enums_1.PopulateHint.ALL,
         connect: true,
         ignoreUndefinedInQuery: false,
+        onQuery: sql => sql,
         autoJoinOneToOneOwner: true,
         autoJoinRefsForFilters: true,
         propagationOnPrototype: true,
@@ -65,12 +67,14 @@ class Configuration {
             mergeEmbeddedProperties: true,
         },
         persistOnCreate: true,
+        upsertManaged: true,
         forceEntityConstructor: false,
         forceUndefined: false,
         ensureDatabase: true,
         ensureIndexes: false,
         batchSize: 300,
         debug: false,
+        ignoreDeprecations: false,
         verbose: false,
         driverOptions: {},
         migrations: {
@@ -142,12 +146,14 @@ class Configuration {
         }
         this.options = Utils_1.Utils.mergeConfig({}, Configuration.DEFAULTS, options);
         this.options.baseDir = Utils_1.Utils.absolutePath(this.options.baseDir);
+        this.options.preferTs ??= options.tsNode;
         if (validate) {
             this.validateOptions();
         }
         this.options.loggerFactory ??= logging_1.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,
@@ -326,6 +332,7 @@ class Configuration {
     }
     sync() {
         process.env.MIKRO_ORM_COLORS = '' + this.options.colors;
+        this.options.tsNode = this.options.preferTs;
         this.logger.setDebugMode(this.options.debug);
     }
     /**

package/utils/ConfigurationLoader.d.ts

@@ -6,9 +6,33 @@ import { Configuration, type Options } from './Configuration';
  * @internal
  */
 export declare class ConfigurationLoader {
-    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = EntityManager>(validate?: boolean, options?: Partial<Options>): Promise<Configuration<D, EM>>;
+    /**
+     * 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 registerTsNode(configPath?: string): boolean;

package/utils/ConfigurationLoader.js

@@ -16,32 +16,103 @@ const Utils_1 = require("./Utils");
  * @internal
  */
 class ConfigurationLoader {
-    static async getConfiguration(validate = true, options = {}) {
-        this.commonJSCompat(options);
-        this.registerDotenv(options);
-        const paths = this.getConfigPaths();
+    static async getConfiguration(contextName = 'default', paths = ConfigurationLoader.getConfigPaths(), options = {}) {
+        // Backwards compatibility layer
+        if (typeof contextName === 'boolean' || !Array.isArray(paths)) {
+            this.commonJSCompat(options);
+            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 = this.loadEnvironmentVars();
+                    const [path, tmp] = await this.getConfigFile(configPaths);
+                    if (!path) {
+                        if (Utils_1.Utils.hasObjectKeys(env)) {
+                            return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig({}, options, env), false);
+                        }
+                        throw new Error(`MikroORM config file not found in ['${configPaths.join(`', '`)}']`);
+                    }
+                    return new Configuration_1.Configuration(Utils_1.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 = this.loadEnvironmentVars();
+        const configFinder = (cfg) => {
+            return typeof cfg === 'object' && cfg !== null && ('contextName' in cfg ? cfg.contextName === contextName : (contextName === 'default'));
+        };
+        const isValidConfigFactoryResult = (cfg) => {
+            return typeof cfg === 'object' && cfg !== null && (!('contextName' in cfg) || cfg.contextName === contextName);
+        };
+        const result = await this.getConfigFile(paths);
+        if (!result[0]) {
+            if (Utils_1.Utils.hasObjectKeys(env)) {
+                return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig({ contextName }, options, env));
+            }
+            throw new Error(`MikroORM config file not found in ['${paths.join(`', '`)}']`);
+        }
+        const path = result[0];
+        let tmp = result[1];
+        if (Array.isArray(tmp)) {
+            const tmpFirstIndex = tmp.findIndex(configFinder);
+            if (tmpFirstIndex === -1) {
+                // Static config not found. Try factory functions
+                let configCandidate;
+                for (let i = 0, l = tmp.length; i < l; ++i) {
+                    const f = tmp[i];
+                    if (typeof f !== 'function') {
+                        continue;
+                    }
+                    configCandidate = await f(contextName);
+                    if (!isValidConfigFactoryResult(configCandidate)) {
+                        continue;
+                    }
+                    tmp = configCandidate;
+                    break;
+                }
+                if (Array.isArray(tmp)) {
+                    throw new Error(`MikroORM config '${contextName}' was not found within the config file '${path}'. Either add a config with this name to the array, or add a function that when given this name will return a configuration object without a name, or with name set to this name.`);
+                }
+            }
+            else {
+                const tmpLastIndex = tmp.findLastIndex(configFinder);
+                if (tmpLastIndex !== tmpFirstIndex) {
+                    throw new Error(`MikroORM config '${contextName}' is not unique within the array exported by '${path}' (first occurrence index: ${tmpFirstIndex}; last occurrence index: ${tmpLastIndex})`);
+                }
+                tmp = tmp[tmpFirstIndex];
+            }
+        }
+        else {
+            if (tmp instanceof Function) {
+                tmp = await tmp(contextName);
+                if (!isValidConfigFactoryResult(tmp)) {
+                    throw new Error(`MikroORM config '${contextName}' was not what the function exported from '${path}' provided. Ensure it returns a config object with no name, or name matching the requested one.`);
+                }
+            }
+            else {
+                if (!configFinder(tmp)) {
+                    throw new Error(`MikroORM config '${contextName}' was not what the default export from '${path}' provided.`);
+                }
+            }
+        }
+        const esmConfigOptions = this.isESM() ? { entityGenerator: { esmImport: true } } : {};
+        return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig({}, esmConfigOptions, tmp, options, env));
+    }
+    static async getConfigFile(paths) {
         for (let path of paths) {
             path = Utils_1.Utils.absolutePath(path);
             path = Utils_1.Utils.normalizePath(path);
             if ((0, fs_extra_1.pathExistsSync)(path)) {
                 const config = await Utils_1.Utils.dynamicImport(path);
                 /* istanbul ignore next */
-                let tmp = config.default ?? config;
-                if (tmp instanceof Function) {
-                    tmp = tmp();
-                }
-                if (tmp instanceof Promise) {
-                    tmp = await tmp;
-                }
-                const esmConfigOptions = this.isESM() ? { entityGenerator: { esmImport: true } } : {};
-                return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig({}, esmConfigOptions, tmp, options, env), validate);
+                return [path, await (config.default ?? config)];
             }
         }
-        if (Utils_1.Utils.hasObjectKeys(env)) {
-            return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig({}, options, env), validate);
-        }
-        throw new Error(`MikroORM config file not found in ['${paths.join(`', '`)}']`);
+        return [];
     }
     static getPackageConfig(basePath = process.cwd()) {
         if ((0, fs_extra_1.pathExistsSync)(`${basePath}/package.json`)) {
@@ -73,12 +144,15 @@ class ConfigurationLoader {
         }
         return settings;
     }
-    static getConfigPaths() {
+    static configPathsFromArg() {
         const options = Utils_1.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();
         if (process.env.MIKRO_ORM_CLI_CONFIG) {

package/utils/DataloaderUtils.d.ts

@@ -23,7 +23,7 @@ export declare class DataloaderUtils {
     static groupInversedOrMappedKeysByEntityAndOpts(collsWithOpts: readonly [Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?][]): Map<string, Map<string, Set<Primary<any>>>>;
     /**
      * Turn the entity+options map into actual queries.
-     * The keys are the entity names + a strigified version of the options and the values are filter Maps which will be used as the values of an $or operator so we end up with a query per entity+opts.
+     * The keys are the entity names + a stringified version of the options and the values are filter Maps which will be used as the values of an $or operator so we end up with a query per entity+opts.
      * We must populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s).
      * Together with the query the promises will also return the key which can be used to narrow down the results pertaining to a certain set of options.
      */
@@ -33,7 +33,7 @@ export declare class DataloaderUtils {
      * First checks if the Entity type matches, then retrieves the inverse side of the relationship
      * where the filtering will be done in order to match the target collection.
      */
-    static getColFilter<T, S extends T>(collection: Collection<any, object>): (result: T) => result is S;
+    static getColFilter<T, S extends T>(collection: Collection<any>): (result: T) => result is S;
     /**
      * Returns the collection dataloader batchLoadFn, which aggregates collections by entity,
      * makes one query per entity and maps each input collection to the corresponding result.

package/utils/DataloaderUtils.js

@@ -4,6 +4,7 @@ exports.DataloaderUtils = void 0;
 const Collection_1 = require("../entity/Collection");
 const wrap_1 = require("../entity/wrap");
 const enums_1 = require("../enums");
+const Reference_1 = require("../entity/Reference");
 class DataloaderUtils {
     /**
      * Groups identified references by entity and returns a Map with the
@@ -92,7 +93,7 @@ class DataloaderUtils {
     }
     /**
      * Turn the entity+options map into actual queries.
-     * The keys are the entity names + a strigified version of the options and the values are filter Maps which will be used as the values of an $or operator so we end up with a query per entity+opts.
+     * The keys are the entity names + a stringified version of the options and the values are filter Maps which will be used as the values of an $or operator so we end up with a query per entity+opts.
      * We must populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s).
      * Together with the query the promises will also return the key which can be used to narrow down the results pertaining to a certain set of options.
      */
@@ -139,20 +140,21 @@ class DataloaderUtils {
             // There is no need to check if Entity matches because we already matched the key which is entity+options.
             // This is the inverse side of the relationship where the filtering will be done in order to match the target collection
             // Either inversedBy or mappedBy exist because we already checked in groupInversedOrMappedKeysByEntity
-            const refOrCol = result[(collection.property.inversedBy ?? collection.property.mappedBy)];
-            if (refOrCol instanceof Collection_1.Collection) {
-                // The inverse side is a Collection
-                // We keep the result if any of PKs of the inverse side matches the PK of the collection owner
-                for (const item of refOrCol.getItems()) {
-                    if ((0, wrap_1.helper)(item).getSerializedPrimaryKey() === (0, wrap_1.helper)(collection.owner).getSerializedPrimaryKey()) {
+            const inverseProp = collection.property.inversedBy ?? collection.property.mappedBy;
+            const target = Reference_1.Reference.unwrapReference(result[inverseProp]);
+            if (target instanceof Collection_1.Collection) {
+                for (const item of target) {
+                    if (item === collection.owner) {
                         return true;
                     }
                 }
             }
-            else {
-                // The inverse side is a Reference
-                // We keep the result if the PK of the inverse side matches the PK of the collection owner
-                return (0, wrap_1.helper)(refOrCol).getSerializedPrimaryKey() === (0, wrap_1.helper)(collection.owner).getSerializedPrimaryKey();
+            else if (target) {
+                return target === collection.owner;
+            }
+            // FIXME https://github.com/mikro-orm/mikro-orm/issues/6031
+            if (!target && collection.property.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+                throw new Error(`Inverse side is required for M:N relations with dataloader: ${collection.owner.constructor.name}.${collection.property.name}`);
             }
             return false;
         };

package/utils/resolveContextProvider.d.ts

@@ -0,0 +1,10 @@
+import { EntityManager } from '../EntityManager';
+import { MikroORM } from '../MikroORM';
+import type { ContextProvider, MaybePromise } from '../typings';
+/**
+ * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
+ */
+export declare function resolveContextProvider<T>(caller: T & {
+    orm?: MaybePromise<MikroORM>;
+    em?: MaybePromise<EntityManager>;
+}, provider?: ContextProvider<T>): Promise<EntityManager | undefined>;

package/utils/resolveContextProvider.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveContextProvider = resolveContextProvider;
+const EntityRepository_1 = require("../entity/EntityRepository");
+const EntityManager_1 = require("../EntityManager");
+const MikroORM_1 = require("../MikroORM");
+function getEntityManager(caller, context) {
+    if (context instanceof EntityManager_1.EntityManager) {
+        return context;
+    }
+    if (context instanceof EntityRepository_1.EntityRepository) {
+        return context.getEntityManager();
+    }
+    if (context instanceof MikroORM_1.MikroORM) {
+        return context.em;
+    }
+    if (caller.em instanceof EntityManager_1.EntityManager) {
+        return caller.em;
+    }
+    if (caller.orm instanceof MikroORM_1.MikroORM) {
+        return caller.orm.em;
+    }
+    return undefined;
+}
+/**
+ * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
+ */
+async function resolveContextProvider(caller, provider) {
+    const context = typeof provider === 'function' ? await provider(caller) : await provider;
+    return getEntityManager({ orm: await caller.orm, em: await caller.em }, context);
+}