Add nested write support

Some of this will need to be refactored/enhanced.

Author: Lee Richmond

src/attribute.ts

@@ -8,13 +8,14 @@ export default class Attribute {
   name: string;
 
   isAttr: boolean = true;
+  isRelationship: boolean = false;
 
   static applyAll(klass: typeof Model) : void {
     this._eachAttribute(klass, (attr) => {
       klass.attributeList.push(attr.name);
-      let instance = new klass();
       let descriptor = attr.descriptor();
       Object.defineProperty(klass.prototype, attr.name, descriptor);
+      let instance = new klass();
 
       let decorators = instance['__attrDecorators'] || [];
       decorators.forEach((d) => {

src/model.ts

@@ -9,6 +9,8 @@ import _extend from './util/extend';
 import { camelize } from './util/string';
 import WritePayload from './util/write-payload';
 import IncludeDirective from './util/include-directive';
+import DirtyChecker from './util/dirty-check';
+import relationshipIdentifiersFor from './util/relationship-identifiers';
 import Request from './request';
 import * as _cloneDeep from './util/clonedeep';
 let cloneDeep: any = (<any>_cloneDeep).default || _cloneDeep;
@@ -26,13 +28,18 @@ export default class Model {
   static parentClass: typeof Model;
 
   id: string;
+  temp_id: string;
   _attributes: Object = {};
+  _originalAttributes: Object = {};
+  _originalRelationships: Object = {};
   relationships: Object = {};
   __meta__: Object | void = null;
   _persisted: boolean = false;
+  _markedForDestruction: boolean = false;
   klass: typeof Model;
 
   static attributeList = [];
+  static relationList = [];
   private static _scope: Scope;
 
   static extend(obj : any) : any {
@@ -138,12 +145,31 @@ export default class Model {
 
   constructor(attributes?: Object) {
     this.attributes = attributes;
+    this._originalAttributes = cloneDeep(this.attributes);
+    this._originalRelationships = this.relationshipResourceIdentifiers(Object.keys(this.relationships));
+  }
+
+  // Todo:
+  // * needs to recurse the directive
+  // * remove the corresponding code from isPersisted and handle here (likely
+  // only an issue with test setup)
+  // * Make all calls go through resetRelationTracking();
+  resetRelationTracking(includeDirective: Object) {
+    this._originalRelationships = this.relationshipResourceIdentifiers(Object.keys(includeDirective));
+  }
+
+  relationshipResourceIdentifiers(relationNames: Array<string>) {
+    return relationshipIdentifiersFor(this, relationNames);
   }
 
   isType(jsonapiType : string) {
     return this.klass.jsonapiType === jsonapiType;
   }
 
+  get resourceIdentifier() : Object {
+    return { type: this.klass.jsonapiType, id: this.id };
+  }
+
   get attributes() : Object {
     return this._attributes;
   }
@@ -160,16 +186,37 @@ export default class Model {
   isPersisted(val? : boolean) : boolean {
     if (val != undefined) {
       this._persisted = val;
+      this._originalAttributes = cloneDeep(this.attributes);
+      this._originalRelationships = this.relationshipResourceIdentifiers(Object.keys(this.relationships));
       return val;
     } else {
       return this._persisted;
     }
   }
 
+  isMarkedForDestruction(val? : boolean) : boolean {
+    if (val != undefined) {
+      this._markedForDestruction = val;
+      return val;
+    } else {
+      return this._markedForDestruction;
+    }
+  }
+
   fromJsonapi(resource: japiResource, payload: japiDoc) : any {
     return deserializeInstance(this, resource, payload);
   }
 
+  isDirty(relationships?: Object | Array<any> | string) : boolean {
+    let dc = new DirtyChecker(this);
+    return dc.check(relationships);
+  }
+
+  hasDirtyRelation(relationName: string, relatedModel: Model) : boolean {
+    let dc = new DirtyChecker(this);
+    return dc.checkRelation(relationName, relatedModel);
+  }
+
   destroy() : Promise<any> {
     let url     = this.klass.url(this.id);
     let verb    = 'delete';
@@ -182,35 +229,35 @@ export default class Model {
     });
   }
 
-  save() : Promise<any> {
+  save(options: Object = {}) : Promise<any> {
     let url     = this.klass.url();
     let verb    = 'post';
     let request = new Request();
-    let payload = new WritePayload(this);
+    let payload = new WritePayload(this, options['with']);
     let jwt     = this.klass.getJWT();
 
     if (this.isPersisted()) {
       url  = this.klass.url(this.id);
       verb = 'put';
     }
 
-    let requestPromise = request[verb](url, payload.asJSON(), { jwt });
+    let json = payload.asJSON();
+    let requestPromise = request[verb](url, json, { jwt });
     return this._writeRequest(requestPromise, () => {
       this.isPersisted(true);
+      payload.postProcess();
     });
   }
 
-  private
-
-  _writeRequest(requestPromise : Promise<any>, callback: Function) : Promise<any> {
+  private _writeRequest(requestPromise : Promise<any>, callback: Function) : Promise<any> {
     return new Promise((resolve, reject) => {
       return requestPromise.then((response) => {
         this._handleResponse(response, resolve, reject, callback);
       });
     });
   }
 
-  _handleResponse(response: any, resolve: Function, reject: Function, callback: Function) : void {
+  private _handleResponse(response: any, resolve: Function, reject: Function, callback: Function) : void {
     if (response.status == 422) {
       resolve(false);
     } else if (response.status >= 500) {

src/scope.ts

@@ -7,6 +7,7 @@ import Request from './request';
 import colorize from './util/colorize';
 import * as _cloneDeep from './util/clonedeep';
 let cloneDeep: any = (<any>_cloneDeep).default || _cloneDeep;
+cloneDeep = cloneDeep.default || cloneDeep;
 
 export default class Scope {
   model: typeof Model;

src/util/deserialize.ts

@@ -26,6 +26,8 @@ class Deserializer {
   }
 
   addResources(data) {
+    if (!data) return;
+
     if (Array.isArray(data)) {
       for (let datum of data) {
         this._resources.push(datum);
@@ -45,6 +47,7 @@ class Deserializer {
       let klass = Config.modelForType(resource.type);
       let instance = new klass();
       record = this.deserializeInstance(instance, resource);
+      record.isPersisted(true);
     }
 
     return record;
@@ -57,19 +60,53 @@ class Deserializer {
     instance.attributes = resource.attributes;
     this._processRelationships(instance, resource.relationships);
     instance.__meta__ = resource.meta;
+    instance.isPersisted(true);
     return instance;
   }
 
+  _pushRelationship(instance: Model, associationName: string, relatedRecord: Model) {
+    let records = instance[associationName];
+    let existingIndex = this._existingRecordIndex(records, relatedRecord);
+    if (existingIndex > -1) {
+      if (records[existingIndex].isMarkedForDestruction()) {
+        records.splice(existingIndex, 1);
+      } else {
+        records[existingIndex] = relatedRecord;
+      }
+    } else {
+      records.push(relatedRecord);
+    }
+    instance[associationName] = records;
+  }
+
+  _existingRecordIndex(records: Array<Model>, record: Model) : number {
+    let index = -1;
+    records.forEach((r, i) => {
+      if ((r.temp_id && r.temp_id === record.temp_id) || (r.id && r.id === record.id)) {
+        index = i;
+      }
+    });
+    return index;
+  }
+
   _processRelationships(instance, relationships) {
     this._iterateValidRelationships(instance, relationships, (relationName, relationData) => {
       if (Array.isArray(relationData)) {
         for (let datum of relationData) {
           let relatedRecord = this.deserialize(datum, true);
-          instance[relationName].push(relatedRecord);
+          relatedRecord.temp_id = datum['temp-id'];
+          this._pushRelationship(instance, relationName, relatedRecord)
+          relatedRecord.temp_id = null;
         }
       } else {
-        let relatedRecord = this.deserialize(relationData, true);
-        instance[relationName] = relatedRecord;
+        if (instance[relationName] && instance[relationName].isMarkedForDestruction()) {
+          instance[relationName] = null;
+        } else {
+          // todo belongsto destruction test removes relation
+          let relatedRecord = this.deserialize(relationData, true);
+          relatedRecord.temp_id = null;
+          instance[relationName] = relatedRecord;
+        }
       }
     });
   }

src/util/dirty-check.ts

@@ -0,0 +1,85 @@
+import Model from '../model';
+import IncludeDirective from './include-directive';
+
+class DirtyChecker {
+  model: Model;
+
+  constructor(model: Model) {
+    this.model = model;
+  }
+
+  // Check if we are switching persisted objects. Either:
+  // * adding a new already-persisted object to a hasMany array
+  // * switching an existing persisted hasOne/belongsTo object
+  checkRelation(relationName: string, relatedModel: Model) : boolean {
+    let dirty = false;
+
+    if (relatedModel.isPersisted()) {
+      let identifiers = this.model._originalRelationships[relationName] || [];
+      let found = identifiers.find((ri) => {
+        return JSON.stringify(ri) == JSON.stringify(relatedModel.resourceIdentifier);
+      });
+      if (!found) dirty = true;
+    }
+
+    return dirty;
+  }
+
+  // Either:
+  // * attributes changed
+  // * marked for destruction
+  // * 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 {
+    let includeDirective = new IncludeDirective(relationships);
+    let includeHash = includeDirective.toObject();
+
+    return this._hasDirtyAttributes() ||
+      this._hasDirtyRelationships(includeHash) ||
+      this.model.isMarkedForDestruction() ||
+      this._isUnpersisted()
+  }
+
+  // TODO: allow attributes == {} configurable
+  private _isUnpersisted() {
+    return !this.model.isPersisted() && JSON.stringify(this.model.attributes) !== JSON.stringify({});
+  }
+
+  private _hasDirtyAttributes() {
+    let originalAttrs = this.model._originalAttributes;
+    let currentAttrs = this.model.attributes;
+
+    return JSON.stringify(originalAttrs) !== JSON.stringify(currentAttrs);
+  }
+
+  private _hasDirtyRelationships(includeHash: Object) : boolean {
+    let dirty = false;
+
+    this._eachRelatedObject(includeHash, (relationName, relatedObject, nested) => {
+      if (relatedObject.isDirty(nested)) {
+        dirty = true;
+      }
+
+      if (this.checkRelation(relationName, relatedObject)) {
+        dirty = true;
+      }
+    });
+
+    return dirty;
+  }
+
+  _eachRelatedObject(includeHash: Object, callback: Function) : void {
+    Object.keys(includeHash).forEach((key) => {
+      let nested = includeHash[key];
+      let relatedObjects = this.model[key];
+      if (!Array.isArray(relatedObjects)) relatedObjects = [relatedObjects];
+      relatedObjects.forEach((relatedObject) => {
+        if (relatedObject) {
+          callback(key, relatedObject, nested);
+        }
+      });
+    });
+  }
+}
+
+export default DirtyChecker;

src/util/relationship-identifiers.ts

@@ -0,0 +1,28 @@
+import Model from '../model';
+
+// Build a hash like
+// {
+//   posts: [{id: 1, type: 'posts'}],
+//   category: [{id: 1, type: 'categories}]
+// }
+// Will be array regardless of relationship type
+// This will only contain persisted objects
+// Used for dirty tracking associations
+export default function(model: Model, relationNames: Array<string>) : Object {
+  let identifiers = {};
+  relationNames.forEach((relationName) => {
+    let relatedObjects = model.relationships[relationName];
+    if (relatedObjects) {
+      if (!Array.isArray(relatedObjects)) relatedObjects = [relatedObjects];
+      relatedObjects.forEach((r) => {
+        if (r.isPersisted()) {
+          if (!identifiers[relationName]) {
+            identifiers[relationName] = [];
+          }
+          identifiers[relationName].push(r.resourceIdentifier);
+        }
+      });
+    }
+  });
+  return identifiers;
+}

src/util/uuid.ts

@@ -0,0 +1,8 @@
+const generate = function() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    let r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
+    return v.toString(16);
+  });
+}
+
+export default { generate };