@mikro-orm/core 6.3.14-dev.5 → 6.3.14-dev.50

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);

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/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

@@ -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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.14-dev.5",
+  "version": "6.3.14-dev.50",
   "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.5",
+    "mikro-orm": "6.3.14-dev.50",
     "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;
@@ -626,11 +627,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 +796,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

@@ -71,6 +71,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
             mergeEmbeddedProperties: true;
         };
         persistOnCreate: true;
+        upsertManaged: true;
         forceEntityConstructor: false;
         forceUndefined: false;
         ensureDatabase: true;
@@ -333,6 +334,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;

package/utils/Configuration.js

@@ -65,6 +65,7 @@ class Configuration {
             mergeEmbeddedProperties: true,
         },
         persistOnCreate: true,
+        upsertManaged: true,
         forceEntityConstructor: false,
         forceUndefined: false,
         ensureDatabase: true,

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/clone.js

@@ -75,7 +75,7 @@ function clone(parent, respectCustomCloneMethod = true) {
                 child.lastIndex = parent.lastIndex;
             }
         }
-        else if (parent instanceof Date || (typeof parent === 'object' && parent.constructor.name === 'Date')) {
+        else if (parent instanceof Date) {
             child = new Date(parent.getTime());
         }
         else if (Buffer.isBuffer(parent)) {

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);
+}