Add isMarkedForDisassociation()

This replicates all the logic from isMarkedForDestruction, but sends the
'dissassociate' method instead of the 'destroy' method. The biggest
thing that might look off here is some duplicative specs, but I'm OK
with this for now.

Author: Lee Richmond

src/model.ts

@@ -38,6 +38,7 @@ export default class Model {
   __meta__: Object | void = null;
   _persisted: boolean = false;
   _markedForDestruction: boolean = false;
+  _markedForDisassociation: boolean = false;
   klass: typeof Model;
 
   static attributeList = [];
@@ -233,6 +234,15 @@ export default class Model {
     }
   }
 
+  isMarkedForDisassociation(val? : boolean) : boolean {
+    if (val != undefined) {
+      this._markedForDisassociation = val;
+      return val;
+    } else {
+      return this._markedForDisassociation;
+    }
+  }
+
   fromJsonapi(resource: japiResource, payload: japiDoc, includeDirective: Object = {}) : any {
     return deserializeInstance(this, resource, payload, includeDirective);
   }

src/util/deserialize.ts

@@ -112,15 +112,15 @@ class Deserializer {
       if (relatedObjects) {
         if (Array.isArray(relatedObjects)) {
           relatedObjects.forEach((relatedObject, index) => {
-            if (relatedObject.isMarkedForDestruction()) {
+            if (relatedObject.isMarkedForDestruction() || relatedObject.isMarkedForDisassociation()) {
               model[key].splice(index, 1);
             } else {
               this._removeDeletions(relatedObject, includeDirective[key] || {});
             }
           });
         } else {
           let relatedObject = relatedObjects;
-          if (relatedObject.isMarkedForDestruction()) {
+          if (relatedObject.isMarkedForDestruction() || relatedObject.isMarkedForDisassociation()) {
             model[key] = null;
           } else {
             this._removeDeletions(relatedObject, includeDirective[key] || {});

src/util/dirty-check.ts

@@ -27,7 +27,7 @@ class DirtyChecker {
 
   // Either:
   // * attributes changed
-  // * marked for destruction
+  // * marked for destruction / disassociation
   // * not persisted (and thus must be send to server)
   // * not itself dirty, but has nested relations that are dirty
   check(relationships: Object | Array<any> | string = {}) : boolean {
@@ -37,6 +37,7 @@ class DirtyChecker {
     return this._hasDirtyAttributes() ||
       this._hasDirtyRelationships(includeHash) ||
       this.model.isMarkedForDestruction() ||
+      this.model.isMarkedForDisassociation() ||
       this._isUnpersisted()
   }
 

src/util/write-payload.ts

@@ -35,15 +35,15 @@ export default class WritePayload {
       if (relatedObjects) {
         if (Array.isArray(relatedObjects)) {
           relatedObjects.forEach((relatedObject, index) => {
-            if (relatedObject.isMarkedForDestruction()) {
+            if (relatedObject.isMarkedForDestruction() || relatedObject.isMarkedForDisassociation()) {
               model[key].splice(index, 1);
             } else {
               this.removeDeletions(relatedObject, nested);
             }
           });
         } else {
           let relatedObject = relatedObjects;
-          if (relatedObject.isMarkedForDestruction()) {
+          if (relatedObject.isMarkedForDestruction() || relatedObject.isMarkedForDisassociation()) {
             model[key] = null;
           } else {
             this.removeDeletions(relatedObject, nested);
@@ -161,8 +161,10 @@ export default class WritePayload {
     if (model.isPersisted()) {
       if (model.isMarkedForDestruction()) {
         method = 'destroy';
+      } else if (model.isMarkedForDisassociation()) {
+        method = 'disassociate';
       } else {
-        method = 'update'
+        method = 'update';
       }
     } else {
       method = 'create';

test/integration/nested-persistence-test.ts

@@ -302,7 +302,33 @@ describe('nested persistence', function() {
   });
 
   describe('basic nested disassociate', function() {
-    xit('sends the correct payload', function() {
+    beforeEach(function() {
+      seedPersistedData();
+    });
+
+    it('sends the correct payload', function(done) {
+      instance.books[0].isMarkedForDisassociation(true);
+      instance.books[0].genre.isMarkedForDisassociation(true);
+      instance.save({ with: { books: 'genre' } }).then((response) => {
+        expect(putPayloads[0]).to.deep.equal(expectedUpdatePayload('disassociate'));
+        done();
+      });
+    });
+
+    it('removes the associated has_many data', function(done) {
+      instance.books[0].isMarkedForDisassociation(true);
+      instance.save({ with: 'books' }).then((response) => {
+        expect(instance.books.length).to.eq(0);
+        done();
+      });
+    });
+
+    it('removes the associated belongs_to data', function(done) {
+      instance.books[0].genre.isMarkedForDisassociation(true);
+      instance.save({ with: { books: 'genre' } }).then((response) => {
+        expect(instance.books[0].genre).to.eq(null);
+        done();
+      });
     });
   });
 });

test/unit/model-test.ts

@@ -432,6 +432,41 @@ describe('Model', function() {
       });
     });
 
+    describe('when a has-many is marked for disassociation', function() {
+      let newDoc, instance, book;
+
+      beforeEach(function() {
+        book = new Book({ id: '1' });
+        book.isPersisted(true);
+        book.isMarkedForDisassociation(true);
+
+        instance = new Author({ books: [book] });
+
+        newDoc = {
+          data: {
+            id: '1',
+            type: 'authors'
+          }
+        }
+      });
+
+      describe('when the relation is part of the include directive', function() {
+        it('is removed from the array', function() {
+          expect(instance.books.length).to.eq(1);
+          instance.fromJsonapi(newDoc.data, newDoc, { books: {} });
+          expect(instance.books.length).to.eq(0);
+        });
+      });
+
+      describe('when the relation is not part of the include directive', function() {
+        it('is NOT removed from the array', function() {
+          expect(instance.books.length).to.eq(1);
+          instance.fromJsonapi(newDoc.data, newDoc, {});
+          expect(instance.books.length).to.eq(1);
+        });
+      });
+    });
+
     describe('when a belongs-to is marked for destruction', function() {
       let newDoc, instance, book;
 
@@ -484,6 +519,59 @@ describe('Model', function() {
         });
       });
     });
+
+    describe('when a belongs-to is marked for disassociation', function() {
+      let newDoc, instance, book;
+
+      beforeEach(function() {
+        let genre = new Genre({ id: '1' });
+        genre.isPersisted(true);
+        genre.isMarkedForDisassociation(true);
+
+        book = new Book({ id: '1', genre: genre });
+        book.isPersisted(true);
+
+        instance = new Author({ books: [book] });
+
+        newDoc = {
+          data: {
+            id: '1',
+            type: 'authors'
+          },
+          relationships: {
+            books: {
+              data: [
+                { id: '1', type: 'books' }
+              ]
+            }
+          },
+          included: [
+            {
+              id: '1',
+              type: 'books',
+              attributes: { title: 'whatever' }
+            }
+          ]
+        }
+      });
+
+      it('is set to null', function() {
+        expect(instance.books[0].genre).to.be.instanceof(Genre);
+        instance.fromJsonapi(newDoc.data, newDoc, { books: { genre: {} }});
+        expect(instance.books[0].genre).to.eq(null);
+      });
+
+      describe('within a nested destruction', function() {
+        beforeEach(function() {
+          book.isMarkedForDisassociation(true);
+        });
+
+        it('is removed via the parent', function() {
+          instance.fromJsonapi(newDoc.data, newDoc, { books: { genre: {} }});
+          expect(instance.books.length).to.eq(0);
+        });
+      });
+    });
   });
 
   describe('isMarkedForDestruction', function() {
@@ -497,6 +585,17 @@ describe('Model', function() {
     });
   });
 
+  describe('isMarkedForDisassociation', function() {
+    it('toggles correctly', function() {
+      instance = new Author();
+      expect(instance.isMarkedForDisassociation()).to.eq(false)
+      instance.isMarkedForDisassociation(true);
+      expect(instance.isMarkedForDisassociation()).to.eq(true)
+      instance.isMarkedForDisassociation(false);
+      expect(instance.isMarkedForDisassociation()).to.eq(false)
+    });
+  });
+
   describe('isDirty', function() {
     describe('when an attribute changes', function() {
       it('is marked as dirty', function() {
@@ -546,8 +645,12 @@ describe('Model', function() {
     });
 
     describe('when marked for disassociation', function() {
-      // disassociations not implemented yet
-      xit('is dirty', function() {
+      it('is dirty', function() {
+        instance = new Author();
+        instance.isPersisted(true);
+        expect(instance.isDirty()).to.eq(false);
+        instance.isMarkedForDisassociation(true);
+        expect(instance.isDirty()).to.eq(true);
       });
     });
 
@@ -659,6 +762,20 @@ describe('Model', function() {
           expect(instance.isDirty()).to.eq(false);
         });
       });
+
+      describe('when a hasMany relationship has a member marked for disassociation', function() {
+        it('is dirty', function() {
+          let book = new Book({ id: 1 });
+          book.isPersisted(true);
+          instance.books = [book];
+          instance.isPersisted(true);
+
+          expect(instance.isDirty('books')).to.eq(false);
+          book.isMarkedForDisassociation(true);
+          expect(instance.isDirty('books')).to.eq(true);
+          expect(instance.isDirty()).to.eq(false);
+        });
+      });
     });
   });
 });