attribute filtering option for resolver

Author: mickhansen

README.md

@@ -20,6 +20,12 @@ graphql-sequelize assumes you have graphql and sequelize installed.
 A helper for resolving graphql queries targeted at Sequelize models or associations.
 Please take a look at [the tests](https://github.com/mickhansen/graphql-sequelize/blob/master/test/integration/resolver.test.js) to best get an idea of implementation.
 
+### Attribute filtering
+
+The graphql-sequelize resolver will by default only select those attributes requested from the database.
+
+If you have non-database values that depend on other values you can either solve this by using virtual attributes with dependencies on your model or disable attribute filtering via `resolver.filterAttributes = false` or for specific resolvers with `resolver(target, {filterAttributes: false})`.
+
 ### Features
 
 - Automatically converts args to where if arg keys matches model attributes
@@ -28,7 +34,7 @@ Please take a look at [the tests](https://github.com/mickhansen/graphql-sequeliz
 - Only loads the attributes defined in the query (automatically adds primary key and foreign keys)
 - Prefetching nested resolvers with includes/joins
 
-### Relay
+### Relay & Connections
 
 [Relay documentation](docs/relay.md)
 

src/generateIncludes.js

@@ -22,8 +22,7 @@ export default function generateIncludes(simpleAST, type, root, options) {
       , includeResolver = type._fields[name].resolve
       , nestedResult
       , allowedAttributes
-      , include
-      , connectionFields = [];
+      , include;
 
     if (!includeResolver) return;
 
@@ -64,10 +63,14 @@ export default function generateIncludes(simpleAST, type, root, options) {
       includeOptions = argsToFindOptions(args, association.target);
       allowedAttributes = Object.keys(association.target.rawAttributes);
 
-      includeOptions.attributes = (includeOptions.attributes || [])
+
+      if (options.filterAttributes) {
+        includeOptions.attributes = (includeOptions.attributes || [])
                                   .concat(Object.keys(fieldAST.fields).map(key => fieldAST.fields[key].key || key))
-                                  .concat(connectionFields)
                                   .filter(inList.bind(null, allowedAttributes));
+      } else {
+        includeOptions.attributes = allowedAttributes;
+      }
 
       if (includeResolver.$before) {
         includeOptions = includeResolver.$before(includeOptions, args, root, {

src/resolver.js

@@ -9,7 +9,7 @@ function inList(list, attribute) {
   return ~list.indexOf(attribute);
 }
 
-module.exports = function (target, options) {
+function resolverFactory(target, options) {
   var resolver
     , targetAttributes
     , isModel = !!target.getTableName
@@ -24,6 +24,7 @@ module.exports = function (target, options) {
   if (options.before === undefined) options.before = (options) => options;
   if (options.after === undefined) options.after = (result) => result;
   if (options.handleConnection === undefined) options.handleConnection = true;
+  if (options.filterAttributes) options.filterAttributes = resolverFactory.filterAttributes;
 
   resolver = function (source, args, info) {
     var root = info.rootValue || {}
@@ -56,9 +57,13 @@ module.exports = function (target, options) {
       });
     }
 
-    findOptions.attributes = Object.keys(fields)
+    if (options.filterAttributes) {
+      findOptions.attributes = Object.keys(fields)
                              .map(key => fields[key].key || key)
                              .filter(inList.bind(null, targetAttributes));
+    } else {
+      findOptions.attributes = targetAttributes;
+    }
 
     findOptions.attributes.push(model.primaryKeyAttribute);
 
@@ -118,4 +123,8 @@ module.exports = function (target, options) {
   resolver.$options = options;
 
   return resolver;
-};
+}
+
+resolverFactory.filterAttributes = false;
+
+module.exports = resolverFactory;

test/integration/resolver.test.js

@@ -1030,4 +1030,107 @@ describe('resolver', function () {
       });
     });
   });
+
+  describe('filterAttributes', function () {
+    beforeEach(function () {
+      this.defaultValue = resolver.filterAttributes;
+      this.userType = new GraphQLObjectType({
+        name: 'User',
+        description: 'A user',
+        fields: {
+          id: {
+            type: new GraphQLNonNull(GraphQLInt),
+          },
+          name: {
+            type: GraphQLString,
+          },
+          fullName: {
+            type: GraphQLString,
+            resolve: (user) => user.get('name')
+          }
+        }
+      });
+    });
+
+    afterEach(function () {
+      resolver.filterAttributes = this.defaultValue;
+    });
+
+    it('should be able to disable via a global option', async function ()  {
+      resolver.filterAttributes = false;
+
+      var user = this.userB
+        , schema;
+
+      schema = new GraphQLSchema({
+        query: new GraphQLObjectType({
+          name: 'RootQueryType',
+          fields: {
+            user: {
+              type: this.userType,
+              args: {
+                id: {
+                  type: GraphQLInt
+                }
+              },
+              resolve: resolver(User, {
+                include: false
+              })
+            }
+          }
+        })
+      });
+
+      return graphql(schema, `
+        {
+          user(id: ${user.get('id')}) {
+            fullName
+          }
+        }
+      `).then(function (result) {
+        if (result.errors) throw new Error(result.errors[0].stack);
+
+        expect(result.data.user.fullName).to.equal(user.get('name'));
+      });
+    });
+
+    it('should be able to disable via a resolver option', async function ()  {
+      resolver.filterAttributes = true;
+      
+      var user = this.userB
+        , schema;
+
+      schema = new GraphQLSchema({
+        query: new GraphQLObjectType({
+          name: 'RootQueryType',
+          fields: {
+            user: {
+              type: this.userType,
+              args: {
+                id: {
+                  type: GraphQLInt
+                }
+              },
+              resolve: resolver(User, {
+                include: false,
+                filterAttributes: false
+              })
+            }
+          }
+        })
+      });
+
+      return graphql(schema, `
+        {
+          user(id: ${user.get('id')}) {
+            fullName
+          }
+        }
+      `).then(function (result) {
+        if (result.errors) throw new Error(result.errors[0].stack);
+
+        expect(result.data.user.fullName).to.equal(user.get('name'));
+      });
+    });
+  });
 });