gRPC transport in NestJS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the gRPC transport from NestJS microservices.

NestJS

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

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

AGrpcTransport

BGrpcClient

CGrpcService

DGrpcOptions

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing GrpcTransport with GrpcOptions.

Using GrpcService which does not exist.

Importing GrpcClient instead of GrpcOptions.

The correct import for gRPC transport options in NestJS microservices is GrpcOptions.

2fill in blank

medium

Complete the code to set the transport type to gRPC in the microservice options.

NestJS

const grpcOptions = {
  transport: [1],
  options: {
    package: 'hero',
    protoPath: 'hero.proto'
  }
};

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

ATransport.REDIS

BTransport.GRPC

CTransport.TCP

DTransport.HTTP

Attempts:

3 left

💡 Hint

Common Mistakes

Using Transport.HTTP instead of Transport.GRPC.

Setting transport to Transport.TCP or Transport.REDIS by mistake.

To use gRPC transport, set transport to Transport.GRPC in the options.

3fill in blank

hard

Fix the error in the code to correctly create a gRPC microservice.

NestJS

const app = await NestFactory.createMicroservice(AppModule, {
  transport: Transport.GRPC,
  options: {
    package: 'hero',
    protoPath: [1]
  }
});

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

A'./proto/hero.proto'

B'hero.proto'

C'./hero.proto'

D'proto/hero.proto'

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting './' causes the file not to be found.

Using incorrect folder paths that don't match the project structure.

The protoPath should be a relative path string starting with './' to correctly locate the proto file.

4fill in blank

hard

Fill both blanks to define a gRPC service client in a NestJS module.

NestJS

imports: [
  ClientsModule.register([
    {
      name: '[1]',
      transport: Transport.GRPC,
      options: {
        package: '[2]',
        protoPath: './hero.proto'
      }
    }
  ])
]

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

AHERO_PACKAGE

Bhero

CHERO_SERVICE

DHeroService

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up client name and package name.

Using incorrect package names that don't match proto.

The client name is usually a service identifier like 'HERO_SERVICE', and the package name matches the proto package 'hero'.

5fill in blank

hard

Fill all three blanks to implement a gRPC method handler in a NestJS controller.

NestJS

@Controller()
export class HeroController {
  @GrpcMethod('[1]', '[2]')
  findOne(data: { id: number }, metadata: any): [3] {
    return { id: data.id, name: 'HeroName' };
  }
}

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

AHeroService

BFindOne

C{ id: number; name: string }

DHero

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect service or method names in the decorator.

Returning wrong types that don't match proto messages.

The GrpcMethod decorator takes the service name and method name. The return type is the message type, here 'Hero'.

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