NestJS suporta comunicação em tempo real, bidirecional via gateways WebSocket — classes decoradas com @WebSocketGateway() que lidam com conexões e mensagens WebSocket (tipicamente via Socket.IO). Elas habilitam recursos como chat, notificações ao vivo e painéis ao vivo, usando a mesma estrutura NestJS (DI, decoradores).
{ , , , } ;
{ } ;
({ : })
{
()
: ;
()
() {
..(, data);
}
}
Um gateway usa @SubscribeMessage("event") para lidar com eventos recebidos (análogo a @Post para HTTP) e o server injetado para emitir eventos de volta aos clientes — server.emit faz broadcast para todos.
export class ChatGateway implements OnGatewayConnection, OnGatewayDisconnect {
handleConnection(client: Socket) {
console.log(`Client connected: ${client.id}`); // a user joined
}
handleDisconnect(client: Socket) {
console.log(`Client disconnected: ${client.id}`); // a user left — clean up
}
}
Gateways podem reagir a clientes se conectando e desconectando — útil para rastreamento de presença e limpeza.
@SubscribeMessage("joinRoom")
handleJoin(@ConnectedSocket() client: Socket, @MessageBody() room: string) {
client.join(room); // add the client to a room
}
@SubscribeMessage("roomMessage")
sendToRoom(@MessageBody() data: { room: string; text: string }) {
this.server.to(data.room).emit("message", data.text); // emit only to that room
// client.emit(...) → just that client; server.emit(...) → everyone
}
Salas agrupam clientes (por exemplo, uma sala de chat, colaboradores de um documento), permitindo broadcast para subconjuntos específicos em vez de todos — essencial para recursos em tempo real com escopo.
Gateways are providers → they support dependency injection (inject services),
and can use guards, pipes, interceptors, and filters — just like HTTP controllers.
→ The same structure/patterns apply to real-time as to REST.
⚠️ WebSocket connections are STATEFUL and live on ONE server instance.
To scale across multiple instances, use a Redis adapter (socket.io-redis) so
broadcasts/rooms work across all instances. (Like sessions, don't keep state in
one process's memory when scaling horizontally.)
Gateways WebSocket são como NestJS suporta recursos em tempo real, bidirecionais — chat, notificações ao vivo, presença, edição colaborativa, painéis ao vivo, interações multijogador — que o modelo request-response do REST não consegue fornecer (o servidor pode enviar push para clientes, não apenas responder a requisições).
Compreendê-los é conhecimento valioso de nível sênior para construir aplicações interativas modernas.
A força principal é que gateways se encaixam na estrutura familiar do NestJS: são provedores que suportam injeção de dependência e podem usar guards, pipes, interceptores e filtros assim como controllers HTTP, então os mesmos padrões e organização de código se aplicam a tempo real quanto ao REST.
Saber como lidar com eventos (@SubscribeMessage), fazer broadcast para clientes (server.emit), usar salas para escopar broadcasts a subconjuntos relevantes (salas de chat, colaboradores de documentos) e gerenciar o ciclo de vida da conexão (presença, limpeza) cobre o toolkit prático de tempo real.
Criticamente importante é a consideração de escalabilidade: conexões WebSocket são com estado e vinculadas a uma única instância de servidor, então escalar horizontalmente requer um adaptador Redis para coordenar broadcasts/salas entre instâncias (uma armadilha comum — assim como sessões, estado em tempo real não pode viver na memória de um único processo quando executando múltiplas instâncias).
Esta é uma capacidade importante, cada vez mais relevante para construir as experiências em tempo real e interativas que usuários modernos esperam, e a integração limpa do NestJS a torna acessível enquanto reutiliza a estrutura do framework.