fix hasMany polymorphic relationship

Author: Resonance1584

lib/serialize.js

@@ -71,7 +71,7 @@ module.exports = function (app, defaults) {
 
     var relation = model.relations[relationName];
     if (relationName && relation) {
-      if (relation.polymorphic) {
+      if (relation.polymorphic && utils.relationFkOnModelFrom(relation)) {
         var discriminator = utils.clone(ctx.instance)[relation.polymorphic.discriminator];
         relatedModel = app.models[discriminator];
       } else {

lib/serializer.js

@@ -170,7 +170,7 @@ function parseRelations (data, relations, options) {
     var fkName = relation.keyTo;
 
     // If relation is belongsTo then fk is the other way around
-    if (relation.type === 'belongsTo' || relation.type === 'referencesMany') {
+    if (utils.relationFkOnModelFrom(relation)) {
       fkName = relation.keyFrom;
     }
 
@@ -195,7 +195,7 @@ function parseRelations (data, relations, options) {
 
     var fromType = utils.pluralForModel(relation.modelFrom);
     var toType = '';
-    if (relation.polymorphic) {
+    if (relation.polymorphic && utils.relationFkOnModelFrom(relation)) {
       var discriminator = relation.polymorphic.discriminator;
       var model = options.app.models[data[discriminator]];
       toType = utils.pluralForModel(model);
@@ -328,7 +328,7 @@ function handleIncludes (resp, includes, relations, app) {
       var relation = relations[include];
       var propertyKey = relation.keyFrom;
       var plural = '';
-      if (relation.polymorphic) {
+      if (relation.polymorphic && utils.relationFkOnModelFrom(relation)) {
         var discriminator = resource.attributes[relation.polymorphic.discriminator];
         plural = utils.pluralForModel(app.models[discriminator]);
       } else {
@@ -337,7 +337,7 @@ function handleIncludes (resp, includes, relations, app) {
       var embeds = [];
 
       // If relation is belongsTo then pk and fk are the other way around
-      if (relation.type === 'belongsTo' || relation.type === 'referencesMany') {
+      if (utils.relationFkOnModelFrom(relation)) {
         propertyKey = relation.keyTo;
       }
 

lib/utils.js

@@ -16,7 +16,8 @@ module.exports = {
   urlFromContext: urlFromContext,
   primaryKeyForModel: primaryKeyForModel,
   shouldNotApplyJsonApi: shouldNotApplyJsonApi,
-  shouldApplyJsonApi: shouldApplyJsonApi
+  shouldApplyJsonApi: shouldApplyJsonApi,
+  relationFkOnModelFrom: relationFkOnModelFrom
 };
 
 function primaryKeyForModel (model) {
@@ -204,3 +205,7 @@ function shouldNotApplyJsonApi (ctx, options) {
   }
   return false;
 }
+
+function relationFkOnModelFrom (relation) {
+  return relation.type === 'belongsTo' || relation.type === 'referencesMany';
+}

test/hasManyPolymorphic.test.js

@@ -0,0 +1,95 @@
+var request = require('supertest');
+var loopback = require('loopback');
+var expect = require('chai').expect;
+var JSONAPIComponent = require('../');
+var app;
+var ds;
+var Post;
+var File;
+
+describe('loopback json api hasMany polymorphic relationships', function () {
+  beforeEach(function () {
+    app = loopback();
+    app.set('legacyExplorer', false);
+    ds = loopback.createDataSource('memory');
+
+    File = ds.createModel('file', {
+      id: {type: Number, id: true},
+      fileName: String,
+      parentId: Number,
+      parentType: String
+    });
+    File.settings.plural = 'files';
+    app.model(File);
+
+    Post = ds.createModel('post', {
+      id: {type: Number, id: true},
+      title: String,
+      content: String
+    });
+    Post.settings.plural = 'posts';
+    Post.hasMany(File, {
+      as: 'files',
+      polymorphic: 'parent'
+    });
+    app.model(Post);
+
+    app.use(loopback.rest());
+    JSONAPIComponent(app);
+  });
+
+  describe('Post hasMany Files', function () {
+    beforeEach(function (done) {
+      Post.create({
+        title: 'Post One',
+        content: 'Content'
+      }, function (err, post) {
+        expect(err).to.equal(null);
+        File.create({
+          fileName: 'blah.jpg',
+          parentId: post.id,
+          parentType: 'post'
+        }, done);
+      });
+    });
+
+    it('should have a relationship to Files', function (done) {
+      request(app).get('/posts/1')
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.errors).to.equal(undefined);
+          expect(res.body.data.relationships.files).to.be.an('object');
+          done();
+        });
+    });
+
+    it('should return the Files that belong to this Post when included flag is present', function (done) {
+      request(app).get('/posts/1?include=files')
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.errors).to.equal(undefined);
+          expect(res.body.included).to.be.an('array');
+          expect(res.body.included[0].type).to.equal('files');
+          expect(res.body.included[0].id).to.equal('1');
+          done();
+        });
+    });
+
+    it('should return the Files that belong to this Post when following the relationship link', function (done) {
+      request(app).get('/posts/1')
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.errors).to.equal(undefined);
+          request(app).get(res.body.data.relationships.files.links.related.split('api')[1])
+            .end(function (err, res) {
+              expect(err).to.equal(null);
+              expect(res.body.errors).to.equal(undefined);
+              expect(res.body.data).to.be.an('array');
+              expect(res.body.data[0].type).to.equal('files');
+              expect(res.body.data[0].id).to.equal('1');
+              done();
+            });
+        });
+    });
+  });
+});