Queries and mutations in NestJS

Introduction

Queries and mutations let you get and change data in your app. Queries fetch data, mutations update or add data.

When you want to get a list of users from a database.

When you need to add a new product to your store.

When you want to update a user's profile information.

When you want to delete an item from a list.

When you want to fetch details about a single record.

Syntax

NestJS

import { Query, Mutation, Resolver } from '@nestjs/graphql';

@Resolver()
export class SampleResolver {
  @Query(() => ReturnType)
  getData() {
    // return data
  }

  @Mutation(() => ReturnType)
  changeData(input: InputType) {
    // update or add data
  }
}

@Query defines a method to fetch data.

@Mutation defines a method to change data.

Examples

This example shows a simple query that returns a greeting string.

NestJS

import { Query, Resolver } from '@nestjs/graphql';

@Resolver()
export class UserResolver {
  @Query(() => String)
  hello() {
    return 'Hello World';
  }
}

This mutation updates a name and returns true if successful.

NestJS

import { Mutation, Resolver, Args } from '@nestjs/graphql';

@Resolver()
export class UserResolver {
  @Mutation(() => Boolean)
  updateName(@Args('name') name: string) {
    // pretend to update name
    return true;
  }
}

Sample Program

This resolver has a query to get all todo tasks as strings. It also has a mutation to add a new todo task and returns a confirmation message.

NestJS

import { Resolver, Query, Mutation, Args } from '@nestjs/graphql';

@Resolver()
export class TodoResolver {
  private todos = [{ id: 1, task: 'Learn NestJS' }];

  @Query(() => [String])
  getTodos() {
    return this.todos.map(todo => todo.task);
  }

  @Mutation(() => String)
  addTodo(@Args('task') task: string) {
    const newTodo = { id: this.todos.length + 1, task };
    this.todos.push(newTodo);
    return `Added: ${task}`;
  }
}

Important Notes

Queries should not change data, only return it.

Mutations can change data and usually return the changed data or a status.

Use @Args to get input values for mutations.

Summary

Queries fetch data without changing it.

Mutations change data and can return results.

Use decorators @Query and @Mutation in NestJS GraphQL resolvers.

Practice

1. In NestJS GraphQL, which decorator is used to define a method that fetches data without modifying it?

easy

A. @Query

B. @Mutation

C. @ResolveField

D. @Subscription

Solution

1. Step 1: Understand the purpose of @Query

   The @Query decorator marks a method as a GraphQL query, which fetches data without changing it.

2. Step 2: Differentiate from @Mutation

   @Mutation is used for methods that change data, so it is not correct here.

3. Final Answer:

   @Query -> Option A

4. Quick Check:

   Fetch data = @Query [OK]

Hint: Queries fetch data, use @Query decorator [OK]

Common Mistakes:

• Confusing @Mutation with @Query
• Using @ResolveField for queries
• Thinking @Subscription fetches data

2. Which of the following is the correct syntax to define a mutation method named createUser in a NestJS GraphQL resolver?

easy

A. @Mutation\ncreateUser() { /*...*/ }

B. @Query(() => User)\ncreateUser() { /*...*/ }

C. @Mutation(() => User)\ncreateUser() { /*...*/ }

D. @Mutation()\ncreateUser() { /*...*/ }

Solution

1. Step 1: Check decorator usage with return type

   The correct syntax uses @Mutation with a function returning the GraphQL type, e.g., @Mutation(() => User).

2. Step 2: Verify method name and decorator match

   The method name is createUser, and it must be decorated with @Mutation, not @Query.

3. Final Answer:

   @Mutation(() => User)\ncreateUser() { /*...*/ } -> Option C

4. Quick Check:

   Mutation with return type syntax = @Mutation(() => User)\ncreateUser() { /*...*/ } [OK]

Hint: Use @Mutation(() => ReturnType) for mutations [OK]

Common Mistakes:

• Omitting the return type function in decorator
• Using @Query instead of @Mutation
• Adding empty parentheses without return type

3. Given the following NestJS GraphQL resolver code, what will be the output when the getUser query is called?

@Query(() => String)
getUser() {
  return 'Alice';
}

medium

A. Error: Return type mismatch

B. "Alice"

C. null

D. undefined

Solution

1. Step 1: Analyze the @Query return type and method

   The method getUser returns the string 'Alice' and is decorated with @Query(() => String), matching the return type.

2. Step 2: Determine the GraphQL response

   GraphQL will return the string value "Alice" as the query result.

3. Final Answer:

   "Alice" -> Option B

4. Quick Check:

   Matching return type returns value correctly [OK]

Hint: Return value matches @Query type, so output is that value [OK]

Common Mistakes:

• Expecting an error due to missing async
• Confusing return value with null or undefined
• Thinking GraphQL wraps string differently

4. Identify the error in this NestJS GraphQL mutation resolver code:

@Mutation(() => Boolean)
async updateUser() {
  this.userService.update();
  return true;
}

medium

A. Incorrect return type Boolean instead of boolean

B. updateUser method must return void

C. Mutation should not be async

D. Missing await before userService.update()

Solution

1. Step 1: Check async method and service call

   The method is async but calls userService.update() without await, so the update may not complete before returning.

2. Step 2: Understand the impact of missing await

   Without await, the mutation returns true immediately, possibly before update finishes, causing unexpected behavior.

3. Final Answer:

   Missing await before userService.update() -> Option D

4. Quick Check:

   Async method must await async calls [OK]

Hint: Always await async calls inside async mutations [OK]

Common Mistakes:

• Ignoring missing await in async methods
• Confusing Boolean with boolean types
• Thinking async is not allowed in mutations

5. You want to create a NestJS GraphQL mutation that updates a user's email and returns the updated user object. Which of the following resolver method signatures correctly combines input argument and mutation decorator?

hard

A. @Mutation(() => User)
updateEmail(@Args('email') email: string) {
return this.userService.updateEmail(email);
}

B. @Query(() => User)
updateEmail(@Args('email') email: string) {
return this.userService.updateEmail(email);
}

C. @Mutation(() => User)
updateEmail(email: string) {
return this.userService.updateEmail(email);
}

D. @Mutation(() => User)
updateEmail(@Args() email: string) {
return this.userService.updateEmail(email);
}

Solution

1. Step 1: Confirm correct decorator for data change

   Since this method updates data, it must use @Mutation with the return type User.

2. Step 2: Check argument decorator usage

   The argument email is correctly decorated with @Args('email') to extract the argument from GraphQL input.

3. Step 3: Verify method signature correctness

   @Mutation(() => User) updateEmail(@Args('email') email: string) { return this.userService.updateEmail(email); } correctly combines @Mutation, return type, and @Args usage.

4. Final Answer:

   @Mutation(() => User) updateEmail(@Args('email') email: string) { return this.userService.updateEmail(email); } -> Option A

5. Quick Check:

   Mutation with @Args('email') and return type = @Mutation(() => User) updateEmail(@Args('email') email: string) { return this.userService.updateEmail(email); } [OK]

Hint: Use @Mutation with @Args('argName') for input arguments [OK]

Common Mistakes:

• Using @Query for mutations
• Omitting @Args decorator
• Using @Args() without argument name