gRPC transport in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this NestJS gRPC service call?

Consider a NestJS gRPC service with this method:

async getHello(): Promise<{ message: string }> { return { message: 'Hello from gRPC!' }; }

If a client calls getHello, what will the client receive?

NestJS

async getHello(): Promise<{ message: string }> { return { message: 'Hello from gRPC!' }; }

A A JSON object with a 'message' property containing 'Hello from gRPC!'

B A plain string 'Hello from gRPC!'

C An error because gRPC does not support returning objects

D An empty response with no data

💡 Hint

gRPC methods typically return objects matching the protobuf message structure.

The method returns an object with a 'message' property. The client receives this object serialized by gRPC.

📝 Syntax

intermediate

Which option correctly configures a NestJS microservice to use gRPC transport?

Choose the correct code snippet to create a NestJS microservice using gRPC transport with package 'hero' and proto file 'hero.proto'.

A app.createMicroservice({ transport: Transport.GRPC, options: { package: 'hero', protoPath: 'hero.proto' } });

B app.connectMicroservice({ transport: Transport.GRPC, options: { package: 'hero', protoPath: 'hero.proto' } });

C app.connectMicroservice({ transport: Transport.TCP, options: { package: 'hero', protoPath: 'hero.proto' } });

D app.createMicroservice({ transport: Transport.HTTP, options: { package: 'hero', protoPath: 'hero.proto' } });

💡 Hint

Use connectMicroservice with Transport.GRPC for gRPC microservices.

Only option B uses connectMicroservice with the correct transport and options for gRPC.

🔧 Debug

advanced

What error occurs if the protoPath is incorrect in NestJS gRPC microservice config?

If you configure a NestJS gRPC microservice with a wrong protoPath that does not exist, what error will you see when starting the app?

A SyntaxError: Unexpected token in proto file

B TypeError: Cannot read property 'package' of undefined

C Error: ENOENT: no such file or directory, open 'wrong.proto'

D No error, the app starts normally

💡 Hint

Check the file path carefully when loading proto files.

If the proto file path is wrong, Node.js throws a file not found error (ENOENT).

❓ state_output

advanced

What is the value of the variable after this gRPC client call in NestJS?

Given this client call:

const response = await client.send<{ message: string }>('getHello', {}).toPromise();

What is the value of response.message if the server returns { message: 'Hi there!' }?

NestJS

const response = await client.send<{ message: string }>('getHello', {}).toPromise();

A null

B An error is thrown

C undefined

D 'Hi there!'

💡 Hint

The client receives the server's response object.

The response variable holds the object returned by the server, so response.message is 'Hi there!'.

🧠 Conceptual

expert

Which statement best describes the role of protobuf in NestJS gRPC transport?

Choose the most accurate description of how protobuf works with NestJS gRPC transport.

A Protobuf defines the message and service structure used to serialize and deserialize data between client and server.

B Protobuf is a database technology used to store gRPC messages persistently.

C Protobuf is a UI framework for building gRPC client interfaces.

D Protobuf automatically generates REST endpoints from gRPC services in NestJS.

💡 Hint

Think about what protobuf files describe in gRPC communication.

Protobuf files define the structure of messages and services so gRPC can serialize and deserialize data correctly.

Practice

1. What is the main purpose of using gRPC transport in a NestJS application?

easy

A. To enable fast and clear communication between microservices using Protocol Buffers

B. To create RESTful APIs with JSON responses

C. To manage database connections efficiently

D. To handle user authentication and authorization

Solution

1. Step 1: Understand gRPC transport role

   gRPC transport in NestJS is designed to enable fast communication between services using Protocol Buffers.

2. Step 2: Compare with other options

   Options B, C, and D describe other unrelated features like REST APIs, database, or auth, which are not the main purpose of gRPC transport.

3. Final Answer:

   To enable fast and clear communication between microservices using Protocol Buffers -> Option A

4. Quick Check:

   gRPC transport = fast microservice communication [OK]

Hint: gRPC = fast microservice communication with Protocol Buffers [OK]

Common Mistakes:

• Confusing gRPC with REST APIs
• Thinking gRPC manages databases
• Assuming gRPC handles authentication

2. Which decorator is used in NestJS to link a method to a gRPC service method?

easy

A. @GrpcMethod

B. @GrpcClient

C. @GrpcHandler

D. @GrpcService

Solution

1. Step 1: Recall NestJS gRPC decorators

   The correct decorator to connect a method to a gRPC service method is @GrpcMethod.

2. Step 2: Eliminate incorrect options

   @GrpcService, @GrpcHandler, and @GrpcClient are not valid decorators for this purpose in NestJS.

3. Final Answer:

   @GrpcMethod -> Option A

4. Quick Check:

   Method to gRPC service = @GrpcMethod [OK]

Hint: Method to gRPC service uses @GrpcMethod decorator [OK]

Common Mistakes:

• Using @GrpcService instead of @GrpcMethod
• Confusing client decorators with method decorators
• Misspelling the decorator name

3. Given this NestJS gRPC service method, what will be the output when called with { id: 5 }?

  @GrpcMethod('HeroService', 'FindOne')
  findOne(data: { id: number }): { name: string } {
    const heroes = [{ id: 1, name: 'Superman' }, { id: 5, name: 'Batman' }];
    return { name: heroes.find(hero => hero.id === data.id)?.name || 'Unknown' };
  }

medium

A. { name: 'Unknown' }

B. { name: 'Superman' }

C. undefined

D. { name: 'Batman' }

Solution

1. Step 1: Analyze the input and method logic

   The method receives { id: 5 } and searches the heroes array for a hero with id 5.

2. Step 2: Find matching hero

   Hero with id 5 is { id: 5, name: 'Batman' }, so it returns { name: 'Batman' }.

3. Final Answer:

   { name: 'Batman' } -> Option D

4. Quick Check:

   Input id 5 returns Batman [OK]

Hint: Find hero by id in array returns matching name [OK]

Common Mistakes:

• Returning Superman instead of Batman
• Returning Unknown when hero exists
• Returning undefined instead of fallback

4. Identify the error in this NestJS gRPC service method:

  @GrpcMethod('HeroService', 'FindOne')
  findOne(data: { id: number }): { name: string } {
    const heroes = [{ id: 1, name: 'Superman' }];
    return heroes.find(hero => hero.id === data.id).name;
  }

medium

A. Incorrect decorator name

B. Missing return type annotation

C. Possible runtime error if hero not found

D. heroes array should be empty

Solution

1. Step 1: Understand the find method behavior

   If no hero matches data.id, find returns undefined.

2. Step 2: Identify the error

   Accessing .name on undefined causes a runtime error.

3. Final Answer:

   Possible runtime error if hero not found -> Option C

4. Quick Check:

   Accessing property on undefined causes error [OK]

Hint: Check if find() result can be undefined before accessing properties [OK]

Common Mistakes:

• Ignoring undefined result from find()
• Assuming decorator name is wrong
• Thinking return type annotation is missing

5. You want to implement a streaming gRPC method in NestJS that sends multiple messages back to the client. Which approach correctly sets up the method signature and decorator?

hard

A. @GrpcMethod('ChatService', 'StreamMessages')
streamMessages(data: { userId: number }): Promise<{ message: string }> {
// implementation
}

B. @GrpcMethod('ChatService', 'StreamMessages')
streamMessages(data: { userId: number }): Observable<{ message: string }> {
// implementation
}

C. @GrpcMethod('ChatService', 'StreamMessages')
streamMessages(data: { userId: number }): { message: string } {
// implementation
}

D. @GrpcMethod('ChatService', 'StreamMessages')
streamMessages(data: { userId: number }): void {
// implementation
}

Solution

1. Step 1: Understand streaming method return types

   Streaming gRPC methods in NestJS return an Observable to send multiple messages over time.

2. Step 2: Evaluate options

   @GrpcMethod('ChatService', 'StreamMessages') streamMessages(data: { userId: number }): Observable<{ message: string }> { // implementation } returns Observable, suitable for streaming. Options A and C return single responses (Promise or object). @GrpcMethod('ChatService', 'StreamMessages') streamMessages(data: { userId: number }): void { // implementation } returns void, which is invalid.

3. Final Answer:

   Method returning Observable for streaming -> Option B

4. Quick Check:

   Streaming gRPC method returns Observable [OK]

Hint: Streaming methods return Observable, not Promise or plain object [OK]

Common Mistakes:

• Using Promise instead of Observable for streaming
• Returning plain object for streaming method
• Using void return type for gRPC method