[BUGFIX] keep local state after a deletion

addon/-private/system/model/internal-model.js

@@ -728,12 +728,6 @@ export default class InternalModel {
     }
   }
 
-  notifyHasManyRemoved(key, record, idx) {
-    if (this.hasRecord) {
-      this._record.notifyHasManyRemoved(key, record, idx);
-    }
-  }
-
   notifyBelongsToChanged(key, record) {
     if (this.hasRecord) {
       this._record.notifyBelongsToChanged(key, record);
@@ -768,7 +762,7 @@ export default class InternalModel {
     }
 
     if (this.isNew()) {
-      this.clearRelationships();
+      this._resetAllRelationshipsToEmpty();
     }
 
     if (this.isValid()) {
@@ -882,20 +876,50 @@ export default class InternalModel {
   }
 
   /*
-    @method clearRelationships
+    This method should only be called by records in the `isNew()` state.
+    It will completely reset all relationships to an empty state and remove
+    the record from any associated inverses as well.
+
+    @method _resetAllRelationshipsToEmpty
     @private
   */
-  clearRelationships() {
+  _resetAllRelationshipsToEmpty() {
     this.eachRelationship((name, relationship) => {
       if (this._relationships.has(name)) {
         let rel = this._relationships.get(name);
+
         rel.clear();
         rel.removeInverseRelationships();
       }
     });
     Object.keys(this._implicitRelationships).forEach((key) => {
-      this._implicitRelationships[key].clear();
-      this._implicitRelationships[key].removeInverseRelationships();
+      let rel = this._implicitRelationships[key];
+
+      rel.clear();
+      rel.removeInverseRelationships();
+    });
+  }
+
+  /*
+    This method should only be called once the record has been deleted
+    and that deletion has been persisted. It will remove this record from
+    any associated relationships.
+
+    @method unloadDeletedRecordFromRelationships
+    @private
+   */
+  unloadDeletedRecordFromRelationships() {
+    this.eachRelationship((name) => {
+      if (this._relationships.has(name)) {
+        let rel = this._relationships.get(name);
+
+        rel.removeDeletedInternalModelFromInverse(this);
+      }
+    });
+    Object.keys(this._implicitRelationships).forEach((key) => {
+      let rel = this._implicitRelationships[key];
+
+      rel.removeDeletedInternalModelFromInverse(this);
     });
   }
 

addon/-private/system/model/states.js

@@ -671,7 +671,7 @@ const RootState = {
       isDirty: false,
 
       setup(internalModel) {
-        internalModel.clearRelationships();
+        internalModel.unloadDeletedRecordFromRelationships();
       },
 
       invokeLifecycleCallbacks(internalModel) {

addon/-private/system/relationships/state/belongs-to.js

@@ -63,6 +63,25 @@ export default class BelongsToRelationship extends Relationship {
     this.notifyBelongsToChanged();
   }
 
+  removeDeletedInternalModelFromOwn(internalModel) {
+    super.removeDeletedInternalModelFromOwn(internalModel);
+    let didChange = false;
+
+    if (this.canonicalState === internalModel) {
+      this.canonicalState = null;
+      didChange = true;
+    }
+
+    if (this.inverseInternalModel === internalModel) {
+      this.inverseInternalModel = this.canonicalState;
+      didChange = true;
+    }
+
+    if (didChange === true) {
+      this.notifyBelongsToChanged();
+    }
+  }
+
   flushCanonical() {
     //temporary fix to not remove newly created records if server returned null.
     //TODO remove once we have proper diffing

addon/-private/system/relationships/state/has-many.js

@@ -111,6 +111,26 @@ export default class ManyRelationship extends Relationship {
     super.removeCanonicalInternalModelFromOwn(internalModel, idx);
   }
 
+  removeDeletedInternalModelFromOwn(internalModel) {
+    super.removeDeletedInternalModelFromOwn(internalModel);
+
+    const canonicalIndex = this.canonicalState.indexOf(internalModel);
+
+    if (canonicalIndex !== -1) {
+      this.canonicalState.splice(canonicalIndex, 1);
+    }
+
+    const manyArray = this._manyArray;
+
+    if (manyArray) {
+      const idx = manyArray.currentState.indexOf(internalModel);
+
+      if (idx !== -1) {
+        manyArray.internalReplace(idx, 1);
+      }
+    }
+  }
+
   flushCanonical() {
     if (this._manyArray) {
       this._manyArray.flushCanonical();

addon/-private/system/relationships/state/relationship.js

@@ -2,6 +2,9 @@
 import { assert, warn } from '@ember/debug';
 import OrderedSet from '../../ordered-set';
 import _normalizeLink from '../../normalize-link';
+import Ember from 'ember';
+
+const { guidFor } = Ember;
 
 const {
   addCanonicalInternalModel,
@@ -266,6 +269,41 @@ export default class Relationship {
     this.flushCanonicalLater();
   }
 
+  /*
+    Call this method once a record deletion has been persisted
+    to purge it from both current and canonical state of all
+    relationships.
+
+    @method removeDeletedInternalModelFromInverse
+    @private
+   */
+  removeDeletedInternalModelFromInverse(internalModel) {
+    if (!this.inverseKey) { return; }
+
+    // we actually want a union of members and canonicalMembers
+    // they should be disjoint but currently are not due to a bug
+    let seen = Object.create(null);
+
+    const unload = inverseInternalModel => {
+      const id = guidFor(inverseInternalModel);
+
+      if (seen[id] === undefined) {
+        const relationship = inverseInternalModel._relationships.get(this.inverseKey);
+        relationship.removeDeletedInternalModelFromOwn(internalModel);
+        seen[id] = true;
+      }
+    };
+
+    this.members.forEach(unload);
+    this.canonicalMembers.forEach(unload);
+  }
+
+  removeDeletedInternalModelFromOwn(internalModel) {
+    this.canonicalMembers.delete(internalModel);
+    this.members.delete(internalModel);
+    this.notifyRecordRelationshipRemoved(internalModel);
+  }
+
   flushCanonical() {
     heimdall.increment(flushCanonical);
     let list = this.members.list;

tests/integration/relationships/has-many-test.js

@@ -2520,7 +2520,9 @@ test("adding and removing records from hasMany relationship #2666", function(ass
         return comments.get('lastObject').destroyRecord();
       }).then(() => {
         let comments = post.get('comments');
-        assert.equal(comments.get('length'), 3, "Comments count after destroy");
+        let length = comments.get('length');
+
+        assert.equal(length, 3, "Comments count after destroy");
 
         // Add another comment #4
         let comment = env.store.createRecord('comment');