fix(mysql): fix reloading of database defaults for complex composite PKs

Closes #3965

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

@@ -329,14 +329,23 @@ export class ChangeSetPersister {
       return;
     }
 
+    reloadProps.unshift(...meta.getPrimaryProps());
     const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
-    const pks = changeSets.map(cs => helper(cs.entity).getPrimaryKey(true));
+    const pks = changeSets.map(cs => {
+      const val = helper(cs.entity).getPrimaryKey(true);
+
+      if (Utils.isPlainObject(val)) {
+        return Utils.getCompositeKeyValue(val, meta, false, this.platform);
+      }
+
+      return val;
+    });
     options = this.propagateSchemaFromMetadata(meta, options, {
-      fields: reloadProps.map(prop => prop.fieldNames[0]),
+      fields: Utils.unique(reloadProps.map(prop => prop.name)),
     });
     const data = await this.driver.find<T>(meta.name!, { [pk]: { $in: pks } } as FilterQuery<T>, options);
     const map = new Map<string, Dictionary>();
-    data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform), item));
+    data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
 
     for (const changeSet of changeSets) {
       const data = map.get(helper(changeSet.entity).getSerializedPrimaryKey());

packages/core/src/utils/Utils.ts

@@ -473,8 +473,12 @@ export class Utils {
     }) as Primary<T>;
   }
 
-  static getCompositeKeyHash<T>(data: EntityData<T>, meta: EntityMetadata<T>, convertCustomTypes = false, platform?: Platform): string {
-    const pks = this.getCompositeKeyValue(data, meta, convertCustomTypes, platform);
+  static getCompositeKeyHash<T>(data: EntityData<T>, meta: EntityMetadata<T>, convertCustomTypes = false, platform?: Platform, flat = false): string {
+    let pks = this.getCompositeKeyValue(data, meta, convertCustomTypes, platform);
+
+    if (flat) {
+      pks = Utils.flatten(pks as unknown[][]) as Primary<T>;
+    }
 
     return Utils.getPrimaryKeyHash(pks as string[]);
   }

packages/core/src/utils/clone.ts

@@ -115,6 +115,7 @@ export function clone<T>(parent: T, respectCustomCloneMethod = true): T {
         const symbol = symbols[i];
         const descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
 
+        /* istanbul ignore next */
         if (descriptor && !descriptor.enumerable) {
           continue;
         }

packages/knex/src/AbstractSqlDriver.ts

@@ -929,7 +929,7 @@ export abstract class AbstractSqlDriver<Connection extends AbstractSqlConnection
     }
 
     if (prop.fieldNames) {
-      ret.push(prop.fieldNames[0]);
+      ret.push(...prop.fieldNames);
     }
   }
 

tests/features/optimistic-lock/GH3440.test.ts

@@ -1,6 +1,6 @@
-import { Entity, MikroORM, PrimaryKey, Property, Type, ValidationError } from '@mikro-orm/core';
+import { Entity, PrimaryKey, Property, Type, ValidationError } from '@mikro-orm/core';
+import { MikroORM } from '@mikro-orm/mysql';
 import { mockLogger } from '../../helpers';
-import { MySqlDriver } from '@mikro-orm/mysql';
 
 export function toBinaryUuid(uuid: string): Buffer {
   const buf = Buffer.from(uuid.replace(/-/g, ''), 'hex');
@@ -65,7 +65,6 @@ beforeAll(async () => {
   orm = await MikroORM.init({
     entities: [Couch],
     dbName: 'mikro_orm_test_3440',
-    driver: MySqlDriver,
     port: 3308,
   });
   await orm.schema.refreshDatabase();

tests/issues/GH3965.test.ts

@@ -0,0 +1,104 @@
+import { Collection, Entity, Property, ManyToOne, OneToMany, PrimaryKey, PrimaryKeyType, Cascade, Ref } from '@mikro-orm/core';
+import { MikroORM } from '@mikro-orm/mysql';
+import { randomUUID } from 'crypto';
+
+@Entity()
+export class Category {
+
+  @PrimaryKey({
+    length: 36,
+  })
+  id!: string;
+
+  @Property({
+    defaultRaw: 'CURRENT_TIMESTAMP',
+  })
+  createdAt?: Date;
+
+  @OneToMany(() => Article, attr => attr.category, {
+    cascade: [Cascade.ALL],
+  })
+  articles = new Collection<Article>(this);
+
+}
+
+@Entity()
+export class Article {
+
+  @PrimaryKey({
+    length: 36,
+  })
+  id!: string;
+
+  @Property({
+    defaultRaw: 'CURRENT_TIMESTAMP',
+  })
+  createdAt?: Date;
+
+  @ManyToOne(() => Category, {
+    primary: true,
+    ref: true,
+  })
+  category!: Ref<Category>;
+
+  [PrimaryKeyType]?: [string, string];
+
+  @OneToMany(() => ArticleAttribute, attr => attr.article, {
+    cascade: [Cascade.ALL],
+  })
+  attributes = new Collection<ArticleAttribute>(this);
+
+}
+
+@Entity()
+export class ArticleAttribute {
+
+  @PrimaryKey({ length: 36 })
+  id!: string;
+
+  @Property({
+    defaultRaw: 'CURRENT_TIMESTAMP',
+  })
+  createdAt?: Date;
+
+  @ManyToOne(() => Article, {
+    primary: true,
+    ref: true,
+  })
+  article!: Ref<Article>;
+
+  [PrimaryKeyType]?: [string, [string, string]];
+
+}
+
+let orm: MikroORM;
+
+beforeAll(async () => {
+  orm = await MikroORM.init({
+    dbName: 'mikro_orm_3965',
+    entities: [Article],
+    port: 3308,
+  });
+  await orm.schema.refreshDatabase();
+});
+
+afterAll(() => orm.close(true));
+
+test('3965', async () => {
+  const category = new Category();
+  category.id = randomUUID();
+
+  const article = new Article();
+  article.id = randomUUID();
+
+  category.articles.add(article);
+
+  const articleAttribute = new ArticleAttribute();
+  articleAttribute.id = randomUUID();
+
+  article.attributes.add(articleAttribute);
+  expect(category.createdAt).toBeUndefined();
+  await orm.em.persistAndFlush(category);
+  expect(category.createdAt).toBeDefined();
+  expect(category.createdAt).toBeInstanceOf(Date);
+});