Input arguments for mutations in GraphQL - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a mutation that takes an input argument named 'name'.

GraphQL

type Mutation { createUser(name: [1]): User }

Drag options to blanks, or click blank then click option'

AFloat

BInt

CString!

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using Int or Boolean instead of String for a name argument.

Forgetting the exclamation mark to make the argument required.

The input argument 'name' should be a non-nullable string, so we use String!.

2fill in blank

medium

Complete the mutation argument to accept an input object called 'UserInput'.

GraphQL

type Mutation { addUser(input: [1]): User }

Drag options to blanks, or click blank then click option'

ABoolean

BUser

CString

DUserInput!

Attempts:

3 left

💡 Hint

Common Mistakes

Using the output type 'User' instead of the input type 'UserInput'.

Omitting the exclamation mark for required input.

Input objects are used as arguments with a type name ending with 'Input' and usually non-nullable.

3fill in blank

hard

Fix the error in the mutation argument type to correctly accept a list of IDs.

GraphQL

type Mutation { deleteUsers(ids: [1]): Boolean }

Drag options to blanks, or click blank then click option'

A[ID!]

BID!

C[ID]

DID

Attempts:

3 left

💡 Hint

Common Mistakes

Using [ID] allows null items in the list, which may cause errors.

Using ID! means a single non-null ID, not a list.

To accept a list of non-null IDs, use [ID!]. This means a list where each ID is required.

4fill in blank

hard

Fill both blanks to define a mutation that takes a required input object and returns a non-nullable User.

GraphQL

type Mutation { updateUser(input: [1]): [2] }

Drag options to blanks, or click blank then click option'

AUserInput!

BUser

CUser!

DUserInput

Attempts:

3 left

💡 Hint

Common Mistakes

Using nullable types for required inputs or outputs.

Confusing input types with output types.

The input argument should be a required input object UserInput!, and the mutation returns a non-nullable User!.

5fill in blank

hard

Fill all three blanks to define a mutation with an optional string argument 'email', a required boolean 'active', and returns a User.

GraphQL

type Mutation { setUserStatus(email: [1], active: [2]): [3] }

Drag options to blanks, or click blank then click option'

AString

BBoolean!

CUser

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Making optional arguments required by adding exclamation marks.

Forgetting to add exclamation marks for required arguments.

The 'email' argument is optional, so just String. The 'active' argument is required, so Boolean!. The mutation returns a User type.

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