WebSocket guards and pipes in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a WebSocket guard denies access?

In a NestJS WebSocket gateway, if a guard returns false, what is the immediate effect on the client connection or message handling?

A The client connection is immediately closed by the server.

B The server throws an exception and disconnects the client.

C The message is ignored and not processed, but the connection stays open.

D The guard result is ignored and the message is processed anyway.

💡 Hint

Think about how guards control message flow without forcibly closing connections.

When a WebSocket guard returns false, NestJS prevents the message handler from running but keeps the connection alive. It does not close the connection or throw errors automatically.

📝 Syntax

intermediate

Identify the correct way to apply a pipe to a WebSocket message handler

Which of the following code snippets correctly applies a pipe to transform incoming WebSocket message data in NestJS?

NestJS

import { SubscribeMessage, WebSocketGateway, MessageBody } from '@nestjs/websockets';
import { UsePipes, ValidationPipe } from '@nestjs/common';

@WebSocketGateway()
export class ChatGateway {
  @SubscribeMessage('message')
  @UsePipes(new ValidationPipe())
  handleMessage(@MessageBody() data: any) {
    return data;
  }
}

A @UsePipes(new ValidationPipe()) placed above the @SubscribeMessage decorator.

B @UsePipes(new ValidationPipe()) placed below the @SubscribeMessage decorator and above the method.

C Passing the pipe instance directly as a parameter to @SubscribeMessage decorator.

D Applying the pipe inside the method body manually.

💡 Hint

Look at the decorator order NestJS expects for pipes on handlers.

The @UsePipes decorator must be placed directly above the method it affects, after the @SubscribeMessage decorator. Passing pipes as parameters or applying them inside the method is not the NestJS pattern.

🔧 Debug

advanced

Why does this WebSocket guard not block unauthorized users?

Consider this guard code for a NestJS WebSocket gateway: ```typescript import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common'; @Injectable() export class AuthGuard implements CanActivate { canActivate(context: ExecutionContext): boolean { const client = context.switchToWs().getClient(); if (client.handshake?.auth?.token === 'valid-token') { return true; } return false; } } ``` Why might this guard fail to block unauthorized users?

A The guard checks the token on the handshake object, but the token is sent in message data instead.

B The guard returns a boolean instead of a Promise<boolean>.

C The guard does not throw an exception on failure, so NestJS ignores the false return.

D The guard uses ExecutionContext instead of WsContext, causing context.switchToWs() to fail.

💡 Hint

Check where the token is expected versus where the guard looks for it.

The guard checks client.handshake.auth.token, but if the client sends the token inside the message payload instead, the guard will not find it and always return false or true incorrectly.

❓ state_output

advanced

What is the output after applying a custom pipe to transform WebSocket message data?

Given this custom pipe and WebSocket handler in NestJS: ```typescript import { PipeTransform, Injectable, ArgumentMetadata } from '@nestjs/common'; @Injectable() export class AppendPipe implements PipeTransform { transform(value: any, metadata: ArgumentMetadata) { return value + ' world'; } } @WebSocketGateway() export class HelloGateway { @SubscribeMessage('greet') @UsePipes(AppendPipe) handleGreet(@MessageBody() message: string) { return message; } } ``` If the client sends the message 'hello', what will the server return?

A Throws a runtime error because AppendPipe is not instantiated.

B 'hello'

C 'helloundefined world'

D 'hello world'

💡 Hint

Consider how pipes are applied and instantiated in NestJS decorators.

The pipe class AppendPipe is passed directly to @UsePipes without instantiation. NestJS expects an instance or a class reference, but for classes it creates instances automatically only if passed as a class reference without parentheses. Here, passing the class without parentheses is correct, but if the pipe requires constructor parameters or is not injectable, it will fail.

In this case, since AppendPipe is injectable and has no constructor parameters, NestJS will instantiate it. So the correct output is 'hello world'.

🧠 Conceptual

expert

Which statement about WebSocket guards and pipes in NestJS is true?

Select the one true statement about how guards and pipes work together in NestJS WebSocket gateways.

A Guards run before pipes, so access control happens before data transformation.

B Pipes run only if guards throw exceptions, otherwise they are skipped.

C Guards and pipes run simultaneously, so their order does not matter.

D Pipes run before guards, so data is transformed before access is checked.

💡 Hint

Think about the security flow: check access first, then transform data.

In NestJS, guards run first to decide if the request or message should proceed. Only if guards allow it do pipes run to transform or validate data before the handler executes.