Updates for new json suite changes + fixes (#12)

* Updates for new json suite changes

* serialize relationships in resource objects ('included'), not resource identifier objects ('relationships')

* restore markManyToManyDeletion functionality

* reuse variable

* Ember.guidFor instead of uuid()

* hide side effects better

Author: jnaglick

.eslintrc.js

@@ -0,0 +1,42 @@
+module.exports = {
+  globals: {
+    server: true,
+  },
+  root: true,
+  parserOptions: {
+    ecmaVersion: 2017,
+    sourceType: 'module'
+  },
+  plugins: [
+    'ember'
+  ],
+  extends: [
+    'eslint:recommended',
+    'plugin:ember/recommended'
+  ],
+  env: {
+    browser: true
+  },
+  rules: {
+  },
+  overrides: [
+    // node files
+    {
+      files: [
+        'ember-cli-build.js',
+        'testem.js',
+        'blueprints/*/index.js',
+        'config/**/*.js',
+        'lib/*/index.js'
+      ],
+      parserOptions: {
+        sourceType: 'script',
+        ecmaVersion: 2015
+      },
+      env: {
+        browser: false,
+        node: true
+      }
+    }
+  ]
+};

addon/mixins/model.js

@@ -75,8 +75,8 @@ export default Ember.Mixin.create({
 
   manyToManyMarkedForDeletionModels(relation) {
     const relationModels = this.get('_manyToManyDeleted') &&
-                            this.get(`_manyToManyDeleted.${relation}`);
-    return relationModels && relationModels.toArray();
+      this.get(`_manyToManyDeleted.${relation}`);
+    return relationModels && relationModels.toArray() || [];
   },
 
   unmarkManyToManyDeletion(relation, model) {
@@ -85,6 +85,12 @@ export default Ember.Mixin.create({
             this.get(`_manyToManyDeleted.${relation}`).removeObject(model);
   },
 
+  tempId() {
+    if (!this._tempId) {
+      this._tempId = Ember.guidFor(this);
+    }
+    return this._tempId;
+  },
 
   jsonapiType() {
     return this.store

addon/mixins/nested-relations.js

@@ -16,7 +16,6 @@ const iterateRelations = function(record, relations, callback) {
     let relatedRecord     = record.get(relationName);
     let manyToManyDeleted = record.manyToManyMarkedForDeletionModels(relationName);
 
-
     if (metadata.options.async !== false) {
       relatedRecord = relatedRecord.get('content');
     }
@@ -31,11 +30,10 @@ const isPresentObject = function(val) {
   return val && Object.keys(val).length > 0;
 };
 
-const attributesFor = function(record, isManyToManyDelete) {
+const attributesFor = function(record) {
   let attrs = {};
 
   let changes = record.changedAttributes();
-
   let serializer = record.store.serializerFor(record.constructor.modelName);
 
   record.eachAttribute((name/* meta */) => {
@@ -50,71 +48,115 @@ const attributesFor = function(record, isManyToManyDelete) {
     }
   });
 
-  if (record.get('markedForDeletion') || isManyToManyDelete) {
-    attrs = { _delete: true };
-  }
-
-  if (!record.get('isNew') && record.get('markedForDestruction')) {
-    attrs = { _destroy: true };
-  }
-
   return attrs;
 };
 
 const jsonapiPayload = function(record, isManyToManyDelete) {
-  let attributes = attributesFor(record, isManyToManyDelete);
+  let attributes = attributesFor(record);
 
   let payload = { type: record.jsonapiType() };
 
   if (isPresentObject(attributes)) {
     payload.attributes = attributes;
   }
 
+  if (record.get('isNew')) {
+    payload['temp-id'] = record.tempId();
+    payload['method'] = 'create';
+  }
+  else if (record.get('markedForDestruction')) {
+    payload['method'] = 'destroy';
+  }
+  else if (record.get('markedForDeletion') || isManyToManyDelete) {
+    payload['method'] = 'disassociate';
+  }
+  else if (record.get('currentState.isDirty')) {
+    payload['method'] = 'update';
+  }
+
   if (record.id) {
     payload.id = record.id;
   }
 
   return payload;
 };
 
-const hasManyData = function(relationName, relatedRecords, subRelations, manyToManyDeleted) {
+const payloadForInclude = function(payload) {
+  let payloadCopy = Ember.copy(payload, true);
+  delete(payloadCopy.method);
+
+  return payloadCopy;
+};
+
+const payloadForRelationship = function(payload) {
+  let payloadCopy = Ember.copy(payload, true);
+  delete(payloadCopy.attributes);
+  delete(payloadCopy.relationships);
+
+  return payloadCopy;
+};
+
+const addToIncludes = function(payload, includedRecords) {
+  let includedPayload = payloadForInclude(payload);
+
+  if (!includedPayload.attributes && !isPresentObject(includedPayload.relationships)) {
+    return;
+  }
+
+  const alreadyIncluded = includedRecords.find((includedRecord) =>
+    includedPayload['type'] === includedRecord['type'] &&
+    ((includedPayload['temp-id'] && includedPayload['temp-id'] === includedRecord['temp-id']) ||
+      (includedPayload['id'] && includedPayload['id'] === includedRecord['id']))
+  ) !== undefined;
+
+  if (!alreadyIncluded) {
+    includedRecords.push(includedPayload);
+  }
+};
+
+const hasManyData = function(relationName, relatedRecords, subRelations, manyToManyDeleted, includedRecords) {
   let payloads = [];
   savedRecords[relationName] = [];
+
   relatedRecords.forEach((relatedRecord) => {
     let payload = jsonapiPayload(relatedRecord, manyToManyDeleted && manyToManyDeleted.includes(relatedRecord));
-    processRelationships(subRelations, payload, relatedRecord);
-    payloads.push(payload);
+    processRelationships(subRelations, payload, relatedRecord, includedRecords);
+    addToIncludes(payload, includedRecords);
+
+    payloads.push(payloadForRelationship(payload));
     savedRecords[relationName].push(relatedRecord);
   });
   return { data: payloads };
 };
 
-const belongsToData = function(relatedRecord, subRelations) {
+const belongsToData = function(relatedRecord, subRelations, includedRecords) {
   let payload = jsonapiPayload(relatedRecord);
-  processRelationships(subRelations, payload, relatedRecord);
-  return { data: payload };
+  processRelationships(subRelations, payload, relatedRecord, includedRecords);
+  addToIncludes(payload, includedRecords);
+
+  return { data: payloadForRelationship(payload) };
 };
 
-const processRelationship = function(name, kind, relationData, subRelations, manyToManyDeleted, callback) {
+const processRelationship = function(name, kind, relationData, subRelations, manyToManyDeleted, includedRecords, callback) {
   let payload = null;
 
   if (kind === 'hasMany') {
-    payload = hasManyData(name, relationData, subRelations, manyToManyDeleted);
+    payload = hasManyData(name, relationData, subRelations, manyToManyDeleted, includedRecords);
   } else {
-    payload = belongsToData(relationData, subRelations);
+    payload = belongsToData(relationData, subRelations, includedRecords);
   }
 
   if (payload && payload.data) {
     callback(payload);
   }
 };
 
-const processRelationships = function(relationshipHash, jsonData, record) {
+const processRelationships = function(relationshipHash, jsonData, record, includedRecords) {
   if (isPresentObject(relationshipHash)) {
     jsonData.relationships = {};
 
     iterateRelations(record, relationshipHash, (name, kind, related, subRelations, manyToManyDeleted) => {
-      processRelationship(name, kind, related, subRelations, manyToManyDeleted, (payload) => {
+      processRelationship(name, kind, related, subRelations, manyToManyDeleted, includedRecords, (payload) => {
         let serializer = record.store.serializerFor(record.constructor.modelName);
         let serializedName = serializer.keyForRelationship(name);
         jsonData.relationships[serializedName] = payload;
@@ -148,7 +190,9 @@ const relationshipsDirective = function(value) {
 export default Ember.Mixin.create({
   serialize(snapshot/*, options */) {
     savedRecords = [];
+
     let json = this._super(...arguments);
+    let includedRecords = [];
 
     if (snapshot.record.get('emberDataExtensions') !== false) {
       delete(json.data.relationships);
@@ -180,7 +224,10 @@ export default Ember.Mixin.create({
       }
 
       let relationships = relationshipsDirective(adapterOptions.relationships);
-      processRelationships(relationships, json.data, snapshot.record);
+      processRelationships(relationships, json.data, snapshot.record, includedRecords);
+      if (includedRecords && includedRecords.length > 0) {
+        json.included = includedRecords;
+      }
       snapshot.record.set('__recordsJustSaved', savedRecords);
     }
 

index.js

@@ -2,5 +2,8 @@
 'use strict';
 
 module.exports = {
-  name: 'ember-data-extensions'
+  name: 'ember-data-extensions',
+  isDevelopingAddon() {
+    return true;
+  }
 };

testem.js

@@ -4,10 +4,9 @@ module.exports = {
   "test_page": "tests/index.html?hidepassed",
   "disable_watching": true,
   "launch_in_ci": [
-    "PhantomJS"
+    "Chrome"
   ],
   "launch_in_dev": [
-    "PhantomJS",
     "Chrome"
   ]
 };

tests/dummy/app/controllers/post-form.js

@@ -1,9 +1,5 @@
 import Ember from 'ember';
 
 export default Ember.Controller.extend({
-  tags: Ember.computed.filterBy(
-    'model.tags',
-    'markedForDeletion',
-    false
-  )
+  tags: Ember.computed.filterBy('model.tags', 'markedForDeletion', false)
 });

tests/dummy/mirage/config.js

@@ -14,16 +14,29 @@ const iterateRelations = function(request, callback) {
 
 // Omit anything that has all blank attributes
 // Akin to rails' accepts_nested_attributes_for :foos, reject_if: :all_blank
-const recordFromJson = function(db, data, callback) {
-  let attributes = data.attributes || {};
+const recordFromJson = function(db, data, includedData, callback) {
+
+  let found;
+
+  if (data['temp-id']) {
+    found = includedData.filter(item => (item['temp-id'] === data['temp-id']))[0];
+  }
+  else {
+    found = includedData.filter(item => (item.id === data.id))[0];
+  }
+
+  let attributes = found ? found.attributes : {};
 
   if (data.id) {
     let record = db[data.type].find(data.id);
-    record.update(attributes);
+
+    if (data['method'] === 'update') {
+      record.update(attributes);
+    }
     callback(record);
     return;
   }
-
+  
   let notNull = false;
   Object.keys(attributes).forEach((key) => {
     if (Ember.isPresent(attributes[key])) {
@@ -53,17 +66,16 @@ const hasRecord = function(array, record) {
   }
 };
 
-const markedForRemoval= function(record) {
-  return record._delete || record._destroy;
-};
-
-const buildOneToMany = function(db, relationData, originalRecords) {
+const buildOneToMany = function(db, relationData, includedRecords, originalRecords) {
   relationData.forEach((data) => {
-    recordFromJson(db, data, (record) => {
-      if (markedForRemoval(record)) {
+    let method = data.method;
+
+    recordFromJson(db, data, includedRecords, (record) => {
+      if (method === 'disassociate' || method === 'destroy') {
         let index = originalRecords.indexOf(record);
         originalRecords.splice(index, 1);
-      } else {
+      }
+      else {
         if (!hasRecord(originalRecords, record)) {
           originalRecords.push(record);
         }
@@ -74,13 +86,18 @@ const buildOneToMany = function(db, relationData, originalRecords) {
 };
 
 const processRelations = function(record, db, request) {
+  let includedRecords = JSON.parse(request.requestBody).included || [];
+
   iterateRelations(request, (relationName, relationData) => {
     if (Array.isArray(relationData)) {
       let originals = record[relationName].models;
-      record[relationName] = buildOneToMany(db, relationData, originals);
+      record[relationName] = buildOneToMany(db, relationData, includedRecords, originals);
     } else {
-      recordFromJson(db, relationData, (relationRecord) => {
+      recordFromJson(db, relationData, includedRecords, (relationRecord, remove) => {
         record[relationName] = relationRecord;
+        if (remove) {
+          delete record[relationName];
+        }
       });
     }
   });

tests/unit/mixins/model-test.js

@@ -70,8 +70,8 @@ test('resetting relations when only sending dirty relations', function(assert) {
         data: [
           {
             id: '2',
+            method: 'update',
             type: 'tags',
-            attributes: { name: 'tag1 changed' }
           },
           {
             id: '3',
@@ -80,6 +80,17 @@ test('resetting relations when only sending dirty relations', function(assert) {
         ]
       }
     });
+
+    let included = JSON.parse(request.requestBody).included;
+    assert.deepEqual(included, [
+      {
+        id: '2',
+        type: 'tags',
+        attributes: { name: 'tag1 changed' }
+      }
+    ]);
+
+
     done();
     let post = db.posts.find(request.params.id);
     post.tags.models[0].update({ name: 'tag1 changed' });