Advanced Design Patterns - 2/2

// The monolithic nightmare that kills performance at scale
class UserAccountService {
  async getUserDashboard(userId: string) {
    // Complex read query that locks tables - RED FLAG #1
    const user = await this.db.query(
      `
      SELECT u.*, p.*, 
             COUNT(t.id) as total_transactions,
             SUM(t.amount) as total_volume,
             AVG(t.amount) as avg_transaction,
             MAX(t.created_at) as last_transaction,
             COUNT(CASE WHEN t.created_at > NOW() - INTERVAL '30 days' THEN 1 END) as monthly_transactions
      FROM users u
      LEFT JOIN profiles p ON u.id = p.user_id
      LEFT JOIN transactions t ON u.id = t.user_id
      WHERE u.id = ? AND u.deleted_at IS NULL
      GROUP BY u.id, p.id
    `,
      [userId]
    );

    // More complex aggregations that compete with writes - RED FLAG #2
    const recentActivity = await this.db.query(
      `
      SELECT t.*, p.name as product_name, c.name as category_name
      FROM transactions t
      JOIN products p ON t.product_id = p.id
      JOIN categories c ON p.category_id = c.id
      WHERE t.user_id = ?
      ORDER BY t.created_at DESC
      LIMIT 50
    `,
      [userId]
    );

    // Analytics queries blocking critical operations - RED FLAG #3
    const monthlyStats = await this.db.query(
      `
      SELECT DATE_TRUNC('month', created_at) as month,
             COUNT(*) as transaction_count,
             SUM(amount) as total_amount,
             AVG(amount) as avg_amount
      FROM transactions
      WHERE user_id = ? AND created_at > NOW() - INTERVAL '12 months'
      GROUP BY DATE_TRUNC('month', created_at)
      ORDER BY month
    `,
      [userId]
    );

    return { user, recentActivity, monthlyStats };
  }

  async createTransaction(transactionData: any) {
    // Critical write operation competing with dashboard queries - RED FLAG #4
    // This might wait minutes if dashboard query has table locks

    const transaction = await this.db.transaction(async (trx) => {
      // Update user balance
      await trx.query("UPDATE users SET balance = balance + ? WHERE id = ?", [
        transactionData.amount,
        transactionData.userId,
      ]);

      // Create transaction record
      const transaction = await trx.query(
        "INSERT INTO transactions (user_id, amount, type, created_at) VALUES (?, ?, ?, NOW()) RETURNING *",
        [transactionData.userId, transactionData.amount, transactionData.type]
      );

      // Update analytics tables (blocking critical business logic) - RED FLAG #5
      await trx.query(
        `
        INSERT INTO monthly_stats (user_id, month, transaction_count, total_amount)
        VALUES (?, DATE_TRUNC('month', NOW()), 1, ?)
        ON CONFLICT (user_id, month) 
        DO UPDATE SET 
          transaction_count = monthly_stats.transaction_count + 1,
          total_amount = monthly_stats.total_amount + ?
      `,
        [transactionData.userId, transactionData.amount, transactionData.amount]
      );

      return transaction;
    });

    return transaction;
  }
}

// Domain model focused on business operations (Write side)
export class Account {
  private events: DomainEvent[] = [];

  constructor(
    public readonly id: string,
    public readonly ownerId: string,
    private balance: number,
    private status: AccountStatus,
    private readonly createdAt: Date
  ) {}

  // Business logic focused on commands
  deposit(amount: number, description: string): void {
    if (amount <= 0) {
      throw new DomainError("Deposit amount must be positive");
    }

    if (this.status !== AccountStatus.Active) {
      throw new DomainError("Cannot deposit to inactive account");
    }

    this.balance += amount;

    this.addEvent(
      new MoneyDepositedEvent(
        this.id,
        this.ownerId,
        amount,
        this.balance,
        description
      )
    );
  }

  withdraw(amount: number, description: string): void {
    if (amount <= 0) {
      throw new DomainError("Withdrawal amount must be positive");
    }

    if (this.status !== AccountStatus.Active) {
      throw new DomainError("Cannot withdraw from inactive account");
    }

    if (this.balance < amount) {
      throw new DomainError("Insufficient funds");
    }

    this.balance -= amount;

    this.addEvent(
      new MoneyWithdrawnEvent(
        this.id,
        this.ownerId,
        amount,
        this.balance,
        description
      )
    );
  }

  freeze(reason: string): void {
    if (this.status === AccountStatus.Frozen) {
      return; // Already frozen
    }

    this.status = AccountStatus.Frozen;

    this.addEvent(new AccountFrozenEvent(this.id, this.ownerId, reason));
  }

  // Domain event management
  getUncommittedEvents(): DomainEvent[] {
    return [...this.events];
  }

  clearEvents(): void {
    this.events = [];
  }

  private addEvent(event: DomainEvent): void {
    this.events.push(event);
  }

  // Getters for business logic
  getCurrentBalance(): number {
    return this.balance;
  }

  isActive(): boolean {
    return this.status === AccountStatus.Active;
  }

  canWithdraw(amount: number): boolean {
    return this.isActive() && this.balance >= amount;
  }
}

// Command side - focused on business operations
export interface ICommand {
  readonly commandId: string;
  readonly userId: string;
  readonly timestamp: Date;
}

export class DepositMoneyCommand implements ICommand {
  readonly commandId = uuidv4();
  readonly timestamp = new Date();

  constructor(
    public readonly userId: string,
    public readonly accountId: string,
    public readonly amount: number,
    public readonly description: string
  ) {}
}

export class WithdrawMoneyCommand implements ICommand {
  readonly commandId = uuidv4();
  readonly timestamp = new Date();

  constructor(
    public readonly userId: string,
    public readonly accountId: string,
    public readonly amount: number,
    public readonly description: string
  ) {}
}

// Command handlers - pure business logic
export class AccountCommandHandler {
  constructor(
    private accountRepository: IAccountRepository,
    private eventStore: IEventStore,
    private eventBus: IEventBus
  ) {}

  async handle(command: DepositMoneyCommand): Promise<void> {
    // Load aggregate from repository
    const account = await this.accountRepository.findById(command.accountId);
    if (!account) {
      throw new DomainError("Account not found");
    }

    // Execute business logic
    account.deposit(command.amount, command.description);

    // Save changes
    await this.accountRepository.save(account);

    // Publish domain events
    const events = account.getUncommittedEvents();
    for (const event of events) {
      await this.eventBus.publish(event);
    }

    account.clearEvents();
  }

  async handle(command: WithdrawMoneyCommand): Promise<void> {
    const account = await this.accountRepository.findById(command.accountId);
    if (!account) {
      throw new DomainError("Account not found");
    }

    account.withdraw(command.amount, command.description);

    await this.accountRepository.save(account);

    const events = account.getUncommittedEvents();
    for (const event of events) {
      await this.eventBus.publish(event);
    }

    account.clearEvents();
  }
}

// Read side - optimized for queries
export class AccountDashboardViewModel {
  constructor(
    public readonly accountId: string,
    public readonly ownerId: string,
    public readonly ownerName: string,
    public readonly currentBalance: number,
    public readonly status: string,
    public readonly totalTransactions: number,
    public readonly totalDeposits: number,
    public readonly totalWithdrawals: number,
    public readonly avgTransactionAmount: number,
    public readonly lastTransactionDate: Date | null,
    public readonly monthlyStats: MonthlyStats[],
    public readonly recentActivity: TransactionSummary[]
  ) {}
}

export class TransactionSummary {
  constructor(
    public readonly id: string,
    public readonly type: "deposit" | "withdrawal",
    public readonly amount: number,
    public readonly description: string,
    public readonly timestamp: Date,
    public readonly balanceAfter: number
  ) {}
}

export class MonthlyStats {
  constructor(
    public readonly month: string,
    public readonly transactionCount: number,
    public readonly totalAmount: number,
    public readonly averageAmount: number
  ) {}
}

// Query handlers - optimized for reads
export class AccountQueryHandler {
  constructor(
    private readDatabase: IReadDatabase // Separate read database
  ) {}

  async getDashboard(
    accountId: string
  ): Promise<AccountDashboardViewModel | null> {
    // Single optimized query from denormalized read model
    const result = await this.readDatabase.query(
      `
      SELECT 
        a.account_id,
        a.owner_id,
        a.owner_name,
        a.current_balance,
        a.status,
        a.total_transactions,
        a.total_deposits,
        a.total_withdrawals,
        a.avg_transaction_amount,
        a.last_transaction_date
      FROM account_dashboard_view a
      WHERE a.account_id = ?
    `,
      [accountId]
    );

    if (!result.rows[0]) {
      return null;
    }

    const account = result.rows[0];

    // Get monthly stats from pre-aggregated table
    const monthlyStats = await this.readDatabase.query(
      `
      SELECT month, transaction_count, total_amount, average_amount
      FROM monthly_account_stats
      WHERE account_id = ?
      ORDER BY month DESC
      LIMIT 12
    `,
      [accountId]
    );

    // Get recent activity from optimized table
    const recentActivity = await this.readDatabase.query(
      `
      SELECT id, type, amount, description, timestamp, balance_after
      FROM transaction_summaries
      WHERE account_id = ?
      ORDER BY timestamp DESC
      LIMIT 20
    `,
      [accountId]
    );

    return new AccountDashboardViewModel(
      account.account_id,
      account.owner_id,
      account.owner_name,
      account.current_balance,
      account.status,
      account.total_transactions,
      account.total_deposits,
      account.total_withdrawals,
      account.avg_transaction_amount,
      account.last_transaction_date,
      monthlyStats.rows.map(
        (row) =>
          new MonthlyStats(
            row.month,
            row.transaction_count,
            row.total_amount,
            row.average_amount
          )
      ),
      recentActivity.rows.map(
        (row) =>
          new TransactionSummary(
            row.id,
            row.type,
            row.amount,
            row.description,
            row.timestamp,
            row.balance_after
          )
      )
    );
  }

  async getAccountHistory(
    accountId: string,
    fromDate: Date,
    toDate: Date
  ): Promise<TransactionSummary[]> {
    // Optimized query for historical data
    const result = await this.readDatabase.query(
      `
      SELECT id, type, amount, description, timestamp, balance_after
      FROM transaction_summaries
      WHERE account_id = ? AND timestamp BETWEEN ? AND ?
      ORDER BY timestamp DESC
    `,
      [accountId, fromDate, toDate]
    );

    return result.rows.map(
      (row) =>
        new TransactionSummary(
          row.id,
          row.type,
          row.amount,
          row.description,
          row.timestamp,
          row.balance_after
        )
    );
  }
}

// Read model projections - update read side when events occur
export class AccountDashboardProjection {
  constructor(private readDatabase: IReadDatabase) {}

  async handle(event: MoneyDepositedEvent): Promise<void> {
    // Update denormalized dashboard view
    await this.readDatabase.query(
      `
      UPDATE account_dashboard_view 
      SET 
        current_balance = ?,
        total_transactions = total_transactions + 1,
        total_deposits = total_deposits + ?,
        avg_transaction_amount = (total_deposits + total_withdrawals) / total_transactions,
        last_transaction_date = ?
      WHERE account_id = ?
    `,
      [event.balanceAfter, event.amount, event.timestamp, event.accountId]
    );

    // Insert transaction summary for quick queries
    await this.readDatabase.query(
      `
      INSERT INTO transaction_summaries 
      (id, account_id, type, amount, description, timestamp, balance_after)
      VALUES (?, ?, 'deposit', ?, ?, ?, ?)
    `,
      [
        uuidv4(),
        event.accountId,
        event.amount,
        event.description,
        event.timestamp,
        event.balanceAfter,
      ]
    );

    // Update monthly stats
    await this.readDatabase.query(
      `
      INSERT INTO monthly_account_stats 
      (account_id, month, transaction_count, total_amount, average_amount)
      VALUES (?, DATE_TRUNC('month', ?), 1, ?, ?)
      ON CONFLICT (account_id, month)
      DO UPDATE SET
        transaction_count = monthly_account_stats.transaction_count + 1,
        total_amount = monthly_account_stats.total_amount + ?,
        average_amount = monthly_account_stats.total_amount / monthly_account_stats.transaction_count
    `,
      [
        event.accountId,
        event.timestamp,
        event.amount,
        event.amount,
        event.amount,
      ]
    );
  }

  async handle(event: MoneyWithdrawnEvent): Promise<void> {
    // Similar logic for withdrawals
    await this.readDatabase.query(
      `
      UPDATE account_dashboard_view 
      SET 
        current_balance = ?,
        total_transactions = total_transactions + 1,
        total_withdrawals = total_withdrawals + ?,
        avg_transaction_amount = (total_deposits + total_withdrawals) / total_transactions,
        last_transaction_date = ?
      WHERE account_id = ?
    `,
      [event.balanceAfter, event.amount, event.timestamp, event.accountId]
    );

    await this.readDatabase.query(
      `
      INSERT INTO transaction_summaries 
      (id, account_id, type, amount, description, timestamp, balance_after)
      VALUES (?, ?, 'withdrawal', ?, ?, ?, ?)
    `,
      [
        uuidv4(),
        event.accountId,
        event.amount,
        event.description,
        event.timestamp,
        event.balanceAfter,
      ]
    );
  }
}

// Clean API layer
export class AccountController {
  constructor(
    private commandHandler: AccountCommandHandler,
    private queryHandler: AccountQueryHandler
  ) {}

  // Command endpoint
  async deposit(req: Request, res: Response): Promise<void> {
    try {
      const { accountId, amount, description } = req.body;
      const userId = req.user.id;

      const command = new DepositMoneyCommand(
        userId,
        accountId,
        amount,
        description
      );
      await this.commandHandler.handle(command);

      res.status(202).json({
        message: "Deposit initiated",
        commandId: command.commandId,
      });
    } catch (error) {
      if (error instanceof DomainError) {
        res.status(400).json({ error: error.message });
      } else {
        res.status(500).json({ error: "Internal server error" });
      }
    }
  }

  // Query endpoint
  async getDashboard(req: Request, res: Response): Promise<void> {
    try {
      const accountId = req.params.accountId;
      const dashboard = await this.queryHandler.getDashboard(accountId);

      if (!dashboard) {
        res.status(404).json({ error: "Account not found" });
        return;
      }

      res.json(dashboard);
    } catch (error) {
      res.status(500).json({ error: "Internal server error" });
    }
  }
}

// The traditional approach that loses valuable business data
class TraditionalUserService {
  async updateUserProfile(userId: string, updates: any) {
    // Destructive update - we lose the history forever - RED FLAG #1
    await this.db.query(
      `
      UPDATE users 
      SET email = ?, name = ?, phone = ?, updated_at = NOW()
      WHERE id = ?
    `,
      [updates.email, updates.name, updates.phone, userId]
    );

    // No way to answer business questions like:
    // - When did the user change their email?
    // - What was their previous phone number?
    // - How many times have they updated their profile?
    // - Did they change their email right before a suspicious transaction?
    // - What was the sequence of changes that led to their current state?
  }

  async processPayment(paymentData: any) {
    // Update account balance - losing the story of how we got here
    await this.db.query(
      `
      UPDATE accounts 
      SET balance = balance + ?
      WHERE user_id = ?
    `,
      [paymentData.amount, paymentData.userId]
    );

    // Insert transaction record - but lose rich context
    await this.db.query(
      `
      INSERT INTO transactions (user_id, amount, type, created_at)
      VALUES (?, ?, ?, NOW())
    `,
      [paymentData.userId, paymentData.amount, "payment"]
    );

    // Questions we can't answer:
    // - What was the exact sequence of operations?
    // - If there was a conflict, which update won?
    // - What was the user's balance at any point in time?
    // - Can we replay this sequence to debug issues?
  }
}

// Domain events capture business facts
export abstract class DomainEvent {
  public readonly eventId = uuidv4();
  public readonly timestamp = new Date();
  public readonly version = 1;

  constructor(
    public readonly aggregateId: string,
    public readonly aggregateType: string
  ) {}

  abstract getEventType(): string;
}

export class UserRegisteredEvent extends DomainEvent {
  constructor(
    aggregateId: string,
    public readonly email: string,
    public readonly name: string,
    public readonly registrationSource: string,
    public readonly initialProfile: UserProfile
  ) {
    super(aggregateId, "User");
  }

  getEventType(): string {
    return "UserRegistered";
  }
}

export class UserEmailChangedEvent extends DomainEvent {
  constructor(
    aggregateId: string,
    public readonly previousEmail: string,
    public readonly newEmail: string,
    public readonly changeReason: string,
    public readonly verificationRequired: boolean
  ) {
    super(aggregateId, "User");
  }

  getEventType(): string {
    return "UserEmailChanged";
  }
}

export class UserProfileUpdatedEvent extends DomainEvent {
  constructor(
    aggregateId: string,
    public readonly fieldChanges: ProfileFieldChange[],
    public readonly updatedBy: string,
    public readonly updateReason?: string
  ) {
    super(aggregateId, "User");
  }

  getEventType(): string {
    return "UserProfileUpdated";
  }
}

export class MoneyDepositedEvent extends DomainEvent {
  constructor(
    aggregateId: string,
    public readonly accountId: string,
    public readonly amount: number,
    public readonly balanceAfter: number,
    public readonly description: string,
    public readonly paymentMethod: string,
    public readonly externalTransactionId?: string
  ) {
    super(aggregateId, "Account");
  }

  getEventType(): string {
    return "MoneyDeposited";
  }
}

export class PaymentProcessedEvent extends DomainEvent {
  constructor(
    aggregateId: string,
    public readonly paymentId: string,
    public readonly amount: number,
    public readonly currency: string,
    public readonly merchant: string,
    public readonly paymentMethod: string,
    public readonly processingFee: number,
    public readonly riskScore: number
  ) {
    super(aggregateId, "Payment");
  }

  getEventType(): string {
    return "PaymentProcessed";
  }
}

// Event store interface
export interface IEventStore {
  saveEvents(
    aggregateId: string,
    events: DomainEvent[],
    expectedVersion: number
  ): Promise<void>;
  getEvents(aggregateId: string, fromVersion?: number): Promise<DomainEvent[]>;
  getAllEvents(
    fromPosition?: number,
    maxCount?: number
  ): Promise<DomainEvent[]>;
  getEventsByType(
    eventType: string,
    fromTimestamp?: Date
  ): Promise<DomainEvent[]>;
}

// Event store implementation
export class PostgresEventStore implements IEventStore {
  constructor(private db: Database) {}

  async saveEvents(
    aggregateId: string,
    events: DomainEvent[],
    expectedVersion: number
  ): Promise<void> {
    if (events.length === 0) return;

    const transaction = await this.db.beginTransaction();

    try {
      // Optimistic concurrency control
      const currentVersion = await this.getCurrentVersion(
        aggregateId,
        transaction
      );
      if (currentVersion !== expectedVersion) {
        throw new ConcurrencyError(
          `Expected version ${expectedVersion}, but current version is ${currentVersion}`
        );
      }

      // Save events
      for (const event of events) {
        await transaction.query(
          `
          INSERT INTO event_store 
          (event_id, aggregate_id, aggregate_type, event_type, event_data, version, timestamp)
          VALUES (?, ?, ?, ?, ?, ?, ?)
        `,
          [
            event.eventId,
            event.aggregateId,
            event.aggregateType,
            event.getEventType(),
            JSON.stringify(event),
            expectedVersion + 1,
            event.timestamp,
          ]
        );
        expectedVersion++;
      }

      await transaction.commit();
    } catch (error) {
      await transaction.rollback();
      throw error;
    }
  }

  async getEvents(
    aggregateId: string,
    fromVersion: number = 0
  ): Promise<DomainEvent[]> {
    const result = await this.db.query(
      `
      SELECT event_data, event_type
      FROM event_store
      WHERE aggregate_id = ? AND version > ?
      ORDER BY version ASC
    `,
      [aggregateId, fromVersion]
    );

    return result.rows.map((row) =>
      this.deserializeEvent(row.event_data, row.event_type)
    );
  }

  async getAllEvents(
    fromPosition: number = 0,
    maxCount: number = 1000
  ): Promise<DomainEvent[]> {
    const result = await this.db.query(
      `
      SELECT event_data, event_type
      FROM event_store
      WHERE id > ?
      ORDER BY id ASC
      LIMIT ?
    `,
      [fromPosition, maxCount]
    );

    return result.rows.map((row) =>
      this.deserializeEvent(row.event_data, row.event_type)
    );
  }

  async getEventsByType(
    eventType: string,
    fromTimestamp?: Date
  ): Promise<DomainEvent[]> {
    let query = `
      SELECT event_data, event_type
      FROM event_store
      WHERE event_type = ?
    `;
    const params = [eventType];

    if (fromTimestamp) {
      query += ` AND timestamp >= ?`;
      params.push(fromTimestamp);
    }

    query += ` ORDER BY timestamp ASC`;

    const result = await this.db.query(query, params);
    return result.rows.map((row) =>
      this.deserializeEvent(row.event_data, row.event_type)
    );
  }

  private async getCurrentVersion(
    aggregateId: string,
    transaction: DatabaseTransaction
  ): Promise<number> {
    const result = await transaction.query(
      `
      SELECT COALESCE(MAX(version), 0) as version
      FROM event_store
      WHERE aggregate_id = ?
    `,
      [aggregateId]
    );

    return result.rows[0].version;
  }

  private deserializeEvent(eventData: string, eventType: string): DomainEvent {
    const data = JSON.parse(eventData);

    // Event factory based on type
    switch (eventType) {
      case "UserRegistered":
        return new UserRegisteredEvent(
          data.aggregateId,
          data.email,
          data.name,
          data.registrationSource,
          data.initialProfile
        );
      case "UserEmailChanged":
        return new UserEmailChangedEvent(
          data.aggregateId,
          data.previousEmail,
          data.newEmail,
          data.changeReason,
          data.verificationRequired
        );
      case "MoneyDeposited":
        return new MoneyDepositedEvent(
          data.aggregateId,
          data.accountId,
          data.amount,
          data.balanceAfter,
          data.description,
          data.paymentMethod,
          data.externalTransactionId
        );
      default:
        throw new Error(`Unknown event type: ${eventType}`);
    }
  }
}

// Aggregate that can be rebuilt from events
export class User {
  private version = 0;
  private uncommittedEvents: DomainEvent[] = [];

  constructor(
    public readonly id: string,
    private email: string = "",
    private name: string = "",
    private profile: UserProfile = new UserProfile(),
    private registrationDate?: Date,
    private isEmailVerified: boolean = false
  ) {}

  // Create new user (generates UserRegistered event)
  static register(
    email: string,
    name: string,
    registrationSource: string,
    initialProfile: UserProfile
  ): User {
    const user = new User(uuidv4());

    const event = new UserRegisteredEvent(
      user.id,
      email,
      name,
      registrationSource,
      initialProfile
    );

    user.apply(event);
    return user;
  }

  // Rebuild user from event history
  static fromHistory(events: DomainEvent[]): User {
    const user = new User(events[0]?.aggregateId || "");

    for (const event of events) {
      user.apply(event, false); // Don't add to uncommitted events
    }

    return user;
  }

  // Business methods that generate events
  changeEmail(
    newEmail: string,
    reason: string,
    requireVerification: boolean = true
  ): void {
    if (newEmail === this.email) {
      return; // No change needed
    }

    if (!this.isValidEmail(newEmail)) {
      throw new DomainError("Invalid email format");
    }

    const event = new UserEmailChangedEvent(
      this.id,
      this.email,
      newEmail,
      reason,
      requireVerification
    );

    this.apply(event);
  }

  updateProfile(
    changes: Partial<UserProfile>,
    updatedBy: string,
    reason?: string
  ): void {
    const fieldChanges: ProfileFieldChange[] = [];

    for (const [field, newValue] of Object.entries(changes)) {
      const currentValue = (this.profile as any)[field];
      if (currentValue !== newValue) {
        fieldChanges.push(
          new ProfileFieldChange(field, currentValue, newValue)
        );
      }
    }

    if (fieldChanges.length === 0) {
      return; // No changes
    }

    const event = new UserProfileUpdatedEvent(
      this.id,
      fieldChanges,
      updatedBy,
      reason
    );

    this.apply(event);
  }

  // Apply events to change state
  private apply(event: DomainEvent, isNew: boolean = true): void {
    switch (event.getEventType()) {
      case "UserRegistered":
        this.applyUserRegistered(event as UserRegisteredEvent);
        break;
      case "UserEmailChanged":
        this.applyUserEmailChanged(event as UserEmailChangedEvent);
        break;
      case "UserProfileUpdated":
        this.applyUserProfileUpdated(event as UserProfileUpdatedEvent);
        break;
    }

    this.version++;

    if (isNew) {
      this.uncommittedEvents.push(event);
    }
  }

  private applyUserRegistered(event: UserRegisteredEvent): void {
    this.email = event.email;
    this.name = event.name;
    this.profile = event.initialProfile;
    this.registrationDate = event.timestamp;
  }

  private applyUserEmailChanged(event: UserEmailChangedEvent): void {
    this.email = event.newEmail;
    this.isEmailVerified = !event.verificationRequired;
  }

  private applyUserProfileUpdated(event: UserProfileUpdatedEvent): void {
    for (const change of event.fieldChanges) {
      (this.profile as any)[change.fieldName] = change.newValue;
    }
  }

  // Repository interface methods
  getUncommittedEvents(): DomainEvent[] {
    return [...this.uncommittedEvents];
  }

  clearUncommittedEvents(): void {
    this.uncommittedEvents = [];
  }

  getVersion(): number {
    return this.version;
  }

  // Query methods
  getEmail(): string {
    return this.email;
  }

  getName(): string {
    return this.name;
  }

  getProfile(): UserProfile {
    return this.profile;
  }

  private isValidEmail(email: string): boolean {
    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
  }
}

// Event-sourced repository
export class EventSourcedUserRepository {
  constructor(private eventStore: IEventStore) {}

  async findById(id: string): Promise<User | null> {
    const events = await this.eventStore.getEvents(id);

    if (events.length === 0) {
      return null;
    }

    return User.fromHistory(events);
  }

  async save(user: User): Promise<void> {
    const events = user.getUncommittedEvents();

    if (events.length === 0) {
      return; // No changes to save
    }

    await this.eventStore.saveEvents(
      user.id,
      events,
      user.getVersion() - events.length
    );
    user.clearUncommittedEvents();
  }
}

// Event sourcing enables powerful business intelligence
export class BusinessIntelligenceService {
  constructor(private eventStore: IEventStore) {}

  // Answer complex business questions using event history
  async getUserEmailChangeHistory(userId: string): Promise<EmailChange[]> {
    const events = await this.eventStore.getEvents(userId);
    const emailChanges: EmailChange[] = [];

    for (const event of events) {
      if (event instanceof UserEmailChangedEvent) {
        emailChanges.push(
          new EmailChange(
            event.previousEmail,
            event.newEmail,
            event.changeReason,
            event.timestamp
          )
        );
      }
    }

    return emailChanges;
  }

  async getAccountBalanceAtTime(
    accountId: string,
    pointInTime: Date
  ): Promise<number> {
    const events = await this.eventStore.getEvents(accountId);
    let balance = 0;

    for (const event of events) {
      if (event.timestamp > pointInTime) {
        break; // Stop at the point in time we're interested in
      }

      if (event instanceof MoneyDepositedEvent) {
        balance = event.balanceAfter; // Events contain the balance after the operation
      }
    }

    return balance;
  }

  async detectSuspiciousEmailChanges(
    timeWindow: number = 24
  ): Promise<SuspiciousActivity[]> {
    const suspicious: SuspiciousActivity[] = [];
    const cutoffTime = new Date(Date.now() - timeWindow * 60 * 60 * 1000);

    const emailChanges = await this.eventStore.getEventsByType(
      "UserEmailChanged",
      cutoffTime
    );

    for (const emailChange of emailChanges) {
      const event = emailChange as UserEmailChangedEvent;

      // Look for large transactions shortly after email change
      const paymentEvents = await this.eventStore.getEventsByType(
        "PaymentProcessed"
      );
      const recentPayments = paymentEvents.filter(
        (p) =>
          p.aggregateId === event.aggregateId &&
          p.timestamp > event.timestamp &&
          p.timestamp <= new Date(event.timestamp.getTime() + 60 * 60 * 1000) // Within 1 hour
      );

      const largePayments = recentPayments.filter((p) => {
        const payment = p as PaymentProcessedEvent;
        return payment.amount > 10000; // $10k+
      });

      if (largePayments.length > 0) {
        suspicious.push(
          new SuspiciousActivity(
            event.aggregateId,
            "large_payment_after_email_change",
            `User changed email then made ${largePayments.length} large payments within 1 hour`,
            event.timestamp
          )
        );
      }
    }

    return suspicious;
  }

  async replayEventsForDebugging(
    aggregateId: string
  ): Promise<StateTransition[]> {
    const events = await this.eventStore.getEvents(aggregateId);
    const transitions: StateTransition[] = [];

    let currentState: any = {};

    for (const event of events) {
      const previousState = { ...currentState };

      // Apply event to state (simplified)
      if (event instanceof UserEmailChangedEvent) {
        currentState.email = event.newEmail;
      } else if (event instanceof MoneyDepositedEvent) {
        currentState.balance = event.balanceAfter;
      }

      transitions.push(
        new StateTransition(
          event.getEventType(),
          event.timestamp,
          previousState,
          { ...currentState },
          event
        )
      );
    }

    return transitions;
  }
}

// Supporting types
export class UserProfile {
  constructor(
    public firstName: string = "",
    public lastName: string = "",
    public phone: string = "",
    public address: Address = new Address(),
    public preferences: UserPreferences = new UserPreferences()
  ) {}
}

export class Address {
  constructor(
    public street: string = "",
    public city: string = "",
    public state: string = "",
    public zipCode: string = "",
    public country: string = ""
  ) {}
}

export class UserPreferences {
  constructor(
    public emailNotifications: boolean = true,
    public smsNotifications: boolean = false,
    public language: string = "en",
    public timezone: string = "UTC"
  ) {}
}

export class ProfileFieldChange {
  constructor(
    public readonly fieldName: string,
    public readonly oldValue: any,
    public readonly newValue: any
  ) {}
}

export class EmailChange {
  constructor(
    public readonly previousEmail: string,
    public readonly newEmail: string,
    public readonly reason: string,
    public readonly timestamp: Date
  ) {}
}

export class SuspiciousActivity {
  constructor(
    public readonly userId: string,
    public readonly activityType: string,
    public readonly description: string,
    public readonly timestamp: Date
  ) {}
}

export class StateTransition {
  constructor(
    public readonly eventType: string,
    public readonly timestamp: Date,
    public readonly previousState: any,
    public readonly newState: any,
    public readonly event: DomainEvent
  ) {}
}

export class ConcurrencyError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "ConcurrencyError";
  }
}

export class DomainError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "DomainError";
  }
}

enum AccountStatus {
  Active = "active",
  Frozen = "frozen",
  Closed = "closed",
}

// The distributed nightmare that creates data inconsistencies
class OrderProcessingService {
  async processOrder(orderData: any) {
    try {
      // Step 1: Reserve inventory
      const inventoryReservation = await this.inventoryService.reserveItems(
        orderData.items
      );

      try {
        // Step 2: Process payment
        const paymentResult = await this.paymentService.processPayment({
          customerId: orderData.customerId,
          amount: orderData.total,
        });

        try {
          // Step 3: Create order record
          const order = await this.orderService.createOrder(
            orderData,
            paymentResult.id
          );

          try {
            // Step 4: Update customer points
            await this.loyaltyService.addPoints(
              orderData.customerId,
              orderData.points
            );

            try {
              // Step 5: Send confirmation email
              await this.emailService.sendOrderConfirmation(order);

              return order;
            } catch (emailError) {
              // What do we rollback here? Everything? Just some things?
              console.error("Email failed, but order is already created...");
              throw emailError;
            }
          } catch (loyaltyError) {
            // Need to rollback order, payment, inventory...
            console.error("Loyalty update failed, rolling back order...");
            throw loyaltyError;
          }
        } catch (orderError) {
          // Need to rollback payment and inventory...
          console.error("Order creation failed, rolling back payment...");
          throw orderError;
        }
      } catch (paymentError) {
        // Need to rollback inventory...
        console.error("Payment failed, rolling back inventory...");
        throw paymentError;
      }
    } catch (inventoryError) {
      // First step failed, nothing to rollback
      throw inventoryError;
    }

    // This nested try-catch hell is unmaintainable and error-prone
    // What if a compensation action also fails?
    // How do we handle partial failures?
    // How do we retry individual steps?
    // How do we monitor long-running processes?
  }
}

// Saga interface for coordinating distributed transactions
export interface ISaga {
  readonly sagaId: string;
  readonly sagaType: string;
  execute(): Promise<void>;
  compensate(): Promise<void>;
  getState(): SagaState;
}

export enum SagaState {
  NotStarted = "not_started",
  Running = "running",
  Completed = "completed",
  Compensating = "compensating",
  Failed = "failed",
  Compensated = "compensated",
}

export interface SagaStep {
  name: string;
  execute(): Promise<StepResult>;
  compensate(): Promise<void>;
  canCompensate(): boolean;
}

export class StepResult {
  constructor(
    public success: boolean,
    public data?: any,
    public error?: Error,
    public retryable: boolean = true
  ) {}

  static success(data?: any): StepResult {
    return new StepResult(true, data);
  }

  static failure(error: Error, retryable: boolean = true): StepResult {
    return new StepResult(false, undefined, error, retryable);
  }
}

// Base saga implementation with orchestration logic
export abstract class BaseSaga implements ISaga {
  protected steps: SagaStep[] = [];
  protected executedSteps: SagaStep[] = [];
  protected state: SagaState = SagaState.NotStarted;
  protected currentStepIndex = 0;

  constructor(
    public readonly sagaId: string,
    public readonly sagaType: string
  ) {}

  protected addStep(step: SagaStep): void {
    this.steps.push(step);
  }

  async execute(): Promise<void> {
    this.state = SagaState.Running;

    try {
      for (let i = this.currentStepIndex; i < this.steps.length; i++) {
        const step = this.steps[i];
        console.log(`Executing saga step: ${step.name}`);

        const result = await this.executeStepWithRetry(step);

        if (!result.success) {
          if (result.retryable) {
            throw new SagaRetryableError(
              `Step ${step.name} failed: ${result.error?.message}`
            );
          } else {
            throw new SagaNonRetryableError(
              `Step ${step.name} failed: ${result.error?.message}`
            );
          }
        }

        this.executedSteps.push(step);
        this.currentStepIndex = i + 1;

        // Save progress for recovery
        await this.saveProgress();
      }

      this.state = SagaState.Completed;
      await this.saveProgress();
    } catch (error) {
      this.state = SagaState.Failed;
      await this.saveProgress();

      // Start compensation
      await this.compensate();
      throw error;
    }
  }

  async compensate(): Promise<void> {
    this.state = SagaState.Compensating;
    await this.saveProgress();

    // Compensate executed steps in reverse order
    const stepsToCompensate = [...this.executedSteps].reverse();

    for (const step of stepsToCompensate) {
      if (step.canCompensate()) {
        try {
          console.log(`Compensating saga step: ${step.name}`);
          await step.compensate();
        } catch (error) {
          console.error(`Compensation failed for step ${step.name}:`, error);
          // Continue compensating other steps even if one fails
        }
      }
    }

    this.state = SagaState.Compensated;
    await this.saveProgress();
  }

  private async executeStepWithRetry(
    step: SagaStep,
    maxRetries: number = 3
  ): Promise<StepResult> {
    let lastResult: StepResult;

    for (let attempt = 1; attempt <= maxRetries; attempt++) {
      try {
        lastResult = await step.execute();

        if (lastResult.success) {
          return lastResult;
        }

        if (!lastResult.retryable) {
          return lastResult; // Don't retry non-retryable failures
        }

        if (attempt < maxRetries) {
          const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
          console.log(
            `Step ${step.name} failed, retrying in ${delay}ms (attempt ${attempt}/${maxRetries})`
          );
          await this.sleep(delay);
        }
      } catch (error) {
        lastResult = StepResult.failure(error as Error);

        if (attempt < maxRetries) {
          const delay = Math.pow(2, attempt) * 1000;
          console.log(
            `Step ${step.name} threw error, retrying in ${delay}ms (attempt ${attempt}/${maxRetries})`
          );
          await this.sleep(delay);
        }
      }
    }

    return lastResult!;
  }

  getState(): SagaState {
    return this.state;
  }

  protected abstract saveProgress(): Promise<void>;

  private sleep(ms: number): Promise<void> {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
}

// Concrete saga for order processing
export class OrderProcessingSaga extends BaseSaga {
  private orderData: OrderData;
  private reservationId?: string;
  private paymentId?: string;
  private orderId?: string;
  private pointsTransactionId?: string;

  constructor(
    sagaId: string,
    orderData: OrderData,
    private inventoryService: IInventoryService,
    private paymentService: IPaymentService,
    private orderService: IOrderService,
    private loyaltyService: ILoyaltyService,
    private emailService: IEmailService,
    private sagaRepository: ISagaRepository
  ) {
    super(sagaId, "OrderProcessing");
    this.orderData = orderData;
    this.setupSteps();
  }

  private setupSteps(): void {
    // Step 1: Reserve inventory
    this.addStep(
      new InventoryReservationStep(
        this.inventoryService,
        this.orderData.items,
        (reservationId) => (this.reservationId = reservationId)
      )
    );

    // Step 2: Process payment
    this.addStep(
      new PaymentProcessingStep(
        this.paymentService,
        this.orderData.customerId,
        this.orderData.total,
        (paymentId) => (this.paymentId = paymentId)
      )
    );

    // Step 3: Create order
    this.addStep(
      new OrderCreationStep(
        this.orderService,
        this.orderData,
        () => this.paymentId!,
        (orderId) => (this.orderId = orderId)
      )
    );

    // Step 4: Add loyalty points (optional - can fail without breaking the flow)
    this.addStep(
      new LoyaltyPointsStep(
        this.loyaltyService,
        this.orderData.customerId,
        this.orderData.loyaltyPoints,
        (transactionId) => (this.pointsTransactionId = transactionId)
      )
    );

    // Step 5: Send confirmation email (optional - can fail without breaking the flow)
    this.addStep(
      new EmailConfirmationStep(
        this.emailService,
        () => this.orderData.customerEmail,
        () => this.orderId!
      )
    );
  }

  protected async saveProgress(): Promise<void> {
    const sagaState = {
      sagaId: this.sagaId,
      sagaType: this.sagaType,
      state: this.state,
      currentStepIndex: this.currentStepIndex,
      executedSteps: this.executedSteps.map((step) => step.name),
      data: {
        orderData: this.orderData,
        reservationId: this.reservationId,
        paymentId: this.paymentId,
        orderId: this.orderId,
        pointsTransactionId: this.pointsTransactionId,
      },
    };

    await this.sagaRepository.saveSagaState(sagaState);
  }

  // Factory method to restore saga from saved state
  static async restore(
    sagaState: any,
    inventoryService: IInventoryService,
    paymentService: IPaymentService,
    orderService: IOrderService,
    loyaltyService: ILoyaltyService,
    emailService: IEmailService,
    sagaRepository: ISagaRepository
  ): Promise<OrderProcessingSaga> {
    const saga = new OrderProcessingSaga(
      sagaState.sagaId,
      sagaState.data.orderData,
      inventoryService,
      paymentService,
      orderService,
      loyaltyService,
      emailService,
      sagaRepository
    );

    // Restore internal state
    saga.state = sagaState.state;
    saga.currentStepIndex = sagaState.currentStepIndex;
    saga.reservationId = sagaState.data.reservationId;
    saga.paymentId = sagaState.data.paymentId;
    saga.orderId = sagaState.data.orderId;
    saga.pointsTransactionId = sagaState.data.pointsTransactionId;

    // Restore executed steps
    for (let i = 0; i < sagaState.currentStepIndex; i++) {
      if (i < saga.steps.length) {
        saga.executedSteps.push(saga.steps[i]);
      }
    }

    return saga;
  }
}

// Individual saga steps with compensation logic
export class InventoryReservationStep implements SagaStep {
  name = "ReserveInventory";

  constructor(
    private inventoryService: IInventoryService,
    private items: OrderItem[],
    private onSuccess: (reservationId: string) => void
  ) {}

  async execute(): Promise<StepResult> {
    try {
      const reservation = await this.inventoryService.reserveItems(this.items);
      this.onSuccess(reservation.id);
      return StepResult.success(reservation);
    } catch (error) {
      return StepResult.failure(error as Error);
    }
  }

  async compensate(): Promise<void> {
    // Release the inventory reservation
    const reservationId = this.getReservationId();
    if (reservationId) {
      await this.inventoryService.releaseReservation(reservationId);
      console.log(`Released inventory reservation: ${reservationId}`);
    }
  }

  canCompensate(): boolean {
    return true;
  }

  private getReservationId(): string | undefined {
    // In a real implementation, this would be stored in the saga state
    // For simplicity, assuming it's available in the saga context
    return undefined;
  }
}

export class PaymentProcessingStep implements SagaStep {
  name = "ProcessPayment";

  constructor(
    private paymentService: IPaymentService,
    private customerId: string,
    private amount: number,
    private onSuccess: (paymentId: string) => void
  ) {}

  async execute(): Promise<StepResult> {
    try {
      const paymentResult = await this.paymentService.processPayment({
        customerId: this.customerId,
        amount: this.amount,
      });

      if (!paymentResult.success) {
        return StepResult.failure(
          new Error(`Payment failed: ${paymentResult.errorMessage}`),
          paymentResult.retryable
        );
      }

      this.onSuccess(paymentResult.transactionId);
      return StepResult.success(paymentResult);
    } catch (error) {
      return StepResult.failure(error as Error);
    }
  }

  async compensate(): Promise<void> {
    // Refund the payment
    const paymentId = this.getPaymentId();
    if (paymentId) {
      await this.paymentService.refundPayment(paymentId);
      console.log(`Refunded payment: ${paymentId}`);
    }
  }

  canCompensate(): boolean {
    return true;
  }

  private getPaymentId(): string | undefined {
    return undefined; // Would be stored in saga context
  }
}

export class OrderCreationStep implements SagaStep {
  name = "CreateOrder";

  constructor(
    private orderService: IOrderService,
    private orderData: OrderData,
    private getPaymentId: () => string,
    private onSuccess: (orderId: string) => void
  ) {}

  async execute(): Promise<StepResult> {
    try {
      const order = await this.orderService.createOrder({
        ...this.orderData,
        paymentId: this.getPaymentId(),
      });

      this.onSuccess(order.id);
      return StepResult.success(order);
    } catch (error) {
      return StepResult.failure(error as Error);
    }
  }

  async compensate(): Promise<void> {
    // Cancel the order
    const orderId = this.getOrderId();
    if (orderId) {
      await this.orderService.cancelOrder(orderId);
      console.log(`Cancelled order: ${orderId}`);
    }
  }

  canCompensate(): boolean {
    return true;
  }

  private getOrderId(): string | undefined {
    return undefined; // Would be stored in saga context
  }
}

export class LoyaltyPointsStep implements SagaStep {
  name = "AddLoyaltyPoints";

  constructor(
    private loyaltyService: ILoyaltyService,
    private customerId: string,
    private points: number,
    private onSuccess: (transactionId: string) => void
  ) {}

  async execute(): Promise<StepResult> {
    try {
      const transaction = await this.loyaltyService.addPoints(
        this.customerId,
        this.points
      );
      this.onSuccess(transaction.id);
      return StepResult.success(transaction);
    } catch (error) {
      // Loyalty points failure is not critical - log but don't fail the saga
      console.warn(`Failed to add loyalty points: ${error.message}`);
      return StepResult.success(); // Treat as success to not break the flow
    }
  }

  async compensate(): Promise<void> {
    // Remove the loyalty points
    const transactionId = this.getTransactionId();
    if (transactionId) {
      await this.loyaltyService.reverseTransaction(transactionId);
      console.log(`Reversed loyalty points transaction: ${transactionId}`);
    }
  }

  canCompensate(): boolean {
    return true;
  }

  private getTransactionId(): string | undefined {
    return undefined; // Would be stored in saga context
  }
}

export class EmailConfirmationStep implements SagaStep {
  name = "SendConfirmationEmail";

  constructor(
    private emailService: IEmailService,
    private getCustomerEmail: () => string,
    private getOrderId: () => string
  ) {}

  async execute(): Promise<StepResult> {
    try {
      await this.emailService.sendOrderConfirmation(
        this.getCustomerEmail(),
        this.getOrderId()
      );
      return StepResult.success();
    } catch (error) {
      // Email failure is not critical - log but don't fail the saga
      console.warn(`Failed to send confirmation email: ${error.message}`);
      return StepResult.success(); // Treat as success to not break the flow
    }
  }

  async compensate(): Promise<void> {
    // Emails cannot be "unsent" - nothing to compensate
    console.log("Email confirmation step - no compensation needed");
  }

  canCompensate(): boolean {
    return false; // Cannot compensate emails
  }
}

// Saga orchestrator that manages saga lifecycle
export class SagaOrchestrator {
  constructor(
    private sagaRepository: ISagaRepository,
    private serviceLocator: ServiceLocator
  ) {}

  async startSaga<T extends ISaga>(sagaFactory: () => T): Promise<string> {
    const saga = sagaFactory();

    try {
      await saga.execute();
      return saga.sagaId;
    } catch (error) {
      console.error(`Saga ${saga.sagaId} failed:`, error);
      throw error;
    }
  }

  async resumeSaga(sagaId: string): Promise<void> {
    const sagaState = await this.sagaRepository.getSagaState(sagaId);
    if (!sagaState) {
      throw new Error(`Saga state not found: ${sagaId}`);
    }

    const saga = await this.restoreSaga(sagaState);

    try {
      if (saga.getState() === SagaState.Failed) {
        await saga.compensate();
      } else if (saga.getState() === SagaState.Running) {
        await saga.execute(); // Resume execution
      }
    } catch (error) {
      console.error(`Failed to resume saga ${sagaId}:`, error);
      throw error;
    }
  }

  private async restoreSaga(sagaState: any): Promise<ISaga> {
    switch (sagaState.sagaType) {
      case "OrderProcessing":
        return await OrderProcessingSaga.restore(
          sagaState,
          this.serviceLocator.get("inventoryService"),
          this.serviceLocator.get("paymentService"),
          this.serviceLocator.get("orderService"),
          this.serviceLocator.get("loyaltyService"),
          this.serviceLocator.get("emailService"),
          this.sagaRepository
        );
      default:
        throw new Error(`Unknown saga type: ${sagaState.sagaType}`);
    }
  }
}

// Clean service using saga orchestration
export class OrderProcessingService {
  constructor(
    private sagaOrchestrator: SagaOrchestrator,
    private inventoryService: IInventoryService,
    private paymentService: IPaymentService,
    private orderService: IOrderService,
    private loyaltyService: ILoyaltyService,
    private emailService: IEmailService,
    private sagaRepository: ISagaRepository
  ) {}

  async processOrder(orderData: OrderData): Promise<ProcessOrderResult> {
    const sagaId = await this.sagaOrchestrator.startSaga(
      () =>
        new OrderProcessingSaga(
          uuidv4(),
          orderData,
          this.inventoryService,
          this.paymentService,
          this.orderService,
          this.loyaltyService,
          this.emailService,
          this.sagaRepository
        )
    );

    return new ProcessOrderResult(sagaId, "Order processing started");
  }

  async retryFailedOrder(sagaId: string): Promise<void> {
    await this.sagaOrchestrator.resumeSaga(sagaId);
  }
}

// Supporting types and interfaces
export interface ISagaRepository {
  saveSagaState(sagaState: any): Promise<void>;
  getSagaState(sagaId: string): Promise<any | null>;
}

export interface ServiceLocator {
  get<T>(serviceName: string): T;
}

export class SagaRetryableError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "SagaRetryableError";
  }
}

export class SagaNonRetryableError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "SagaNonRetryableError";
  }
}

export class ProcessOrderResult {
  constructor(
    public readonly sagaId: string,
    public readonly message: string
  ) {}
}

export interface OrderData {
  customerId: string;
  customerEmail: string;
  items: OrderItem[];
  total: number;
  loyaltyPoints: number;
}

export interface OrderItem {
  productId: string;
  quantity: number;
  price: number;
}

// Service interfaces for dependency injection
interface IInventoryService {
  reserveItems(items: OrderItem[]): Promise<{ id: string }>;
  releaseReservation(reservationId: string): Promise<void>;
}

interface IPaymentService {
  processPayment(request: { customerId: string; amount: number }): Promise<{
    success: boolean;
    transactionId: string;
    errorMessage?: string;
    retryable: boolean;
  }>;
  refundPayment(paymentId: string): Promise<void>;
}

interface IOrderService {
  createOrder(orderData: any): Promise<{ id: string }>;
  cancelOrder(orderId: string): Promise<void>;
}

interface ILoyaltyService {
  addPoints(customerId: string, points: number): Promise<{ id: string }>;
  reverseTransaction(transactionId: string): Promise<void>;
}

interface IEmailService {
  sendOrderConfirmation(email: string, orderId: string): Promise<void>;
}