mutationMiddleware move all args into input! arg

if `input` exists add only `clientMutationId` to it and leave rest args untouched.

Author: nodkz

README.md

@@ -13,29 +13,33 @@ import { TypeComposer } from 'graphql-compose';
 import { RootQueryType, UserType } from './my-graphq-object-types';
 
 const rootQueryTypeComposer = new TypeComposer(RootQueryType);
-const userTypeComposer = new TypeComposer(UserType); 
+const userTypeComposer = new TypeComposer(UserType);
 
-// If passed RootQuery, then will be added only `node` field to this type. 
+// If passed RootQuery, then will be added only `node` field to this type.
 // Via RootQuery.node you may find objects by globally unique ID among all types.
-composeWithRelay(rootQueryTypeComposer); 
+composeWithRelay(rootQueryTypeComposer);
 
 // Other types, like User, will be wrapped with middlewares that:
 // - add relay's id field. Field will be added or wrapped to return Relay's globally unique ID.
 // - for mutations will be added clientMutationId to input and output objects types
 // - this type will be added to NodeInterface for resolving via RootQuery.node
-composeWithRelay(userTypeComposer); 
+composeWithRelay(userTypeComposer);
 ```
 That's all!
 
-No annoying `clientMutationId` manipulations (declaration, passthru, stripping from input).
-No manual adding/wrapping `id` field. This field returns globally unique ID among all types in format `base64(TypeName + ':' + recordId)`.  
-All relay magic done internally by middleware for you.
+All mutations resolvers' arguments will be placed into `input` field, and added `clientMutationId`. If `input` fields already exists in resolver, then  `clientMutationId` will be added to it, rest argument stays untouched. Accepted value via `args.input.clientMutationId` will be transfer to `payload.clientMutationId`, as Relay required it.
+
+To all wrapped Types with Relay, will be added `id` field or wrapped, if it exist already. This field will return globally unique ID among all types in the following format `base64(TypeName + ':' + recordId)`.  
+
+For `RootQuery` will be added `node` field, that will resolve by globalId only that types, which you wrap with `composeWithRelay`.
+
+All this annoying operations is too fatigue to do by hands. So this middleware done all Relay magic implicitly for you.
 
 Requirements
 ============
 Method `composeWithRelay` accept `TypeComposer` as input argument. So `TypeComposer` should meet following requirements:
-- has defined `recordIdFn` (function that from object gives you id)
-- should have `findById` resolver
+- has defined `recordIdFn` (function that from object of this type, returns you id for the globalId construction)
+- should have `findById` resolver (that will be used by `RootQuery.node`)
 
 If something is missing `composeWithRelay` throws error.
 

resources/watch.js

@@ -15,7 +15,6 @@ function exec(command, options) {
       cmd: cmd,
       env: {
         ...process.env,
-        BABEL_ENV: 'cjs',
       },
       stdio: 'inherit'
     });
@@ -121,6 +120,7 @@ function runTests(filepaths) {
     '--compilers', 'js:babel-core/register',
     // '--reporter', 'progress',
     '--reporter', 'dot',
+    '--require', 'babel-polyfill',
     '--require', './resources/mocha-bootload',
   ].concat(
     allTests(filepaths) ?

src/__mocks__/userTypeComposer.js

@@ -86,3 +86,72 @@ export const createOneResolver = new Resolver(userTypeComposer, {
     });
   },
 });
+
+export const manyArgsWithInputResolver = new Resolver(userTypeComposer, {
+  name: 'manyArgsWithInput',
+  kind: 'mutation',
+  outputType: new GraphQLObjectType({
+    name: 'UserPayload',
+    fields: {
+      record: {
+        type: UserType,
+      },
+    },
+  }),
+  args: {
+    input: {
+      name: 'input',
+      type: new GraphQLInputObjectType({
+        name: 'UserInput',
+        fields: {
+          name: {
+            type: GraphQLString,
+          },
+        },
+      }),
+    },
+    sort: {
+      name: 'sort',
+      type: GraphQLString,
+    },
+    limit: {
+      name: 'limit',
+      type: GraphQLInt,
+    },
+  },
+  resolve: (resolveParams) => {
+    return Promise.resolve({
+      recordId: resolveParams.args.input.id,
+      record: resolveParams.args && resolveParams.args.input || {},
+    });
+  },
+});
+
+export const manyArgsWithoutInputResolver = new Resolver(userTypeComposer, {
+  name: 'manyArgsWithoutInput',
+  kind: 'mutation',
+  outputType: new GraphQLObjectType({
+    name: 'UserPayload',
+    fields: {
+      record: {
+        type: UserType,
+      },
+    },
+  }),
+  args: {
+    sort: {
+      name: 'sort',
+      type: GraphQLString,
+    },
+    limit: {
+      name: 'limit',
+      type: GraphQLInt,
+    },
+  },
+  resolve: (resolveParams) => {
+    return Promise.resolve({
+      recordId: resolveParams.args.input.id,
+      record: resolveParams.args && resolveParams.args.input || {},
+    });
+  },
+});

src/__tests__/mutationMiddleware-test.js

@@ -6,18 +6,52 @@ import { toGlobalId } from '../globalId';
 import {
   GraphQLString,
   GraphQLID,
+  GraphQLNonNull,
+  getNamedType,
 } from 'graphql';
 
 describe('MutationMiddleware', () => {
   composeWithRelay(userTypeComposer);
   const fieldConfig = userTypeComposer.getResolver('createOne').getFieldConfig();
+  const fieldConfigManyArgsWithInput
+    = userTypeComposer.getResolver('manyArgsWithInput').getFieldConfig();
+  const fieldConfigManyArgsWithoutInput
+    = userTypeComposer.getResolver('manyArgsWithoutInput').getFieldConfig();
 
   describe('args', () => {
     it('should add `clientMutationId` field to args.input', () => {
       const itc = new InputTypeComposer(fieldConfig.args.input.type);
       expect(itc.hasField('clientMutationId')).to.be.true;
       expect(itc.getFieldType('clientMutationId')).equal(GraphQLString);
     });
+
+
+    it('should create required args.input! if not exists', () => {
+      expect(fieldConfigManyArgsWithoutInput.args).property('input').to.be.ok;
+
+      expect(fieldConfigManyArgsWithoutInput.args)
+        .deep.property('input.type').instanceof(GraphQLNonNull);
+    });
+
+    it('should create args.input if not exists and move all args into it', () => {
+      expect(fieldConfigManyArgsWithoutInput.args).to.have.all.keys(['input']);
+
+      const type = getNamedType(fieldConfigManyArgsWithoutInput.args.input.type);
+      const itc = new InputTypeComposer(type);
+      expect(itc.hasField('sort')).to.be.true;
+      expect(itc.hasField('limit')).to.be.true;
+      expect(itc.hasField('clientMutationId')).to.be.true;
+    });
+
+    it('should leave other arg untouched if args.input exists', () => {
+      expect(fieldConfigManyArgsWithInput.args).to.have.all.keys(['input', 'sort', 'limit']);
+
+      const type = getNamedType(fieldConfigManyArgsWithInput.args.input.type);
+      const itc = new InputTypeComposer(type);
+      expect(itc.hasField('sort')).to.be.false;
+      expect(itc.hasField('limit')).to.be.false;
+      expect(itc.hasField('clientMutationId')).to.be.true;
+    });
   });
 
   describe('outputType', () => {

src/composeWithRelay.js

@@ -56,7 +56,7 @@ export function composeWithRelay(
 
   typeComposer.getResolvers().forEach(resolver => {
     if (resolver.kind === 'mutation') {
-      resolver.addMiddleware(new MutationMiddleware(typeComposer));
+      resolver.addMiddleware(new MutationMiddleware(typeComposer, resolver));
     }
   });
 

src/mutationMiddleware.js

@@ -2,7 +2,14 @@
 /* eslint-disable no-param-reassign */
 
 import { ResolverMiddleware, TypeComposer, InputTypeComposer } from 'graphql-compose';
-import { GraphQLID, GraphQLString, GraphQLObjectType } from 'graphql';
+import {
+  GraphQLID,
+  GraphQLString,
+  GraphQLObjectType,
+  getNamedType,
+  GraphQLInputObjectType,
+  GraphQLNonNull,
+} from 'graphql';
 import { toGlobalId } from './globalId';
 import type {
   ResolverMWArgsFn,
@@ -15,25 +22,44 @@ import type {
 
 export default class MutationMiddleware extends ResolverMiddleware {
   // middleware has constructor
-  // constructor(typeComposer, opts = {}) {
+  // constructor(typeComposer, typeResolver, opts = {}) {
   //   super(typeComposer, opts);
   //   // some setup staff
   // }
 
   args:ResolverMWArgs = (next: ResolverMWArgsFn) => (args) => {
     const nextArgs = next(args);
+    let inputTC: InputTypeComposer;
+    let newNextArgs = {};
+
     if (nextArgs.input && nextArgs.input.type) {
-      const itc = new InputTypeComposer(nextArgs.input.type);
-      if (!itc.hasField('clientMutationId')) {
-        itc.addField('clientMutationId', {
-          type: GraphQLString,
-          description: 'The client mutation ID used by clients like Relay to track the mutation. '
-                     + 'If given, returned in the response payload of the mutation.',
-        });
-      }
+      // pass args unchanged
+      inputTC = new InputTypeComposer(getNamedType(nextArgs.input.type));
+      newNextArgs = nextArgs;
+    } else {
+      // create input arg, and put into all current args
+      inputTC = new InputTypeComposer(new GraphQLInputObjectType({
+        name: `Relay${this.typeResolver.getNameCamelCase()}${this.typeComposer.getTypeName()}Input`,
+        fields: nextArgs,
+      }));
+      newNextArgs = {
+        input: {
+          name: 'input',
+          type: new GraphQLNonNull(inputTC.getType()),
+        },
+      };
+    }
+
+    // add `clientMutationId` to args.input field
+    if (!inputTC.hasField('clientMutationId')) {
+      inputTC.addField('clientMutationId', {
+        type: GraphQLString,
+        description: 'The client mutation ID used by clients like Relay to track the mutation. '
+                   + 'If given, returned in the response payload of the mutation.',
+      });
     }
 
-    return nextArgs;
+    return newNextArgs;
   };