gridpilot.gg/adapters/payments/persistence/inmemory/InMemoryWalletRepository.ts

/**
 * In-Memory Implementation: InMemoryWalletRepository
 */

import type { WalletRepository, TransactionRepository } from '@core/payments/domain/repositories/WalletRepository';
import type { Logger } from '@core/shared/domain/Logger';
import type { Wallet, Transaction } from '@core/payments/domain/entities/Wallet';

const wallets: Map<string, Wallet> = new Map();
const transactions: Map<string, Transaction> = new Map();

export class InMemoryWalletRepository implements WalletRepository {
  constructor(private readonly logger: Logger) {}

  async findById(id: string): Promise<Wallet | null> {
    this.logger.debug('[InMemoryWalletRepository] findById', { id });
    return wallets.get(id) || null;
  }

  async findByLeagueId(leagueId: string): Promise<Wallet | null> {
    this.logger.debug('[InMemoryWalletRepository] findByLeagueId', { leagueId });
    return Array.from(wallets.values()).find(w => w.leagueId === leagueId) || null;
  }

  async create(wallet: Wallet): Promise<Wallet> {
    this.logger.debug('[InMemoryWalletRepository] create', { wallet });
    wallets.set(wallet.id, wallet);
    return wallet;
  }

  async update(wallet: Wallet): Promise<Wallet> {
    this.logger.debug('[InMemoryWalletRepository] update', { wallet });
    wallets.set(wallet.id, wallet);
    return wallet;
  }

  async delete(id: string): Promise<void> {
    wallets.delete(id);
  }

  async exists(id: string): Promise<boolean> {
    return wallets.has(id);
  }

  clear(): void {
    wallets.clear();
  }
}

export class InMemoryTransactionRepository implements TransactionRepository {
  constructor(private readonly logger: Logger) {}

  async findById(id: string): Promise<Transaction | null> {
    this.logger.debug('[InMemoryTransactionRepository] findById', { id });
    return transactions.get(id) || null;
  }

  async findByWalletId(walletId: string): Promise<Transaction[]> {
    this.logger.debug('[InMemoryTransactionRepository] findByWalletId', { walletId });
    return Array.from(transactions.values()).filter(t => t.walletId === walletId);
  }

  async create(transaction: Transaction): Promise<Transaction> {
    this.logger.debug('[InMemoryTransactionRepository] create', { transaction });
    transactions.set(transaction.id, transaction);
    return transaction;
  }

  async update(transaction: Transaction): Promise<Transaction> {
    transactions.set(transaction.id, transaction);
    return transaction;
  }

  async delete(id: string): Promise<void> {
    transactions.delete(id);
  }

  async exists(id: string): Promise<boolean> {
    return transactions.has(id);
  }

  findByType(type: any): Promise<Transaction[]> {
    return Promise.resolve(Array.from(transactions.values()).filter(t => t.type === type));
  }

  clear(): void {
    transactions.clear();
  }
}