Client mutation id on deleteClass mutation

Author: davimacedo

spec/ParseGraphQLServer.spec.js

@@ -1059,6 +1059,42 @@ describe('ParseGraphQLServer', () => {
 
           expect(payloadFields).toEqual(['class', 'clientMutationId']);
         });
+
+        it('should have clientMutationId in deleteClass mutation input', async () => {
+          const inputFields = (await apolloClient.query({
+            query: gql`
+              query {
+                __type(name: "DeleteClassInput") {
+                  inputFields {
+                    name
+                  }
+                }
+              }
+            `,
+          })).data['__type'].inputFields
+            .map(field => field.name)
+            .sort();
+
+          expect(inputFields).toEqual(['clientMutationId', 'name']);
+        });
+
+        it('should have clientMutationId in deleteClass mutation payload', async () => {
+          const payloadFields = (await apolloClient.query({
+            query: gql`
+              query {
+                __type(name: "UpdateClassPayload") {
+                  fields {
+                    name
+                  }
+                }
+              }
+            `,
+          })).data['__type'].fields
+            .map(field => field.name)
+            .sort();
+
+          expect(payloadFields).toEqual(['class', 'clientMutationId']);
+        });
       });
 
       describe('Parse Class Types', () => {
@@ -3481,6 +3517,7 @@ describe('ParseGraphQLServer', () => {
 
         it('should delete an existing class', async () => {
           try {
+            const clientMutationId = uuidv4();
             const result = await apolloClient.mutate({
               mutation: gql`
                 mutation {
@@ -3498,10 +3535,13 @@ describe('ParseGraphQLServer', () => {
                       }
                     }
                   }
-                  deleteClass(name: "MyNewClass") {
-                    name
-                    schemaFields {
+                  deleteClass(input: { clientMutationId: "${clientMutationId}" name: "MyNewClass" }) {
+                    clientMutationId
+                    class {
                       name
+                      schemaFields {
+                        name
+                      }
                     }
                   }
                 }
@@ -3515,7 +3555,7 @@ describe('ParseGraphQLServer', () => {
             result.data.createClass.class.schemaFields = result.data.createClass.class.schemaFields.sort(
               (a, b) => (a.name > b.name ? 1 : -1)
             );
-            result.data.deleteClass.schemaFields = result.data.deleteClass.schemaFields.sort(
+            result.data.deleteClass.class.schemaFields = result.data.deleteClass.class.schemaFields.sort(
               (a, b) => (a.name > b.name ? 1 : -1)
             );
             expect(result).toEqual({
@@ -3538,15 +3578,22 @@ describe('ParseGraphQLServer', () => {
                   __typename: 'CreateClassPayload',
                 },
                 deleteClass: {
-                  name: 'MyNewClass',
-                  schemaFields: [
-                    { name: 'ACL', __typename: 'SchemaACLField' },
-                    { name: 'createdAt', __typename: 'SchemaDateField' },
-                    { name: 'objectId', __typename: 'SchemaStringField' },
-                    { name: 'updatedAt', __typename: 'SchemaDateField' },
-                    { name: 'willBeRemoved', __typename: 'SchemaStringField' },
-                  ],
-                  __typename: 'Class',
+                  clientMutationId,
+                  class: {
+                    name: 'MyNewClass',
+                    schemaFields: [
+                      { name: 'ACL', __typename: 'SchemaACLField' },
+                      { name: 'createdAt', __typename: 'SchemaDateField' },
+                      { name: 'objectId', __typename: 'SchemaStringField' },
+                      { name: 'updatedAt', __typename: 'SchemaDateField' },
+                      {
+                        name: 'willBeRemoved',
+                        __typename: 'SchemaStringField',
+                      },
+                    ],
+                    __typename: 'Class',
+                  },
+                  __typename: 'DeleteClassPayload',
                 },
               },
             });
@@ -3604,8 +3651,8 @@ describe('ParseGraphQLServer', () => {
             await apolloClient.mutate({
               mutation: gql`
                 mutation {
-                  deleteClass(name: "SomeClass") {
-                    name
+                  deleteClass(input: { name: "SomeClass" }) {
+                    clientMutationId
                   }
                 }
               `,
@@ -3626,8 +3673,8 @@ describe('ParseGraphQLServer', () => {
             await apolloClient.mutate({
               mutation: gql`
                 mutation {
-                  deleteClass(name: "SomeInexistentClass") {
-                    name
+                  deleteClass(input: { name: "SomeInexistentClass" }) {
+                    clientMutationId
                   }
                 }
               `,

src/GraphQL/loaders/schemaMutations.js

@@ -84,7 +84,7 @@ const load = parseGraphQLSchema => {
     },
     outputFields: {
       class: {
-        description: 'This is the created class.',
+        description: 'This is the updated class.',
         type: new GraphQLNonNull(schemaTypes.CLASS),
       },
     },
@@ -136,41 +136,57 @@ const load = parseGraphQLSchema => {
     true
   );
 
-  parseGraphQLSchema.addGraphQLMutation(
-    'deleteClass',
-    {
-      description:
-        'The deleteClass mutation can be used to delete an existing object class.',
-      args: {
-        name: schemaTypes.CLASS_NAME_ATT,
+  const deleteClassMutation = mutationWithClientMutationId({
+    name: 'DeleteClass',
+    description:
+      'The deleteClass mutation can be used to delete an existing object class.',
+    inputFields: {
+      name: schemaTypes.CLASS_NAME_ATT,
+    },
+    outputFields: {
+      class: {
+        description: 'This is the deleted class.',
+        type: new GraphQLNonNull(schemaTypes.CLASS),
       },
-      type: new GraphQLNonNull(schemaTypes.CLASS),
-      resolve: async (_source, args, context) => {
-        try {
-          const { name } = args;
-          const { config, auth } = context;
-
-          enforceMasterKeyAccess(auth);
-
-          if (auth.isReadOnly) {
-            throw new Parse.Error(
-              Parse.Error.OPERATION_FORBIDDEN,
-              "read-only masterKey isn't allowed to delete a schema."
-            );
-          }
-
-          const schema = await config.database.loadSchema({ clearCache: true });
-          const existingParseClass = await getClass(name, schema);
-          await config.database.deleteSchema(name);
-          return {
+    },
+    mutateAndGetPayload: async (args, context) => {
+      try {
+        const { name } = args;
+        const { config, auth } = context;
+
+        enforceMasterKeyAccess(auth);
+
+        if (auth.isReadOnly) {
+          throw new Parse.Error(
+            Parse.Error.OPERATION_FORBIDDEN,
+            "read-only masterKey isn't allowed to delete a schema."
+          );
+        }
+
+        const schema = await config.database.loadSchema({ clearCache: true });
+        const existingParseClass = await getClass(name, schema);
+        await config.database.deleteSchema(name);
+        return {
+          class: {
             name: existingParseClass.className,
             schemaFields: transformToGraphQL(existingParseClass.fields),
-          };
-        } catch (e) {
-          parseGraphQLSchema.handleError(e);
-        }
-      },
+          },
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
     },
+  });
+
+  parseGraphQLSchema.addGraphQLType(
+    deleteClassMutation.args.input.type.ofType,
+    true,
+    true
+  );
+  parseGraphQLSchema.addGraphQLType(deleteClassMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation(
+    'deleteClass',
+    deleteClassMutation,
     true,
     true
   );