bug: QueryBuilder execute Method Doesn't Properly Map Embeddables

src/example.test.ts

@@ -1,30 +1,71 @@
-import { Entity, MikroORM, PrimaryKey, Property } from '@mikro-orm/sqlite';
+import { EntitySchema, MikroORM } from '@mikro-orm/sqlite';
 
-@Entity()
-class User {
-
-  @PrimaryKey()
-  id!: number;
+class PersonName {
+  constructor(readonly givenName: string, readonly surname: string) {}
+}
 
-  @Property()
-  name: string;
+export const PersonNameSchema = new EntitySchema<PersonName>({
+  class: PersonName,
+  embeddable: true,
+  properties: {
+    givenName: { type: 'string' },
+    surname: { type: 'string' },
+  },
+});
 
-  @Property({ unique: true })
-  email: string;
+class EmergencyContact {
+  constructor(readonly name: PersonName, readonly relationship: string) {}
+}
 
-  constructor(name: string, email: string) {
-    this.name = name;
-    this.email = email;
-  }
+export const EmergencyContactSchema = new EntitySchema<EmergencyContact>({
+  class: EmergencyContact,
+  embeddable: true,
+  properties: {
+    name: {
+      kind: 'embedded',
+      entity: () => PersonName,
+      prefix: 'emergency_contact_', // have to override the parent prefix
+    },
+    relationship: { type: 'string' },
+  },
+});
 
+class Patient {
+  constructor(
+    readonly id: string, 
+    readonly name: PersonName, 
+    readonly emergencyContact: EmergencyContact
+  ) {}
 }
 
+export const PatientSchema = new EntitySchema<Patient>({
+  class: Patient,
+  properties: {
+    id: {
+      type: 'text',
+      primary: true,
+    },
+    name: {
+      kind: 'embedded',
+      entity: () => PersonName,
+      prefix: false,
+    },
+    emergencyContact: {
+      kind: 'embedded',
+      entity: () => EmergencyContact,
+      prefix: 'emergency_contact_',
+      nullable: true,
+    },
+  },
+});
+
+
 let orm: MikroORM;
 
 beforeAll(async () => {
   orm = await MikroORM.init({
     dbName: ':memory:',
-    entities: [User],
+    entities: [PatientSchema, PersonNameSchema, EmergencyContactSchema],
     debug: ['query', 'query-params'],
     allowGlobalContext: true, // only for testing
   });
@@ -36,16 +77,35 @@ afterAll(async () => {
 });
 
 test('basic CRUD example', async () => {
-  orm.em.create(User, { name: 'Foo', email: 'foo' });
+  orm.em.create(Patient, { id: '1', name: {
+    givenName: 'John',
+    surname: 'Doe',
+  }, emergencyContact: {
+    name: {
+      givenName: 'Jane',
+      surname: 'Doe',
+    },
+    relationship: 'wife',
+  } });
   await orm.em.flush();
   orm.em.clear();
 
-  const user = await orm.em.findOneOrFail(User, { email: 'foo' });
-  expect(user.name).toBe('Foo');
-  user.name = 'Bar';
-  orm.em.remove(user);
-  await orm.em.flush();
+  const qb = orm.em.createQueryBuilder('Patient');
 
-  const count = await orm.em.count(User, { email: 'foo' });
-  expect(count).toBe(0);
+  qb.select(['*']).where({ id: '1' });
+  const patient = await qb.execute('get', true);
+  expect(patient).toStrictEqual({
+    id: '1',
+    name: {
+      givenName: 'John',
+      surname: 'Doe'
+    },
+    emergencyContact: {
+      name: {
+        givenName: 'Jane',
+        surname: 'Doe'
+      },
+      relationship: 'wife'
+    }
+  });
 });