Node.js Backend Development Bootcamp · Lesson

Gateway Configuration

Configure WebSocket gateways in NestJS, handling connection events, messages, and room management.

Gateway Configuration is a free Node.js Backend Development Bootcamp lesson on CoddyKit — lesson 4 of 6. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Node.js Backend Development Bootcamp learning path, one of 6 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Unlocking Real-time with Gateways

Welcome back! In the previous lesson, we learned about WebSockets. Now, let's dive into how NestJS makes real-time communication easy with Gateways.

Think of a Gateway as a special controller for WebSocket connections. It listens for messages from clients and sends responses back, enabling dynamic, two-way communication.

Creating Your First Gateway

To create a Gateway, we use the @WebSocketGateway() decorator. This decorator marks a class as a WebSocket gateway.

By default, NestJS uses Socket.IO. You can specify a port, namespace, or other options. Let's start with a basic gateway:

import { WebSocketGateway,
         WebSocketServer } from '@nestjs/websockets';
import { Server } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001) // Listens on port 3001 for WS
export class EventsGateway {
  @WebSocketServer() server: Server;
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000); // HTTP app, WS runs alongside
}
bootstrap();

Gateway Configuration Options

The @WebSocketGateway() decorator accepts an optional configuration object. This lets you customize how your WebSocket server behaves:

port: The port the WebSocket server listens on (e.g., 3001).
namespace: Group connections under a specific path (e.g., '/chat').
cors: Configure Cross-Origin Resource Sharing for browser clients.
adapter: Specify a custom WebSocket adapter (e.g., for `ws` instead of `socket.io`).

Handling Connections & Disconnections

Gateways can react to client connections and disconnections using lifecycle hooks. These are interfaces your gateway can implement:

OnGatewayInit: Called once the gateway is initialized.
OnGatewayConnection: Called when a client connects.
OnGatewayDisconnect: Called when a client disconnects.

Use these to perform setup or cleanup tasks.

import { WebSocketGateway,
         OnGatewayConnection,
         OnGatewayDisconnect,
         WebSocketServer } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001)
export class EventsGateway
  implements OnGatewayConnection, OnGatewayDisconnect {
  @WebSocketServer() server: Server;

  handleConnection(client: Socket, ...args: any[]) {
    console.log(`Client connected: ${client.id}`);
  }

  handleDisconnect(client: Socket) {
    console.log(`Client disconnected: ${client.id}`);
  }
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Subscribing to Client Messages

Clients send messages with an 'event name'. Your gateway listens for these specific events using the @SubscribeMessage() decorator.

The decorated method receives the client (Socket instance) and the payload (data sent by the client).

import { WebSocketGateway,
         SubscribeMessage,
         WebSocketServer } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001)
export class EventsGateway {
  @WebSocketServer() server: Server;

  @SubscribeMessage('sendMessage')
  handleMessage(client: Socket, payload: string): void {
    console.log(`Message from ${client.id}: ${payload}`);
    // Process payload, then send response
  }
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Sending Messages Back to Clients

Once your gateway receives a message, you'll often want to send a response. You can inject the WebSocketServer instance using @WebSocketServer().

To send a message to a specific client, use client.emit('eventName', data). To broadcast to all clients, use this.server.emit('eventName', data).

import { WebSocketGateway,
         SubscribeMessage,
         WebSocketServer } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001)
export class EventsGateway {
  @WebSocketServer() server: Server;

  @SubscribeMessage('echo')
  handleEcho(client: Socket, payload: string): void {
    console.log(`Received: ${payload} from ${client.id}`);
    client.emit('echoResponse', `You said: ${payload}`);
  }

  @SubscribeMessage('broadcast')
  handleBroadcast(client: Socket, payload: string): void {
    this.server.emit(
      'broadcastMessage', 
      `${client.id} broadcasted: ${payload}`
    );
  }
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Organizing Clients with Rooms

For more complex applications, you might not want to broadcast every message to every client. This is where rooms come in handy!

Rooms allow you to group specific clients together. Messages can then be sent only to clients within a particular room. This is perfect for chat channels, game lobbies, or specific user notifications.

Joining and Leaving Rooms

Socket.IO clients can join or leave rooms dynamically. You can manage this from your gateway methods using the client instance:

client.join(roomName): Adds the client to the specified room.
client.leave(roomName): Removes the client from the specified room.

A client can be in multiple rooms simultaneously.

import { WebSocketGateway,
         SubscribeMessage,
         WebSocketServer } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001)
export class EventsGateway {
  @WebSocketServer() server: Server;

  @SubscribeMessage('joinRoom')
  handleJoinRoom(client: Socket, room: string): void {
    client.join(room);
    client.emit('joinedRoom', `You joined ${room}`);
    console.log(`${client.id} joined room: ${room}`);
  }

  @SubscribeMessage('leaveRoom')
  handleLeaveRoom(client: Socket, room: string): void {
    client.leave(room);
    client.emit('leftRoom', `You left ${room}`);
    console.log(`${client.id} left room: ${room}`);
  }
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Sending Messages to Specific Rooms

Once clients are in rooms, you can send targeted messages. Use the server.to(roomName).emit('eventName', data) method.

This ensures only clients subscribed to that particular room receive the message, making your real-time updates efficient and relevant.

import { WebSocketGateway,
         SubscribeMessage,
         WebSocketServer } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

// src/events.gateway.ts
@WebSocketGateway(3001)
export class EventsGateway {
  @WebSocketServer() server: Server;

  @SubscribeMessage('roomMessage')
  handleRoomMessage(
    client: Socket,
    payload: { room: string; message: string },
  ): void {
    const { room, message } = payload;
    this.server
      .to(room)
      .emit('roomUpdate',
            `[${room}] ${client.id}: ${message}`);
    console.log(
      `Message in ${room} from ${client.id}: ${message}`
    );
  }
}

// src/app.module.ts (minimal)
import { Module } from '@nestjs/common';
import { EventsGateway } from './events.gateway';

@Module({
  providers: [EventsGateway],
})
export class AppModule {}

// src/main.ts (minimal)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Gateway Configuration Quiz

Which of the following statements about NestJS WebSocket Gateways and rooms are TRUE?

Recap: Master Your Gateway

Great job! You've learned how to configure NestJS Gateways for powerful real-time communication.

We defined gateways using @WebSocketGateway().
We explored configuration options like port and namespace.
We implemented lifecycle hooks for connections and disconnections.
We handled client messages with @SubscribeMessage().
We used @WebSocketServer() to broadcast and send targeted messages.
Finally, we mastered rooms for efficient client grouping and targeted messaging.

Next, we'll build a full real-time chat application!

Frequently asked questions

Is the “Gateway Configuration” lesson free?

Yes — the full text of “Gateway Configuration” is free to read here on the web, and the Node.js Backend Development Bootcamp course includes 6 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Node.js Backend Development Bootcamp course, upgrade to CoddyKit PRO.

What will I learn in “Gateway Configuration”?

Configure WebSocket gateways in NestJS, handling connection events, messages, and room management. You practise Node.js Backend Development Bootcamp with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Node.js Backend Development Bootcamp?

No prior experience is required. Node.js Backend Development Bootcamp on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 6, so you can start here or from the beginning and move at your own pace.

How long does the “Gateway Configuration” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Node.js Backend Development Bootcamp lesson?

Yes. Every Node.js Backend Development Bootcamp lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Node.js Backend Development Bootcamp