gRPC transport in NestJS - Step-by-Step Execution

Concept Flow - gRPC transport

Define Proto File

↓

Generate gRPC Service Interfaces

↓

Create NestJS gRPC Microservice

↓

Implement Service Handlers

↓

Start Microservice

↓

Client Sends gRPC Request

↓

Server Processes Request

↓

Server Sends Response

↓

Client Receives Response

This flow shows how NestJS uses gRPC transport: define proto, generate interfaces, create microservice, implement handlers, start service, then client-server communication.

Execution Sample

NestJS

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

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

This NestJS service listens for gRPC calls to 'FindOne' method and returns a hero object with id and name.

Execution Table

Step	Action	Input	Internal State	Output
1	Receive gRPC request	{ id: 1 }	Waiting for request	None
2	Invoke findOne handler	{ id: 1 }	Processing request with id=1	None
3	Create response object	{ id: 1 }	Response = { id: 1, name: 'Hero1' }	None
4	Send response back	Response object	Response sent	{ id: 1, name: 'Hero1' }
5	Client receives response	Response object	Client processes response	{ id: 1, name: 'Hero1' }
6	End	No input	Idle	No further output

💡 No more requests; microservice continues listening for new calls.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
data	undefined	{ id: 1 }	{ id: 1 }	{ id: 1 }	undefined
response	undefined	undefined	{ id: 1, name: 'Hero1' }	{ id: 1, name: 'Hero1' }	undefined

Key Moments - 2 Insights

Why does the findOne method receive an object with id instead of separate parameters?

Because gRPC methods receive a single object representing the request message, matching the proto definition. See execution_table step 2 where data is { id: 1 }.

How does NestJS know which method to call for a gRPC request?

The @GrpcMethod decorator links the proto service and method name to the handler. In the code, @GrpcMethod('HeroService', 'FindOne') tells NestJS to call findOne for that gRPC method.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'response' after Step 3?

A { id: 1, name: 'Hero1' }

B undefined

C { id: 1 }

D null

💡 Hint

Check the 'Internal State' column at Step 3 in execution_table.

At which step does the server send the response back to the client?

A Step 2

B Step 4

C Step 5

D Step 3

💡 Hint

Look for 'Send response back' action in execution_table.

If the client sends { id: 5 } instead, what will be the 'name' in the response?

A 'Hero1'

B 'Hero'

C 'Hero5'

D undefined

💡 Hint

See the code in execution_sample where name is 'Hero' + data.id.

Concept Snapshot

NestJS gRPC transport uses proto files to define services.
Use @GrpcMethod to link proto methods to handlers.
Handlers receive request objects and return response objects.
Microservice listens and processes gRPC calls asynchronously.
Client-server communicate via defined proto messages.

Full Transcript

This visual execution shows how NestJS handles gRPC transport. First, a proto file defines the service and messages. NestJS generates interfaces and creates a microservice. The service class uses @GrpcMethod to handle specific gRPC calls. When a client sends a request like { id: 1 }, the findOne method receives it as an object. It processes and returns a response object with id and name. The microservice sends this back to the client. Variables like 'data' and 'response' change during execution steps. Key points include how NestJS maps proto methods to handlers and how request data is structured. The quiz tests understanding of response values and flow steps.