Client mutation id on logIn mutation

Author: davimacedo

spec/ParseGraphQLServer.spec.js

@@ -903,6 +903,46 @@ describe('ParseGraphQLServer', () => {
 
           expect(payloadFields).toEqual(['clientMutationId', 'viewer']);
         });
+
+        it('should have clientMutationId in log in mutation input', async () => {
+          const inputFields = (await apolloClient.query({
+            query: gql`
+              query {
+                __type(name: "LogInInput") {
+                  inputFields {
+                    name
+                  }
+                }
+              }
+            `,
+          })).data['__type'].inputFields
+            .map(field => field.name)
+            .sort();
+
+          expect(inputFields).toEqual([
+            'clientMutationId',
+            'password',
+            'username',
+          ]);
+        });
+
+        it('should have clientMutationId in log in mutation payload', async () => {
+          const payloadFields = (await apolloClient.query({
+            query: gql`
+              query {
+                __type(name: "LogInPayload") {
+                  fields {
+                    name
+                  }
+                }
+              }
+            `,
+          })).data['__type'].fields
+            .map(field => field.name)
+            .sort();
+
+          expect(payloadFields).toEqual(['clientMutationId', 'viewer']);
+        });
       });
 
       describe('Parse Class Types', () => {
@@ -5826,6 +5866,7 @@ describe('ParseGraphQLServer', () => {
         });
 
         it('should log the user in', async () => {
+          const clientMutationId = uuidv4();
           const user = new Parse.User();
           user.setUsername('user1');
           user.setPassword('user1');
@@ -5835,24 +5876,29 @@ describe('ParseGraphQLServer', () => {
           await parseGraphQLServer.parseGraphQLSchema.databaseController.schemaCache.clear();
           const result = await apolloClient.mutate({
             mutation: gql`
-              mutation LogInUser($fields: LogInFieldsInput) {
-                logIn(fields: $fields) {
-                  sessionToken
-                  someField
+              mutation LogInUser($input: LogInInput!) {
+                logIn(input: $input) {
+                  clientMutationId
+                  viewer {
+                    sessionToken
+                    someField
+                  }
                 }
               }
             `,
             variables: {
-              fields: {
+              input: {
+                clientMutationId,
                 username: 'user1',
                 password: 'user1',
               },
             },
           });
 
-          expect(result.data.logIn.sessionToken).toBeDefined();
-          expect(result.data.logIn.someField).toEqual('someValue');
-          expect(typeof result.data.logIn.sessionToken).toBe('string');
+          expect(result.data.logIn.clientMutationId).toEqual(clientMutationId);
+          expect(result.data.logIn.viewer.sessionToken).toBeDefined();
+          expect(result.data.logIn.viewer.someField).toEqual('someValue');
+          expect(typeof result.data.logIn.viewer.sessionToken).toBe('string');
         });
 
         it('should log the user out', async () => {
@@ -5864,21 +5910,23 @@ describe('ParseGraphQLServer', () => {
 
           const logIn = await apolloClient.mutate({
             mutation: gql`
-              mutation LogInUser($fields: LogInFieldsInput) {
-                logIn(fields: $fields) {
-                  sessionToken
+              mutation LogInUser($input: LogInInput!) {
+                logIn(input: $input) {
+                  viewer {
+                    sessionToken
+                  }
                 }
               }
             `,
             variables: {
-              fields: {
+              input: {
                 username: 'user1',
                 password: 'user1',
               },
             },
           });
 
-          const sessionToken = logIn.data.logIn.sessionToken;
+          const sessionToken = logIn.data.logIn.viewer.sessionToken;
 
           const logOut = await apolloClient.mutate({
             mutation: gql`
@@ -5900,7 +5948,7 @@ describe('ParseGraphQLServer', () => {
             await apolloClient.query({
               query: gql`
                 query GetCurrentUser {
-                  me {
+                  viewer {
                     username
                   }
                 }

src/GraphQL/ParseGraphQLSchema.js

@@ -38,7 +38,8 @@ const RESERVED_GRAPHQL_TYPE_NAMES = [
   'Viewer',
   'SignUpInput',
   'SignUpPayload',
-  'LogInFieldsInput',
+  'LogInInput',
+  'LogInPayload',
   'CloudCodeFunction',
   'CallCloudCodeInput',
   'CallCloudCodePayload',

src/GraphQL/loaders/parseClassTypes.js

@@ -569,27 +569,6 @@ const load = (
     });
     parseGraphQLSchema.viewerType = viewerType;
     parseGraphQLSchema.addGraphQLType(viewerType, true, true);
-
-    const userLogInInputTypeName = 'LogInFieldsInput';
-    const userLogInInputType = new GraphQLInputObjectType({
-      name: userLogInInputTypeName,
-      description: `The ${userLogInInputTypeName} input type is used to login.`,
-      fields: {
-        username: {
-          description: 'This is the username used to log the user in.',
-          type: new GraphQLNonNull(GraphQLString),
-        },
-        password: {
-          description: 'This is the password used to log the user in.',
-          type: new GraphQLNonNull(GraphQLString),
-        },
-      },
-    });
-    parseGraphQLSchema.addGraphQLType(userLogInInputType, true, true);
-
-    parseGraphQLSchema.parseClassTypes[
-      className
-    ].logInInputType = userLogInInputType;
   }
 };
 

src/GraphQL/loaders/usersMutations.js

@@ -1,4 +1,4 @@
-import { GraphQLNonNull } from 'graphql';
+import { GraphQLNonNull, GraphQLString } from 'graphql';
 import { mutationWithClientMutationId } from 'graphql-relay';
 import UsersRouter from '../../Routers/UsersRouter';
 import * as objectsMutations from '../helpers/objectsMutations';
@@ -62,42 +62,60 @@ const load = parseGraphQLSchema => {
   parseGraphQLSchema.addGraphQLType(signUpMutation.type, true, true);
   parseGraphQLSchema.addGraphQLMutation('signUp', signUpMutation, true, true);
 
-  parseGraphQLSchema.addGraphQLMutation(
-    'logIn',
-    {
-      description: 'The logIn mutation can be used to log the user in.',
-      args: {
-        fields: {
-          description: 'This is data needed to login',
-          type: parseGraphQLSchema.parseClassTypes['_User'].logInInputType,
-        },
+  const logInMutation = mutationWithClientMutationId({
+    name: 'LogIn',
+    description: 'The logIn mutation can be used to log in an existing user.',
+    inputFields: {
+      username: {
+        description: 'This is the username used to log in the user.',
+        type: new GraphQLNonNull(GraphQLString),
       },
-      type: new GraphQLNonNull(parseGraphQLSchema.viewerType),
-      async resolve(_source, args, context) {
-        try {
-          const {
-            fields: { username, password },
-          } = args;
-          const { config, auth, info } = context;
-
-          return (await usersRouter.handleLogIn({
-            body: {
-              username,
-              password,
-            },
-            query: {},
-            config,
-            auth,
-            info,
-          })).response;
-        } catch (e) {
-          parseGraphQLSchema.handleError(e);
-        }
+      password: {
+        description: 'This is the password used to log in the user.',
+        type: new GraphQLNonNull(GraphQLString),
+      },
+    },
+    outputFields: {
+      viewer: {
+        description:
+          'This is the existing user that was logged in and returned as a viewer.',
+        type: new GraphQLNonNull(parseGraphQLSchema.viewerType),
       },
     },
+    mutateAndGetPayload: async (args, context, mutationInfo) => {
+      try {
+        const { username, password } = args;
+        const { config, auth, info } = context;
+
+        const { sessionToken } = (await usersRouter.handleLogIn({
+          body: {
+            username,
+            password,
+          },
+          query: {},
+          config,
+          auth,
+          info,
+        })).response;
+
+        info.sessionToken = sessionToken;
+
+        return {
+          viewer: await getUserFromSessionToken(config, info, mutationInfo),
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    },
+  });
+
+  parseGraphQLSchema.addGraphQLType(
+    logInMutation.args.input.type.ofType,
     true,
     true
   );
+  parseGraphQLSchema.addGraphQLType(logInMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('logIn', logInMutation, true, true);
 
   parseGraphQLSchema.addGraphQLMutation(
     'logOut',