NestJS และ WebSockets ในปี 2026: Real-Time, Gateway และคำถามสัมภาษณ์งาน

import {
  WebSocketGateway,
  WebSocketServer,
  SubscribeMessage,
  MessageBody,
  ConnectedSocket,
  OnGatewayInit,
  OnGatewayConnection,
  OnGatewayDisconnect,
} from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';
import { Logger } from '@nestjs/common';

@WebSocketGateway({
  cors: {
    origin: process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'],
    credentials: true,
  },
  namespace: '/events',
  transports: ['websocket', 'polling'],
})
export class EventsGateway
  implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect
{
  @WebSocketServer()
  server: Server;

  private readonly logger = new Logger(EventsGateway.name);

  afterInit(server: Server): void {
    this.logger.log('WebSocket Gateway initialized');
  }

  handleConnection(client: Socket): void {
    this.logger.log(`Client connected: ${client.id}`);
  }

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

  @SubscribeMessage('message')
  handleMessage(
    @MessageBody() data: { content: string; room?: string },
    @ConnectedSocket() client: Socket,
  ): { event: string; data: unknown } {
    if (data.room) {
      client.to(data.room).emit('message', data);
    }
    return { event: 'message', data: { received: true, timestamp: Date.now() } };
  }
}

import { NestFactory } from '@nestjs/core';
import { IoAdapter } from '@nestjs/platform-socket.io';
import { WsAdapter } from '@nestjs/platform-ws';
import { AppModule } from './app.module';

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

  // ใช้ Socket.IO adapter
  app.useWebSocketAdapter(new IoAdapter(app));

  // หรือใช้ ws adapter
  // app.useWebSocketAdapter(new WsAdapter(app));

  await app.listen(3000);
}
bootstrap();

import { IoAdapter } from '@nestjs/platform-socket.io';
import { ServerOptions } from 'socket.io';
import { createAdapter } from '@socket.io/redis-adapter';
import { createClient } from 'redis';
import { INestApplication } from '@nestjs/common';

export class RedisIoAdapter extends IoAdapter {
  private adapterConstructor: ReturnType<typeof createAdapter>;

  async connectToRedis(): Promise<void> {
    const pubClient = createClient({
      url: process.env.REDIS_URL || 'redis://localhost:6379',
    });
    const subClient = pubClient.duplicate();

    await Promise.all([pubClient.connect(), subClient.connect()]);

    this.adapterConstructor = createAdapter(pubClient, subClient);
  }

  createIOServer(port: number, options?: ServerOptions): unknown {
    const server = super.createIOServer(port, options);
    server.adapter(this.adapterConstructor);
    return server;
  }
}

// ใน main.ts
async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  const redisIoAdapter = new RedisIoAdapter(app);
  await redisIoAdapter.connectToRedis();
  app.useWebSocketAdapter(redisIoAdapter);

  await app.listen(3000);
}

import {
  WebSocketGateway,
  OnGatewayConnection,
  WsException,
} from '@nestjs/websockets';
import { Socket } from 'socket.io';
import { JwtService } from '@nestjs/jwt';
import { UsersService } from '../users/users.service';

@WebSocketGateway()
export class AuthenticatedGateway implements OnGatewayConnection {
  constructor(
    private readonly jwtService: JwtService,
    private readonly usersService: UsersService,
  ) {}

  async handleConnection(client: Socket): Promise<void> {
    try {
      const token =
        client.handshake.auth?.token ||
        client.handshake.headers?.authorization?.split(' ')[1];

      if (!token) {
        throw new WsException('Authentication token required');
      }

      const payload = await this.jwtService.verifyAsync(token);
      const user = await this.usersService.findById(payload.sub);

      if (!user) {
        throw new WsException('User not found');
      }

      // เก็บข้อมูล user ไว้ใน socket เพื่อเข้าถึงในภายหลัง
      client.data.user = user;
      client.join(`user:${user.id}`);
    } catch (error) {
      client.emit('error', { message: 'Authentication failed' });
      client.disconnect();
    }
  }
}

import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { WsException } from '@nestjs/websockets';
import { Socket } from 'socket.io';

@Injectable()
export class WsAuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const client: Socket = context.switchToWs().getClient();
    const user = client.data?.user;

    if (!user) {
      throw new WsException('Unauthorized');
    }

    return true;
  }
}

@Injectable()
export class WsRolesGuard implements CanActivate {
  constructor(private readonly requiredRoles: string[]) {}

  canActivate(context: ExecutionContext): boolean {
    const client: Socket = context.switchToWs().getClient();
    const user = client.data?.user;

    if (!user || !this.requiredRoles.some((role) => user.roles?.includes(role))) {
      throw new WsException('Insufficient permissions');
    }

    return true;
  }
}

import {
  WebSocketGateway,
  WebSocketServer,
  SubscribeMessage,
  MessageBody,
  ConnectedSocket,
} from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';
import { UseGuards } from '@nestjs/common';
import { WsAuthGuard } from './guards/ws-auth.guard';

interface RoomMessage {
  roomId: string;
  content: string;
  type?: 'text' | 'system';
}

@WebSocketGateway()
@UseGuards(WsAuthGuard)
export class RoomsGateway {
  @WebSocketServer()
  server: Server;

  @SubscribeMessage('joinRoom')
  async handleJoinRoom(
    @MessageBody() data: { roomId: string },
    @ConnectedSocket() client: Socket,
  ): Promise<{ success: boolean; roomId: string }> {
    const { roomId } = data;
    const user = client.data.user;

    await client.join(roomId);

    // แจ้งสมาชิกอื่นใน room
    client.to(roomId).emit('userJoined', {
      userId: user.id,
      username: user.name,
      timestamp: Date.now(),
    });

    return { success: true, roomId };
  }

  @SubscribeMessage('leaveRoom')
  async handleLeaveRoom(
    @MessageBody() data: { roomId: string },
    @ConnectedSocket() client: Socket,
  ): Promise<{ success: boolean }> {
    const { roomId } = data;
    const user = client.data.user;

    await client.leave(roomId);

    client.to(roomId).emit('userLeft', {
      userId: user.id,
      username: user.name,
      timestamp: Date.now(),
    });

    return { success: true };
  }

  @SubscribeMessage('roomMessage')
  handleRoomMessage(
    @MessageBody() data: RoomMessage,
    @ConnectedSocket() client: Socket,
  ): void {
    const user = client.data.user;

    this.server.to(data.roomId).emit('roomMessage', {
      ...data,
      senderId: user.id,
      senderName: user.name,
      timestamp: Date.now(),
    });
  }

  // Broadcast ไปยัง client ทั้งหมดที่เชื่อมต่ออยู่
  broadcastToAll(event: string, payload: unknown): void {
    this.server.emit(event, payload);
  }

  // Broadcast ไปยัง user เฉพาะ (ทุกอุปกรณ์/แท็บ)
  broadcastToUser(userId: string, event: string, payload: unknown): void {
    this.server.to(`user:${userId}`).emit(event, payload);
  }
}

import {
  Catch,
  ArgumentsHost,
  ExceptionFilter,
  HttpException,
} from '@nestjs/common';
import { WsException } from '@nestjs/websockets';
import { Socket } from 'socket.io';

interface WsErrorResponse {
  status: 'error';
  code: string;
  message: string;
  timestamp: string;
}

@Catch()
export class WsExceptionFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost): void {
    const client: Socket = host.switchToWs().getClient();

    let errorResponse: WsErrorResponse;

    if (exception instanceof WsException) {
      const error = exception.getError();
      errorResponse = {
        status: 'error',
        code: 'WS_ERROR',
        message: typeof error === 'string' ? error : (error as { message: string }).message,
        timestamp: new Date().toISOString(),
      };
    } else if (exception instanceof HttpException) {
      errorResponse = {
        status: 'error',
        code: `HTTP_${exception.getStatus()}`,
        message: exception.message,
        timestamp: new Date().toISOString(),
      };
    } else {
      errorResponse = {
        status: 'error',
        code: 'INTERNAL_ERROR',
        message: 'An unexpected error occurred',
        timestamp: new Date().toISOString(),
      };
    }

    client.emit('exception', errorResponse);
  }
}

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import { IoAdapter } from '@nestjs/platform-socket.io';
import { io, Socket as ClientSocket } from 'socket.io-client';
import { EventsGateway } from './events.gateway';

describe('EventsGateway', () => {
  let app: INestApplication;
  let clientSocket: ClientSocket;
  const PORT = 3001;

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      providers: [EventsGateway],
    }).compile();

    app = moduleFixture.createNestApplication();
    app.useWebSocketAdapter(new IoAdapter(app));
    await app.listen(PORT);
  });

  afterAll(async () => {
    if (clientSocket?.connected) {
      clientSocket.disconnect();
    }
    await app.close();
  });

  beforeEach((done) => {
    clientSocket = io(`http://localhost:${PORT}/events`, {
      transports: ['websocket'],
      autoConnect: false,
    });
    clientSocket.connect();
    clientSocket.on('connect', done);
  });

  afterEach(() => {
    if (clientSocket?.connected) {
      clientSocket.disconnect();
    }
  });

  it('should handle message event', (done) => {
    const testData = { content: 'Hello, WebSocket!' };

    clientSocket.emit('message', testData, (response: unknown) => {
      expect(response).toEqual({
        event: 'message',
        data: expect.objectContaining({ received: true }),
      });
      done();
    });
  });

  it('should broadcast to room members', (done) => {
    const secondClient = io(`http://localhost:${PORT}/events`, {
      transports: ['websocket'],
    });

    secondClient.on('connect', () => {
      // เข้าร่วม room
      clientSocket.emit('joinRoom', { roomId: 'test-room' });
      secondClient.emit('joinRoom', { roomId: 'test-room' });

      setTimeout(() => {
        secondClient.on('roomMessage', (data) => {
          expect(data.content).toBe('Test message');
          secondClient.disconnect();
          done();
        });

        clientSocket.emit('roomMessage', {
          roomId: 'test-room',
          content: 'Test message',
        });
      }, 100);
    });
  });
});