Merge pull request #91 from digitalsadhu/add_include_whitelist_option

Add include whitelist option

Author: digitalsadhu

README.md

@@ -76,7 +76,12 @@ Example:
     "hideIrrelevantMethods": true,
     "attributes": {
       "posts": ["title"]
-    }
+    },
+    "include": [
+      {"methods": "customMethod"},
+      {"model": "post", "methods": "customMethod"},
+      {"model": "person", "methods": ["customMethod1", "customMethod2"]}
+    ]
   }
 }
 ```
@@ -171,6 +176,31 @@ The default behavior for modifying input only applies to the following methods o
 - `create`
 - `updateAttributes`
 
+### include
+Allows whitelisting of methods.
+Define an array of whitelist objects. Whitelist objects can contain a "methods" key
+or both a "models" key and a "methods" key. If just the "methods" key is defined then
+the methods specified will be serialized or deserialized using jsonapi on all models that have
+the specified methods. If a combination of
+"model" and "methods" keys are used then the specific combination of model and methods
+specified will be serialized or deserialized using jsonapi.
+
+#### example
+```js
+{
+  ...
+  "include": [
+    {"methods": "customMethod"},
+    {"model": "post", "methods": "customMethod"},
+    {"model": "person", "methods": ["customMethod1", "customMethod2"]}
+  ],
+  ...
+}
+```
+
+- Type: `array`
+- Default: `null`
+
 ### hideIrrelevantMethods
 By default, `loopback-component-jsonapi` disables a number of methods from each endpoint
 that are not jsonapi relevant. These methods are:

lib/deserialize.js

@@ -25,7 +25,7 @@ module.exports = function (app, options) {
       return regex.test(ctx.method.name);
     });
 
-    if (matches.length > 0) {
+    if (utils.shouldApplyJsonApi(ctx, options) || matches.length > 0) {
       // set the JSON API Content-Type response header
       ctx.res.set({'Content-Type': 'application/vnd.api+json'});
 

lib/serialize.js

@@ -31,7 +31,7 @@ module.exports = function (app, defaults) {
       return regex.test(ctx.method.name);
     });
 
-    if (!matches.length) {
+    if (!utils.shouldApplyJsonApi(ctx, defaults) && !matches.length) {
       return next();
     }
 

lib/utils.js

@@ -15,7 +15,8 @@ module.exports = {
   pluralForModel: pluralForModel,
   urlFromContext: urlFromContext,
   primaryKeyForModel: primaryKeyForModel,
-  shouldNotApplyJsonApi: shouldNotApplyJsonApi
+  shouldNotApplyJsonApi: shouldNotApplyJsonApi,
+  shouldApplyJsonApi: shouldApplyJsonApi
 };
 
 function primaryKeyForModel (model) {
@@ -167,6 +168,24 @@ function buildModelUrl (protocol, host, apiRoot, modelName, id) {
   return result;
 }
 
+function shouldApplyJsonApi (ctx, options) {
+  if (!options.include) return false;
+
+  var modelName = ctx.method.sharedClass.name;
+  var methodName = ctx.method.name;
+  var model;
+  var methods;
+  for (var i = 0; i < options.include.length; i++) {
+    model = options.include[i].model;
+    methods = options.include[i].methods;
+    if (model === modelName && !methods) return true;
+    if (!model && methods === methodName) return true;
+    if (model === modelName && methods === methodName) return true;
+    if (model === modelName && _.contains(methods, methodName)) return true;
+  }
+  return false;
+}
+
 function shouldNotApplyJsonApi (ctx, options) {
   //handle options.exclude
   if (!options.exclude) return false;

test/include.test.js

@@ -0,0 +1,138 @@
+var request = require('supertest');
+var loopback = require('loopback');
+var expect = require('chai').expect;
+var JSONAPIComponent = require('../');
+var app;
+var Post;
+var Comment;
+
+describe('include option', function () {
+  beforeEach(function (done) {
+    app = loopback();
+    app.set('legacyExplorer', false);
+    var ds = loopback.createDataSource('memory');
+
+    Post = ds.createModel('post', { title: String });
+    app.model(Post);
+    Post.customMethod = function (cb) {
+      cb(null, {prop: 'value'});
+    };
+    Post.remoteMethod('customMethod', {
+      http: {verb: 'get', path: '/custom'},
+      returns: {root: true}
+    });
+    Post.customMethod2 = function (cb) {
+      cb(null, {prop: 'value'});
+    };
+    Post.remoteMethod('customMethod2', {
+      http: {verb: 'get', path: '/custom2'},
+      returns: {root: true}
+    });
+
+    Comment = ds.createModel('comment', { comment: String });
+    app.model(Comment);
+    Comment.customMethod = function (cb) {
+      cb(null, {prop: 'value'});
+    };
+    Comment.remoteMethod('customMethod', {
+      http: {verb: 'get', path: '/custom'},
+      returns: {root: true}
+    });
+
+    app.use(loopback.rest());
+
+    Post.create({title: 'my post'}, function () {
+      Comment.create({comment: 'my comment'}, done);
+    });
+  });
+
+  describe('including a specific method', function () {
+    beforeEach(function () {
+      JSONAPIComponent(app, {
+        include: [
+          {methods: 'customMethod'}
+        ]
+      });
+    });
+
+    it('should apply jsonapi to post model output for customMethod method', function (done) {
+      request(app).get('/posts/custom')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.data).to.have.keys('type', 'attributes', 'links');
+          done();
+        });
+    });
+
+    it('should apply jsonapi to comment model output for customMethod method', function (done) {
+      request(app).get('/comments/custom')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.data).to.have.keys('type', 'attributes', 'links');
+          done();
+        });
+    });
+  });
+
+  describe('including a specific method on a specific model', function () {
+    beforeEach(function () {
+      JSONAPIComponent(app, {
+        include: [
+          {model: 'post', methods: 'customMethod'}
+        ]
+      });
+    });
+
+    it('should apply jsonapi to post model output for customMethod method', function (done) {
+      request(app).get('/posts/custom')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.data).to.have.keys('type', 'attributes', 'links');
+          done();
+        });
+    });
+
+    it('should not apply jsonapi to comment model output for customMethod method', function (done) {
+      request(app).get('/comments/custom')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body).to.deep.equal({ prop: 'value'});
+          done();
+        });
+    });
+  });
+
+  describe('including a specific set of methods on a specific model', function () {
+    beforeEach(function () {
+      JSONAPIComponent(app, {
+        include: [
+          {model: 'post', methods: ['customMethod', 'customMethod2']}
+        ]
+      });
+    });
+
+    it('should apply jsonapi to post model output for customMethod method', function (done) {
+      request(app).get('/posts/custom')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.data).to.have.keys('type', 'attributes', 'links');
+          done();
+        });
+    });
+
+    it('should apply jsonapi to post model output for customMethod method', function (done) {
+      request(app).get('/posts/custom2')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.data).to.have.keys('type', 'attributes', 'links');
+          done();
+        });
+    });
+  });
+});