@mikro-orm/core 6.4.1-dev.17 → 6.4.1-dev.19

package/entity/EntityFactory.js

@@ -283,18 +283,21 @@ class EntityFactory {
     extractConstructorParams(meta, data, options) {
         return meta.constructorParams.map(k => {
             if (meta.properties[k] && [enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(meta.properties[k].kind) && data[k]) {
-                const entity = this.unitOfWork.getById(meta.properties[k].type, data[k], options.schema);
+                const pk = Reference_1.Reference.unwrapReference(data[k]);
+                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema);
                 if (entity) {
                     return entity;
                 }
                 if (Utils_1.Utils.isEntity(data[k])) {
                     return data[k];
                 }
-                if (Utils_1.Utils.isObject(data[k]) && !Utils_1.Utils.extractPK(data[k], meta.properties[k].targetMeta, true)) {
+                const nakedPk = Utils_1.Utils.extractPK(data[k], meta.properties[k].targetMeta, true);
+                if (Utils_1.Utils.isObject(data[k]) && !nakedPk) {
                     return this.create(meta.properties[k].type, data[k], options);
                 }
                 const { newEntity, initialized, ...rest } = options;
-                return this.createReference(meta.properties[k].type, data[k], rest);
+                const target = this.createReference(meta.properties[k].type, nakedPk, rest);
+                return Reference_1.Reference.wrapReference(target, meta.properties[k]);
             }
             if (meta.properties[k]?.kind === enums_1.ReferenceKind.EMBEDDED && data[k]) {
                 /* istanbul ignore next */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.4.1-dev.17",
+  "version": "6.4.1-dev.19",
   "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.4.1-dev.17",
+    "mikro-orm": "6.4.1-dev.19",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -388,6 +388,7 @@ export declare class EntityMetadata<T = any> {
     addProperty(prop: Partial<EntityProperty<T>>, sync?: boolean): void;
     removeProperty(name: string, sync?: boolean): void;
     getPrimaryProps(): EntityProperty<T>[];
+    getPrimaryProp(): EntityProperty<T>;
     get tableName(): string;
     set tableName(name: string);
     sync(initIndexes?: boolean): void;

package/typings.js

@@ -50,6 +50,9 @@ class EntityMetadata {
     getPrimaryProps() {
         return this.primaryKeys.map(pk => this.properties[pk]);
     }
+    getPrimaryProp() {
+        return this.properties[this.primaryKeys[0]];
+    }
     get tableName() {
         return this.collection;
     }

package/unit-of-work/ChangeSet.js

@@ -31,6 +31,14 @@ class ChangeSet {
         else {
             this.primaryKey = this.originalEntity[this.meta.primaryKeys[0]];
         }
+        if (!this.meta.compositePK
+            && this.meta.getPrimaryProp().targetMeta?.compositePK
+            && typeof this.primaryKey === 'object'
+            && this.primaryKey !== null) {
+            this.primaryKey = this.meta.getPrimaryProp().targetMeta.primaryKeys.map(childPK => {
+                return this.primaryKey[childPK];
+            });
+        }
         if (object && this.primaryKey != null) {
             return Utils_1.Utils.primaryKeyToObject(this.meta, this.primaryKey);
         }

package/unit-of-work/UnitOfWork.js

@@ -774,7 +774,7 @@ class UnitOfWork {
     findExtraUpdates(changeSet, props) {
         for (const prop of props) {
             const ref = changeSet.entity[prop.name];
-            if (!ref) {
+            if (!ref || prop.deferMode === enums_1.DeferMode.INITIALLY_DEFERRED) {
                 continue;
             }
             if (Utils_1.Utils.isCollection(ref)) {

package/utils/EntityComparator.js

@@ -74,7 +74,19 @@ class EntityComparator {
         else {
             const pk = meta.primaryKeys[0];
             if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
-                lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) return entity${this.wrap(pk)}.__helper.getPrimaryKey();`);
+                lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) {`);
+                lines.push(`    const pk = entity${this.wrap(pk)}.__helper.getPrimaryKey();`);
+                if (meta.properties[pk].targetMeta.compositePK) {
+                    lines.push(`    if (typeof pk === 'object') {`);
+                    lines.push(`      return [`);
+                    for (const childPK of meta.properties[pk].targetMeta.primaryKeys) {
+                        lines.push(`        pk${this.wrap(childPK)},`);
+                    }
+                    lines.push(`      ];`);
+                    lines.push(`    }`);
+                }
+                lines.push(`    return pk;`);
+                lines.push(`  }`);
             }
             lines.push(`  return entity${this.wrap(pk)};`);
         }