gridpilot.gg/adapters/events/InMemoryEventPublisher.ts

import {
  DashboardEventPublisher,
  DashboardAccessedEvent,
  DashboardErrorEvent,
} from '../../core/dashboard/application/ports/DashboardEventPublisher';
import {
  LeagueEventPublisher,
  LeagueCreatedEvent,
  LeagueUpdatedEvent,
  LeagueDeletedEvent,
  LeagueAccessedEvent,
  LeagueRosterAccessedEvent,
} from '../../core/leagues/application/ports/LeagueEventPublisher';
import { EventPublisher, DomainEvent } from '../../core/shared/ports/EventPublisher';

export class InMemoryEventPublisher implements DashboardEventPublisher, LeagueEventPublisher, EventPublisher {
  private dashboardAccessedEvents: DashboardAccessedEvent[] = [];
  private dashboardErrorEvents: DashboardErrorEvent[] = [];
  private leagueCreatedEvents: LeagueCreatedEvent[] = [];
  private leagueUpdatedEvents: LeagueUpdatedEvent[] = [];
  private leagueDeletedEvents: LeagueDeletedEvent[] = [];
  private leagueAccessedEvents: LeagueAccessedEvent[] = [];
  private leagueRosterAccessedEvents: LeagueRosterAccessedEvent[] = [];
  private events: DomainEvent[] = [];
  private shouldFail: boolean = false;

  async publishDashboardAccessed(event: DashboardAccessedEvent): Promise<void> {
    if (this.shouldFail) throw new Error('Event publisher failed');
    this.dashboardAccessedEvents.push(event);
  }

  async publishDashboardError(event: DashboardErrorEvent): Promise<void> {
    if (this.shouldFail) throw new Error('Event publisher failed');
    this.dashboardErrorEvents.push(event);
  }

  async emitLeagueCreated(event: LeagueCreatedEvent): Promise<void> {
    if (this.shouldFail) throw new Error('Event publisher failed');
    this.leagueCreatedEvents.push(event);
  }

  async emitLeagueUpdated(event: LeagueUpdatedEvent): Promise<void> {
    if (this.shouldFail) throw new Error('Event publisher failed');
    this.leagueUpdatedEvents.push(event);
  }

  async emitLeagueDeleted(event: LeagueDeletedEvent): Promise<void> {
    if (this.shouldFail) throw new Error('Event publisher failed');
    this.leagueDeletedEvents.push(event);
  }

  async emitLeagueAccessed(event: LeagueAccessedEvent): Promise<void> {
    if (this.shouldFail) throw new Error('Event publisher failed');
    this.leagueAccessedEvents.push(event);
  }

  async emitLeagueRosterAccessed(event: LeagueRosterAccessedEvent): Promise<void> {
    if (this.shouldFail) throw new Error('Event publisher failed');
    this.leagueRosterAccessedEvents.push(event);
  }

  getDashboardAccessedEventCount(): number {
    return this.dashboardAccessedEvents.length;
  }

  getDashboardErrorEventCount(): number {
    return this.dashboardErrorEvents.length;
  }

  getLeagueCreatedEventCount(): number {
    return this.leagueCreatedEvents.length;
  }

  getLeagueUpdatedEventCount(): number {
    return this.leagueUpdatedEvents.length;
  }

  getLeagueDeletedEventCount(): number {
    return this.leagueDeletedEvents.length;
  }

  getLeagueAccessedEventCount(): number {
    return this.leagueAccessedEvents.length;
  }

  getLeagueRosterAccessedEventCount(): number {
    return this.leagueRosterAccessedEvents.length;
  }

  getLeagueRosterAccessedEvents(): LeagueRosterAccessedEvent[] {
    return [...this.leagueRosterAccessedEvents];
  }

  getLeagueCreatedEvents(): LeagueCreatedEvent[] {
    return [...this.leagueCreatedEvents];
  }

  clear(): void {
    this.dashboardAccessedEvents = [];
    this.dashboardErrorEvents = [];
    this.leagueCreatedEvents = [];
    this.leagueUpdatedEvents = [];
    this.leagueDeletedEvents = [];
    this.leagueAccessedEvents = [];
    this.leagueRosterAccessedEvents = [];
    this.events = [];
    this.shouldFail = false;
  }

  setShouldFail(shouldFail: boolean): void {
    this.shouldFail = shouldFail;
  }

  async publish(event: DomainEvent): Promise<void> {
    if (this.shouldFail) throw new Error('Event publisher failed');
    this.events.push(event);
  }

  getEvents(): DomainEvent[] {
    return [...this.events];
  }
}