Merge pull request #18 from ConciergeAuctions/master

Add support for GraphQL-Relay Connections

Author: mickhansen

.gitignore

@@ -7,6 +7,8 @@ pids
 *.pid
 *.seed
 
+.idea
+
 # Directory for instrumented libs generated by jscoverage/JSCover
 lib-cov
 

package.json

@@ -44,6 +44,7 @@
   },
   "dependencies": {
     "babel-runtime": "^5.6.20",
+    "graphql-relay": "^0.3.2",
     "lodash": "^3.10.0"
   }
 }

src/attributeFields.js

@@ -1,5 +1,5 @@
 import * as typeMapper from './typeMapper';
-import { GraphQLNonNull } from 'graphql';
+import { GraphQLNonNull, GraphQLEnumType } from 'graphql';
 
 module.exports = function (Model, options) {
   options = options || {};
@@ -14,6 +14,10 @@ module.exports = function (Model, options) {
       type: typeMapper.toGraphQL(type, Model.sequelize.constructor)
     };
 
+    if ( memo[key].type instanceof GraphQLEnumType ) {
+      memo[key].type.name = `${Model.name}${key}EnumType`;
+    }
+
     if (attribute.allowNull === false || attribute.primaryKey === true) {
       memo[key].type = new GraphQLNonNull(memo[key].type);
     }

src/generateIncludes.js

@@ -1,4 +1,5 @@
 import argsToFindOptions from './argsToFindOptions';
+import {isConnection} from './relay';
 import _ from 'lodash';
 
 function inList(list, attribute) {
@@ -96,5 +97,15 @@ export default function generateIncludes(simpleAST, type, root, options) {
     }
   });
 
+  if (isConnection(type)) {
+    let node = simpleAST.fields.edges.fields.node;
+    let fields = [];
+    _.forIn(node.fields, (field, key) => {
+      if (!field.fields.hasOwnProperty('edges')) {
+        fields.push(key);
+      }
+    });
+    result.attributes = result.attributes.concat(fields);
+  }
   return result;
 }

src/relay.js

@@ -0,0 +1,50 @@
+import {fromGlobalId, connectionFromArray, nodeDefinitions} from 'graphql-relay';
+
+class NodeTypeMapper {
+
+  constructor( sequelize ) {
+    this.models = Object.keys(sequelize.models);
+    this.models.forEach(model => {
+      this[model] = null;
+    });
+  }
+
+  mapTypes( types ) {
+    this.models.forEach(model => {
+      if (types[model]) {
+        this[model] = types[model];
+      }
+    });
+  }
+}
+
+export function idFetcher(sequelize) {
+  return globalId => {
+    let {type, id} = fromGlobalId(globalId);
+    const models = Object.keys(sequelize.models);
+    type = type.toLowerCase();
+    if (models.some(model => model === type)) {
+      return sequelize.models[type].findById(id);
+    }
+    return null;
+  };
+}
+
+export function isConnection(type) {
+  return typeof type.name !== 'undefined' && type.name.endsWith('Connection');
+}
+
+export function handleConnection(values, args) {
+  return connectionFromArray(values, args);
+}
+
+export function sequelizeNodeInterface(sequelize) {
+  let nodeTypeMapper = new NodeTypeMapper(sequelize);
+  const nodeObjects = nodeDefinitions(idFetcher(sequelize), obj => {
+    return nodeTypeMapper[obj.Model.options.name.singular];
+  });
+  return {
+    nodeTypeMapper,
+    ...nodeObjects
+  };
+}

src/resolver.js

@@ -3,6 +3,7 @@ import _ from 'lodash';
 import simplifyAST from './simplifyAST';
 import generateIncludes from './generateIncludes';
 import argsToFindOptions from './argsToFindOptions';
+import { isConnection, handleConnection } from './relay';
 
 function inList(list, attribute) {
   return ~list.indexOf(attribute);
@@ -25,6 +26,9 @@ module.exports = function (target, options) {
 
   resolver = function (source, args, info) {
     if (association && source.get(association.as) !== undefined) {
+      if (isConnection(info.returnType)) {
+        return handleConnection(source[info.fieldName], args);
+      }
       return source.get(association.as);
     }
 
@@ -66,6 +70,9 @@ module.exports = function (target, options) {
 
     if (association) {
       return source[association.accessors.get](findOptions).then(function (result) {
+        if (isConnection(info.returnType)) {
+          result = handleConnection(result, args);
+        }
         return options.after(result, args, root, {
           ast: simpleAST,
           type: type

test/attributeFields.test.js

@@ -19,9 +19,9 @@ import {
 
 describe('attributeFields', function () {
   var Model;
-
+  var modelName = Math.random().toString();
   before(function () {
-    Model = sequelize.define(Math.random().toString(), {
+    Model = sequelize.define(modelName, {
       email: {
         type: Sequelize.STRING,
         allowNull: false
@@ -38,6 +38,9 @@ describe('attributeFields', function () {
       enum: {
         type: Sequelize.ENUM('first', 'second')
       },
+      enumTwo: {
+        type: Sequelize.ENUM('first', 'second')
+      },
       list: {
         type: Sequelize.ARRAY(Sequelize.STRING)
       },
@@ -55,7 +58,7 @@ describe('attributeFields', function () {
   it('should return fields for a simple model', function () {
     var fields = attributeFields(Model);
 
-    expect(Object.keys(fields)).to.deep.equal(['id', 'email', 'firstName', 'lastName', 'float', 'enum', 'list', 'virtualInteger', 'virtualBoolean']);
+    expect(Object.keys(fields)).to.deep.equal(['id', 'email', 'firstName', 'lastName', 'float', 'enum', 'enumTwo', 'list', 'virtualInteger', 'virtualBoolean']);
 
     expect(fields.id.type).to.be.an.instanceOf(GraphQLNonNull);
     expect(fields.id.type.ofType).to.equal(GraphQLInt);
@@ -69,6 +72,8 @@ describe('attributeFields', function () {
 
     expect(fields.enum.type).to.be.an.instanceOf(GraphQLEnumType);
 
+    expect(fields.enumTwo.type).to.be.an.instanceOf(GraphQLEnumType);
+
     expect(fields.list.type).to.be.an.instanceOf(GraphQLList);
 
     expect(fields.float.type).to.equal(GraphQLFloat);
@@ -80,9 +85,19 @@ describe('attributeFields', function () {
 
   it('should be possible to exclude fields', function () {
     var fields = attributeFields(Model, {
-      exclude: ['id', 'email', 'float', 'enum', 'list', 'virtualInteger', 'virtualBoolean']
+      exclude: ['id', 'email', 'float', 'enum', 'enumTwo', 'list', 'virtualInteger', 'virtualBoolean']
     });
 
     expect(Object.keys(fields)).to.deep.equal(['firstName', 'lastName']);
   });
+
+  it('should automatically name enum types', function () {
+    var fields = attributeFields(Model);
+
+    expect(fields.enum.type.name).to.not.be.undefined;
+    expect(fields.enumTwo.type.name).to.not.be.undefined;
+
+    expect(fields.enum.type.name).to.equal(modelName + 'enum' + 'EnumType');
+    expect(fields.enumTwo.type.name).to.equal(modelName + 'enumTwo' + 'EnumType');
+  });
 });