feat(rooms): add rooms for io events filtering

src/app.module.ts

@@ -34,6 +34,7 @@ import { validateEnvironment } from './validate-environment';
 import { Etf2lModule } from './etf2l/etf2l.module';
 import { SteamModule } from './steam/steam.module';
 import { CacheModule } from '@nestjs/cache-manager';
+import { RoomsModule } from './rooms/rooms.module';
 
 @Module({
   imports: [
@@ -100,6 +101,7 @@ import { CacheModule } from '@nestjs/cache-manager';
     QueueConfigModule,
     Etf2lModule,
     SteamModule,
+    RoomsModule,
   ],
   controllers: [AppController],
 })

src/games/games.module.ts

@@ -16,6 +16,7 @@ import { GameServerAssignerService } from './services/game-server-assigner.servi
 import { QueueConfigModule } from '@/queue-config/queue-config.module';
 import { GamesConfigurationService } from './services/games-configuration.service';
 import { GameSlotsGateway } from './gateways/game-slots.gateway';
+import { GameEventsGateway } from './gateways/game-events.gateway';
 
 @Module({
   imports: [
@@ -38,6 +39,7 @@ import { GameSlotsGateway } from './gateways/game-slots.gateway';
     GameServerAssignerService,
     GamesConfigurationService,
     GameSlotsGateway,
+    GameEventsGateway,
   ],
   exports: [GamesService, PlayerSubstitutionService],
   controllers: [GamesController, GamesWithSubstitutionRequestsController],

src/games/gateways/game-events.gateway.spec.ts

@@ -0,0 +1,84 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { GameEventsGateway } from './game-events.gateway';
+import { Events } from '@/events/events';
+import { Socket } from 'socket.io';
+import { GameState } from '../models/game-state';
+import { Game } from '../models/game';
+import { GameEventType } from '../models/game-event-type';
+import { Types } from 'mongoose';
+import { PlayerId } from '@/players/types/player-id';
+import { waitABit } from '@/utils/wait-a-bit';
+import { WebsocketEvent } from '@/websocket-event';
+
+describe('GameEventsGateway', () => {
+  let gateway: GameEventsGateway;
+  let events: Events;
+  let socket: jest.Mocked<Socket>;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [GameEventsGateway, Events],
+    }).compile();
+
+    gateway = module.get<GameEventsGateway>(GameEventsGateway);
+    events = module.get(Events);
+  });
+
+  beforeEach(() => {
+    socket = {
+      to: jest.fn().mockReturnThis(),
+      emit: jest.fn(),
+    } as unknown as jest.Mocked<Socket>;
+
+    gateway.onModuleInit();
+    gateway.afterInit(socket);
+  });
+
+  it('should be defined', () => {
+    expect(gateway).toBeDefined();
+  });
+
+  describe('when game events change', () => {
+    beforeEach(async () => {
+      const slotId = new Types.ObjectId();
+      const player1 = new Types.ObjectId() as PlayerId;
+
+      const oldGame = {
+        number: 1,
+        state: GameState.launching,
+        events: [
+          {
+            event: GameEventType.gameCreated,
+            at: new Date(),
+          },
+        ],
+      } as Game;
+
+      const newGame = {
+        number: 1,
+        state: GameState.launching,
+        events: [
+          {
+            event: GameEventType.gameCreated,
+            at: new Date(),
+          },
+          {
+            event: GameEventType.gameEnded,
+            at: new Date(),
+          },
+        ],
+      } as Game;
+
+      events.gameChanges.next({ oldGame, newGame });
+      await waitABit(100);
+    });
+
+    it('should emit', () => {
+      expect(socket.to).toHaveBeenCalledWith('/games/1/events');
+      expect(socket.emit).toHaveBeenCalledWith(
+        WebsocketEvent.gameEventsUpdated,
+        expect.any(Object),
+      );
+    });
+  });
+});

src/games/gateways/game-events.gateway.ts

@@ -0,0 +1,40 @@
+import { WebsocketEventEmitter } from '@/shared/websocket-event-emitter';
+import { WebSocketGateway } from '@nestjs/websockets';
+import { GameEventDto } from '../dto/game-event.dto';
+import { OnModuleInit } from '@nestjs/common';
+import { Events } from '@/events/events';
+import { filter, map } from 'rxjs';
+import { isEqual } from 'lodash';
+import { WebsocketEvent } from '@/websocket-event';
+
+const roomName = (gameNumber: number) => `/games/${gameNumber}/events`;
+
+@WebSocketGateway()
+export class GameEventsGateway
+  extends WebsocketEventEmitter<GameEventDto>
+  implements OnModuleInit
+{
+  constructor(private readonly events: Events) {
+    super();
+  }
+
+  onModuleInit() {
+    this.events.gameChanges
+      .pipe(
+        filter(
+          ({ oldGame, newGame }) => !isEqual(oldGame.events, newGame.events),
+        ),
+        map(({ newGame }) => ({
+          number: newGame.number,
+          events: newGame.events,
+        })),
+      )
+      .subscribe(({ number, events }) => {
+        this.emit({
+          room: roomName(number),
+          event: WebsocketEvent.gameEventsUpdated,
+          payload: events,
+        });
+      });
+  }
+}

src/games/gateways/game-slots.gateway.spec.ts

@@ -81,7 +81,7 @@ describe('GameSlotsGateway', () => {
     });
 
     it('should emit', () => {
-      expect(socket.to).toHaveBeenCalledWith('game/1');
+      expect(socket.to).toHaveBeenCalledWith('/games/1/slots');
       expect(socket.emit).toHaveBeenCalledWith(
         WebsocketEvent.gameSlotsUpdated,
         expect.any(Object),

src/games/gateways/game-slots.gateway.ts

@@ -7,6 +7,8 @@ import { WebsocketEventEmitter } from '@/shared/websocket-event-emitter';
 import { filter, map } from 'rxjs/operators';
 import { isEqual } from 'lodash';
 
+const roomName = (gameNumber: number) => `/games/${gameNumber}/slots`;
+
 @WebSocketGateway()
 export class GameSlotsGateway
   extends WebsocketEventEmitter<GameSlotDto>
@@ -29,7 +31,7 @@ export class GameSlotsGateway
       )
       .subscribe(({ number, slots }) => {
         this.emit({
-          room: `game/${number}`,
+          room: roomName(number),
           event: WebsocketEvent.gameSlotsUpdated,
           payload: slots,
         });

src/rooms/gateways/rooms.gateway.spec.ts

@@ -0,0 +1,46 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { RoomsGateway } from './rooms.gateway';
+import { Socket } from 'socket.io';
+
+describe('RoomsGateway', () => {
+  let gateway: RoomsGateway;
+  let socket: jest.Mocked<Socket>;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [RoomsGateway],
+    }).compile();
+
+    gateway = module.get<RoomsGateway>(RoomsGateway);
+  });
+
+  beforeEach(() => {
+    socket = {
+      rooms: new Set(),
+      join: jest.fn().mockImplementation((room) => socket.rooms.add(room)),
+      leave: jest.fn().mockImplementation((room) => socket.rooms.delete(room)),
+    } as unknown as jest.Mocked<Socket>;
+  });
+
+  it('should be defined', () => {
+    expect(gateway).toBeDefined();
+  });
+
+  describe('#join()', () => {
+    it('should join', () => {
+      const ret = gateway.join(socket, 'FAKE_ROOM');
+      expect(ret).toEqual(['FAKE_ROOM']);
+    });
+  });
+
+  describe('#leave()', () => {
+    beforeEach(() => {
+      socket.rooms.add('FAKE_ROOM');
+    });
+
+    it('should leave', () => {
+      const ret = gateway.leave(socket, 'FAKE_ROOM');
+      expect(ret).toEqual([]);
+    });
+  });
+});

src/rooms/gateways/rooms.gateway.ts

@@ -0,0 +1,35 @@
+import { ZodPipe } from '@/shared/pipes/zod.pipe';
+import {
+  ConnectedSocket,
+  MessageBody,
+  SubscribeMessage,
+  WebSocketGateway,
+} from '@nestjs/websockets';
+import { Socket } from 'socket.io';
+import { z } from 'zod';
+
+const joinRoomSchema = z.string();
+const leaveRoomSchema = z.string();
+
+@WebSocketGateway()
+export class RoomsGateway {
+  @SubscribeMessage('join')
+  join(
+    @ConnectedSocket() client: Socket,
+    @MessageBody(new ZodPipe(joinRoomSchema))
+    room: z.infer<typeof joinRoomSchema>,
+  ): string[] {
+    client.join(room);
+    return Array.from(client.rooms);
+  }
+
+  @SubscribeMessage('leave')
+  leave(
+    @ConnectedSocket() client: Socket,
+    @MessageBody(new ZodPipe(leaveRoomSchema))
+    room: z.infer<typeof leaveRoomSchema>,
+  ): string[] {
+    client.leave(room);
+    return Array.from(client.rooms);
+  }
+}

src/rooms/rooms.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common';
+import { RoomsGateway } from './gateways/rooms.gateway';
+
+@Module({
+  providers: [RoomsGateway],
+})
+export class RoomsModule {}

src/websocket-event.ts

@@ -3,7 +3,8 @@ export enum WebsocketEvent {
 
   gameCreated = 'game created',
   gameUpdated = 'game updated',
-  gameSlotsUpdated = 'game slots updated',
+  gameSlotsUpdated = 'slots updated',
+  gameEventsUpdated = 'events updated',
 
   queueSlotsUpdate = 'queue slots update',
   queueStateUpdate = 'queue state update',