ember-data-model-fragments 7.0.3 → 8.0.0

package/.release-plan.json

@@ -1,18 +1,30 @@
 {
   "solution": {
     "ember-data-model-fragments": {
-      "impact": "patch",
-      "oldVersion": "7.0.2",
-      "newVersion": "7.0.3",
+      "impact": "major",
+      "oldVersion": "7.0.3",
+      "newVersion": "8.0.0",
       "tagName": "latest",
       "constraints": [
+        {
+          "impact": "major",
+          "reason": "Appears in changelog section :boom: Breaking Change"
+        },
+        {
+          "impact": "minor",
+          "reason": "Appears in changelog section :rocket: Enhancement"
+        },
         {
           "impact": "patch",
           "reason": "Appears in changelog section :bug: Bug Fix"
+        },
+        {
+          "impact": "patch",
+          "reason": "Appears in changelog section :house: Internal"
         }
       ],
       "pkgJSONPath": "./package.json"
     }
   },
-  "description": "## Release (2026-02-27)\n\n* ember-data-model-fragments 7.0.3 (patch)\n\n#### :bug: Bug Fix\n* `ember-data-model-fragments`\n  * [#514](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/514) Guard fragment access on destroyed/unloaded records ([@deanmarano](https://github.com/deanmarano))\n\n#### Committers: 1\n- Dean Marano ([@deanmarano](https://github.com/deanmarano))\n"
+  "description": "## Release (2026-04-28)\n\n* ember-data-model-fragments 8.0.0 (major)\n\n#### :boom: Breaking Change\n* `ember-data-model-fragments`\n  * [#507](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/507) Support ember-data 4.13.x and require extending FragmentStore/FragmentSerializer ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n\n#### :rocket: Enhancement\n* `ember-data-model-fragments`\n  * [#523](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/523) Add ember-data 5.x support ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n  * [#521](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/521) Import Comparable directly in fragments ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n\n#### :bug: Bug Fix\n* `ember-data-model-fragments`\n  * [#526](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/526) Fix fragmentSerialize writing to wrong location for fragment-only models ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n  * [#525](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/525) Fix createRecord crash when initializing fragment attrs with fragment instances ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n  * [#524](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/524) Fix fragment serializer resolution falling back to application serializer ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n\n#### :house: Internal\n* `ember-data-model-fragments`\n  * [#522](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/522) Update release-plan ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n  * [#520](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/520) Remove unused legacy record-data implementation ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n  * [#519](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/519) Remove old ember-data version checks ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n  * [#517](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/517) Various tech debt cleanup ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n\n#### Committers: 1\n- Robbie Wagner ([@RobbieTheWagner](https://github.com/RobbieTheWagner))\n"
 }

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## Release (2026-04-28)
+
+* ember-data-model-fragments 8.0.0 (major)
+
+#### :boom: Breaking Change
+* `ember-data-model-fragments`
+  * [#507](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/507) Support ember-data 4.13.x and require extending FragmentStore/FragmentSerializer ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+
+#### :rocket: Enhancement
+* `ember-data-model-fragments`
+  * [#523](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/523) Add ember-data 5.x support ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+  * [#521](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/521) Import Comparable directly in fragments ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+
+#### :bug: Bug Fix
+* `ember-data-model-fragments`
+  * [#526](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/526) Fix fragmentSerialize writing to wrong location for fragment-only models ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+  * [#525](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/525) Fix createRecord crash when initializing fragment attrs with fragment instances ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+  * [#524](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/524) Fix fragment serializer resolution falling back to application serializer ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+
+#### :house: Internal
+* `ember-data-model-fragments`
+  * [#522](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/522) Update release-plan ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+  * [#520](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/520) Remove unused legacy record-data implementation ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+  * [#519](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/519) Remove old ember-data version checks ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+  * [#517](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/517) Various tech debt cleanup ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+
+#### Committers: 1
+- Robbie Wagner ([@RobbieTheWagner](https://github.com/RobbieTheWagner))
+
 ## Release (2026-02-27)
 
 * ember-data-model-fragments 7.0.3 (patch)

package/README.md

@@ -20,20 +20,7 @@ Use the following table to decide which version of this project to use with your
 | >= v3.13.x < v3.27.x | v5.x            | 12+     |
 | >= v3.28.x < v4.7.x  | v6.0.x          | 14+     |
 | v4.12.x              | v7.x            | 18+     |
-
-### Upgrading to ember-data 4.12
-
-When using ember-data 4.12, you must add the following entry to your app's deprecation workflow to allow the app to boot. This addon uses `reopenClass` internally, which ember-data 4.12 deprecates:
-
-```javascript
-// config/deprecation-workflow.js
-self.deprecationWorkflow = self.deprecationWorkflow || {};
-self.deprecationWorkflow.config = {
-  workflow: [
-    { handler: "silence", matchId: "ember-data:deprecate-model-reopenclass" },
-  ],
-};
-```
+| v4.12.x < v6.x       | v8.x            | 20.19+  |
 
 ## Installation
 
@@ -51,6 +38,36 @@ $ ember generate fragment foo someAttr:string anotherAttr:boolean
 
 Which will create the module `app/models/foo.js` which exports a `Fragment` class with the given attributes.
 
+## Setup
+
+This addon requires you to extend the provided `FragmentStore` and a fragment-aware serializer in your application.
+
+### Store
+
+Create or update your application's store service to extend `FragmentStore`:
+
+```javascript
+// app/services/store.js
+
+import FragmentStore from "ember-data-model-fragments/store";
+
+export default class Store extends FragmentStore {}
+```
+
+### Serializer
+
+Create or update your application serializer to extend one of the fragment-aware serializers:
+
+```javascript
+// app/serializers/application.js
+
+import FragmentSerializer from "ember-data-model-fragments/serializer";
+
+export default class ApplicationSerializer extends FragmentSerializer {}
+```
+
+See the [Serialization](#serializing) section for more options if you're using `RESTSerializer` or `JSONAPISerializer`.
+
 ## Example
 
 ```javascript
@@ -297,42 +314,89 @@ export default class NameSerializer extends JSONSerializer {
 }
 ```
 
-Since fragment deserialization uses the value of a single attribute in the parent model, the `normalizeResponse` method of the serializer is never used. And since the attribute value is not a full-fledged [JSON API](http://jsonapi.org/) response, `JSONAPISerializer` cannot be used with fragments. Because of this, auto-generated fragment serializers **do not use the application serializer** and instead use `JSONSerializer`.
+Since fragment deserialization uses the value of a single attribute in the parent model, the `normalizeResponse` method of the serializer is never used. The fragment value is not a full-fledged [JSON:API](http://jsonapi.org/) resource, so a `JSONAPISerializer` cannot be used to normalize a fragment directly. The addon takes care of this for you (see [Fragment serializer resolution](#fragment-serializer-resolution) below) — your application serializer can still be `FragmentJSONAPISerializer` or `FragmentRESTSerializer`.
 
-If common logic must be added to auto-generated fragment serializers, apps can register a custom `serializer:-fragment` with the application in an initializer.
+Your application serializer should extend one of the fragment-aware serializers provided by this addon:
 
 ```javascript
-// app/serializers/fragment.js
+// app/serializers/application.js
 
-import JSONSerializer from "@ember-data/serializer/json";
+import FragmentSerializer from "ember-data-model-fragments/serializer";
 
-export default class FragmentSerializer extends JSONSerializer {}
+export default class ApplicationSerializer extends FragmentSerializer {}
 ```
 
+If you're using `RESTSerializer`, use `FragmentRESTSerializer` instead:
+
 ```javascript
-// app/initializers/fragment-serializer.js
+// app/serializers/application.js
 
-import FragmentSerializer from "../serializers/fragment";
+import { FragmentRESTSerializer } from "ember-data-model-fragments/serializer";
+
+export default class ApplicationSerializer extends FragmentRESTSerializer {}
+```
+
+If you're using `JSONAPISerializer`, use `FragmentJSONAPISerializer`:
+
+```javascript
+// app/serializers/application.js
 
-export function initialize(application) {
-  application.register("serializer:-fragment", FragmentSerializer);
+import { FragmentJSONAPISerializer } from "ember-data-model-fragments/serializer";
+
+export default class ApplicationSerializer extends FragmentJSONAPISerializer {}
+```
+
+### Fragment serializer resolution
+
+When this addon needs to (de)serialize a fragment, it looks up a serializer for that fragment's model name in this order:
+
+1. **A serializer registered for the specific fragment type** — e.g. `app/serializers/name.js` for an `MF.fragment("name")` attribute. Use this to customize how a single fragment type is (de)serialized (see the `NameSerializer` example above).
+2. **An app-wide fragment serializer registered as `serializer:-fragment`** — use this if you want every fragment in your app to share custom behavior without registering a separate serializer for each fragment type.
+3. **The bundled `FragmentSerializer`** (a `JSONSerializer`-based serializer) — registered automatically the first time it is needed. This is what powers the "just works" behavior for apps that don't customize fragment serialization.
+
+Fragment lookups never fall back to `serializer:application`. This is intentional: a typical application serializer is a `RESTSerializer` or `JSONAPISerializer`, neither of which can normalize a raw fragment hash. Your application serializer therefore remains free to be `FragmentRESTSerializer` or `FragmentJSONAPISerializer`, while fragments themselves are always handled by a JSON serializer.
+
+#### Customizing serialization for one fragment type
+
+```javascript
+// app/serializers/name.js
+
+import FragmentSerializer from "ember-data-model-fragments/serializer";
+
+export default class NameSerializer extends FragmentSerializer {
+  attrs = {
+    given: "first",
+    family: "last",
+  };
 }
+```
 
-export default {
-  name: "fragment-serializer",
-  initialize: initialize,
-};
+#### Customizing serialization for every fragment
+
+```javascript
+// app/serializers/-fragment.js
+
+import FragmentSerializer from "ember-data-model-fragments/serializer";
+
+export default class AppFragmentSerializer extends FragmentSerializer {
+  keyForAttribute(key) {
+    // e.g. snake_case fragment attribute keys app-wide
+    return key.replace(/([A-Z])/g, "_$1").toLowerCase();
+  }
+}
 ```
 
+Per-fragment-type serializers (`app/serializers/<fragment-name>.js`) take precedence over `serializer:-fragment`.
+
 If custom serialization of the owner record is needed, fragment [snapshots](http://emberjs.com/api/data/classes/DS.Snapshot.html) can be accessed using the [`Snapshot#attr`](http://emberjs.com/api/data/classes/DS.Snapshot.html#method_attr) method. Note that this differs from how relationships are accessed on snapshots (using `belongsTo`/`hasMany` methods):
 
 ```javascript
 // apps/serializers/person.js
 // Fragment snapshots are accessed using `snapshot.attr()`
 
-import JSONSerializer from "@ember-data/serializer/json";
+import FragmentSerializer from "ember-data-model-fragments/serializer";
 
-export default JSONSerializer.extend({
+export default class PersonSerializer extends FragmentSerializer {
   serialize(snapshot, options) {
     const json = super.serialize(...arguments);
 
@@ -355,8 +419,8 @@ export default JSONSerializer.extend({
     json.title_count = titlesSnapshot.length;
 
     return json;
-  },
-});
+  }
+}
 ```
 
 ## Nesting

package/addon/array/fragment.js

@@ -1,5 +1,6 @@
 import { assert } from '@ember/debug';
 import { typeOf } from '@ember/utils';
+import { dependencySatisfies, macroCondition } from '@embroider/macros';
 import StatefulArray from './stateful';
 import { isFragment, setFragmentOwner } from '../fragment';
 import isInstanceOfType from '../util/instance-of-type';
@@ -166,10 +167,28 @@ const FragmentArray = StatefulArray.extend({
       this.key,
       props,
     );
+    if (macroCondition(dependencySatisfies('ember-data', '>=5.8.0'))) {
+      const fragment = this.store._instanceCache.getRecord(fragmentIdentifier);
+      const definitions = this.store
+        .getSchemaDefinitionService()
+        .fields(fragmentIdentifier);
+
+      if (props) {
+        for (const [key, value] of Object.entries(props)) {
+          if (!definitions.has(key)) {
+            fragment.set(key, value);
+          }
+        }
+      }
+
+      return this.pushObject(fragment);
+    }
+
     const fragment = this.store._instanceCache.getRecord(
       fragmentIdentifier,
       props,
     );
+
     return this.pushObject(fragment);
   },
 });

package/addon/array/stateful.js

@@ -2,24 +2,13 @@ import EmberObject, { get } from '@ember/object';
 import { isArray } from '@ember/array';
 import MutableArray from '@ember/array/mutable';
 import { assert } from '@ember/debug';
-import { diffArray } from '@ember-data/model/-private';
 import { copy } from '../util/copy';
-import { gte } from 'ember-compatibility-helpers';
+import fragmentCacheFor from '../util/fragment-cache';
 
 /**
   @module ember-data-model-fragments
 */
 
-/**
- * Whether the current version of ember supports array observers.
- * Array observers were deprecated in ember 3.26 and removed in 4.0.
- * @see https://deprecations.emberjs.com/v3.x#toc_array-observers
- * @see https://github.com/emberjs/ember.js/pull/19833
- * @type {boolean}
- * @private
- */
-export const HAS_ARRAY_OBSERVERS = !gte('4.0.0');
-
 /**
   A state-aware array that is tied to an attribute of a `DS.Model` instance.
 
@@ -73,7 +62,7 @@ const StatefulArray = EmberObject.extend(MutableArray, {
     @private
   */
   get cache() {
-    return this.store.cache;
+    return fragmentCacheFor(this.store);
   },
 
   init() {
@@ -88,14 +77,10 @@ const StatefulArray = EmberObject.extend(MutableArray, {
 
   notify() {
     this._isDirty = true;
-    if (HAS_ARRAY_OBSERVERS && this.hasArrayObservers && !this._hasNotified) {
-      this.retrieveLatest();
-    } else {
-      this._hasNotified = true;
-      this.notifyPropertyChange('[]');
-      this.notifyPropertyChange('firstObject');
-      this.notifyPropertyChange('lastObject');
-    }
+    this._hasNotified = true;
+    this.notifyPropertyChange('[]');
+    this.notifyPropertyChange('firstObject');
+    this.notifyPropertyChange('lastObject');
   },
 
   get length() {
@@ -181,30 +166,9 @@ const StatefulArray = EmberObject.extend(MutableArray, {
 
     this._isDirty = false;
     this._isUpdating = true;
-    if (HAS_ARRAY_OBSERVERS && this.hasArrayObservers && !this._hasNotified) {
-      // diff to find changes
-      const diff = diffArray(this.currentState, currentState);
-      // it's null if no change found
-      if (diff.firstChangeIndex !== null) {
-        // we found a change
-        this.arrayContentWillChange(
-          diff.firstChangeIndex,
-          diff.removedCount,
-          diff.addedCount,
-        );
-        this._length = currentState.length;
-        this.currentState = currentState;
-        this.arrayContentDidChange(
-          diff.firstChangeIndex,
-          diff.removedCount,
-          diff.addedCount,
-        );
-      }
-    } else {
-      this._hasNotified = false;
-      this._length = currentState.length;
-      this.currentState = currentState;
-    }
+    this._hasNotified = false;
+    this._length = currentState.length;
+    this.currentState = currentState;
     this._isUpdating = false;
   },
 

package/addon/attributes/array.js

@@ -3,6 +3,7 @@ import { isArray } from '@ember/array';
 import { assert } from '@ember/debug';
 import { recordIdentifierFor } from '@ember-data/store';
 import metaTypeFor from '../util/meta-type-for';
+import fragmentCacheFor from '../util/fragment-cache';
 import StatefulArray from '../array/stateful';
 
 /**
@@ -52,51 +53,59 @@ export default function array(type, options) {
     options,
   };
 
-  // eslint-disable-next-line ember/require-computed-property-dependencies
-  return computed({
-    get(key) {
-      if (this.isDestroying || this.isDestroyed) {
-        return null;
-      }
-      const identifier = recordIdentifierFor(this);
-      const cache = this.store.cache;
-      if (cache.getFragment(identifier, key) === null) {
-        return null;
-      }
-      let array = cache.getFragmentArrayCache(identifier, key);
-      if (!array) {
-        array = StatefulArray.create({
-          store: this.store,
-          identifier,
-          key,
-        });
-        cache.setFragmentArrayCache(identifier, key, array);
-      }
-      return array;
+  // Use computed with a dependency on hasDirtyAttributes which changes on rollback
+  // This ensures the computed property is re-evaluated when dirty state changes
+  return computed(
+    'currentState',
+    'hasDirtyAttributes',
+    'isDestroyed',
+    'isDestroying',
+    'store.cache',
+    {
+      get(key) {
+        if (this.isDestroying || this.isDestroyed) {
+          return null;
+        }
+        const identifier = recordIdentifierFor(this);
+        const cache = fragmentCacheFor(this.store);
+        if (cache.getFragment(identifier, key) === null) {
+          return null;
+        }
+        let array = cache.getFragmentArrayCache(identifier, key);
+        if (!array) {
+          array = StatefulArray.create({
+            store: this.store,
+            identifier,
+            key,
+          });
+          cache.setFragmentArrayCache(identifier, key, array);
+        }
+        return array;
+      },
+      set(key, value) {
+        assert(
+          'You must pass an array or null to set an array',
+          value === null || isArray(value),
+        );
+        const identifier = recordIdentifierFor(this);
+        const cache = fragmentCacheFor(this.store);
+        if (value === null) {
+          cache.setDirtyFragment(identifier, key, null);
+          return null;
+        }
+        cache.setDirtyFragment(identifier, key, value.slice());
+        let array = cache.getFragmentArrayCache(identifier, key);
+        if (!array) {
+          array = StatefulArray.create({
+            store: this.store,
+            identifier,
+            key,
+          });
+          cache.setFragmentArrayCache(identifier, key, array);
+        }
+        array._setFragments(value);
+        return array;
+      },
     },
-    set(key, value) {
-      assert(
-        'You must pass an array or null to set an array',
-        value === null || isArray(value),
-      );
-      const identifier = recordIdentifierFor(this);
-      const cache = this.store.cache;
-      if (value === null) {
-        cache.setDirtyFragment(identifier, key, null);
-        return null;
-      }
-      cache.setDirtyFragment(identifier, key, value.slice());
-      let array = cache.getFragmentArrayCache(identifier, key);
-      if (!array) {
-        array = StatefulArray.create({
-          store: this.store,
-          identifier,
-          key,
-        });
-        cache.setFragmentArrayCache(identifier, key, array);
-      }
-      array._setFragments(value);
-      return array;
-    },
-  }).meta(meta);
+  ).meta(meta);
 }

package/addon/attributes/fragment-array.js

@@ -4,6 +4,7 @@ import { typeOf } from '@ember/utils';
 import { isArray } from '@ember/array';
 import { recordIdentifierFor } from '@ember-data/store';
 import { isFragment } from '../fragment';
+import fragmentCacheFor from '../util/fragment-cache';
 import metaTypeFor from '../util/meta-type-for';
 import FragmentArray from '../array/fragment';
 
@@ -61,54 +62,62 @@ export default function fragmentArray(type, options) {
     options,
   };
 
-  // eslint-disable-next-line ember/require-computed-property-dependencies
-  return computed({
-    get(key) {
-      if (this.isDestroying || this.isDestroyed) {
-        return null;
-      }
-      const identifier = recordIdentifierFor(this);
-      const cache = this.store.cache;
-      if (cache.getFragment(identifier, key) === null) {
-        return null;
-      }
-      let fragmentArray = cache.getFragmentArrayCache(identifier, key);
-      if (!fragmentArray) {
-        fragmentArray = FragmentArray.create({
-          modelName: type,
-          store: this.store,
-          identifier,
-          key,
-        });
-        cache.setFragmentArrayCache(identifier, key, fragmentArray);
-      }
-      return fragmentArray;
+  // Use computed with a dependency on hasDirtyAttributes which changes on rollback
+  // This ensures the computed property is re-evaluated when dirty state changes
+  return computed(
+    'currentState',
+    'hasDirtyAttributes',
+    'isDestroyed',
+    'isDestroying',
+    'store.cache',
+    {
+      get(key) {
+        if (this.isDestroying || this.isDestroyed) {
+          return null;
+        }
+        const identifier = recordIdentifierFor(this);
+        const cache = fragmentCacheFor(this.store);
+        if (cache.getFragment(identifier, key) === null) {
+          return null;
+        }
+        let fragmentArray = cache.getFragmentArrayCache(identifier, key);
+        if (!fragmentArray) {
+          fragmentArray = FragmentArray.create({
+            modelName: type,
+            store: this.store,
+            identifier,
+            key,
+          });
+          cache.setFragmentArrayCache(identifier, key, fragmentArray);
+        }
+        return fragmentArray;
+      },
+      set(key, value) {
+        assert(
+          'You must pass an array of fragments, or null to set a fragmentArray',
+          value === null ||
+            (isArray(value) &&
+              value.every((v) => isFragment(v) || typeOf(v) === 'object')),
+        );
+        const identifier = recordIdentifierFor(this);
+        const cache = fragmentCacheFor(this.store);
+        if (value === null) {
+          cache.setDirtyFragment(identifier, key, null);
+          return null;
+        }
+        let fragmentArray = cache.getFragmentArrayCache(identifier, key);
+        if (!fragmentArray) {
+          fragmentArray = FragmentArray.create({
+            modelName: type,
+            store: this.store,
+            identifier,
+            key,
+          });
+          cache.setFragmentArrayCache(identifier, key, fragmentArray);
+        }
+        fragmentArray._setFragments(value);
+        return fragmentArray;
+      },
     },
-    set(key, value) {
-      assert(
-        'You must pass an array of fragments, or null to set a fragmentArray',
-        value === null ||
-          (isArray(value) &&
-            value.every((v) => isFragment(v) || typeOf(v) === 'object')),
-      );
-      const identifier = recordIdentifierFor(this);
-      const cache = this.store.cache;
-      if (value === null) {
-        cache.setDirtyFragment(identifier, key, null);
-        return null;
-      }
-      let fragmentArray = cache.getFragmentArrayCache(identifier, key);
-      if (!fragmentArray) {
-        fragmentArray = FragmentArray.create({
-          modelName: type,
-          store: this.store,
-          identifier,
-          key,
-        });
-        cache.setFragmentArrayCache(identifier, key, fragmentArray);
-      }
-      fragmentArray._setFragments(value);
-      return fragmentArray;
-    },
-  }).meta(meta);
+  ).meta(meta);
 }

package/addon/attributes/fragment-owner.js

@@ -3,6 +3,7 @@ import { computed } from '@ember/object';
 import { isDestroying, isDestroyed } from '@ember/destroyable';
 import { isFragment } from '../fragment';
 import { recordIdentifierFor } from '@ember-data/store';
+import fragmentCacheFor from '../util/fragment-cache';
 
 /**
  `MF.fragmentOwner` defines a read-only attribute on a `MF.Fragment`
@@ -42,7 +43,7 @@ export default function fragmentOwner() {
       isFragment(this),
     );
     const identifier = recordIdentifierFor(this);
-    const owner = this.store.cache.getFragmentOwner(identifier);
+    const owner = fragmentCacheFor(this.store).getFragmentOwner(identifier);
     if (!owner) {
       return null;
     }