Delete mutation pattern in GraphQL - Step-by-Step Execution

Concept Flow - Delete mutation pattern

Client sends Delete Mutation Request

↓

Server receives mutation with ID

↓

Server checks if record exists

↓

Delete record

↓

Return success response

The client sends a delete request with an ID, the server checks if the record exists, deletes it if found, and returns success or error.

Execution Sample

GraphQL

mutation {
  deleteUser(id: "123") {
    id
    name
  }
}

This mutation requests to delete a user with ID '123' and returns the deleted user's id and name.

Execution Table

Step	Action	Input	Check	Result	Output
1	Receive mutation	id = '123'	N/A	Mutation accepted	N/A
2	Check record existence	id = '123'	Record found?	Yes	N/A
3	Delete record	id = '123'	N/A	Record deleted	N/A
4	Return response	Deleted user data	N/A	Success	{ id: "123", name: "Alice" }
5	End	N/A	N/A	Mutation complete	N/A

💡 Mutation ends after returning success response with deleted user data.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
id	undefined	"123"	"123"	"123"
recordExists	undefined	true	true	true
deletedRecord	undefined	undefined	{ id: "123", name: "Alice" }	{ id: "123", name: "Alice" }
response	undefined	undefined	undefined	{ id: "123", name: "Alice" }

Key Moments - 2 Insights

What happens if the record with the given ID does not exist?

If the record does not exist (Step 2 check is No), the server returns an error response instead of deleting, stopping the mutation early.

Why does the mutation return the deleted record's data?

Returning the deleted record's data confirms what was deleted and helps the client update its state accordingly, as shown in Step 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the result of the record existence check at Step 2?

A Yes

B No

C Error

D Undefined

💡 Hint

Check the 'Result' column in Step 2 of the execution_table.

At which step is the record actually deleted?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Action' column to find when deletion happens.

If the record did not exist, how would the execution table change?

A Step 3 would delete a record anyway

B Step 4 would return deleted user data

C Step 2 result would be 'No' and mutation would return error

D Mutation would continue normally

💡 Hint

Refer to key_moments about what happens when record is missing.

Concept Snapshot

Delete Mutation Pattern in GraphQL:
- Client sends mutation with record ID.
- Server checks if record exists.
- If yes, deletes record and returns deleted data.
- If no, returns error.
- Helps client confirm deletion and update UI.

Full Transcript

In the Delete mutation pattern, the client sends a mutation request with the ID of the record to delete. The server receives this request and checks if the record exists. If the record is found, the server deletes it and returns the deleted record's data as confirmation. If the record does not exist, the server returns an error. This pattern ensures the client knows exactly what was deleted or if the deletion failed. The execution table shows each step: receiving the mutation, checking existence, deleting, and returning the response. Variables like the record ID, existence flag, and deleted record data change as the mutation progresses. Understanding these steps helps beginners see how delete mutations work in GraphQL.