WebSocket guards and pipes in NestJS - Performance & Optimization

Performance: WebSocket guards and pipes

MEDIUM IMPACT

This concept affects the responsiveness and throughput of WebSocket message handling by controlling access and transforming data before processing.

Validating and transforming incoming WebSocket messages

NestJS

import { SubscribeMessage, WebSocketGateway } from '@nestjs/websockets';
import { UseGuards, UsePipes, ValidationPipe } from '@nestjs/common';
import { WsGuard } from './ws.guard';

@WebSocketGateway()
export class ChatGateway {
  @UseGuards(WsGuard)
  @UsePipes(new ValidationPipe({ transform: true }))
  @SubscribeMessage('message')
  handleMessage(client, payload) {
    // Payload is already validated and transformed
    return { text: payload.text };
  }
}

Using guards and pipes offloads validation and transformation before handler execution, reducing handler complexity and improving throughput.

📈 Performance GainReduces event loop blocking time per message, improving INP and overall responsiveness.

Validating and transforming incoming WebSocket messages

NestJS

import { SubscribeMessage, WebSocketGateway } from '@nestjs/websockets';

@WebSocketGateway()
export class ChatGateway {
  @SubscribeMessage('message')
  handleMessage(client, payload) {
    // Manual validation and transformation inside handler
    if (!payload.text || typeof payload.text !== 'string') {
      return { error: 'Invalid message' };
    }
    const transformed = payload.text.trim().toLowerCase();
    // Process message
    return { text: transformed };
  }
}

Manual validation and transformation inside the handler causes repeated code and blocks the event loop longer, delaying message processing.

📉 Performance CostBlocks event loop per message, increasing INP latency especially under high message volume.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Manual validation in handler	N/A	N/A	N/A	[X] Bad
Validation and transformation via guards and pipes	N/A	N/A	N/A	[OK] Good

Rendering Pipeline

WebSocket guards and pipes operate before the message reaches the handler, filtering and transforming data to optimize processing.

→Message Reception

→Pre-processing

→Handler Execution

⚠️ BottleneckHandler Execution stage can be delayed if validation/transformation is done inside handlers.

Core Web Vital Affected

INP

This concept affects the responsiveness and throughput of WebSocket message handling by controlling access and transforming data before processing.

Optimization Tips

1Use guards to block unauthorized WebSocket messages early.

2Use pipes to validate and transform messages before handlers run.

3Avoid heavy processing inside message handlers to keep responsiveness high.

Performance Quiz - 3 Questions

What is the main performance benefit of using WebSocket guards in NestJS?

A They increase the size of the WebSocket payload.

B They prevent unauthorized messages early, reducing unnecessary processing.

C They delay message handling to batch process messages.

D They add extra logging for debugging.

DevTools: Performance

How to check: Record a session while sending multiple WebSocket messages. Look for long tasks or delays in the main thread related to message handling.

What to look for: Reduced blocking time and faster message processing indicate efficient use of guards and pipes.

Practice

1. What is the main purpose of a WebSocket guard in a NestJS application?

easy

A. To control access and decide if a client can connect or send messages

B. To transform incoming message data before it reaches the handler

C. To log all WebSocket messages for debugging

D. To automatically retry failed WebSocket connections

Solution

1. Step 1: Understand the role of guards

   Guards in NestJS are used to control access by allowing or denying client connections or message handling.

2. Step 2: Differentiate guards from pipes

   Pipes transform or validate data, not control access, so they do not decide connection permissions.

3. Final Answer:

   To control access and decide if a client can connect or send messages -> Option A

4. Quick Check:

   Guards control access = A [OK]

Hint: Guards control access, pipes transform data [OK]

Common Mistakes:

• Confusing guards with pipes
• Thinking guards transform data
• Assuming guards handle logging

2. Which of the following is the correct way to apply a guard to a WebSocket gateway method in NestJS?

easy

A. @UseGuards(MyGuard) on the gateway class

B. @UseGuards(MyGuard) on the gateway method

C. @UsePipes(MyGuard) on the gateway method

D. @UseFilters(MyGuard) on the gateway class

Solution

1. Step 1: Recall decorator usage for guards

   Guards are applied using @UseGuards decorator either on the class or method. Applying on method is valid and common.

2. Step 2: Identify correct decorator and target

   @UseGuards is correct for guards; @UsePipes is for pipes, and @UseFilters is for exception filters.

3. Final Answer:

   @UseGuards(MyGuard) on the gateway method -> Option B

4. Quick Check:

   @UseGuards on method = A [OK]

Hint: Use @UseGuards for guards, not pipes or filters [OK]

Common Mistakes:

• Using @UsePipes instead of @UseGuards for guards
• Applying filters instead of guards
• Applying decorators on wrong targets

3. Given this WebSocket gateway method with a pipe, what will happen if the incoming message payload is invalid?

@SubscribeMessage('msg')
@UsePipes(new ValidationPipe())
handleMessage(@MessageBody() data: CreateDto) {
  return 'Received';
}

medium

A. The server crashes due to invalid data

B. The message is accepted without validation

C. The message is rejected and an error is sent back to the client

D. The message is transformed but still processed

Solution

1. Step 1: Understand ValidationPipe behavior

   ValidationPipe checks incoming data and rejects it if invalid, sending an error response.

2. Step 2: Analyze the method setup

   The method uses @UsePipes with ValidationPipe, so invalid data triggers rejection, not acceptance or crash.

3. Final Answer:

   The message is rejected and an error is sent back to the client -> Option C

4. Quick Check:

   ValidationPipe rejects invalid data = C [OK]

Hint: ValidationPipe rejects invalid data automatically [OK]

Common Mistakes:

• Assuming invalid data is accepted
• Thinking server crashes on invalid data
• Confusing transformation with acceptance

4. Identify the error in this WebSocket gateway code snippet:

@SubscribeMessage('chat')
@UseGuards(AuthGuard)
@UsePipes(new ParseIntPipe())
handleChat(@MessageBody() data: string) {
  return data;
}

medium

A. handleChat method must return a Promise

B. AuthGuard cannot be used with WebSocket gateways

C. @UsePipes must be placed before @UseGuards

D. ParseIntPipe cannot parse a string directly without conversion

Solution

1. Step 1: Check pipe compatibility with data type

   ParseIntPipe expects a value that can be parsed to integer, but data is a string that may not convert properly.

2. Step 2: Validate other decorator usage

   AuthGuard is valid for WebSocket guards, and decorator order does not cause error here. Returning Promise is optional.

3. Final Answer:

   ParseIntPipe cannot parse a string directly without conversion -> Option D

4. Quick Check:

   ParseIntPipe needs numeric input = D [OK]

Hint: Pipes must match expected input types [OK]

Common Mistakes:

• Assuming guards can't be used on WebSocket
• Thinking decorator order always matters
• Believing return type must be Promise

5. You want to ensure only authenticated users can send messages and that the message payload is a valid JSON object with a 'text' property. Which combination of guard and pipe setup is best in a NestJS WebSocket gateway?

hard

A. Use @UseGuards(AuthGuard) to check authentication and @UsePipes(ValidationPipe) with a DTO validating 'text' property

B. Use @UsePipes(AuthGuard) to check authentication and @UseGuards(ValidationPipe) for payload validation

C. Use @UseGuards(AuthGuard) only, and validate payload manually inside the handler

D. Use @UsePipes(ValidationPipe) only, assuming it checks authentication too

Solution

1. Step 1: Assign correct roles to guard and pipe

   Guards handle authentication and authorization, so AuthGuard should be used as a guard.

2. Step 2: Use ValidationPipe with DTO for payload validation

   ValidationPipe validates and transforms incoming data using a DTO that checks the 'text' property.

3. Step 3: Evaluate other options

   Swapping guards and pipes misuses decorators; using guards only requires manual payload validation lacking automation; using pipes only misses authentication checks.

4. Final Answer:

   Use @UseGuards(AuthGuard) to check authentication and @UsePipes(ValidationPipe) with a DTO validating 'text' property -> Option A

5. Quick Check:

   Guard for auth + Pipe for validation = B [OK]

Hint: Guards for auth, pipes for data validation [OK]

Common Mistakes:

• Swapping guards and pipes roles
• Skipping automatic validation
• Assuming pipes handle authentication