ember-data-model-fragments 7.0.2 → 8.0.0

package/addon/cache/fragment-state-manager.js

@@ -1,10 +1,42 @@
 import { assert } from '@ember/debug';
 import { typeOf } from '@ember/utils';
 import { isArray } from '@ember/array';
-import { diffArray } from '@ember-data/model/-private';
 import { recordIdentifierFor } from '@ember-data/store';
+import { dependencySatisfies, macroCondition } from '@embroider/macros';
 import { getActualFragmentType, isFragment } from '../fragment';
 import isInstanceOfType from '../util/instance-of-type';
+import fragmentCacheFor from '../util/fragment-cache';
+
+/**
+ * Simple array diff implementation.
+ * Returns an object with `firstChangeIndex` indicating where the arrays first differ.
+ * Returns `{ firstChangeIndex: null }` if arrays are identical.
+ *
+ * @param {Array} oldArray
+ * @param {Array} newArray
+ * @returns {Object} Object with firstChangeIndex property
+ */
+function diffArray(oldArray, newArray) {
+  if (oldArray === newArray) {
+    return { firstChangeIndex: null };
+  }
+
+  if (!oldArray || !newArray) {
+    return { firstChangeIndex: 0 };
+  }
+
+  if (oldArray.length !== newArray.length) {
+    return { firstChangeIndex: Math.min(oldArray.length, newArray.length) };
+  }
+
+  for (let i = 0; i < oldArray.length; i++) {
+    if (oldArray[i] !== newArray[i]) {
+      return { firstChangeIndex: i };
+    }
+  }
+
+  return { firstChangeIndex: null };
+}
 
 /**
  * Behavior for single fragment attributes
@@ -429,6 +461,14 @@ export default class FragmentStateManager {
     return this.__storeWrapper._store;
   }
 
+  get cache() {
+    return fragmentCacheFor(this.store);
+  }
+
+  get innerCache() {
+    return this.cache.__innerCache;
+  }
+
   _identifierFor(fragmentOrRecord) {
     // Use recordIdentifierFor for records/fragments that already exist
     // This is the correct way to get an identifier from an instantiated record
@@ -441,36 +481,53 @@ export default class FragmentStateManager {
 
   _getBehaviors(identifier) {
     let behaviors = this.__behaviors.get(identifier.lid);
-    if (!behaviors) {
-      behaviors = Object.create(null);
-      const definitions = this.__storeWrapper
-        .getSchemaDefinitionService()
-        .attributesDefinitionFor(identifier);
-      for (const [key, definition] of Object.entries(definitions)) {
-        if (!definition.isFragment) {
-          continue;
-        }
-        switch (definition.kind) {
-          case 'fragment-array':
-            behaviors[key] = new FragmentArrayBehavior(
-              this,
-              identifier,
-              definition,
-            );
-            break;
-          case 'fragment':
-            behaviors[key] = new FragmentBehavior(this, identifier, definition);
-            break;
-          case 'array':
-            behaviors[key] = new ArrayBehavior(this, identifier, definition);
-            break;
-          default:
-            assert(`Unsupported fragment type: ${definition.kind}`);
-            break;
-        }
+    if (behaviors) {
+      return behaviors;
+    }
+
+    behaviors = Object.create(null);
+
+    const definitions = this.__storeWrapper
+      .getSchemaDefinitionService()
+      .attributesDefinitionFor(identifier);
+
+    for (const [key, definition] of Object.entries(definitions)) {
+      // Support both metadata formats:
+      // - ember-data 4.12: definition.isFragment (direct property on meta)
+      // - ember-data 4.13: definition.options.isFragment (transformed by FragmentSchemaService)
+      const isFragmentAttr =
+        definition.isFragment || definition.options?.isFragment;
+
+      if (!isFragmentAttr) {
+        continue;
+      }
+
+      // Get the fragment kind from the appropriate location:
+      // - ember-data 4.12: definition.kind (original location)
+      // - ember-data 4.13: definition.options.fragmentKind (preserved by FragmentSchemaService)
+      const fragmentKind = definition.options?.fragmentKind || definition.kind;
+
+      switch (fragmentKind) {
+        case 'fragment-array':
+          behaviors[key] = new FragmentArrayBehavior(
+            this,
+            identifier,
+            definition,
+          );
+          break;
+        case 'fragment':
+          behaviors[key] = new FragmentBehavior(this, identifier, definition);
+          break;
+        case 'array':
+          behaviors[key] = new ArrayBehavior(this, identifier, definition);
+          break;
+        default:
+          assert(`Unsupported fragment type: ${fragmentKind}`);
+          break;
       }
-      this.__behaviors.set(identifier.lid, behaviors);
     }
+
+    this.__behaviors.set(identifier.lid, behaviors);
     return behaviors;
   }
 
@@ -621,6 +678,119 @@ export default class FragmentStateManager {
     });
   }
 
+  /**
+   * Returns true if the given attribute value is, or contains, an instantiated
+   * Fragment. Used by FragmentCache.clientDidCreate to route fragment-instance
+   * initialization (from `store.createRecord(type, { key: fragmentInstance })`)
+   * through the adopt-fragment path instead of pushFragmentData (which only
+   * accepts raw object/null canonical data).
+   */
+  valueContainsFragmentInstance(value) {
+    if (value == null) {
+      return false;
+    }
+    if (isFragment(value)) {
+      return true;
+    }
+    if (isArray(value)) {
+      return value.some((item) => isFragment(item));
+    }
+    return false;
+  }
+
+  /**
+   * Adopt an existing fragment instance (or array of fragment instances) for the
+   * given owner identifier + key. This is used by the client-created path
+   * (`createRecord(...props)`) when consumers pass already-instantiated
+   * fragments rather than raw object data.
+   *
+   * Returns the canonical fragment identifier value to be stored in the
+   * fragment data map (a single identifier for `fragment` kind, an array of
+   * identifiers for `fragment-array` kind).
+   *
+   * Asserts when the provided value does not match the fragment kind/type
+   * declared on the owner's schema.
+   */
+  adoptFragmentForKey(ownerIdentifier, key, value) {
+    const behaviors = this._getBehaviors(ownerIdentifier);
+    const behavior = behaviors[key];
+    assert(
+      `Attribute '${key}' for model '${ownerIdentifier.type}' must be a fragment`,
+      behavior != null,
+    );
+
+    const definition = behavior.definition;
+    const isArrayBehavior = behavior instanceof FragmentArrayBehavior;
+    const isSingleFragmentBehavior = behavior instanceof FragmentBehavior;
+
+    // Only single-fragment and fragment-array behaviors support adopting
+    // fragment instances. Plain array behavior should never receive a
+    // fragment instance.
+    if (!isSingleFragmentBehavior && !isArrayBehavior) {
+      return undefined;
+    }
+
+    if (isSingleFragmentBehavior) {
+      if (value === null) {
+        return null;
+      }
+      if (!isFragment(value)) {
+        return undefined;
+      }
+      assert(
+        `The value provided for fragment attribute '${key}' must be a '${definition.modelName}' fragment`,
+        isInstanceOfType(
+          this.__storeWrapper._store.modelFor(definition.modelName),
+          value,
+        ),
+      );
+      const fragmentIdentifier = this._identifierFor(value);
+      this.setFragmentOwner(fragmentIdentifier, ownerIdentifier, key);
+      return fragmentIdentifier;
+    }
+
+    // fragment-array behavior
+    if (value === null) {
+      return null;
+    }
+    if (!isArray(value)) {
+      return undefined;
+    }
+    // Only treat the value as fragment-instance input if at least one entry is
+    // a fragment instance. Otherwise let the regular pushData path handle it
+    // (raw object array).
+    if (!value.some((item) => isFragment(item))) {
+      return undefined;
+    }
+    return value.map((item) => {
+      if (isFragment(item)) {
+        assert(
+          `The value provided for fragment array attribute '${key}' can only include '${definition.modelName}' fragments`,
+          isInstanceOfType(
+            this.__storeWrapper._store.modelFor(definition.modelName),
+            item,
+          ),
+        );
+        const fragmentIdentifier = this._identifierFor(item);
+        this.setFragmentOwner(fragmentIdentifier, ownerIdentifier, key);
+        return fragmentIdentifier;
+      }
+      // Raw object entry mixed in with fragments - create a new fragment for it.
+      return this._newFragmentIdentifier(ownerIdentifier, definition, item);
+    });
+  }
+
+  /**
+   * Set canonical fragment data for a key on an owner identifier. Used by the
+   * client-created path after adopting fragment instances so subsequent
+   * getFragment/getCurrentState calls find the canonical value without going
+   * through pushData (which only accepts raw object/null canonical data).
+   */
+  setCanonicalFragmentValue(identifier, key, value) {
+    const fragmentData = this._getFragmentDataMap(identifier);
+    fragmentData[key] = value;
+  }
+
   _newFragmentIdentifierForKey(identifier, key, attributes) {
     const behaviors = this._getBehaviors(identifier);
     const behavior = behaviors[key];
@@ -645,27 +815,21 @@ export default class FragmentStateManager {
     const fragmentIdentifier =
       this.store.identifierCache.createIdentifierForNewRecord({ type });
     this.setFragmentOwner(fragmentIdentifier, ownerIdentifier, definition.name);
-    // Initialize the fragment in the cache - use clientDidCreate to set up
-    // the record's internal state, then upsert to set canonical data
-    this.store.cache.__innerCache.clientDidCreate(fragmentIdentifier, {});
-    // Push the attributes to the inner cache
+    this.innerCache.clientDidCreate(fragmentIdentifier, {});
+
     if (attributes) {
-      this.store.cache.__innerCache.upsert(
-        fragmentIdentifier,
-        { attributes },
-        false,
-      );
+      this.innerCache.upsert(fragmentIdentifier, { attributes }, false);
     }
+
     // Process any nested fragment attributes
     this.pushFragmentData(fragmentIdentifier, { attributes }, false);
     return fragmentIdentifier;
   }
 
   hasChangedAttributes(identifier) {
-    // Check both fragment state and inner cache state
     return (
       this.hasChangedFragments(identifier) ||
-      this.store.cache.__innerCache.hasChangedAttrs(identifier)
+      this.innerCache.hasChangedAttrs(identifier)
     );
   }
 
@@ -675,7 +839,7 @@ export default class FragmentStateManager {
     // Explicitly return boolean to ensure false instead of undefined
     return Boolean(
       (fragments && Object.keys(fragments).length > 0) ||
-        (inFlight && Object.keys(inFlight).length > 0),
+      (inFlight && Object.keys(inFlight).length > 0),
     );
   }
 
@@ -684,14 +848,16 @@ export default class FragmentStateManager {
     const definitions = this.__storeWrapper
       .getSchemaDefinitionService()
       .attributesDefinitionFor(identifier);
-    const cache = this.store.cache.__innerCache;
+    const cache = this.innerCache;
 
     // Get changed attrs from inner cache to find original values for dirty attrs
     const changedAttrs = cache.changedAttrs(identifier);
 
     // Get canonical values for all attributes
     for (const [key, definition] of Object.entries(definitions)) {
-      if (definition.isFragment) {
+      const isFragmentAttr =
+        definition.isFragment || definition.options?.isFragment;
+      if (isFragmentAttr) {
         // Fragment attributes - use behavior's canonicalState
         const behaviors = this._getBehaviors(identifier);
         const behavior = behaviors[key];
@@ -723,14 +889,16 @@ export default class FragmentStateManager {
 
     // Get current values for all attributes
     for (const [key, definition] of Object.entries(definitions)) {
-      if (definition.isFragment) {
+      const isFragmentAttr =
+        definition.isFragment || definition.options?.isFragment;
+      if (isFragmentAttr) {
         // Fragment attributes - use behavior's currentState
         const behaviors = this._getBehaviors(identifier);
         const behavior = behaviors[key];
         result[key] = behavior.currentState(this.getFragment(identifier, key));
       } else {
         // Regular attributes - get from inner cache
-        const cache = this.store.cache.__innerCache;
+        const cache = this.innerCache;
         result[key] = cache.getAttr(identifier, key);
       }
     }
@@ -796,7 +964,7 @@ export default class FragmentStateManager {
     return changedKeys;
   }
 
-  pushFragmentData(identifier, data, calculateChange) {
+  pushFragmentData(identifier, data, calculateChange, shouldNotify = true) {
     let changedFragmentKeys;
     const behaviors = this._getBehaviors(identifier);
     const subFragmentsToProcess = [];
@@ -823,23 +991,28 @@ export default class FragmentStateManager {
         newCanonicalFragments[key] = behavior.pushData(current, canonical);
       });
 
-      if (calculateChange) {
-        changedFragmentKeys = this._changedFragmentKeys(
-          identifier,
-          newCanonicalFragments,
-        );
-      }
+      // Always calculate which keys changed so we can notify observers
+      changedFragmentKeys = this._changedFragmentKeys(
+        identifier,
+        newCanonicalFragments,
+      );
 
       Object.assign(fragmentData, newCanonicalFragments);
-      changedFragmentKeys?.forEach((key) => {
-        // Notify the storeWrapper that the fragment attribute changed
-        this.__storeWrapper.notifyChange(identifier, 'attributes', key);
-        const arrayCache = this.__fragmentArrayCache.get(identifier.lid);
-        arrayCache?.[key]?.notify();
-      });
+
+      if (shouldNotify) {
+        // Notify the storeWrapper that fragment attributes changed when this is
+        // an update to existing state. For clientDidCreate initialization we
+        // skip notification so initial props don't look like post-consumption
+        // mutations during first render in WarpDrive 5.8.
+        changedFragmentKeys.forEach((key) => {
+          this.__storeWrapper.notifyChange(identifier, 'attributes', key);
+          const arrayCache = this.__fragmentArrayCache.get(identifier.lid);
+          arrayCache?.[key]?.notify();
+        });
+      }
     }
 
-    return changedFragmentKeys || [];
+    return calculateChange ? changedFragmentKeys || [] : [];
   }
 
   willCommitFragments(identifier) {
@@ -968,6 +1141,16 @@ export default class FragmentStateManager {
   }
 
   unloadFragments(identifier) {
+    // Guard against store being destroyed during teardown
+    if (this.store.isDestroying || this.store.isDestroyed) {
+      // Just clear our internal data structures
+      this.__fragments.delete(identifier.lid);
+      this.__inFlightFragments.delete(identifier.lid);
+      this.__fragmentData.delete(identifier.lid);
+      this.__fragmentArrayCache.delete(identifier.lid);
+      return;
+    }
+
     const behaviors = this._getBehaviors(identifier);
     const fragments = this.__fragments.get(identifier.lid) || {};
     const inFlight = this.__inFlightFragments.get(identifier.lid) || {};
@@ -1059,14 +1242,38 @@ export default class FragmentStateManager {
 
   _notifyStateChange(identifier, key) {
     this.__storeWrapper.notifyChange(identifier, 'attributes', key);
+    if (macroCondition(dependencySatisfies('ember-data', '<5.8.0'))) {
+      // 5.8+ already wires cache notifications into reactivity, and directly notifying
+      // the record can trip mutation-after-consumption assertions during initial render.
+      if (key) {
+        try {
+          const record = this.store._instanceCache.getRecord(identifier);
+          if (record && typeof record.notifyPropertyChange === 'function') {
+            record.notifyPropertyChange(key);
+            // Also clear any cached value by directly removing from Ember's cache
+            // This is needed because computed setters cache their return value
+            // and notifyPropertyChange alone may not clear it in all Ember versions
+            const meta = record.constructor.metaForProperty?.(key);
+            if (meta) {
+              // Force the computed property to re-evaluate by clearing its cache entry
+              const cache = record['__ember_meta__']?.peekCache?.(key);
+              if (cache !== undefined) {
+                record['__ember_meta__']?.deleteFromCache?.(key);
+              }
+            }
+          }
+        } catch {
+          // Record may not be instantiated yet
+        }
+      }
+    }
   }
 
   // Fragment lifecycle methods using cache API directly
   _fragmentPushData(identifier, data) {
     // Push data to the cache for the fragment
     if (data?.attributes) {
-      // Use the inner cache's upsert for the fragment's own attributes
-      const cache = this.store.cache.__innerCache;
+      const cache = this.innerCache;
       cache.upsert(identifier, data, false);
       // Notify that attributes changed so computed properties are invalidated
       for (const key of Object.keys(data.attributes)) {
@@ -1079,14 +1286,16 @@ export default class FragmentStateManager {
 
   _fragmentWillCommit(identifier) {
     // Capture the current attribute values before commit - these are what will be committed
-    const innerCache = this.store.cache.__innerCache;
+    const innerCache = this.innerCache;
     const definitions = this.__storeWrapper
       .getSchemaDefinitionService()
       .attributesDefinitionFor(identifier);
 
     const inFlightValues = {};
     for (const [key, definition] of Object.entries(definitions)) {
-      if (!definition.isFragment) {
+      const isFragmentAttr =
+        definition.isFragment || definition.options?.isFragment;
+      if (!isFragmentAttr) {
         // getAttr returns dirty value if exists, else canonical
         inFlightValues[key] = innerCache.getAttr(identifier, key);
       }
@@ -1095,7 +1304,7 @@ export default class FragmentStateManager {
 
     // Signal to cache that fragment is being committed
     this.willCommitFragments(identifier);
-    this.store.cache.__innerCache.willCommit(identifier);
+    innerCache.willCommit(identifier);
   }
 
   _fragmentDidCommit(identifier, data) {
@@ -1113,7 +1322,7 @@ export default class FragmentStateManager {
     // 4. Rollback to clear in-flight state
     // 5. Upsert the committed values as new canonical
     // 6. Re-apply any new dirty changes that were made during in-flight
-    const innerCache = this.store.cache.__innerCache;
+    const innerCache = this.innerCache;
 
     // Get schema for non-fragment attributes
     const definitions = this.__storeWrapper
@@ -1127,7 +1336,9 @@ export default class FragmentStateManager {
     // Get current values (may include new dirty changes made during in-flight)
     const currentValues = {};
     for (const [key, definition] of Object.entries(definitions)) {
-      if (!definition.isFragment) {
+      const isFragmentAttr =
+        definition.isFragment || definition.options?.isFragment;
+      if (!isFragmentAttr) {
         currentValues[key] = innerCache.getAttr(identifier, key);
       }
     }
@@ -1140,7 +1351,9 @@ export default class FragmentStateManager {
     const newDirtyAttrs = {};
 
     for (const [key, definition] of Object.entries(definitions)) {
-      if (definition.isFragment) continue;
+      const isFragmentAttr =
+        definition.isFragment || definition.options?.isFragment;
+      if (isFragmentAttr) continue;
 
       // Determine the new canonical value
       const canonicalValue =
@@ -1199,13 +1412,13 @@ export default class FragmentStateManager {
   _fragmentRollbackAttributes(identifier) {
     // Rollback fragment attributes
     this.rollbackFragments(identifier);
-    this.store.cache.__innerCache.rollbackAttrs(identifier);
+    this.innerCache.rollbackAttrs(identifier);
   }
 
   _fragmentCommitWasRejected(identifier) {
     // Signal that commit was rejected
     this.commitWasRejectedFragments(identifier);
-    this.store.cache.__innerCache.commitWasRejected(identifier);
+    this.innerCache.commitWasRejected(identifier);
   }
 
   _fragmentUnloadRecord(identifier) {
@@ -1223,7 +1436,7 @@ export default class FragmentStateManager {
       // Fragment may already be unloaded or destroyed
       // Fall back to just clearing the inner cache
       try {
-        this.store.cache.__innerCache.unloadRecord(identifier);
+        this.innerCache.unloadRecord(identifier);
       } catch {
         // May already be unloaded
       }