gRPC transport in NestJS

Introduction

gRPC transport helps your NestJS app talk to other apps fast and clearly using a special language called Protocol Buffers.

You want your app to communicate quickly with other services.

You need a clear contract for messages between apps.

You want to build microservices that work well together.

You want to use streaming data between client and server.

You want to use a popular, efficient way to connect apps.

Syntax

NestJS

import { Controller } from '@nestjs/common';
import { GrpcMethod } from '@nestjs/microservices';

@Controller()
export class MyGrpcService {
  @GrpcMethod('ServiceName', 'MethodName')
  methodName(data: RequestType): ResponseType {
    // handle request and return response
  }
}

@GrpcMethod decorator links your method to a gRPC service and method name.

Request and response types come from your Protocol Buffers definitions.

Examples

This example shows a simple gRPC method that returns a hero name by id.

NestJS

import { Controller } from '@nestjs/common';
import { GrpcMethod } from '@nestjs/microservices';

@Controller()
export class HeroService {
  @GrpcMethod('HeroService', 'FindOne')
  findOne(data: { id: number }): { name: string } {
    return { name: 'Superman' };
  }
}

This example adds two numbers sent by the client and returns the result.

NestJS

import { Controller } from '@nestjs/common';
import { GrpcMethod } from '@nestjs/microservices';

@Controller()
export class MathService {
  @GrpcMethod('MathService', 'Sum')
  sum(data: { a: number; b: number }): { result: number } {
    return { result: data.a + data.b };
  }
}

Sample Program

This NestJS gRPC service has one method called multiply. It takes two numbers and returns their product.

NestJS

import { Controller } from '@nestjs/common';
import { GrpcMethod } from '@nestjs/microservices';

@Controller()
export class CalculatorService {
  @GrpcMethod('CalculatorService', 'Multiply')
  multiply(data: { x: number; y: number }): { product: number } {
    return { product: data.x * data.y };
  }
}

Important Notes

Make sure your .proto files match the service and method names exactly.

Use NestJS microservices options to configure gRPC transport in your main app module.

Test your gRPC methods with tools like BloomRPC or Evans for easy debugging.

Summary

gRPC transport lets NestJS apps talk fast and clearly using Protocol Buffers.

Use @GrpcMethod to connect your methods to gRPC service methods.

It is great for microservices and streaming data.

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