events.gateway.ts

import { Logger } from '@nestjs/common';
import {
  OnGatewayConnection,
  OnGatewayDisconnect,
  WebSocketGateway,
  WebSocketServer,
} from '@nestjs/websockets';
import { DefaultEventsMap, Server, Socket } from 'socket.io';
import { Task } from '../tasks/entities/task.entity';
import { TASK_EVENTS } from './task-events';

/**
 * Typed server→client event contract. Emitting a wrong payload for an event
 * (or a typo'd event name) is now a compile error, not a runtime surprise.
 */
interface TaskBroadcastEvents {
  [TASK_EVENTS.Created]: (task: Task) => void;
  [TASK_EVENTS.Updated]: (task: Task) => void;
  [TASK_EVENTS.Deleted]: (task: Task) => void;
}

type TaskServer = Server<DefaultEventsMap, TaskBroadcastEvents>;

/**
 * Broadcasts task mutations to connected clients. The tasks service calls the
 * helpers below after every successful mutation, fanning the *full* updated
 * task out to every client connected to THIS instance.
 *
 * Data flows one way (service → gateway → clients) and the gateway has no
 * dependency on the tasks service, keeping the dependency graph acyclic. CORS
 * is configured centrally by `ConfiguredIoAdapter`, not hardcoded here.
 *
 * NOTE: `server.emit` reaches only clients on the current process. For a
 * horizontally-scaled deployment, plug a Redis (or other) Socket.IO adapter
 * into `ConfiguredIoAdapter` so broadcasts fan out across instances.
 */
@WebSocketGateway()
export class EventsGateway
  implements OnGatewayConnection, OnGatewayDisconnect
{
  private readonly logger = new Logger(EventsGateway.name);

  @WebSocketServer()
  private server!: TaskServer;

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

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

  broadcastCreated(task: Task): void {
    this.server.emit(TASK_EVENTS.Created, task);
  }

  broadcastUpdated(task: Task): void {
    this.server.emit(TASK_EVENTS.Updated, task);
  }

  broadcastDeleted(task: Task): void {
    this.server.emit(TASK_EVENTS.Deleted, task);
  }
}