fix(core): delay snapshotting of entity state to fix differences with joined strategy

Closes #3876

Author: B4nan

packages/core/src/unit-of-work/UnitOfWork.ts

@@ -100,21 +100,22 @@ export class UnitOfWork {
     wrapped.__managed = true;
 
     if (data && (options?.refresh || !wrapped.__originalEntityData)) {
-      const callback = () => {
-        // we can't use the `data` directly here as it can contain fetch joined data, that can't be used for diffing the state
-        wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
-        wrapped.__touched = false;
-      };
-
       Object.keys(data).forEach(key => helper(entity).__loadedProperties.add(key));
       this.queuedActions.delete(wrapped.__meta.className);
-      callback();
 
-      // schedule re-snapshotting in case it's a reference, as there might be some updates made via propagation
-      // we need to have in the snapshot in case the entity reference gets modified
-      if (!wrapped.__initialized) {
-        this.snapshotQueue.push(callback);
+      // assign the data early, delay recompute via snapshot queue unless we refresh the state
+      if (options?.refresh) {
+        wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
+      } else {
+        wrapped.__originalEntityData = data;
       }
+
+      wrapped.__touched = false;
+      this.snapshotQueue.push(() => {
+        // we can't use the `data` directly here as it can contain fetch joined data, that can't be used for diffing the state
+        wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
+        wrapped.__touched = false;
+      });
     }
 
     return entity;

tests/issues/GH3876.test.ts

@@ -0,0 +1,97 @@
+import { MikroORM } from '@mikro-orm/postgresql';
+import { Collection, OneToMany, OneToOne, Rel, Entity, LoadStrategy, ManyToOne, PrimaryKey, Property } from '@mikro-orm/core';
+import { v4 } from 'uuid';
+
+@Entity()
+class Book {
+
+  @PrimaryKey({ type: 'uuid' })
+  id: string = v4();
+
+  @Property()
+  name!: string;
+
+  @Property({ nullable: true })
+  description?: string;
+
+  @ManyToOne({ entity: () => User })
+  user!: Rel<User>;
+
+}
+
+@Entity()
+class ProfileInfo {
+
+  @PrimaryKey({ type: 'uuid' })
+  id: string = v4();
+
+  @Property()
+  email!: string;
+
+  @OneToOne({
+    entity: () => User,
+    mappedBy: user => user.profileInfo,
+  })
+  user!: Rel<User>;
+
+}
+
+@Entity()
+class User {
+
+  @PrimaryKey({ type: 'uuid' })
+  id: string = v4();
+
+  @Property()
+  name!: string;
+
+  @OneToOne({
+    entity: () => ProfileInfo,
+    nullable: true,
+  })
+  profileInfo?: ProfileInfo;
+
+  @OneToMany({
+    entity: () => Book,
+    mappedBy: book => book.user,
+  })
+  books = new Collection<Book>(this);
+
+}
+
+let orm: MikroORM;
+
+beforeAll(async () => {
+  orm = await MikroORM.init({
+    loadStrategy: LoadStrategy.JOINED,
+    dbName: 'mikro_orm_3876',
+    entities: [Book, User, ProfileInfo],
+  });
+  await orm.getSchemaGenerator().refreshDatabase();
+});
+
+afterAll(async () => {
+  await orm.close(true);
+});
+
+test('3876', async () => {
+  const user = orm.em.create(User, {
+    name: 'user1',
+  });
+  orm.em.create(Book, {
+    name: 'book1',
+    user,
+  });
+  orm.em.create(Book, {
+    name: 'book2',
+    user,
+  });
+  await orm.em.flush();
+  await orm.em.clear();
+
+  await orm.em.find(Book, {}, { populate: ['user'] });
+  const uow1 = orm.em.getUnitOfWork();
+  uow1.computeChangeSets();
+
+  expect(uow1.getChangeSets()).toHaveLength(0);
+});