Client mutation id on signUp mutation

Author: davimacedo

spec/ParseGraphQLServer.spec.js

@@ -867,6 +867,42 @@ describe('ParseGraphQLServer', () => {
             'result',
           ]);
         });
+
+        it('should have clientMutationId in sign up mutation input', async () => {
+          const inputFields = (await apolloClient.query({
+            query: gql`
+              query {
+                __type(name: "SignUpInput") {
+                  inputFields {
+                    name
+                  }
+                }
+              }
+            `,
+          })).data['__type'].inputFields
+            .map(field => field.name)
+            .sort();
+
+          expect(inputFields).toEqual(['clientMutationId', 'userFields']);
+        });
+
+        it('should have clientMutationId in sign up mutation payload', async () => {
+          const payloadFields = (await apolloClient.query({
+            query: gql`
+              query {
+                __type(name: "SignUpPayload") {
+                  fields {
+                    name
+                  }
+                }
+              }
+            `,
+          })).data['__type'].fields
+            .map(field => field.name)
+            .sort();
+
+          expect(payloadFields).toEqual(['clientMutationId', 'viewer']);
+        });
       });
 
       describe('Parse Class Types', () => {
@@ -894,7 +930,6 @@ describe('ParseGraphQLServer', () => {
             'User',
             'UserWhereInput',
             'UserFindResult',
-            'SignUpFieldsInput',
             'CreateUserFieldsInput',
             'UpdateUserFieldsInput',
           ];
@@ -5755,31 +5790,39 @@ describe('ParseGraphQLServer', () => {
 
       describe('Users Mutations', () => {
         it('should sign user up', async () => {
+          const clientMutationId = uuidv4();
           const userSchema = new Parse.Schema('_User');
           userSchema.addString('someField');
           await userSchema.update();
           await parseGraphQLServer.parseGraphQLSchema.databaseController.schemaCache.clear();
           const result = await apolloClient.mutate({
             mutation: gql`
-              mutation SignUp($fields: SignUpFieldsInput) {
-                signUp(fields: $fields) {
-                  sessionToken
-                  someField
+              mutation SignUp($input: SignUpInput!) {
+                signUp(input: $input) {
+                  clientMutationId
+                  viewer {
+                    sessionToken
+                    someField
+                  }
                 }
               }
             `,
             variables: {
-              fields: {
-                username: 'user1',
-                password: 'user1',
-                someField: 'someValue',
+              input: {
+                clientMutationId,
+                userFields: {
+                  username: 'user1',
+                  password: 'user1',
+                  someField: 'someValue',
+                },
               },
             },
           });
 
-          expect(result.data.signUp.sessionToken).toBeDefined();
-          expect(result.data.signUp.someField).toEqual('someValue');
-          expect(typeof result.data.signUp.sessionToken).toBe('string');
+          expect(result.data.signUp.clientMutationId).toEqual(clientMutationId);
+          expect(result.data.signUp.viewer.sessionToken).toBeDefined();
+          expect(result.data.signUp.viewer.someField).toEqual('someValue');
+          expect(typeof result.data.signUp.viewer.sessionToken).toBe('string');
         });
 
         it('should log the user in', async () => {
@@ -8347,6 +8390,7 @@ describe('ParseGraphQLServer', () => {
         variables: {
           user: {
             username: 'somefolk',
+            password: 'somepassword',
           },
         },
       });

src/GraphQL/ParseGraphQLSchema.js

@@ -36,7 +36,8 @@ const RESERVED_GRAPHQL_TYPE_NAMES = [
   'CreateFileInput',
   'CreateFilePayload',
   'Viewer',
-  'SignUpFieldsInput',
+  'SignUpInput',
+  'SignUpPayload',
   'LogInFieldsInput',
   'CloudCodeFunction',
   'CallCloudCodeInput',

src/GraphQL/loaders/parseClassTypes.js

@@ -153,7 +153,11 @@ const load = (
               ...fields,
               [field]: {
                 description: `This is the object ${field}.`,
-                type,
+                type:
+                  className === '_User' &&
+                  (field === 'username' || field === 'password')
+                    ? new GraphQLNonNull(type)
+                    : type,
               },
             };
           } else {
@@ -566,35 +570,6 @@ const load = (
     parseGraphQLSchema.viewerType = viewerType;
     parseGraphQLSchema.addGraphQLType(viewerType, true, true);
 
-    const userSignUpInputTypeName = 'SignUpFieldsInput';
-    const userSignUpInputType = new GraphQLInputObjectType({
-      name: userSignUpInputTypeName,
-      description: `The ${userSignUpInputTypeName} input type is used in operations that involve inputting objects of ${graphQLClassName} class when signing up.`,
-      fields: () =>
-        classCreateFields.reduce((fields, field) => {
-          const type = transformInputTypeToGraphQL(
-            parseClass.fields[field].type,
-            parseClass.fields[field].targetClass,
-            parseGraphQLSchema.parseClassTypes
-          );
-          if (type) {
-            return {
-              ...fields,
-              [field]: {
-                description: `This is the object ${field}.`,
-                type:
-                  field === 'username' || field === 'password'
-                    ? new GraphQLNonNull(type)
-                    : type,
-              },
-            };
-          } else {
-            return fields;
-          }
-        }, {}),
-    });
-    parseGraphQLSchema.addGraphQLType(userSignUpInputType, true, true);
-
     const userLogInInputTypeName = 'LogInFieldsInput';
     const userLogInInputType = new GraphQLInputObjectType({
       name: userLogInInputTypeName,
@@ -612,9 +587,6 @@ const load = (
     });
     parseGraphQLSchema.addGraphQLType(userLogInInputType, true, true);
 
-    parseGraphQLSchema.parseClassTypes[
-      className
-    ].signUpInputType = userSignUpInputType;
     parseGraphQLSchema.parseClassTypes[
       className
     ].logInInputType = userLogInInputType;

src/GraphQL/loaders/usersMutations.js

@@ -1,4 +1,5 @@
 import { GraphQLNonNull } from 'graphql';
+import { mutationWithClientMutationId } from 'graphql-relay';
 import UsersRouter from '../../Routers/UsersRouter';
 import * as objectsMutations from '../helpers/objectsMutations';
 import { getUserFromSessionToken } from './usersQueries';
@@ -10,42 +11,56 @@ const load = parseGraphQLSchema => {
     return;
   }
 
-  parseGraphQLSchema.addGraphQLMutation(
-    'signUp',
-    {
-      description: 'The signUp mutation can be used to sign the user up.',
-      args: {
-        fields: {
-          descriptions: 'These are the fields of the user.',
-          type: parseGraphQLSchema.parseClassTypes['_User'].signUpInputType,
-        },
+  const signUpMutation = mutationWithClientMutationId({
+    name: 'SignUp',
+    description:
+      'The signUp mutation can be used to create and sign up a new user.',
+    inputFields: {
+      userFields: {
+        descriptions:
+          'These are the fields of the new user to be created and signed up.',
+        type:
+          parseGraphQLSchema.parseClassTypes['_User'].classGraphQLCreateType,
       },
-      type: new GraphQLNonNull(parseGraphQLSchema.viewerType),
-      async resolve(_source, args, context, mutationInfo) {
-        try {
-          const { fields } = args;
-
-          const { config, auth, info } = context;
+    },
+    outputFields: {
+      viewer: {
+        description:
+          'This is the new user that was created, signed up and returned as a viewer.',
+        type: new GraphQLNonNull(parseGraphQLSchema.viewerType),
+      },
+    },
+    mutateAndGetPayload: async (args, context, mutationInfo) => {
+      try {
+        const { userFields } = args;
+        const { config, auth, info } = context;
 
-          const { sessionToken } = await objectsMutations.createObject(
-            '_User',
-            fields,
-            config,
-            auth,
-            info
-          );
+        const { sessionToken } = await objectsMutations.createObject(
+          '_User',
+          userFields,
+          config,
+          auth,
+          info
+        );
 
-          info.sessionToken = sessionToken;
+        info.sessionToken = sessionToken;
 
-          return await getUserFromSessionToken(config, info, mutationInfo);
-        } catch (e) {
-          parseGraphQLSchema.handleError(e);
-        }
-      },
+        return {
+          viewer: await getUserFromSessionToken(config, info, mutationInfo),
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
     },
+  });
+
+  parseGraphQLSchema.addGraphQLType(
+    signUpMutation.args.input.type.ofType,
     true,
     true
   );
+  parseGraphQLSchema.addGraphQLType(signUpMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('signUp', signUpMutation, true, true);
 
   parseGraphQLSchema.addGraphQLMutation(
     'logIn',