Why GraphQL fits NestJS architecture - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the GraphQL module in a NestJS app.

NestJS

import { [1] } from '@nestjs/graphql';

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

AHttpModule

BConfigModule

CGraphQLModule

DDatabaseModule

Attempts:

3 left

💡 Hint

Common Mistakes

Importing unrelated modules like HttpModule.

Confusing GraphQLModule with ConfigModule.

The GraphQLModule is the main module to integrate GraphQL in NestJS.

2fill in blank

medium

Complete the code to configure GraphQL in NestJS with code-first approach.

NestJS

GraphQLModule.forRoot({
  autoSchemaFile: [1],
}),

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

Atrue

Bfalse

C'schema.gql'

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string filename instead of true for code-first.

Setting autoSchemaFile to false disables schema generation.

Setting autoSchemaFile to true enables code-first schema generation.

3fill in blank

hard

Fix the error in the resolver decorator to define a GraphQL query.

NestJS

@[1]()
export class SampleResolver {
  @Query(() => String)
  hello() {
    return 'Hello World';
  }
}

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

AModule

BController

CInjectable

DResolver

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Controller instead of @Resolver.

Forgetting to decorate the resolver class.

The @Resolver() decorator marks the class as a GraphQL resolver in NestJS.

4fill in blank

hard

Fill both blanks to define a GraphQL query method with a return type.

NestJS

import { Query, [1] } from '@nestjs/graphql';

@Resolver()
export class UserResolver {
  @Query(() => [2])
  getUser() {
    return 'User1';
  }
}

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

AResolver

BMutation

CString

DInjectable

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Mutation instead of Resolver.

Using Injectable instead of Resolver.

Using Mutation as return type.

The Resolver decorator is imported to mark classes, and String is used as the GraphQL return type.

5fill in blank

hard

Fill all three blanks to create a GraphQL mutation method with an argument.

NestJS

import { Mutation, Arg, [1] } from '@nestjs/graphql';

@[2]()
export class PostResolver {
  @Mutation(() => Boolean)
  createPost(@Arg('[3]') title: string) {
    return true;
  }
}

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

AResolver

BQuery

Ctitle

DInjectable

Attempts:

3 left

💡 Hint

Common Mistakes

Using Query instead of Resolver for the class.

Using Injectable instead of Resolver.

Mismatching argument name in @Arg.

The Resolver decorator marks the class, and the argument name title is used in @Arg.

Practice

1. Why does GraphQL fit well with NestJS architecture?

easy

A. Because both use modern TypeScript features for strong typing

B. Because GraphQL only works with JavaScript, not TypeScript

C. Because NestJS does not support REST APIs

D. Because GraphQL requires no schema definition

Solution

1. Step 1: Understand NestJS and GraphQL typing

   NestJS and GraphQL both use TypeScript, which provides strong typing and modern language features.

2. Step 2: Connect typing to architecture fit

   This shared use of TypeScript makes it easier to build and maintain APIs with clear contracts and fewer errors.

3. Final Answer:

   Because both use modern TypeScript features for strong typing -> Option A

4. Quick Check:

   TypeScript use = A [OK]

Hint: Match TypeScript use in both for best fit [OK]

Common Mistakes:

• Thinking GraphQL only works with JavaScript
• Assuming NestJS does not support REST
• Believing GraphQL needs no schema

2. Which of the following is the correct way to define a GraphQL resolver in NestJS?

easy

A. function MyResolver() {}

B. @Resolver() export class MyResolver {}

C. class MyResolver extends Resolver {}

D. const resolver = new Resolver()

Solution

1. Step 1: Recall NestJS GraphQL resolver syntax

   Resolvers in NestJS are classes decorated with @Resolver() to define GraphQL query/mutation handlers.

2. Step 2: Identify correct syntax

   @Resolver() export class MyResolver {} shows the correct decorator and class export syntax used in NestJS GraphQL.

3. Final Answer:

   @Resolver() export class MyResolver {} -> Option B

4. Quick Check:

   @Resolver decorator = A [OK]

Hint: Look for @Resolver decorator on exported class [OK]

Common Mistakes:

• Using plain functions instead of classes
• Trying to extend Resolver class which doesn't exist
• Instantiating Resolver directly

3. Given this NestJS GraphQL resolver snippet, what will be the output when querying hello?

@Resolver()
export class HelloResolver {
  @Query(() => String)
  hello() {
    return 'Hello, NestJS GraphQL!';
  }
}

medium

A. "hello"

B. null

C. "Hello, NestJS GraphQL!"

D. Error: Query not found

Solution

1. Step 1: Understand the resolver method

   The method hello() returns the string 'Hello, NestJS GraphQL!'.

2. Step 2: Match query to method output

   Querying hello calls this method, so the output is the returned string.

3. Final Answer:

   "Hello, NestJS GraphQL!" -> Option C

4. Quick Check:

   Method return = D [OK]

Hint: Match query name to method return value [OK]

Common Mistakes:

• Expecting null if method returns string
• Confusing query name with string output
• Assuming error without syntax issues

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

@Resolver()
export class UserResolver {
  @Query(() => User)
  getUser(id: string) {
    return this.userService.findById(id);
  }
}

medium

A. All of the above

B. userService is not injected

C. User type is not imported

D. Missing @Args decorator for the id parameter

Solution

1. Step 1: Check parameter decorators

   The id parameter lacks the @Args decorator, so GraphQL won't pass the argument correctly.

2. Step 2: Verify service injection and imports

   The code snippet does not show userService injection or User type import, both needed for this to work.

3. Final Answer:

   All of the above -> Option A

4. Quick Check:

   Missing decorators, imports, injection = D [OK]

Hint: Check for missing decorators, imports, and injections [OK]

Common Mistakes:

• Forgetting @Args on parameters
• Not injecting services in constructor
• Ignoring necessary imports

5. How does using GraphQL in NestJS help support multiple client types efficiently?

hard

A. By requiring separate APIs for each client type

B. By forcing clients to use the same fixed REST endpoints

C. By disabling TypeScript features for faster responses

D. By providing a single flexible API endpoint that clients can query as needed

Solution

1. Step 1: Understand GraphQL API flexibility

   GraphQL exposes one endpoint where clients specify exactly what data they want, making it flexible for different clients.

2. Step 2: Contrast with REST and other options

   Unlike REST, which often requires multiple endpoints, GraphQL's single endpoint reduces complexity and supports many client needs efficiently.

3. Final Answer:

   By providing a single flexible API endpoint that clients can query as needed -> Option D

4. Quick Check:

   Single flexible endpoint = C [OK]

Hint: Remember GraphQL uses one endpoint for all clients [OK]

Common Mistakes:

• Thinking GraphQL requires multiple endpoints
• Confusing REST fixed endpoints with GraphQL flexibility
• Assuming TypeScript is disabled for performance