Input arguments for mutations in GraphQL - Mini Project: Build & Apply

Input Arguments for Mutations in GraphQL

📖 Scenario: You are building a simple GraphQL API for a bookstore. You want to allow users to add new books to the store by sending a mutation with the book details.

🎯 Goal: Create a GraphQL mutation called addBook that accepts input arguments for the book's title, author, and publishedYear. The mutation should return the added book's details.

📋 What You'll Learn

Define a Book type with fields title, author, and publishedYear.

Create an addBook mutation that takes input arguments title (String!), author (String!), and publishedYear (Int!).

The mutation should return the newly added Book object.

Use input arguments correctly in the mutation definition.

💡 Why This Matters

🌍 Real World

GraphQL mutations with input arguments are used in real APIs to create or update data, such as adding new books to a bookstore database.

💼 Career

Understanding how to define and use input arguments in GraphQL mutations is essential for backend developers working with GraphQL APIs.

1

Define the Book type

Create a GraphQL type called Book with fields title of type String!, author of type String!, and publishedYear of type Int!.

GraphQL

# Define the Book type here
type Book {
  # Your code here
}

Hint

Use type Book { ... } and define each field with its type and exclamation mark for required fields.

2

Add the addBook mutation with input arguments

Add a mutation called addBook inside the type Mutation that accepts three input arguments: title of type String!, author of type String!, and publishedYear of type Int!. The mutation should return a Book.

GraphQL

type Book {
  title: String!
  author: String!
  publishedYear: Int!
}

type Mutation {
  # Your code here
}

Hint

Define type Mutation { addBook(title: String!, author: String!, publishedYear: Int!): Book }.

3

Create an input type for the book details

Create an input type called BookInput with fields title (String!), author (String!), and publishedYear (Int!).

GraphQL

type Book {
  title: String!
  author: String!
  publishedYear: Int!
}

input BookInput {
  # Your code here
}

type Mutation {
  addBook(title: String!, author: String!, publishedYear: Int!): Book
}

Hint

Use input BookInput { ... } to define input fields.

4

Update addBook mutation to use BookInput argument

Modify the addBook mutation to accept a single argument called input of type BookInput! instead of separate arguments. The mutation should still return a Book.

GraphQL

type Book {
  title: String!
  author: String!
  publishedYear: Int!
}

input BookInput {
  title: String!
  author: String!
  publishedYear: Int!
}

type Mutation {
  # Your code here
}

Hint

Change mutation argument to input: BookInput!.

Practice

1. What is the main purpose of input arguments in GraphQL mutations?

easy

A. To send data to create, update, or delete records

B. To define the schema of queries

C. To style the GraphQL interface

D. To fetch data without any changes

Solution

1. Step 1: Understand the role of mutations

   Mutations in GraphQL are used to change data, such as creating or updating records.

2. Step 2: Identify the use of input arguments

   Input arguments provide the data needed for these changes, like new values or identifiers.

3. Final Answer:

   To send data to create, update, or delete records -> Option A

4. Quick Check:

   Input arguments = send data for mutations [OK]

Hint: Input arguments send data to mutations for changes [OK]

Common Mistakes:

• Confusing input arguments with query filters
• Thinking input arguments style the API
• Assuming mutations fetch data only

2. Which of the following is the correct way to define an input argument for a mutation in GraphQL?

easy

A. mutation addUser(name: String!) { createUser(name: name) { id } }

B. mutation addUser($name: String!) { createUser(name: $name) { id } }

C. mutation addUser { createUser(name: String!) { id } }

D. mutation addUser($name) { createUser(name: $name) { id } }

Solution

1. Step 1: Recognize variable declaration syntax

   Input arguments must be declared with a $ prefix and type, like $name: String!.

2. Step 2: Use variables inside mutation

   Inside the mutation body, use the variable with $name to pass the value.

3. Final Answer:

   mutation addUser($name: String!) { createUser(name: $name) { id } } -> Option B

4. Quick Check:

   Variables use $name: Type! and $name inside mutation [OK]

Hint: Declare variables with $ and type, use $ inside mutation [OK]

Common Mistakes:

• Omitting $ in variable declaration
• Using type inside mutation call instead of variable
• Not specifying variable type

3. Given the mutation and variables below, what will be the returned id after execution?

mutation updateUser($id: ID!, $email: String!) { updateUser(id: $id, email: $email) { id email } }
{ "id": "123", "email": "[e-mail]" }

medium

A. "123"

B. "[e-mail]"

C. null

D. Error: Missing required fields

Solution

1. Step 1: Understand mutation input and output

   The mutation updates the user with id "123" and new email, returning the user's id and email.

2. Step 2: Identify returned id value

   The returned id is the same as the input id, which is "123".

3. Final Answer:

   "123" -> Option A

4. Quick Check:

   Returned id matches input id "123" [OK]

Hint: Returned id matches input id argument [OK]

Common Mistakes:

• Confusing returned id with email
• Assuming null if email changes
• Expecting error without missing fields

4. Identify the error in this mutation definition:

mutation deleteUser(id: ID!) { removeUser(id: id) { success } }

medium

A. removeUser field cannot have arguments

B. Variable type ID! is incorrect

C. Mutation name deleteUser is invalid

D. Missing $ before variable name in mutation definition

Solution

1. Step 1: Check variable declaration syntax

   Variables in mutation definitions must start with $, e.g., $id: ID!.

2. Step 2: Verify usage inside mutation

   Inside the mutation body, use the variable with $id, not just id.

3. Final Answer:

   Missing $ before variable name in mutation definition -> Option D

4. Quick Check:

   Variables require $ prefix in definition and usage [OK]

Hint: Always prefix variables with $ in mutation definitions [OK]

Common Mistakes:

• Omitting $ in variable declaration
• Using variable name without $ inside mutation
• Assuming mutation name must match field

5. You want to create a mutation that accepts a complex input object with fields title (String), content (String), and tags (list of Strings). Which is the correct way to define the input argument and use it in the mutation?

hard

A. type PostInput { title: String!, content: String!, tags: [String!]! }mutation createPost(post: PostInput!) { addPost(post: post) { id } }

B. input PostInput { title: String, content: String, tags: String }mutation createPost($post: PostInput) { addPost(post: $post) { id } }

C. input PostInput { title: String!, content: String!, tags: [String!]! }mutation createPost($post: PostInput!) { addPost(input: $post) { id } }

D. input PostInput { title: String!, content: String!, tags: [String] }mutation createPost($post: PostInput!) { addPost(input: post) { id } }

Solution

1. Step 1: Define input type correctly

   Use input keyword with required fields and list type: tags: [String!]! means list of non-null strings, list itself required.

2. Step 2: Declare variable and use it properly

   Declare variable with $post: PostInput! and use it as input: $post inside mutation.

3. Final Answer:

   input PostInput { title: String!, content: String!, tags: [String!]! }
   mutation createPost($post: PostInput!) { addPost(input: $post) { id } } -> Option C

4. Quick Check:

   Use input type and $variable with correct usage [OK]

Hint: Use input type and $variable with correct usage inside mutation [OK]

Common Mistakes:

• Using type instead of input for input objects
• Omitting $ in variable declaration or usage
• Incorrect list type syntax or missing non-null markers
• Passing variable without $ inside mutation