Fixes #223. Add cache argument to attributeFields (#272)

* See #223. Add failing unit test for multiple enum types with same name

* Fixes #223. Add cache argument to attributeFields

* Clean up commenting of attributeFields

* See #223. Document attributeFields 'cache' option

* See #229. Document attributeFields commentToDescription option

Author: Glavin001

README.md

@@ -157,13 +157,16 @@ var Model = sequelize.define('User', {
 
 import {attributeFields} from 'graphql-sequelize';
 
+var cache = {}; // Reusable cache of enum types
 attributeFields(Model, {
   // ... options
   exclude: [], // array of model attributes to ignore - default: []
   only: [], // only generate definitions for these model attributes - default: null
   globalId: true, // return an relay global id field - default: false
   map: {}, // rename fields - default: {}
   allowNull: false, // disable wrapping mandatory fields in `GraphQLNonNull` - default: false
+  commentToDescription: false, // convert model comment to GraphQL description - default: false
+  cache: cache, // Cache enum types to prevent duplicate type name error - default: {}
 });
 
 /*

src/attributeFields.js

@@ -3,6 +3,7 @@ import { GraphQLNonNull, GraphQLEnumType } from 'graphql';
 import { globalIdField } from 'graphql-relay';
 
 module.exports = function (Model, options = {}) {
+  var cache = options.cache || {};
   var result = Object.keys(Model.rawAttributes).reduce(function (memo, key) {
     if (options.exclude && ~options.exclude.indexOf(key)) return memo;
     if (options.only && !~options.only.indexOf(key)) return memo;
@@ -24,7 +25,18 @@ module.exports = function (Model, options = {}) {
     };
 
     if (memo[key].type instanceof GraphQLEnumType ) {
-      memo[key].type.name = `${Model.name}${key}EnumType`;
+      var typeName = `${Model.name}${key}EnumType`;
+      /*
+      Cache enum types to prevent duplicate type name error
+      when calling attributeFields multiple times on the same model
+      */
+      if (cache[typeName]) {
+        memo[key].type = cache[typeName];
+      } else {
+        memo[key].type.name = typeName;
+        cache[typeName] = memo[key].type;
+      }
+
     }
 
     if (!options.allowNull) {

test/unit/attributeFields.test.js

@@ -14,7 +14,9 @@ import {
   GraphQLNonNull,
   GraphQLBoolean,
   GraphQLEnumType,
-  GraphQLList
+  GraphQLList,
+  GraphQLObjectType,
+  GraphQLSchema
 } from 'graphql';
 
 import {
@@ -197,6 +199,56 @@ describe('attributeFields', function () {
     expect(fields.enumTwo.type.getValues()[0].value).to.equal('foo_bar');
   });
 
+  it('should not create multiple enum types with same name when using cache', function () {
+
+    // Create Schema
+    var schemaFn = function (fields1, fields2) {
+      return function () {
+        var object1 = new GraphQLObjectType({
+          name: 'Object1',
+          fields: fields1
+        });
+        var object2 = new GraphQLObjectType({
+          name: 'Object2',
+          fields: fields2
+        });
+        return new GraphQLSchema({
+          query: new GraphQLObjectType({
+            name: 'RootQueryType',
+            fields: {
+              object1: {
+                type: object1,
+                resolve: function () {
+                  return {};
+                }
+              },
+              object2: {
+                type: object2,
+                resolve: function () {
+                  return {};
+                }
+              }
+            }
+          })
+        });
+      }
+    };
+
+    // Bad: Will create multiple/duplicate types with same name
+    var fields1a = attributeFields(Model);
+    var fields2a = attributeFields(Model);
+
+    expect(schemaFn(fields1a, fields2a)).to.throw(Error);
+
+    // Good: Will use cache and not create mutliple/duplicate types with same name
+    var cache = {};
+    var fields1b = attributeFields(Model, {cache: cache});
+    var fields2b = attributeFields(Model, {cache: cache});
+
+    expect(schemaFn(fields1b, fields2b)).to.not.throw(Error);
+
+  });
+
   describe('with non-default primary key', function () {
     var ModelWithoutId;
     var modelName = Math.random().toString();