add(relay): connection.resolveEdge as a tiny helper for mutations

Author: mickhansen

package.json

@@ -12,7 +12,7 @@
     "lint": "eslint src",
     "build": "rm -rf lib/* && babel src --ignore test --optional runtime --out-dir lib",
     "test": "npm run test-unit && npm run test-docker",
-    "test-unit": "mocha $npm_package_options_mocha test/unit/*.test.js",
+    "test-unit": "mocha $npm_package_options_mocha test/unit/*.test.js test/unit/**/*.test.js",
     "build-docker": "docker-compose build",
     "test-docker": "docker-compose run dev /bin/sh -c \"npm run test-integration\"",
     "test-integration": "mocha $npm_package_options_mocha test/integration/*.test.js test/integration/**/*.test.js"
@@ -46,12 +46,13 @@
     "pg-hstore": "^2.3.2",
     "sequelize": "^3.16.0",
     "sinon": "^1.15.4",
+    "sinon-as-promised": "^4.0.0",
     "sinon-chai": "^2.8.0",
     "sqlite3": "^3.0.9"
   },
   "dependencies": {
     "babel-runtime": "^6.0.8",
-    "graphql-relay": "^0.3.3",
+    "graphql-relay": "^0.3.6",
     "lodash": "^3.10.0"
   }
 }

scripts/mocha-bootload

@@ -5,4 +5,5 @@ require('babel/register')({
 var chai = require('chai');
 
 chai.use(require('chai-as-promised'));
-chai.use(require('sinon-chai'));
+chai.use(require('sinon-chai'));
+require('sinon-as-promised')(require('bluebird'));

src/relay.js

@@ -92,7 +92,11 @@ export function sequelizeConnection({name, nodeType, target, orderBy: orderByEnu
   const {
     edgeType,
     connectionType
-  } = connectionDefinitions({name, nodeType, connectionFields});
+  } = connectionDefinitions({
+    name,
+    nodeType,
+    connectionFields
+  });
 
   const model = target.target ? target.target : target;
   const SEPERATOR = '$';
@@ -107,6 +111,8 @@ export function sequelizeConnection({name, nodeType, target, orderBy: orderByEnu
     });
   }
 
+  let defaultOrderBy = orderByEnum._values[0].value;
+
   before = before || ((options) => options);
 
   let $connectionArgs = {
@@ -148,6 +154,17 @@ export function sequelizeConnection({name, nodeType, target, orderBy: orderByEnu
     return result;
   };
 
+  let resolveEdge = function (item, args = {}) {
+    if (!args.orderBy) {
+      args.orderBy = [defaultOrderBy];
+    }
+
+    return {
+      cursor: toCursor(item, args.orderBy),
+      node: item
+    };
+  };
+
   let $resolver = require('./resolver')(target, {
     handleConnection: false,
     include: true,
@@ -224,15 +241,8 @@ export function sequelizeConnection({name, nodeType, target, orderBy: orderByEnu
       return before(options, args, root);
     },
     after: function (values, args, root, {source}) {
-      if (!args.orderBy) {
-        args.orderBy = [orderByEnum._values[0].value];
-      }
-
       let edges = values.map((value) => {
-        return {
-          cursor: toCursor(value, args.orderBy),
-          node: value
-        };
+        return resolveEdge(value, args);
       });
 
       let firstEdge = edges[0];
@@ -282,6 +292,7 @@ export function sequelizeConnection({name, nodeType, target, orderBy: orderByEnu
     connectionType,
     edgeType,
     nodeType,
+    resolveEdge,
     connectionArgs: $connectionArgs,
     resolve: resolver
   };

test/integration/relay/connection.test.js

@@ -340,6 +340,7 @@ if (helper.sequelize.dialect.name === 'postgres') {
             user(id: ${this.userA.id}) {
               tasks(first: 2, completed: true, orderBy: LATEST) {
                 edges {
+                  cursor
                   node {
                     id
                     name

test/unit/relay/mutation.test.js

@@ -0,0 +1,190 @@
+'use strict';
+
+import {expect} from 'chai';
+import helper from '../helper';
+import Sequelize from 'sequelize';
+import sinon from 'sinon';
+import attributeFields from '../../../src/attributeFields';
+
+const {
+  sequelize,
+  Promise
+} = helper;
+
+import {
+  sequelizeConnection
+} from '../../../src/relay';
+
+import {
+  GraphQLString,
+  GraphQLInt,
+  GraphQLFloat,
+  GraphQLNonNull,
+  GraphQLBoolean,
+  GraphQLEnumType,
+  GraphQLList,
+  GraphQLObjectType,
+  GraphQLSchema,
+  GraphQLID,
+  graphql
+} from 'graphql';
+
+import {
+  globalIdField,
+  toGlobalId,
+  fromGlobalId,
+  mutationWithClientMutationId
+} from 'graphql-relay';
+
+describe('relay', function () {
+  describe('mutation', function () {
+    describe('connections', function () {
+      before(function () {
+        this.User = sequelize.define('user', {}, {timestamps: false});
+        this.Task = sequelize.define('task', {title: Sequelize.STRING}, {timestamps: false});
+
+        this.User.Tasks = this.User.hasMany(this.Task, {as: 'tasks', foreignKey: 'userId'});
+
+        this.taskType = new GraphQLObjectType({
+          name: this.Task.name,
+          fields: {
+            ...attributeFields(this.Task),
+            id: globalIdField(this.Task.name)
+          }
+        });
+
+        this.viewerTaskConnection = sequelizeConnection({
+          name: 'Viewer' + this.Task.name,
+          nodeType: this.taskType,
+          target: this.User.Tasks,
+          orderBy: new GraphQLEnumType({
+            name: 'Viewer' + this.Task.name + 'ConnectionOrder',
+            values: {
+              ID: {value: [this.Task.primaryKeyAttribute, 'ASC']},
+            }
+          })
+        });
+
+        this.viewerType = new GraphQLObjectType({
+          name: 'Viewer',
+          fields: {
+            tasks: {
+              type: this.viewerTaskConnection.connectionType,
+              args: this.viewerTaskConnection.connectionArgs,
+              resolve: this.viewerTaskConnection.resolve
+            }
+          }
+        });
+
+        const addTaskMutation = mutationWithClientMutationId({
+          name: 'addTask',
+          inputFields: {
+            title: {
+              type: new GraphQLNonNull(GraphQLString)
+            }
+          },
+          outputFields: () => ({
+            viewer: {
+              type: this.viewerType,
+              resolve: (payload, {rootValue}) => {
+                return rootValue.viewer;
+              }
+            },
+            task: {
+              type: this.taskType,
+              resolve: (payload) => payload.task
+            },
+            newTaskEdge: {
+              type: this.viewerTaskConnection.edgeType,
+              resolve: (payload) => this.viewerTaskConnection.resolveEdge(payload.task)
+            }
+          }),
+          mutateAndGetPayload: async ({title}, {rootValue}) => {
+            let task = await this.Task.create({
+              title: title,
+              userId: rootValue.viewer.id
+            });
+
+            return {
+              task: task
+            };
+          }
+        });
+
+        this.schema = new GraphQLSchema({
+          query: new GraphQLObjectType({
+            name: 'RootQueryType',
+            fields: {
+              viewer: {
+                type: this.viewerType,
+                resolve: function (source, args, info) {
+                  return info.rootValue.viewer;
+                }
+              }
+            }
+          }),
+          mutation: new GraphQLObjectType({
+            name: 'Mutation',
+            fields: {
+              addTask: addTaskMutation
+            }
+          })
+        });
+      });
+
+      beforeEach(function () {
+        this.sinon = sinon.sandbox.create();
+
+        this.viewer = this.User.build({
+          id: Math.ceil(Math.random() * 999)
+        });
+
+        this.sinon.stub(this.Task, 'create').resolves();
+      });
+
+      afterEach(function () {
+        this.sinon.restore();
+      });
+
+      describe('addEdgeMutation', function () {
+        it('should return a appropriate cursor and node', async function () {
+          let title = Math.random().toString()
+            , id = Math.ceil(Math.random() * 999);
+
+          this.Task.create.resolves(this.Task.build({
+            id: id,
+            title: title,
+            userId: this.viewer.get('id')
+          }));
+
+          let result = await graphql(this.schema, `
+            mutation {
+              addTask(input: {title: "${title}", clientMutationId: "${Math.random().toString()}"}) {
+                task {
+                  id
+                }
+
+                newTaskEdge {
+                  cursor
+                  node {
+                    id
+                    title
+                  }
+                }
+              }
+            }
+          `, {
+            viewer: this.viewer
+          });
+
+          if (result.errors) throw new Error(result.errors[0].stack);
+
+          expect(result.data.addTask.task.id).to.equal(toGlobalId(this.Task.name, id));
+          expect(result.data.addTask.newTaskEdge.cursor).to.be.ok;
+          expect(result.data.addTask.newTaskEdge.node.id).to.equal(toGlobalId(this.Task.name, id));
+          expect(result.data.addTask.newTaskEdge.node.title).to.equal(title);
+        });
+      });
+    });
+  });
+});