ember-data-model-fragments 4.0.0 → 5.0.0-beta.3

package/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+	"workbench.colorCustomizations": {
+		"activityBar.background": "#24320F",
+		"titleBar.activeBackground": "#334615",
+		"titleBar.activeForeground": "#F8FCF3"
+	}
+}

package/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Changelog
 
-### v4.0.0 (January 25, 2018)
+### v5.0.0-beta.1 (November 12, 2020)
+
+* [#381](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/381) Fix `hasDirtyAttributes` when resetting a property (@VincentMolinie)
+* [#385](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/385) Upgrade to Ember 3.20 LTS (@patocallaghan)
+
+### v5.0.0-beta.0 (May 28, 2020)
+
+* [#360](https://github.com/adopted-ember-addons/ember-data-model-fragments/pull/360) Upgrade to work with Ember Data 3.16 (@richgt, @igorT)
+
+### v4.0.0 (January 25, 2019)
 
 * Ember 3.5.0 compatibility with breaking changes related to `RecordData`. (@cohitre)
 * Fixed `changedAtributes` with fragments (@Gorzas)

package/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2020
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # Ember Data Model Fragments
 
-[![Build Status](https://travis-ci.org/lytics/ember-data-model-fragments.svg)](https://travis-ci.org/lytics/ember-data-model-fragments)
+[![CI](https://github.com/adopted-ember-addons/ember-data-model-fragments/actions/workflows/ci.yml/badge.svg)](https://github.com/adopted-ember-addons/ember-data-model-fragments/actions/workflows/ci.yml)
 [![NPM Version](https://badge.fury.io/js/ember-data-model-fragments.svg)](http://badge.fury.io/js/ember-data-model-fragments)
 [![Ember Observer Score](http://emberobserver.com/badges/ember-data-model-fragments.svg)](http://emberobserver.com/addons/ember-data-model-fragments)
 
@@ -27,7 +27,9 @@ Use the following table to decide which version of this project to use with your
 | >= v2.14.x < v3.0.x | v2.14.x |
 | >= v3.0.x < v3.2.x | v3.0.x-beta.1 |
 | >= v3.2.x < v3.4.x | v3.3.x |
-| >= v3.5.x | v4.0.x |
+| >= v3.5.x < v3.12.x | v4.0.x |
+| >= v3.13.x | v5.0.x |
+| >= v3.28.x | Not fully compatible (See [issue](https://github.com/adopted-ember-addons/ember-data-model-fragments/issues/406)) |
 
 #### Notes
 
@@ -40,6 +42,7 @@ Use the following table to decide which version of this project to use with your
 - Ember Data 3.0 changed `ContainerInstanceCache` import paths. See [e4749c10](https://github.com/lytics/ember-data-model-fragments/pull/287/commits/e4749c107610a6d0dd6032a58c66356e6064562a).
 - Ember Data 3.2 changed `InternalModel#fields`. See: [#310](https://github.com/lytics/ember-data-model-fragments/pull/310).
 - Ember Data 3.5 added `RecordData` interfaces. See: [#324](https://github.com/lytics/ember-data-model-fragments/pull/324), [emberjs/rfcs#293](https://github.com/emberjs/rfcs/pull/293), and [emberjs/data#5616](https://github.com/emberjs/data/pull/5616).
+- Ember Data 3.13 changed `InternalModel` Private APIs. See: [#360] (https://github.com/lytics/ember-data-model-fragments/pull/360)
 
 ## Installation
 
@@ -455,7 +458,7 @@ with `polymorphic` set to true. In addition the `typeKey` can be set, which defa
 
 The `typeKey`'s value must be the lowercase name of a class that is assignment-compatible to the declared type of the fragment attribute. That is, it must be the declared type itself or a subclass. Additionally, the `typeKey`'s value must be a field on the parent class.
 
-In the following example the declared type of `animals` is `animal`, which corresponds to the class `App.Animal`. `App.Animal` has two subclasses: `App.Elephant` and `App.Lion`,
+In the following example the declared type of `animals` is `animal`, which corresponds to the class `Animal`. `Animal` has two subclasses: `Elephant` and `Lion`,
 so to `typeKey`'s value can be `'animal'`, `'elephant'` or `'lion'`.
 
 ```javascript
@@ -476,7 +479,7 @@ export default Model.extend({
 import Fragment from 'ember-data-model-fragments/fragment';
 import attr from 'ember-data/attr';
 
-App.Animal = Fragment.extend({
+export default Fragment.extend({
   $type: attr('string'),
   name: attr('string'),
 });
@@ -540,14 +543,16 @@ Serializing the fragment type back to JSON is not currently supported out of the
 ```javascript
 // app/serializers/animal.js
 import JSONSerializer from 'ember-data/serializers/json';
+import Elephant from 'app/models/elephant';
+import Lion from 'app/models/elephant';
 
 export default JSONSerializer.extend({
   serialize(record, options) {
     let json = this._super(...arguments);
 
-    if (record instanceof App.Elephant) {
+    if (record instanceof Elephant) {
       json.$type = 'elephant';
-    } else if (record instanceof App.Lion) {
+    } else if (record instanceof Lion) {
       json.$type = 'lion';
     } else {
       json.$type = 'animal';

package/addon/array/fragment.js

@@ -87,7 +87,7 @@ const FragmentArray = StatefulArray.extend({
     @param {Object} data
   */
   _normalizeData(data) {
-    let content = get(this, 'content');
+    let content = this.content;
 
     return normalizeFragmentArray(this, content, data, true);
   },
@@ -113,16 +113,16 @@ const FragmentArray = StatefulArray.extend({
   },
 
   /**
-    @method _adapterDidCommit
+    @method _didCommit
     @private
   */
-  _adapterDidCommit(data) {
+  _didCommit(data) {
     this._super(...arguments);
 
     // Notify all records of commit; if the adapter update did not contain new
     // data, just notify each fragment so it can transition to a clean state
     this.forEach((fragment, index) => {
-      fragment._adapterDidCommit(data && data[index]);
+      fragment._didCommit(data && data[index]);
     });
   },
 
@@ -200,7 +200,7 @@ const FragmentArray = StatefulArray.extend({
     @private
   */
   replaceContent(index, amount, objs) {
-    let content = get(this, 'content');
+    let content = this.content;
     let replacedContent = content.slice(index, index + amount);
     let fragments = normalizeFragmentArray(this, replacedContent, objs);
 
@@ -239,9 +239,9 @@ const FragmentArray = StatefulArray.extend({
     @return {MF.Fragment} the newly added fragment
     */
   createFragment(props) {
-    let record = get(this, 'owner');
+    let record = this.owner;
     let store = get(record, 'store');
-    let type = get(this, 'type');
+    let type = this.type;
     let fragment = store.createFragment(type, props);
 
     return this.pushObject(fragment);

package/addon/array/stateful.js

@@ -77,7 +77,6 @@ const StatefulArray = ArrayProxy.extend(Copyable, {
 
     // Completely replace the contents with the new data
     content.replace(0, get(content, 'length'), processedData);
-
     this._pendingData = undefined;
   },
 
@@ -105,10 +104,10 @@ const StatefulArray = ArrayProxy.extend(Copyable, {
   _flushChangedAttributes() {},
 
   /**
-    @method _adapterDidCommit
+    @method _didCommit
     @private
   */
-  _adapterDidCommit(data) {
+  _didCommit(data) {
     if (data) {
       this.setupData(data);
     } else {
@@ -140,6 +139,7 @@ const StatefulArray = ArrayProxy.extend(Copyable, {
     @readOnly
   */
   hasDirtyAttributes: computed('[]', '_originalState', function() {
+
     return compare(this.toArray(), get(this, '_originalState')) !== 0;
   }),
 

package/addon/attributes.js

@@ -1,22 +1,9 @@
 import { assert } from '@ember/debug';
-import { copy } from 'ember-copy';
-import { typeOf } from '@ember/utils';
-import { isArray } from '@ember/array';
-import { get, setProperties, computed } from '@ember/object';
-import StatefulArray from './array/stateful';
-import FragmentArray from './array/fragment';
-import {
-  fragmentDidDirty,
-  fragmentDidReset
-} from './states';
+import { computed } from '@ember/object';
 import {
   internalModelFor,
-  setFragmentOwner,
-  setFragmentData,
-  createFragment,
   isFragment
 } from './fragment';
-import isInstanceOfType from './util/instance-of-type';
 
 /**
   @module ember-data-model-fragments
@@ -80,76 +67,7 @@ function fragment(declaredModelName, options) {
 
   let metaType = metaTypeFor('fragment', declaredModelName, options);
 
-  function setupFragment(store, record, key) {
-    let internalModel = internalModelFor(record);
-    let data = getWithDefault(internalModel, key, options, 'object');
-    let fragment = internalModel._recordData.getFragment(key);
-
-    // Regardless of whether being called as a setter or getter, the fragment
-    // may not be initialized yet, in which case the data will contain a
-    // raw response or a stashed away fragment
-
-    // If we already have a processed fragment in _data and our current fragment is
-    // null simply reuse the one from data. We can be in this state after a rollback
-    // for example
-    if (!fragment && isFragment(data)) {
-      fragment = data;
-    // Else initialize the fragment
-    } else if (data && data !== fragment) {
-      if (fragment) {
-        // It's important to update internal model data to fragment before calling
-        // setFragmentData since updating the fragment can trigger calls to
-        // notifyPropertyChange which can in turn call setupFragment again, creating
-        // an infinite recursion loop. Since it's a reference anyway doing the
-        // assignation sooner has no side effect
-        internalModel._recordData._data[key] = fragment;
-        setFragmentData(fragment, data);
-      } else {
-        fragment = createFragment(store, declaredModelName, record, key, options, data);
-        internalModel._recordData._data[key] = fragment;
-      }
-
-    } else {
-      // Handle the adapter setting the fragment to null
-      fragment = data;
-    }
-
-    return fragment;
-  }
-
-  function setFragmentValue(record, key, fragment, value) {
-    let store = record.store;
-    let internalModel = internalModelFor(record);
-
-    assert(`You can only assign \`null\`, an object literal or a '${declaredModelName}' fragment instance to this property`, value === null || typeOf(value) === 'object' || isInstanceOfType(store.modelFor(declaredModelName), value));
-
-    if (!value) {
-      fragment = null;
-    } else if (isFragment(value)) {
-      // A fragment instance was given, so just replace the existing value
-      fragment = setFragmentOwner(value, record, key);
-    } else if (!fragment) {
-      // A property hash was given but the property was null, so create a new
-      // fragment with the data
-      fragment = createFragment(store, declaredModelName, record, key, options, value);
-    } else {
-      // The fragment already exists and a property hash is given, so just set
-      // its values and let the state machine take care of the dirtiness
-      setProperties(fragment, value);
-
-      return fragment;
-    }
-
-    if (internalModel._recordData._data[key] !== fragment) {
-      fragmentDidDirty(record, key, fragment);
-    } else {
-      fragmentDidReset(record, key);
-    }
-
-    return fragment;
-  }
-
-  return fragmentProperty(metaType, options, setupFragment, setFragmentValue);
+  return fragmentProperty(metaType, options, declaredModelName);
 }
 
 /**
@@ -197,14 +115,8 @@ function fragmentArray(modelName, options) {
 
   let metaType = metaTypeFor('fragment-array', modelName, options);
 
-  return fragmentArrayProperty(metaType, options, function createFragmentArray(record, key) {
-    return FragmentArray.create({
-      type: modelName,
-      options: options,
-      name: key,
-      owner: record
-    });
-  });
+  // fragmentArrayProperty takes type, options, modelName, isFragmentArray
+  return fragmentArrayProperty(metaType, options, modelName, true);
 }
 
 /**
@@ -245,16 +157,11 @@ function array(type, options) {
 
   let metaType = metaTypeFor('array', type);
 
-  return fragmentArrayProperty(metaType, options, function createStatefulArray(record, key) {
-    return StatefulArray.create({
-      options: options,
-      name: key,
-      owner: record
-    });
-  });
+  // fragmentArrayProperty takes type, options, modelName, isArray, isFragmentArray
+  return fragmentArrayProperty(metaType, options, null, false);
 }
 
-function fragmentProperty(type, options, setupFragment, setFragmentValue) {
+function fragmentProperty(type, options, declaredModelName, isArray = false, isFragmentArray = false) {
   options = options || {};
 
   let meta = {
@@ -266,68 +173,32 @@ function fragmentProperty(type, options, setupFragment, setFragmentValue) {
 
   return computed({
     get(key) {
+      let fragment;
       let internalModel = internalModelFor(this);
-      let fragment = setupFragment(this.store, this, key);
-
-      return internalModel._recordData.setFragment(key, fragment);
+      if (isArray) {
+        fragment = internalModel._recordData.getFragmentArray(key, options, declaredModelName, this, isFragmentArray);
+      } else {
+        fragment = internalModel._recordData.getFragment(key, options, declaredModelName, this);
+      }
+      return fragment;
     },
     set(key, value) {
+      let fragment;
       let internalModel = internalModelFor(this);
-      let fragment = setupFragment(this.store, this, key);
-
-      fragment = setFragmentValue(this, key, fragment, value);
-
-      return internalModel._recordData.setFragment(key, fragment);
+      if (isArray) {
+        fragment = internalModel._recordData.getFragmentArray(key, options, declaredModelName, this, isFragmentArray);
+        fragment = internalModel._recordData.setFragmentArrayValue(key, fragment, value, this, declaredModelName, options, isFragmentArray);
+      } else {
+        fragment = internalModel._recordData.getFragment(key, options, declaredModelName, this);
+        fragment = internalModel._recordData.setFragmentValue(key, fragment, value, this, declaredModelName, options);
+      }
+      return internalModel._recordData.fragments[key] = fragment;
     }
   }).meta(meta);
 }
 
-function fragmentArrayProperty(metaType, options, createArray) {
-  function setupFragmentArray(store, record, key) {
-    let internalModel = internalModelFor(record);
-    let data = getWithDefault(internalModel, key, options, 'array');
-    let fragments = internalModel._recordData.getFragment(key) || null;
-
-    // If we already have a processed fragment in _data and our current fragment is
-    // null simply reuse the one from data. We can be in this state after a rollback
-    // for example
-    if (data instanceof StatefulArray && !fragments) {
-      fragments = data;
-    // Create a fragment array and initialize with data
-    } else if (data && data !== fragments) {
-      fragments || (fragments = createArray(record, key));
-      internalModel._recordData._data[key] = fragments;
-      fragments.setupData(data);
-    } else {
-      // Handle the adapter setting the fragment array to null
-      fragments = data;
-    }
-
-    return fragments;
-  }
-
-  function setFragmentValue(record, key, fragments, value) {
-    let internalModel = internalModelFor(record);
-
-    if (isArray(value)) {
-      fragments || (fragments = createArray(record, key));
-      fragments.setObjects(value);
-    } else if (value === null) {
-      fragments = null;
-    } else {
-      assert('A fragment array property can only be assigned an array or null');
-    }
-
-    if (internalModel._recordData._data[key] !== fragments || (fragments && get(fragments, 'hasDirtyAttributes'))) {
-      fragmentDidDirty(record, key, fragments);
-    } else {
-      fragmentDidReset(record, key);
-    }
-
-    return fragments;
-  }
-
-  return fragmentProperty(metaType, options, setupFragmentArray, setFragmentValue);
+function fragmentArrayProperty(metaType, options, declaredModelName, isFragmentArray) {
+  return fragmentProperty(metaType, options, declaredModelName, true, isFragmentArray);
 }
 
 /**
@@ -357,47 +228,12 @@ function fragmentOwner() {
   return computed(function() {
     assert('Fragment owner properties can only be used on fragments.', isFragment(this));
 
-    return internalModelFor(this)._recordData.getOwner();
+    return internalModelFor(this)._recordData._owner;
   }).meta({
     isFragmentOwner: true
   }).readOnly();
 }
 
-// The default value of a fragment is either an array or an object,
-// which should automatically get deep copied
-function getDefaultValue(record, options, type) {
-  let value;
-
-  if (typeof options.defaultValue === 'function') {
-    value = options.defaultValue();
-  } else if ('defaultValue' in options) {
-    value = options.defaultValue;
-  } else if (type === 'array') {
-    value = [];
-  } else {
-    return null;
-  }
-
-  assert(`The fragment's default value must be an ${type}`, (typeOf(value) == type) || (value === null));
-
-  // No need to copy value if it was a function
-  if (typeof options.defaultValue === 'function') {
-    return value;
-  }
-
-  // Create a deep copy of the resulting value to avoid shared reference errors
-  return copy(value, true);
-}
-
-// Returns the value of the property or the default propery
-function getWithDefault(internalModel, key, options, type) {
-  if (key in internalModel._recordData._data) {
-    return internalModel._recordData._data[key];
-  } else {
-    return getDefaultValue(internalModel, options, type);
-  }
-}
-
 export {
   fragment,
   fragmentArray,

package/addon/ext.js

@@ -1,17 +1,20 @@
 import { assert } from '@ember/debug';
-import Store from 'ember-data/store';
-import Model from 'ember-data/model';
+import Store from '@ember-data/store';
+import Model from '@ember-data/model';
+// eslint-disable-next-line ember/use-ember-data-rfc-395-imports
 import { coerceId, RecordData, InternalModel, normalizeModelName } from 'ember-data/-private';
-import JSONSerializer from 'ember-data/serializers/json';
+import JSONSerializer from '@ember-data/serializer/json';
 import FragmentRootState from './states';
+import FragmentRecordData from './record-data';
 import {
   internalModelFor,
   default as Fragment
 } from './fragment';
-import FragmentArray from './array/fragment';
 import { isPresent } from '@ember/utils';
 import { computed } from '@ember/object';
 import { getOwner } from '@ember/application';
+import { assign } from '@ember/polyfills';
+import { lte, gte } from 'ember-compatibility-helpers';
 
 function serializerForFragment(owner, normalizedModelName) {
   let serializer = owner.lookup(`serializer:${normalizedModelName}`);
@@ -39,7 +42,7 @@ function serializerForFragment(owner, normalizedModelName) {
 const InternalModelPrototype = InternalModel.prototype;
 const RecordDataPrototype = RecordData.prototype;
 
-Object.assign(RecordDataPrototype, {
+assign(RecordDataPrototype, {
   eachFragmentKey(fn) {
     this._fragments = this._fragments || Object.create({});
     Object.keys(this._fragments).forEach(fn);
@@ -82,6 +85,11 @@ Object.assign(RecordDataPrototype, {
   },
 
   didCommit(data) {
+    if (this._attributes) {
+      // willCommit was never called
+      this._inFlightAttributes = this._attributes;
+      this._attributes = null;
+    }
     this._isNew = false;
     if (data) {
       if (data.relationships) {
@@ -95,15 +103,14 @@ Object.assign(RecordDataPrototype, {
       data = data.attributes;
 
       // Notify fragments that the record was committed
-      this.eachFragmentKeyValue((key, fragment) => fragment._adapterDidCommit(data[key]));
+      this.eachFragmentKeyValue((key, fragment) => fragment._didCommit(data[key]));
     } else {
-      this.eachFragmentKeyValue((key, fragment) => fragment._adapterDidCommit());
+      this.eachFragmentKeyValue((key, fragment) => fragment._didCommit());
     }
 
     const changedKeys = this._changedKeys(data);
 
-    Object.assign(this._data, this.__inFlightAttributes, this._attributes, data);
-    this._attributes = null;
+    assign(this._data, this._inFlightAttributes, data);
     this._inFlightAttributes = null;
     this._updateChangedAttributes();
 
@@ -116,6 +123,19 @@ Object.assign(RecordDataPrototype, {
   @namespace DS
 */
 Store.reopen({
+  createRecordDataFor(type, id, lid, storeWrapper) {
+    let identifier;
+    if (lte('ember-data', '3.13.0')) {
+      throw new Error('This version of Ember Data Model Fragments is incompatible with Ember Data Versions below 3.13. See matrix at https://github.com/lytics/ember-data-model-fragments#compatibility for details.');
+    }
+    if (gte('ember-data', '3.15.0')) {
+      identifier = this.identifierCache.getOrCreateRecordIdentifier({ type, id, lid });
+    } else {
+      identifier = { type, id, clientId: lid };
+    }
+    return new FragmentRecordData(identifier, storeWrapper);
+  },
+
   /**
     Create a new fragment that does not yet have an owner record.
     The properties passed to this method are set on the newly created
@@ -138,16 +158,22 @@ Store.reopen({
   */
   createFragment(modelName, props) {
     assert(`The '${modelName}' model must be a subclass of MF.Fragment`, this.isFragment(modelName));
-
-    let internalModel = new InternalModel(modelName, null, this, getOwner(this).container);
+    let internalModel;
+    if (gte('ember-data', '3.15.0')) {
+      const identifier = this.identifierCache.createIdentifierForNewRecord({ type: modelName });
+      internalModel = this._internalModelForResource(identifier);
+    } else {
+      let identifier = { type: modelName, id: `${Math.random()}`, lid: `${Math.random()}` };
+      internalModel = this._internalModelForResource(identifier);
+    }
 
     // Re-wire the internal model to use the fragment state machine
     internalModel.currentState = FragmentRootState.empty;
 
     internalModel._recordData._name = null;
-    internalModel._recordData.setOwner(null);
+    internalModel._recordData._owner = null;
 
-    internalModel.loadedData();
+    internalModel.send('loadedData');
 
     let fragment = internalModel.getRecord();
 
@@ -191,7 +217,7 @@ Store.reopen({
 
     if (this.isFragment(normalizedModelName)) {
       return serializerForFragment(owner, normalizedModelName);
-    } else  {
+    } else {
       return this._super(...arguments);
     }
   }
@@ -202,29 +228,14 @@ Store.reopen({
   @namespace DS
   */
 Model.reopen({
+
   willDestroy() {
     this._super(...arguments);
 
     let internalModel = internalModelFor(this);
-    let key, fragment;
 
     // destroy the current state
-    for (key in internalModel._recordData._fragments) {
-      fragment = internalModel._recordData._fragments[key];
-      if (fragment) {
-        fragment.destroy();
-        delete internalModel._recordData._fragments[key];
-      }
-    }
-
-    // destroy the original state
-    for (key in internalModel._recordData._data) {
-      fragment = internalModel._recordData._data[key];
-      if (fragment instanceof Fragment || fragment instanceof FragmentArray) {
-        fragment.destroy();
-        delete internalModel._recordData._data[key];
-      }
-    }
+    internalModel._recordData.resetFragments();
   }
 });
 
@@ -259,14 +270,6 @@ function decorateMethod(obj, name, fn) {
   };
 }
 
-function decorateMethodBefore(obj, name, fn) {
-  const originalFn = obj[name];
-  obj[name] = function() {
-    fn.apply(this, arguments);
-    return originalFn.apply(this, arguments);
-  };
-}
-
 /**
   Override parent method to snapshot fragment attributes before they are
   passed to the `DS.Model#serialize`.
@@ -281,6 +284,7 @@ decorateMethod(InternalModelPrototype, 'createSnapshot', function createFragment
     // If the attribute has a `_createSnapshot` method, invoke it before the
     // snapshot gets passed to the serializer
     if (attr && typeof attr._createSnapshot === 'function') {
+
       attrs[key] = attr._createSnapshot();
     }
   });
@@ -288,39 +292,6 @@ decorateMethod(InternalModelPrototype, 'createSnapshot', function createFragment
   return snapshot;
 });
 
-decorateMethod(InternalModelPrototype, 'adapterDidError', function adapterDidErrorFragments(returnValue, args) {
-  const error = args[0] || Object.create(null);
-  this._recordData.eachFragmentKeyValue((key, value) => {
-    value._adapterDidError(error);
-  });
-});
-
-decorateMethod(InternalModelPrototype, 'rollbackAttributes', function rollbackFragments() {
-  this._recordData.eachFragmentKeyValue((key, value) => {
-    value.rollbackAttributes();
-  });
-});
-
-decorateMethod(RecordDataPrototype, 'changedAttributes', function changedAttributes(diffData) {
-  this.eachFragmentKey((name) => {
-    if (name in this._attributes) {
-      diffData[name] = [
-        diffData[name][0],
-        diffData[name][1] ? diffData[name][1]._record : diffData[name][1]
-      ];
-    }
-  });
-  return diffData;
-});
-
-decorateMethodBefore(RecordDataPrototype, 'willCommit', function willCommit() {
-  this.eachFragmentKeyValue((key, fragment) => fragment._flushChangedAttributes());
-});
-
-decorateMethodBefore(RecordDataPrototype, 'commitWasRejected', function commitWasRejected() {
-  this.eachFragmentKeyValue((key, fragment) => fragment._adapterDidError());
-});
-
 /**
   @class JSONSerializer
   @namespace DS