Add defaultAttributes resolver option

Author: jonathanglasmeyer

README.md

@@ -1,7 +1,7 @@
 # graphql-sequelize
 
 [![NPM](https://img.shields.io/npm/v/graphql-sequelize.svg)](https://www.npmjs.com/package/graphql-sequelize)
-[![Build Status](https://travis-ci.org/mickhansen/graphql-sequelize.svg?branch=master)](https://travis-ci.org/mickhansen/graphql-sequelize) 
+[![Build Status](https://travis-ci.org/mickhansen/graphql-sequelize.svg?branch=master)](https://travis-ci.org/mickhansen/graphql-sequelize)
 [![Slack Status](http://sequelize-slack.herokuapp.com/badge.svg)](http://sequelize-slack.herokuapp.com)
 
 - [Installation](#installation)
@@ -26,6 +26,9 @@ The graphql-sequelize resolver will by default only select those attributes requ
 
 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})`.
 
+#### Default attributes
+When filtering attributes you might need some fields every time, regardless of wether they have been requested in the query. You can specify those fields with the `defaultAttributes` resolver option like `resolver(target, {defaultAttributes: ['default', 'field', 'names']})`. A common use case would be the need to fetch a `userId` for every query and every resource of your domain model for permission checking -- in that case you would write your `resolver` functions like `resolver(target, {defaultAttributes: ['userId']})`.
+
 ### Features
 
 - Automatically converts args to where if arg keys matches model attributes
@@ -38,7 +41,7 @@ If you have non-database values that depend on other values you can either solve
 
 [Relay documentation](docs/relay.md)
 
-### Examples 
+### Examples
 
 ```js
 import {resolver} from 'graphql-sequelize';
@@ -236,7 +239,7 @@ attributeFields(Model);
 ### Renaming generated fields
 
 attributeFields accepts a ```map``` option to customize the way the attribute fields are named. The ```map``` option accepts
-an object or a function that returns a string. 
+an object or a function that returns a string.
 
 ```js
 
@@ -336,12 +339,12 @@ fullName: {
 
 ### defaultArgs
 
-`defaultArgs(Model)` will return an object containing an arg with a key and type matching your models primary key and 
+`defaultArgs(Model)` will return an object containing an arg with a key and type matching your models primary key and
 the "where" argument for passing complex query operations described [here](http://docs.sequelizejs.com/en/latest/docs/querying/)
 
 ```js
 var Model = sequelize.define('User', {
-  
+
 });
 
 defaultArgs(Model);
@@ -387,7 +390,7 @@ defaultArgs(Model);
     type: GraphQLString
   },
   where: {
-    type JSONType 
+    type JSONType
   }
 }
 ```

package.json

@@ -54,6 +54,7 @@
   "dependencies": {
     "babel-runtime": "^6.0.8",
     "graphql-relay": "^0.3.6",
+    "invariant": "2.2.1",
     "lodash": "^4.0.0"
   }
 }

src/resolver.js

@@ -4,11 +4,19 @@ import simplifyAST from './simplifyAST';
 import generateIncludes from './generateIncludes';
 import argsToFindOptions from './argsToFindOptions';
 import { isConnection, handleConnection, nodeAST, nodeType } from './relay';
+import invariant from 'invariant';
 
 function inList(list, attribute) {
   return ~list.indexOf(attribute);
 }
 
+function validateOptions(options) {
+  invariant(
+    !options.defaultAttributes || Array.isArray(options.defaultAttributes),
+    'options.defaultAttributes must be an array of field names.'
+  );
+}
+
 function resolverFactory(target, options) {
   var resolver
     , targetAttributes
@@ -26,6 +34,8 @@ function resolverFactory(target, options) {
   if (options.handleConnection === undefined) options.handleConnection = true;
   if (options.filterAttributes === undefined) options.filterAttributes = resolverFactory.filterAttributes;
 
+  validateOptions(options);
+
   resolver = function (source, args, info) {
     var root = info.rootValue || {}
       , ast = info.fieldASTs
@@ -61,6 +71,11 @@ function resolverFactory(target, options) {
       findOptions.attributes = Object.keys(fields)
         .map(key => fields[key].key || key)
         .filter(inList.bind(null, targetAttributes));
+
+      if (options.defaultAttributes) {
+        findOptions.attributes = findOptions.attributes.concat(options.defaultAttributes);
+      }
+
     } else {
       findOptions.attributes = targetAttributes;
     }

test/integration/resolver.test.js

@@ -1,10 +1,10 @@
 'use strict';
 
-import {expect} from 'chai';
+import { expect } from 'chai';
 import sinon from 'sinon';
 import Sequelize from 'sequelize';
 
-import {sequelize, Promise} from './helper';
+import { sequelize, Promise } from './helper';
 import resolver from '../../src/resolver';
 
 import {
@@ -46,8 +46,6 @@ describe('resolver', function () {
           return 'lol';
         }
       }
-    }, {
-      timestamps: false
     });
 
     Task = sequelize.define('task', {
@@ -309,7 +307,6 @@ describe('resolver', function () {
     return graphql(schema, `
       {
         user(id: ${user.id}) {
-          id
           name
           myVirtual
         }
@@ -319,7 +316,6 @@ describe('resolver', function () {
 
       expect(result.data).to.deep.equal({
         user: {
-          id: user.id,
           name: user.name,
           myVirtual: 'lol'
         }
@@ -408,7 +404,6 @@ describe('resolver', function () {
   it('should resolve an array result with a single model', function () {
     var users = this.users;
 
-
     return graphql(schema, `
       {
         users {
@@ -1146,4 +1141,61 @@ describe('resolver', function () {
       });
     });
   });
+
+  describe('defaultAttributes', () => {
+    it('should only accept an array as input', () => {
+      const f = () => resolver(User, {
+        defaultAttributes: 'not_an_array',
+      });
+      expect(f).to.throw();
+    });
+
+    it('should automatically include fields specified in that array', function () {
+      const user = this.userA;
+      const sqlSpy = sinon.spy();
+
+      const makeSchema = (defaultAttributes) => {
+        return new GraphQLSchema({
+          query: new GraphQLObjectType({
+            name: 'RootQueryType',
+            fields: {
+              user: {
+                type: userType,
+                args: { id: { type: GraphQLInt } },
+                resolve: resolver(User, {
+                  filterAttributes: true,
+                  defaultAttributes,
+                })
+              }
+            }
+          })
+        });
+      };
+
+      const normalSchema = makeSchema();
+
+      const defaultAttributes = ['createdAt'];
+      const schemaWithDefaultAttributes = makeSchema(defaultAttributes);
+
+      const query = `{ user(id: ${user.id}) { name } } `;
+
+      return graphql(normalSchema, query, {logging: sqlSpy}).then(function () {
+        const [sqlQuery] = sqlSpy.args[0];
+        // As we have
+        //   1) `filterAttributes` set to true,
+        //   2) no `defaultAttributes` defined and
+        //   3) `createdAt` hasn't been requested in the graphql query,
+        // `createdAt` should not be fetched
+        expect(sqlQuery).to.not.contain('createdAt');
+
+        return graphql(schemaWithDefaultAttributes, query, {logging: sqlSpy});
+      }).then(function (result) {
+        // With the schema that defined `createdAt` as a default attribute for
+        // user, it should be fetched
+        const [sqlQuery] = sqlSpy.args[1];
+        expect(sqlQuery).to.contain('createdAt');
+        expect(result.data.user.createdAt);
+      });
+    });
+  });
 });