Client mutation id on callCloudCode mutation

Author: davimacedo

spec/ParseGraphQLServer.spec.js

@@ -820,6 +820,53 @@ describe('ParseGraphQLServer', () => {
             'fileInfo',
           ]);
         });
+
+        it('should have clientMutationId in call function input', async () => {
+          Parse.Cloud.define('hello', () => {});
+
+          const callFunctionInputFields = (await apolloClient.query({
+            query: gql`
+              query {
+                __type(name: "CallCloudCodeInput") {
+                  inputFields {
+                    name
+                  }
+                }
+              }
+            `,
+          })).data['__type'].inputFields
+            .map(field => field.name)
+            .sort();
+
+          expect(callFunctionInputFields).toEqual([
+            'clientMutationId',
+            'functionName',
+            'params',
+          ]);
+        });
+
+        it('should have clientMutationId in call function payload', async () => {
+          Parse.Cloud.define('hello', () => {});
+
+          const callFunctionPayloadFields = (await apolloClient.query({
+            query: gql`
+              query {
+                __type(name: "CallCloudCodePayload") {
+                  fields {
+                    name
+                  }
+                }
+              }
+            `,
+          })).data['__type'].fields
+            .map(field => field.name)
+            .sort();
+
+          expect(callFunctionPayloadFields).toEqual([
+            'clientMutationId',
+            'result',
+          ]);
+        });
       });
 
       describe('Parse Class Types', () => {
@@ -5923,19 +5970,33 @@ describe('ParseGraphQLServer', () => {
       describe('Functions Mutations', () => {
         it('can be called', async () => {
           try {
+            const clientMutationId = uuidv4();
+
             Parse.Cloud.define('hello', async () => {
               return 'Hello world!';
             });
 
             const result = await apolloClient.mutate({
               mutation: gql`
-                mutation CallFunction {
-                  callCloudCode(functionName: hello)
+                mutation CallFunction($input: CallCloudCodeInput!) {
+                  callCloudCode(input: $input) {
+                    clientMutationId
+                    result
+                  }
                 }
               `,
+              variables: {
+                input: {
+                  clientMutationId,
+                  functionName: 'hello',
+                },
+              },
             });
 
-            expect(result.data.callCloudCode).toEqual('Hello world!');
+            expect(result.data.callCloudCode.clientMutationId).toEqual(
+              clientMutationId
+            );
+            expect(result.data.callCloudCode.result).toEqual('Hello world!');
           } catch (e) {
             handleError(e);
           }
@@ -5950,7 +6011,9 @@ describe('ParseGraphQLServer', () => {
             await apolloClient.mutate({
               mutation: gql`
                 mutation CallFunction {
-                  callCloudCode(functionName: hello)
+                  callCloudCode(input: { functionName: hello }) {
+                    result
+                  }
                 }
               `,
             });
@@ -6051,7 +6114,9 @@ describe('ParseGraphQLServer', () => {
           apolloClient.mutate({
             mutation: gql`
               mutation CallFunction($params: Object) {
-                callCloudCode(functionName: hello, params: $params)
+                callCloudCode(input: { functionName: hello, params: $params }) {
+                  result
+                }
               }
             `,
             variables: {

src/GraphQL/ParseGraphQLSchema.js

@@ -39,6 +39,8 @@ const RESERVED_GRAPHQL_TYPE_NAMES = [
   'SignUpFieldsInput',
   'LogInFieldsInput',
   'CloudCodeFunction',
+  'CallCloudCodeInput',
+  'CallCloudCodePayload',
 ];
 const RESERVED_GRAPHQL_QUERY_NAMES = ['health', 'viewer', 'class', 'classes'];
 const RESERVED_GRAPHQL_MUTATION_NAMES = [

src/GraphQL/loaders/filesMutations.js

@@ -83,7 +83,11 @@ const load = parseGraphQLSchema => {
     },
   });
 
-  parseGraphQLSchema.addGraphQLType(createMutation.args.input.type, true, true);
+  parseGraphQLSchema.addGraphQLType(
+    createMutation.args.input.type.ofType,
+    true,
+    true
+  );
   parseGraphQLSchema.addGraphQLType(createMutation.type, true, true);
   parseGraphQLSchema.addGraphQLMutation(
     'createFile',

src/GraphQL/loaders/functionsMutations.js

@@ -1,4 +1,5 @@
 import { GraphQLNonNull, GraphQLEnumType } from 'graphql';
+import { mutationWithClientMutationId } from 'graphql-relay';
 import { FunctionsRouter } from '../../Routers/FunctionsRouter';
 import * as defaultGraphQLTypes from './defaultGraphQLTypes';
 
@@ -21,41 +22,58 @@ const load = parseGraphQLSchema => {
       true
     );
 
-    parseGraphQLSchema.addGraphQLMutation(
-      'callCloudCode',
-      {
-        description:
-          'The call mutation can be used to invoke a cloud code function.',
-        args: {
-          functionName: {
-            description: 'This is the function to be called.',
-            type: new GraphQLNonNull(cloudCodeFunctionEnum),
-          },
-          params: {
-            description: 'These are the params to be passed to the function.',
-            type: defaultGraphQLTypes.OBJECT,
-          },
+    const callCloudCodeMutation = mutationWithClientMutationId({
+      name: 'CallCloudCode',
+      description:
+        'The callCloudCode mutation can be used to invoke a cloud code function.',
+      inputFields: {
+        functionName: {
+          description: 'This is the function to be called.',
+          type: new GraphQLNonNull(cloudCodeFunctionEnum),
+        },
+        params: {
+          description: 'These are the params to be passed to the function.',
+          type: defaultGraphQLTypes.OBJECT,
         },
-        type: defaultGraphQLTypes.ANY,
-        async resolve(_source, args, context) {
-          try {
-            const { functionName, params } = args;
-            const { config, auth, info } = context;
+      },
+      outputFields: {
+        result: {
+          description:
+            'This is the result value of the cloud code function execution.',
+          type: defaultGraphQLTypes.ANY,
+        },
+      },
+      mutateAndGetPayload: async (args, context) => {
+        try {
+          const { functionName, params } = args;
+          const { config, auth, info } = context;
 
-            return (await FunctionsRouter.handleCloudFunction({
+          return {
+            result: (await FunctionsRouter.handleCloudFunction({
               params: {
                 functionName,
               },
               config,
               auth,
               info,
               body: params,
-            })).response.result;
-          } catch (e) {
-            parseGraphQLSchema.handleError(e);
-          }
-        },
+            })).response.result,
+          };
+        } catch (e) {
+          parseGraphQLSchema.handleError(e);
+        }
       },
+    });
+
+    parseGraphQLSchema.addGraphQLType(
+      callCloudCodeMutation.args.input.type.ofType,
+      true,
+      true
+    );
+    parseGraphQLSchema.addGraphQLType(callCloudCodeMutation.type, true, true);
+    parseGraphQLSchema.addGraphQLMutation(
+      'callCloudCode',
+      callCloudCodeMutation,
       true,
       true
     );