feat(meeting): 예약 회의 + lazy 방 생성, host 승계, idle 자동 종료 (#16)

Author: yuchem2

apps/backend/src/mediasoup/application/mediasoup-meeting-lifecycle.listener.spec.ts

@@ -32,9 +32,9 @@ const makeListener = () => {
 describe('MediasoupMeetingLifecycleListener', () => {
   const code = 'abc12xyz';
 
-  it('meeting.created → MediasoupSignalingService.openRoom을 호출한다', async () => {
+  it('meeting.opened → MediasoupSignalingService.openRoom을 호출한다', async () => {
     const { listener, calls } = makeListener();
-    await listener.onMeetingCreated({ code });
+    await listener.onMeetingOpened({ code });
     expect(calls).toEqual([{ name: 'openRoom', args: [{ meetingCode: code }] }]);
   });
 

apps/backend/src/mediasoup/application/mediasoup-meeting-lifecycle.listener.ts

@@ -4,7 +4,7 @@ import { OnEvent } from '@nestjs/event-emitter';
 
 import { MediasoupSignalingService } from './mediasoup-signaling.service';
 
-interface MeetingCreatedPayload {
+interface MeetingOpenedPayload {
   code: string;
 }
 interface ParticipantJoinedPayload {
@@ -26,8 +26,9 @@ interface MeetingEndedPayload {
 export class MediasoupMeetingLifecycleListener {
   constructor(private readonly service: MediasoupSignalingService) {}
 
-  @OnEvent(MEETING_EVENTS.CREATED)
-  async onMeetingCreated(payload: MeetingCreatedPayload): Promise<void> {
+  // 회의 발급(created)이 아니라 방이 열리는 시점에 만든다. 예약 회의는 첫 참가자가 들어와야 열린다.
+  @OnEvent(MEETING_EVENTS.OPENED)
+  async onMeetingOpened(payload: MeetingOpenedPayload): Promise<void> {
     await this.service.openRoom({ meetingCode: payload.code });
   }
 

apps/backend/src/meeting/application/meeting-creation.adapter.ts

@@ -10,6 +10,7 @@ export class MeetingCreationAdapter implements MeetingCreationPort {
       meetingType: input.meetingType,
       externalReference: input.externalReference,
       title: input.title ?? null,
+      scheduled: input.scheduled,
     });
     return {
       code: meeting.code.value,

apps/backend/src/meeting/application/meeting-idle.scheduler.spec.ts

@@ -0,0 +1,62 @@
+import { IdleSweepOutcome, MeetingService } from '@/meeting/application/meeting.service';
+import { LoggerPort } from '@/shared-kernel/domain/ports';
+
+import { MeetingIdleScheduler } from './meeting-idle.scheduler';
+
+function silentLogger(): LoggerPort {
+  const noop = (): void => undefined;
+  return { debug: noop, info: noop, warn: noop, error: noop };
+}
+
+const NOTHING_CLOSED: IdleSweepOutcome = { scanned: 0, closed: 0 };
+
+describe('MeetingIdleScheduler.sweep', () => {
+  it('회의 sweep 유스케이스를 호출한다', async () => {
+    const service = {
+      sweepIdleMeetings: jest.fn(async () => NOTHING_CLOSED),
+    } as unknown as MeetingService;
+
+    await new MeetingIdleScheduler(service, silentLogger()).sweep();
+
+    expect(service.sweepIdleMeetings).toHaveBeenCalledTimes(1);
+  });
+
+  it('이전 sweep이 진행 중이면 재진입을 건너뛴다', async () => {
+    let calls = 0;
+    let release!: () => void;
+    const gate = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const service = {
+      sweepIdleMeetings: async (): Promise<IdleSweepOutcome> => {
+        calls += 1;
+        await gate;
+        return NOTHING_CLOSED;
+      },
+    } as unknown as MeetingService;
+    const scheduler = new MeetingIdleScheduler(service, silentLogger());
+
+    const first = scheduler.sweep();
+    await scheduler.sweep();
+
+    expect(calls).toBe(1);
+    release();
+    await first;
+  });
+
+  it('sweep이 throw해도 삼키고 다음 주기를 허용한다', async () => {
+    let calls = 0;
+    const service = {
+      sweepIdleMeetings: async (): Promise<IdleSweepOutcome> => {
+        calls += 1;
+        throw new Error('redis down');
+      },
+    } as unknown as MeetingService;
+    const scheduler = new MeetingIdleScheduler(service, silentLogger());
+
+    await expect(scheduler.sweep()).resolves.toBeUndefined();
+    await scheduler.sweep();
+
+    expect(calls).toBe(2);
+  });
+});

apps/backend/src/meeting/application/meeting-idle.scheduler.ts

@@ -0,0 +1,35 @@
+import { Injectable } from '@nestjs/common';
+import { Interval } from '@nestjs/schedule';
+
+import { MeetingService } from '@/meeting/application/meeting.service';
+import { LoggerPort } from '@/shared-kernel/domain/ports';
+
+// idle 임계(1분)보다 촘촘히 돌아 종료 지연이 주기 이상 벌어지지 않게 한다.
+export const IDLE_SWEEP_INTERVAL_MS = 30_000;
+
+@Injectable()
+export class MeetingIdleScheduler {
+  private running = false;
+
+  constructor(
+    private readonly service: MeetingService,
+    private readonly logger: LoggerPort,
+  ) {}
+
+  @Interval(IDLE_SWEEP_INTERVAL_MS)
+  async sweep(): Promise<void> {
+    if (this.running) return;
+    this.running = true;
+    try {
+      const { scanned, closed } = await this.service.sweepIdleMeetings();
+      if (closed > 0) {
+        this.logger.info({ scanned, closed }, 'idle 회의 종료');
+      }
+    } catch (error) {
+      // sweep 전체 실패(예: redis 장애)가 프로세스를 죽이지 않도록 삼킨다.
+      this.logger.error({ err: error }, 'idle sweep 실패');
+    } finally {
+      this.running = false;
+    }
+  }
+}

apps/backend/src/meeting/application/meeting.service.spec.ts

@@ -67,6 +67,7 @@ describe('MeetingService.createMeeting', () => {
           saved.push(m);
         },
         findByCode: async () => null,
+        listOpenCodes: async () => [],
       },
       chatRepository: noopChatRepository(),
       codeGenerator: { next: () => code },
@@ -120,17 +121,30 @@ describe('MeetingService.createMeeting', () => {
     expect(result.source).toBe('notion-issue');
   });
 
-  it('생성 후 meeting.created 도메인 이벤트를 발행한다', async () => {
+  it('생성 후 meeting.created와 meeting.opened를 발행한다', async () => {
     const { service, events } = makeService();
     await service.createMeeting({ source: 'web', externalReference: externalReference() });
     expect(events).toEqual([
       {
         name: MEETING_EVENTS.CREATED,
         payload: { code: code.value, source: 'web', startedAt: fakeNow },
       },
+      { name: MEETING_EVENTS.OPENED, payload: { code: code.value } },
     ]);
   });
 
+  it('예약 생성(scheduled)은 방을 열지 않아 meeting.opened를 발행하지 않는다', async () => {
+    const { service, events } = makeService();
+    const meeting = await service.createMeeting({
+      source: 'notion-issue',
+      externalReference: externalReference({ issueId: 'NTN-1' }),
+      scheduled: true,
+    });
+    expect(meeting.status).toBe('scheduled');
+    expect(meeting.isOpen).toBe(false);
+    expect(events.map((e) => e.name)).toEqual([MEETING_EVENTS.CREATED]);
+  });
+
   it('HostTokenGenerator가 발급한 hostToken을 Meeting에 부여한다', async () => {
     const { service } = makeService();
     const result = await service.createMeeting({
@@ -163,6 +177,7 @@ describe('MeetingService.joinMeeting', () => {
     const service = new MeetingService({
       repository: {
         findByCode: async (c) => (meeting && c === meeting.code.value ? meeting : null),
+        listOpenCodes: async () => [],
         save: async (m) => {
           saved.push(m);
         },
@@ -227,6 +242,42 @@ describe('MeetingService.joinMeeting', () => {
       },
     ]);
   });
+
+  it('빈 방에 처음 들어온 참가자는 hostToken을 받는다', async () => {
+    const meeting = makeMeeting(t0);
+    const { service } = makeService(meeting);
+    const result = await service.joinMeeting({
+      code: 'abc12xyz',
+      participantId: 's1',
+      nickname: 'alice',
+    });
+    expect(result.hostToken).toBe('host-token-1');
+  });
+
+  it('이미 참가자가 있는 방에 들어오면 hostToken을 받지 못한다', async () => {
+    const meeting = makeMeeting(t0);
+    meeting.addParticipant('s1', 'alice', t0);
+    const { service } = makeService(meeting);
+    const result = await service.joinMeeting({
+      code: 'abc12xyz',
+      participantId: 's2',
+      nickname: 'bob',
+    });
+    expect(result.hostToken).toBeNull();
+  });
+
+  it('모두 나간 방에 다시 들어오면 host를 다시 가져간다', async () => {
+    const meeting = makeMeeting(t0);
+    meeting.addParticipant('s1', 'alice', t0);
+    meeting.removeParticipant('s1', t0);
+    const { service } = makeService(meeting);
+    const result = await service.joinMeeting({
+      code: 'abc12xyz',
+      participantId: 's2',
+      nickname: 'bob',
+    });
+    expect(result.hostToken).toBe('host-token-1');
+  });
 });
 
 describe('MeetingService.leaveMeeting', () => {
@@ -246,6 +297,7 @@ describe('MeetingService.leaveMeeting', () => {
     const service = new MeetingService({
       repository: {
         findByCode: async (c) => (meeting && c === meeting.code.value ? meeting : null),
+        listOpenCodes: async () => [],
         save: async (m) => {
           saved.push(m);
         },
@@ -318,6 +370,7 @@ describe('MeetingService.postChat', () => {
     const service = new MeetingService({
       repository: {
         findByCode: async (c) => (meeting && c === meeting.code.value ? meeting : null),
+        listOpenCodes: async () => [],
         save: async (m) => {
           saved.push(m);
         },
@@ -401,6 +454,7 @@ describe('MeetingService.closeMeeting', () => {
     const service = new MeetingService({
       repository: {
         findByCode: async (c) => (meeting && c === meeting.code.value ? meeting : null),
+        listOpenCodes: async () => [],
         save: async (m) => {
           saved.push(m);
         },
@@ -456,6 +510,7 @@ describe('MeetingService.closeMeeting', () => {
     const service = new MeetingService({
       repository: {
         findByCode: async (c) => (c === 'abc12xyz' ? meeting : null),
+        listOpenCodes: async () => [],
         save: async (m) => {
           saved.push(m);
         },
@@ -519,6 +574,7 @@ describe('MeetingService.detectIdleAndClose', () => {
     const service = new MeetingService({
       repository: {
         findByCode: async (c) => (meeting && c === meeting.code.value ? meeting : null),
+        listOpenCodes: async () => [],
         save: async (m) => {
           saved.push(m);
         },
@@ -609,3 +665,73 @@ describe('MeetingService.detectIdleAndClose', () => {
     expect(events).toHaveLength(0);
   });
 });
+
+describe('MeetingService.sweepIdleMeetings', () => {
+  const t0 = new Date('2026-01-01T00:00:00Z');
+  const tJoin = new Date('2026-01-01T00:01:00Z');
+  const tLeave = new Date('2026-01-01T00:02:00Z');
+  const tIdleElapsed = new Date('2026-01-01T00:03:30Z');
+
+  /** idle=true면 참가자가 모두 나간 상태(= 만료 대상). */
+  const meetingOf = (codeStr: string, idle: boolean) => {
+    const m = Meeting.create({
+      code: MeetingCode.from(codeStr),
+      source: 'web',
+      externalReference: externalReference(),
+      idleTimeout: IdleTimeout.default(),
+      startedAt: t0,
+      hostToken: 'host-token-1',
+      title: null,
+    });
+    m.addParticipant('s1', 'alice', tJoin);
+    if (idle) m.removeParticipant('s1', tLeave);
+    return m;
+  };
+
+  const makeService = (meetings: Meeting[], brokenCode?: string) => {
+    const byCode = new Map(meetings.map((m) => [m.code.value, m]));
+    const { publisher, events } = makeEventPublisher();
+    const service = new MeetingService({
+      repository: {
+        findByCode: async (c) => {
+          if (c === brokenCode) throw new Error('redis down');
+          return byCode.get(c) ?? null;
+        },
+        listOpenCodes: async () => [...byCode.keys(), ...(brokenCode ? [brokenCode] : [])],
+        save: async () => {},
+      },
+      chatRepository: noopChatRepository(),
+      codeGenerator: { next: () => code },
+      hostTokenGenerator: { next: () => 'host-token-generated' },
+      clock: { now: () => tIdleElapsed },
+      eventPublisher: publisher,
+      logger: noopLogger(),
+    });
+    return { service, events };
+  };
+
+  it('열린 회의를 훑어 idle인 회의만 닫고 조회·종료 건수를 돌려준다', async () => {
+    const idle = meetingOf('aaa11aaa', true);
+    const busy = meetingOf('bbb22bbb', false);
+    const { service } = makeService([idle, busy]);
+
+    await expect(service.sweepIdleMeetings()).resolves.toEqual({ scanned: 2, closed: 1 });
+    expect(idle.isOpen).toBe(false);
+    expect(busy.isOpen).toBe(true);
+  });
+
+  it('한 회의 처리가 실패해도 나머지 회의를 계속 훑는다', async () => {
+    const idle = meetingOf('aaa11aaa', true);
+    const { service } = makeService([idle], 'ccc33ccc');
+
+    await expect(service.sweepIdleMeetings()).resolves.toEqual({ scanned: 2, closed: 1 });
+    expect(idle.isOpen).toBe(false);
+  });
+
+  it('열린 회의가 없으면 아무것도 닫지 않는다', async () => {
+    const { service, events } = makeService([]);
+
+    await expect(service.sweepIdleMeetings()).resolves.toEqual({ scanned: 0, closed: 0 });
+    expect(events).toHaveLength(0);
+  });
+});