Implement "exclude" option api

Author: digitalsadhu

README.md

@@ -67,7 +67,13 @@ Example:
   "loopback-component-jsonapi": {
     "restApiRoot": "/api",
     "enable": true,
-    "handleErrors": true
+    "handleErrors": true,
+    "exclude": [
+      {"model": "comment"},
+      {"methods": "find"},
+      {"model": "post", "methods": "find"},
+      {"model": "person", "methods": ["find", "create"]}
+    ]
   }
 }
 ```
@@ -87,6 +93,34 @@ format. Validation errors include the correct properties in order to work
 out of the box with ember.
 Default: true
 
+### exclude
+Allows blacklisting of models and methods. (See example above)
+Define an array of blacklist objects. Blacklist objects can contain "model" key
+"methods" key or both. If just "model" is defined then all methods for the
+specified model will not use jsonapi. If just the "methods" key is defined then
+all methods specified on all models will be not use jsonapi. If a combination of
+"model" and "methods" keys are used then the specific combination of model and methods
+specified will not use jsonapi.
+
+#### Please note
+The default component behavior currently is to only modify the output of the following
+methods on all models to be json api compliant:
+- find
+- create
+- updateAttributes
+- deleteById
+- findById
+- __get__.*
+- __findRelationships__.*
+
+And the default current behavior for modifying input only applies to the following methods on
+all models:
+- create
+- updateAttributes
+
+Type: array
+Default: null
+
 ## Debugging
 You can enable debug logging by setting an environment variable:
 DEBUG=loopback-component-jsonapi

lib/create.js

@@ -1,4 +1,5 @@
 var url = require('url');
+var utils = require('./utils');
 
 module.exports = function (app, options) {
   //get remote methods.
@@ -9,6 +10,10 @@ module.exports = function (app, options) {
   //register after remote method hook on all methods
   remotes.after('**', function (ctx, next) {
 
+    if (utils.shouldNotApplyJsonApi(ctx, options)) {
+      return next();
+    };
+
     //in this case we are only interested in handling create operations.
     if (ctx.method.name === 'create') {
       //JSON API specifies that created resources should have the

lib/delete.js

@@ -1,3 +1,5 @@
+var utils = require('./utils');
+
 module.exports = function (app, options) {
   //get remote methods.
   //set strong-remoting for more information
@@ -7,6 +9,10 @@ module.exports = function (app, options) {
   //register after remote method hook on all methods
   remotes.after('**', function (ctx, next) {
 
+    if (utils.shouldNotApplyJsonApi(ctx, options)) {
+      return next();
+    };
+
     //in this case we are only interested in handling create operations.
     if (ctx.method.name === 'deleteById') {
       //JSON API specifies that successful

lib/deserialize.js

@@ -3,14 +3,19 @@ var deserializer = require('./deserializer');
 var RelUtils = require('./utilities/relationship-utils');
 var utils = require('./utils');
 
-module.exports = function (app) {
+module.exports = function (app, options) {
   /**
    * Register a handler to run before all remote methods so that we can
    * transform JSON API structured JSON payload into something loopback
    * can work with.
    */
   app.remotes().before('**', function (ctx, next) {
     var data, serverRelations, errors;
+
+    if (utils.shouldNotApplyJsonApi(ctx, options)) {
+      return next();
+    };
+
     var regexs = [
       /^create$/,
       /^updateAttributes$/

lib/headers.js

@@ -1,11 +1,17 @@
 'use strict';
 var is = require('type-is');
 var _ = require('lodash');
+var utils = require('./utils');
 
 module.exports = function (app, options) {
   var remotes = app.remotes();
 
   remotes.before('**', function (ctx, next) {
+
+    if (utils.shouldNotApplyJsonApi(ctx, options)) {
+      return next();
+    };
+
     // We must force `application/json` until we can override it through strong remoting
     if (ctx.req.accepts('application/vnd.api+json')) {
       ctx.req.headers.accept = 'application/json';

lib/relationships.js

@@ -12,6 +12,10 @@ module.exports = function (app, options) {
 
   remotes.before('**', function (ctx, next) {
 
+    if (utils.shouldNotApplyJsonApi(ctx, options)) {
+      return next();
+    };
+
     id = ctx.req.params.id;
     data = ctx.args.data;
     model = utils.getModelFromContext(ctx, app);
@@ -23,6 +27,10 @@ module.exports = function (app, options) {
   // for create
   remotes.after('**', function (ctx, next) {
 
+    if (utils.shouldNotApplyJsonApi(ctx, options)) {
+      return next();
+    };
+
     if (ctx.result) {
       id = ctx.result.id;
       data = ctx.req.body;

lib/serialize.js

@@ -24,6 +24,10 @@ module.exports = function (app, defaults) {
       model,
       requestedIncludes;
 
+    if (utils.shouldNotApplyJsonApi(ctx, defaults)) {
+      return next();
+    };
+
     var matches = regexs.filter(function (regex) {
       return regex.test(ctx.method.name);
     });

lib/update.js

@@ -1,7 +1,14 @@
+var utils = require('./utils');
+
 module.exports = function (app, options) {
   var remotes = app.remotes();
 
   remotes.after('**', function (ctx, next) {
+
+    if (utils.shouldNotApplyJsonApi(ctx, options)) {
+      return next();
+    };
+
     if (ctx.method.name === 'updateAttributes') {
       // remote links object from resource response
       delete ctx.result.links;

lib/utils.js

@@ -1,5 +1,6 @@
 var url = require('url');
 var inflection = require('inflection');
+var _ = require('lodash');
 
 /**
  * Public API
@@ -13,7 +14,8 @@ module.exports = {
   modelNameFromContext: modelNameFromContext,
   pluralForModel: pluralForModel,
   urlFromContext: urlFromContext,
-  primaryKeyForModel: primaryKeyForModel
+  primaryKeyForModel: primaryKeyForModel,
+  shouldNotApplyJsonApi: shouldNotApplyJsonApi
 };
 
 function primaryKeyForModel (model) {
@@ -164,3 +166,22 @@ function buildModelUrl (protocol, host, apiRoot, modelName, id) {
 
   return result;
 }
+
+function shouldNotApplyJsonApi (ctx, options) {
+  //handle options.exclude
+  if (!options.exclude) return false;
+
+  var modelName = ctx.method.sharedClass.name;
+  var methodName = ctx.method.name;
+  var model;
+  var methods;
+  for (var i = 0; i < options.exclude.length; i++) {
+    model = options.exclude[i].model;
+    methods = options.exclude[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;
+}

test/exclude.test.js

@@ -0,0 +1,187 @@
+var request = require('supertest');
+var loopback = require('loopback');
+var expect = require('chai').expect;
+var JSONAPIComponent = require('../');
+var app;
+var Post;
+var Comment;
+
+describe('exclude 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);
+
+    Comment = ds.createModel('comment', { comment: String });
+    app.model(Comment);
+
+    app.use(loopback.rest());
+
+    Post.create({title: 'my post'}, function () {
+      Comment.create({comment: 'my comment'}, done);
+    });
+  });
+
+  describe('excluding a specific model', function () {
+    beforeEach(function () {
+      JSONAPIComponent(app, {
+        exclude: [
+          {model: 'post'}
+        ]
+      });
+    });
+    it('should not apply jsonapi to post model method input', function (done) {
+      request(app).post('/posts')
+        .send({ title: 'my post' })
+        .set('Accept', 'application/vnd.api+json')
+        .set('Content-Type', 'application/json')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body).to.deep.equal({ title: 'my post', id: 2 });
+          done();
+        });
+    });
+    it('should not apply jsonapi to post model output', function (done) {
+      request(app).get('/posts')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body).to.deep.equal([ { title: 'my post', id: 1 } ]);
+          done();
+        });
+    });
+    it('should apply jsonapi to comment model method output', function (done) {
+      request(app).get('/comments')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.data[0]).to.have.keys('type', 'id', 'attributes', 'links');
+          done();
+        });
+    });
+  });
+
+  describe('excluding a specific method', function () {
+    beforeEach(function () {
+      JSONAPIComponent(app, {
+        exclude: [
+          {methods: 'find'}
+        ]
+      });
+    });
+
+    it('should not apply jsonapi to post model output for find method', function (done) {
+      request(app).get('/posts')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body).to.deep.equal([ { title: 'my post', id: 1 } ]);
+          done();
+        });
+    });
+
+    it('should not apply jsonapi to comment model output for find method', function (done) {
+      request(app).get('/comments')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body).to.deep.equal([ { comment: 'my comment', id: 1 } ]);
+          done();
+        });
+    });
+
+    it('should apply jsonapi to post model output for findById method', function (done) {
+      request(app).get('/posts/1')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.data).to.have.keys('type', 'id', 'attributes', 'links');
+          done();
+        });
+    });
+
+    it('should apply jsonapi to comment model output for findById method', function (done) {
+      request(app).get('/comments/1')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.data).to.have.keys('type', 'id', 'attributes', 'links');
+          done();
+        });
+    });
+  });
+
+  describe('excluding a specific method on a specific model', function () {
+    beforeEach(function () {
+      JSONAPIComponent(app, {
+        exclude: [
+          {model: 'post', methods: 'find'}
+        ]
+      });
+    });
+
+    it('should not apply jsonapi to post model output for find method', function (done) {
+      request(app).get('/posts')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body).to.deep.equal([ { title: 'my post', id: 1 } ]);
+          done();
+        });
+    });
+
+    it('should apply jsonapi to post model output for findById method', function (done) {
+      request(app).get('/posts/1')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.data).to.have.keys('type', 'id', 'attributes', 'links');
+          done();
+        });
+    });
+
+    it('should apply jsonapi to comment model output for find method', function (done) {
+      request(app).get('/comments')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body.data[0]).to.have.keys('type', 'id', 'attributes', 'links');
+          done();
+        });
+    });
+  });
+
+  describe('excluding a specific set of methods on a specific model', function () {
+    beforeEach(function () {
+      JSONAPIComponent(app, {
+        exclude: [
+          {model: 'post', methods: ['find', 'findById']}
+        ]
+      });
+    });
+
+    it('should not apply jsonapi to post model output for find method', function (done) {
+      request(app).get('/posts')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body).to.deep.equal([ { title: 'my post', id: 1 } ]);
+          done();
+        });
+    });
+
+    it('should not apply jsonapi to post model output for findById method', function (done) {
+      request(app).get('/posts/1')
+        .expect(200)
+        .end(function (err, res) {
+          expect(err).to.equal(null);
+          expect(res.body).to.deep.equal({ title: 'my post', id: 1 });
+          done();
+        });
+    });
+  });
+});