Add linkage from relationships.data to included

Author: digitalsadhu

lib/serializer.js

@@ -276,22 +276,36 @@ function handleIncludes (resp, includes, relations) {
       if (!relation) {
         throw RelUtils.getInvalidIncludesError('Can\'t locate relationship "' + include + '" to include');
       }
+
+      resource.relationships[include] = resource.relationships[include] || {};
+
       if (resource.relationships[include] && resource.attributes[include]) {
         if (_.isArray(resource.attributes[include])) {
           embeds = resource.attributes[include].map(function (rel) {
             rel = utils.clone(rel);
-            return createCompoundIncludes(rel, propertyKey, plural);
+            return createCompoundIncludes(rel, propertyKey, relation.keyTo, plural);
           });
           embeds = _.compact(embeds);
 
-          resource.attributes[include] = _.map(embeds, 'id');
+          resource.relationships[include].data = resource.attributes[include].map(function (relData) {
+            return {
+              id: String(relData[propertyKey]),
+              type: plural
+            };
+          });
         } else {
           var rel = utils.clone(resource.attributes[include]);
-          var compoundIncludes = createCompoundIncludes(rel, propertyKey, plural);
-          resource.attributes[include] = String(resource.attributes[include][propertyKey]);
+          var compoundIncludes = createCompoundIncludes(rel, propertyKey, relation.keyFrom, plural);
 
+          resource.relationships[include].data = {
+            id: String(resource.attributes[include][propertyKey]),
+            type: plural
+          };
           embeds.push(compoundIncludes);
         }
+        delete resource.attributes[relation.keyFrom];
+        delete resource.attributes[relation.keyTo];
+        delete resource.attributes[include];
       }
       return embeds;
     });
@@ -307,15 +321,16 @@ function handleIncludes (resp, includes, relations) {
  * @private
  * @memberOf {Serializer}
  * @param {Object} relationship
- * @param {String} id
+ * @param {String} key
  * @param {String} type
  * @return {Object}
  */
-function createCompoundIncludes (relationship, key, type) {
+function createCompoundIncludes (relationship, key, fk, type) {
   var compoundInclude = makeRelation(type, String(relationship[key]));
 
   // remove the id key since its part of the base compound document, not part of attributes
   delete relationship[key];
+  delete relationship[fk];
 
   // The rest of the data goes in the attributes
   compoundInclude.attributes = relationship;

test/belongsTo.test.js

@@ -215,8 +215,8 @@ describe('loopback json api belongsTo relationships', function () {
           });
       });
 
-      it.skip('should return included data as a compound document using key "included"', function (done) {
-        request(app).get('/comments?filter={"include":"post"}')
+      it('should return included data as a compound document using key "included"', function (done) {
+        request(app).get('/comments?filter[include]=post')
           .end(function (err, res) {
             expect(err).to.equal(null);
             expect(res.body.data[0].relationships).to.be.an('object');
@@ -229,8 +229,8 @@ describe('loopback json api belongsTo relationships', function () {
             expect(res.body.data[0].relationships.post.links.related).to.match(/comments\/1\/post/);
             expect(res.body.included).to.be.an('array');
             expect(res.body.included.length).to.equal(1);
-            expect(res.body.included[0]).to.have.all.keys('type', 'id', 'attributes', 'links');
-            expect(res.body.included[0].type).to.equal('post');
+            expect(res.body.included[0]).to.have.all.keys('type', 'id', 'attributes');
+            expect(res.body.included[0].type).to.equal('posts');
             expect(res.body.included[0].id).to.equal('1');
             done();
           });

test/hasMany.test.js

@@ -171,21 +171,24 @@ describe('loopback json api hasMany relationships', function () {
           });
       });
 
-      it.skip('should return included data as a compound document using key "included"', function (done) {
-        request(app).get('/posts?filter={"include":"comments"}')
+      it('should return included data as a compound document using key "included"', function (done) {
+        request(app).get('/posts?filter[include]=comments')
           .end(function (err, res) {
             expect(err).to.equal(null);
             expect(res.body.data[0].relationships).to.be.an('object');
             expect(res.body.data[0].relationships.comments).to.be.an('object');
-            expect(res.body.data[0].relationships.comments.data).to.deep.equal({
+            expect(res.body.data[0].relationships.comments.data).to.deep.equal([{
               type: 'comments',
               id: '1'
-            });
+            }, {
+              type: 'comments',
+              id: '2'
+            }]);
             expect(res.body.data[0].relationships.comments.links).to.be.an('object');
             expect(res.body.data[0].relationships.comments.links.related).to.match(/posts\/1\/comments/);
             expect(res.body.included).to.be.an('array');
-            expect(res.body.included.length).to.equal(1);
-            expect(res.body.included[0]).to.have.all.keys('type', 'id', 'attributes', 'links');
+            expect(res.body.included.length).to.equal(2);
+            expect(res.body.included[0]).to.have.all.keys('type', 'id', 'attributes');
             expect(res.body.included[0].type).to.equal('comments');
             expect(res.body.included[0].id).to.equal('1');
             done();
@@ -204,12 +207,11 @@ describe('loopback json api hasMany relationships', function () {
             expect(err).to.equal(null);
             expect(res.body.included).to.be.an('array');
             expect(res.body.included.length).to.equal(2);
-            expect(res.body.data[0].attributes.comments).to.deep.equal(['1', '2']);
+            expect(res.body.data[0].attributes).to.not.have.keys('comments');
             expect(res.body.included[0]).to.deep.equal({
               id: '1',
               type: 'comments',
               attributes: {
-                postId: 1,
                 title: 'My comment',
                 comment: 'My comment text'
               }
@@ -218,7 +220,6 @@ describe('loopback json api hasMany relationships', function () {
               id: '2',
               type: 'comments',
               attributes: {
-                postId: 1,
                 title: 'My second comment',
                 comment: 'My second comment text'
               }
@@ -256,21 +257,24 @@ describe('loopback json api hasMany relationships', function () {
           });
       });
 
-      it.skip('should return included data as a compound document using key "included"', function (done) {
-        request(app).get('/posts/1?filter={"include":"comments"}')
+      it('should return included data as a compound document using key "included"', function (done) {
+        request(app).get('/posts/1?filter[include]=comments')
           .end(function (err, res) {
             expect(err).to.equal(null);
             expect(res.body.data.relationships).to.be.an('object');
             expect(res.body.data.relationships.comments).to.be.an('object');
-            expect(res.body.data.relationships.comments.data).to.deep.equal({
+            expect(res.body.data.relationships.comments.data).to.deep.equal([{
               type: 'comments',
               id: '1'
-            });
+            }, {
+              type: 'comments',
+              id: '2'
+            }]);
             expect(res.body.data.relationships.comments.links).to.be.an('object');
             expect(res.body.data.relationships.comments.links.related).to.match(/posts\/1\/comments/);
             expect(res.body.included).to.be.an('array');
-            expect(res.body.included.length).to.equal(1);
-            expect(res.body.included[0]).to.have.all.keys('type', 'id', 'attributes', 'links');
+            expect(res.body.included.length).to.equal(2);
+            expect(res.body.included[0]).to.have.all.keys('type', 'id', 'attributes');
             expect(res.body.included[0].type).to.equal('comments');
             expect(res.body.included[0].id).to.equal('1');
             done();

test/hasManyRelationships.test.js

@@ -11,91 +11,77 @@ describe('loopback json api hasMany relationships', function () {
     ds = loopback.createDataSource('memory');
 
     Post = ds.createModel('post', {
-      id: {
-        type: Number,
-        id: true
-      },
       title: String,
       content: String
     });
     app.model(Post);
 
     Comment = ds.createModel('comment', {
-      id: {
-        type: Number,
-        id: true
-      },
-      postId: Number,
       title: String,
       comment: String
     });
     Comment.settings.plural = 'comments';
     app.model(Comment);
 
     Author = ds.createModel('author', {
-      id: {
-        type: Number,
-        id: true
-      },
       firstName: String,
       lastName: String
     });
     Author.settings.plural = 'authors';
     app.model(Author);
 
-    Post.hasMany(Comment, {
-      as: 'comments',
-      foreignKey: 'postId'
-    });
-    Post.hasOne(Author, {
-      as: 'author',
-      foreignKey: 'id'
-    });
+    Post.hasMany(Comment);
+    Comment.belongsTo(Post);
+    Post.belongsTo(Author);
+    Author.hasMany(Post);
 
     app.use(loopback.rest());
     JSONAPIComponent(app, {restApiRoot: '/'});
   });
 
-  describe('Requesting multiple via `includes` should return relationships', function (done) {
+  describe('Multiple `includes`', function (done) {
     beforeEach(function (done) {
       Author.create({
         firstName: 'Joe',
         lastName: 'Shmoe'
       }, function (err, author) {
         expect(err).to.equal(null);
-        Post.create({
+        author.posts.create({
           title: 'my post',
           content: 'my post content'
         }, function (err, post) {
           expect(err).to.equal(null);
-          post.comments.create({
+          post.comments.create([{
             title: 'My comment',
             comment: 'My comment text'
-          }, function () {
-            post.comments.create({
-              title: 'My second comment',
-              comment: 'My second comment text'
-            }, done);
-          });
+          }, {
+            title: 'My second comment',
+            comment: 'My second comment text'
+          }], done);
         });
       });
     });
 
-    it('should return stuff', function (done) {
+    it('should sideload author and comments', function (done) {
       request(app).get('/posts/1/?include=author,comments')
         .expect(200)
         .end(function (err, res) {
+          var data = res.body.data;
           expect(err).to.equal(null);
-          //expect(res.body.data.id).to.equal('1');
-          expect(res.body.data.type).to.equal('posts');
-          expect(res.body.data.relationships).to.be.a('object');
-          expect(res.body.data.relationships.author).to.be.a('object');
-          expect(res.body.data.relationships.comments).to.be.a('object');
-          expect(res.body.data.attributes).to.deep.equal({
+          expect(data.id).to.equal('1');
+          expect(data.type).to.equal('posts');
+          expect(data.relationships).to.be.a('object');
+          expect(data.relationships.author).to.be.a('object');
+          expect(data.relationships.author.data.id).to.equal('1');
+          expect(data.relationships.author.data.type).to.equal('authors');
+          expect(data.relationships.comments.data).to.be.a('array');
+          expect(data.relationships.comments.data[0].id).to.equal('1');
+          expect(data.relationships.comments.data[0].type).to.equal('comments');
+          expect(data.relationships.comments.data[1].id).to.equal('2');
+          expect(data.relationships.comments.data[1].type).to.equal('comments');
+          expect(data.attributes).to.deep.equal({
             title: 'my post',
-            content: 'my post content',
-            author: '1',
-            comments: [ '1', '2' ]
+            content: 'my post content'
           });
           expect(res.body.included).to.be.an('array');
           expect(res.body.included.length).to.equal(3);
@@ -111,7 +97,6 @@ describe('loopback json api hasMany relationships', function () {
             id: '1',
             type: 'comments',
             attributes: {
-              postId: 1,
               title: 'My comment',
               comment: 'My comment text'
             }
@@ -120,7 +105,6 @@ describe('loopback json api hasMany relationships', function () {
             id: '2',
             type: 'comments',
             attributes: {
-              postId: 1,
               title: 'My second comment',
               comment: 'My second comment text'
             }

test/hasOne.test.js

@@ -166,8 +166,8 @@ describe('loopback json api hasOne relationships', function () {
           });
       });
 
-      it.skip('should return included data as a compound document using key "included"', function (done) {
-        request(app).get('/posts?filter={"include":"author"}')
+      it('should return included data as a compound document using key "included"', function (done) {
+        request(app).get('/posts?filter[include]=author')
           .end(function (err, res) {
             expect(err).to.equal(null);
             expect(res.body.data[0].relationships).to.be.an('object');
@@ -180,7 +180,7 @@ describe('loopback json api hasOne relationships', function () {
             expect(res.body.data[0].relationships.author.links.related).to.match(/posts\/1\/author/);
             expect(res.body.included).to.be.an('array');
             expect(res.body.included.length).to.equal(1);
-            expect(res.body.included[0]).to.have.all.keys('type', 'id', 'attributes', 'links');
+            expect(res.body.included[0]).to.have.all.keys('type', 'id', 'attributes');
             expect(res.body.included[0].type).to.equal('people');
             expect(res.body.included[0].id).to.equal('1');
             done();
@@ -240,8 +240,8 @@ describe('loopback json api hasOne relationships', function () {
           });
       });
 
-      it.skip('should return included data as a compound document using key "included"', function (done) {
-        request(app).get('/posts/1?filter={"include":"author"}')
+      it('should return included data as a compound document using key "included"', function (done) {
+        request(app).get('/posts/1?filter[include]=author')
           .end(function (err, res) {
             expect(err).to.equal(null);
             expect(res.body.data.relationships).to.be.an('object');
@@ -254,7 +254,7 @@ describe('loopback json api hasOne relationships', function () {
             expect(res.body.data.relationships.author.links.related).to.match(/posts\/1\/author/);
             expect(res.body.included).to.be.an('array');
             expect(res.body.included.length).to.equal(1);
-            expect(res.body.included[0]).to.have.all.keys('type', 'id', 'attributes', 'links');
+            expect(res.body.included[0]).to.have.all.keys('type', 'id', 'attributes');
             expect(res.body.included[0].type).to.equal('people');
             expect(res.body.included[0].id).to.equal('1');
             done();