@mikro-orm/core 7.2.0-dev.1 → 7.2.0-dev.11

package/utils/TransactionManager.js

@@ -169,19 +169,52 @@ export class TransactionManager {
                 if (!wrapped.__initialized && parentWrapped.__initialized) {
                     continue;
                 }
-                parentWrapped.__data = wrapped.__data;
-                parentWrapped.__originalEntityData = wrapped.__originalEntityData;
+                const parentData = parentWrapped.__data;
+                const parentSnapshot = parentWrapped.__originalEntityData;
+                parentWrapped.__data = { ...wrapped.__data };
+                const originalEntityData = { ...wrapped.__originalEntityData };
                 for (const prop of meta.hydrateProps) {
+                    const tracked = this.getTrackedValues(prop, entity[prop.name]);
+                    // the fork entity can be partially loaded, and propagating a property it does not know about
+                    // would clobber the parent state, so we restore both its value and its snapshot entries
+                    if (!tracked.every(([key, value]) => value !== undefined || wrapped.__loadedProperties.has(key))) {
+                        this.restore(parentWrapped.__data, parentData, prop.name);
+                        tracked.forEach(([key]) => this.restore(originalEntityData, parentSnapshot, key));
+                        continue;
+                    }
                     if (prop.kind === ReferenceKind.SCALAR) {
                         parentEntity[prop.name] = entity[prop.name];
                     }
                 }
+                if (wrapped.__originalEntityData) {
+                    parentWrapped.__originalEntityData = originalEntityData;
+                }
             }
             else {
                 parentUoW.merge(entity, new Set([entity]));
             }
         }
     }
+    /**
+     * Returns the property names a given property is tracked and snapshotted under, paired with their values.
+     * Inlined embeddables are hydrated as a single object, so only their leaves tell whether it is complete.
+     */
+    getTrackedValues(prop, value) {
+        if (prop.kind === ReferenceKind.EMBEDDED && !prop.object) {
+            return Object.values(prop.embeddedProps).flatMap(child => {
+                return this.getTrackedValues(child, value?.[child.embedded[1]]);
+            });
+        }
+        return [[prop.name, value]];
+    }
+    restore(target, source, key) {
+        if (source && key in source) {
+            target[key] = source[key];
+        }
+        else {
+            delete target[key];
+        }
+    }
     /**
      * Registers a deletion handler to unset entity identities after flush.
      */

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.2.0-dev.1';
+    static #ORM_VERSION = '7.2.0-dev.11';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -402,7 +402,8 @@ export class Utils {
     static getCompositeKeyHash(data, meta, convertCustomTypes = false, platform, flat = false) {
         let pks = this.getCompositeKeyValue(data, meta, convertCustomTypes, platform);
         if (flat) {
-            pks = Utils.flatten(pks);
+            // deep flatten, nested composite PKs produce nested arrays that would be comma-joined by the hash
+            pks = Utils.flatten(pks, true);
         }
         return Utils.getPrimaryKeyHash(pks);
     }
@@ -462,7 +463,9 @@ export class Utils {
     }
     static getPrimaryKeyCond(entity, primaryKeys) {
         const cond = primaryKeys.reduce((o, pk) => {
-            o[pk] = Utils.extractPK(entity[pk]);
+            const value = entity[pk];
+            // FKs pointing to a composite PK are arrays, which `extractPK` rejects
+            o[pk] = Utils.isPrimaryKey(value, true) ? value : Utils.extractPK(value);
             return o;
         }, {});
         if (Object.values(cond).some(v => v === null)) {

package/utils/clone.js

@@ -112,6 +112,12 @@ export function clone(parent, respectCustomCloneMethod = true) {
             });
         }
         for (const i in parent) {
+            // an own `__proto__` key (as produced by `JSON.parse`) has no own counterpart on
+            // `child` to shadow the inherited accessor, so assigning it would replace the
+            // clone's prototype instead of copying the value
+            if (i === '__proto__') {
+                continue;
+            }
             let attrs;
             if (proto) {
                 attrs = getPropertyDescriptor(proto, i);

package/utils/env-vars.js

@@ -79,6 +79,7 @@ export function loadEnvironmentVars() {
     read2('silent', bool);
     read2('emit');
     read2('snapshot', bool);
+    read2('snapshotOnMigrate', bool);
     read2('snapshotName');
     cleanup(ret, 'migrations');
     ret.schemaGenerator = {};