Merge pull request #11 from richmolj/disassociate

Add isMarkedForDisassociation()

Author: richmolj

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);
+        });
+      });
     });
   });
 });