refactor

adapters/payments/persistence/inmemory/InMemoryMembershipFeeRepository.ts

@@ -0,0 +1,77 @@
+/**
+ * In-Memory Implementation: InMemoryMembershipFeeRepository
+ */
+
+import type { Logger } from '@gridpilot/shared/application/Logger';
+import type { IMembershipFeeRepository, IMemberPaymentRepository } from '../../../../core/payments/domain/repositories/IMembershipFeeRepository';
+import type { MembershipFee } from '../../../../core/payments/domain/entities/MembershipFee';
+import type { MemberPayment } from '../../../../core/payments/domain/entities/MemberPayment';
+
+const membershipFees: Map<string, MembershipFee> = new Map();
+const memberPayments: Map<string, MemberPayment> = new Map();
+
+export class InMemoryMembershipFeeRepository implements IMembershipFeeRepository {
+  constructor(private readonly logger: Logger) {}
+
+  async findById(id: string): Promise<MembershipFee | null> {
+    this.logger.debug('[InMemoryMembershipFeeRepository] findById', { id });
+    return membershipFees.get(id) || null;
+  }
+
+  async findByLeagueId(leagueId: string): Promise<MembershipFee | null> {
+    this.logger.debug('[InMemoryMembershipFeeRepository] findByLeagueId', { leagueId });
+    return Array.from(membershipFees.values()).find(f => f.leagueId === leagueId) || null;
+  }
+
+  async create(fee: MembershipFee): Promise<MembershipFee> {
+    this.logger.debug('[InMemoryMembershipFeeRepository] create', { fee });
+    membershipFees.set(fee.id, fee);
+    return fee;
+  }
+
+  async update(fee: MembershipFee): Promise<MembershipFee> {
+    this.logger.debug('[InMemoryMembershipFeeRepository] update', { fee });
+    membershipFees.set(fee.id, fee);
+    return fee;
+  }
+}
+
+export class InMemoryMemberPaymentRepository implements IMemberPaymentRepository {
+  constructor(private readonly logger: Logger) {}
+
+  async findById(id: string): Promise<MemberPayment | null> {
+    this.logger.debug('[InMemoryMemberPaymentRepository] findById', { id });
+    return memberPayments.get(id) || null;
+  }
+
+  async findByFeeIdAndDriverId(feeId: string, driverId: string): Promise<MemberPayment | null> {
+    this.logger.debug('[InMemoryMemberPaymentRepository] findByFeeIdAndDriverId', { feeId, driverId });
+    return Array.from(memberPayments.values()).find(
+      p => p.feeId === feeId && p.driverId === driverId
+    ) || null;
+  }
+
+  async findByLeagueIdAndDriverId(leagueId: string, driverId: string, membershipFeeRepo: IMembershipFeeRepository): Promise<MemberPayment[]> {
+    this.logger.debug('[InMemoryMemberPaymentRepository] findByLeagueIdAndDriverId', { leagueId, driverId });
+    const results: MemberPayment[] = [];
+    for (const payment of memberPayments.values()) {
+      const fee = await membershipFeeRepo.findById(payment.feeId);
+      if (fee && fee.leagueId === leagueId && payment.driverId === driverId) {
+        results.push(payment);
+      }
+    }
+    return results;
+  }
+
+  async create(payment: MemberPayment): Promise<MemberPayment> {
+    this.logger.debug('[InMemoryMemberPaymentRepository] create', { payment });
+    memberPayments.set(payment.id, payment);
+    return payment;
+  }
+
+  async update(payment: MemberPayment): Promise<MemberPayment> {
+    this.logger.debug('[InMemoryMemberPaymentRepository] update', { payment });
+    memberPayments.set(payment.id, payment);
+    return payment;
+  }
+}

adapters/payments/persistence/inmemory/InMemoryPaymentRepository.ts

@@ -0,0 +1,62 @@
+/**
+ * In-Memory Implementation: InMemoryPaymentRepository
+ */
+
+import type { Logger } from '@gridpilot/shared/application/Logger';
+import type { IPaymentRepository } from '../../../../core/payments/domain/repositories/IPaymentRepository';
+import type { Payment, PaymentType } from '../../../../core/payments/domain/entities/Payment';
+
+const payments: Map<string, Payment> = new Map();
+
+export class InMemoryPaymentRepository implements IPaymentRepository {
+  constructor(private readonly logger: Logger) {}
+
+  async findById(id: string): Promise<Payment | null> {
+    this.logger.debug('[InMemoryPaymentRepository] findById', { id });
+    return payments.get(id) || null;
+  }
+
+  async findByLeagueId(leagueId: string): Promise<Payment[]> {
+    this.logger.debug('[InMemoryPaymentRepository] findByLeagueId', { leagueId });
+    return Array.from(payments.values()).filter(p => p.leagueId === leagueId);
+  }
+
+  async findByPayerId(payerId: string): Promise<Payment[]> {
+    this.logger.debug('[InMemoryPaymentRepository] findByPayerId', { payerId });
+    return Array.from(payments.values()).filter(p => p.payerId === payerId);
+  }
+
+  async findByType(type: PaymentType): Promise<Payment[]> {
+    this.logger.debug('[InMemoryPaymentRepository] findByType', { type });
+    return Array.from(payments.values()).filter(p => p.type === type);
+  }
+
+  async findByFilters(filters: { leagueId?: string; payerId?: string; type?: PaymentType }): Promise<Payment[]> {
+    this.logger.debug('[InMemoryPaymentRepository] findByFilters', { filters });
+    let results = Array.from(payments.values());
+
+    if (filters.leagueId) {
+      results = results.filter(p => p.leagueId === filters.leagueId);
+    }
+    if (filters.payerId) {
+      results = results.filter(p => p.payerId === filters.payerId);
+    }
+    if (filters.type) {
+      results = results.filter(p => p.type === filters.type);
+    }
+
+    return results;
+  }
+
+  async create(payment: Payment): Promise<Payment> {
+    this.logger.debug('[InMemoryPaymentRepository] create', { payment });
+    payments.set(payment.id, payment);
+    return payment;
+  }
+
+  async update(payment: Payment): Promise<Payment> {
+    this.logger.debug('[InMemoryPaymentRepository] update', { payment });
+    payments.set(payment.id, payment);
+    return payment;
+  }
+}

adapters/payments/persistence/inmemory/InMemoryPrizeRepository.ts

@@ -0,0 +1,54 @@
+/**
+ * In-Memory Implementation: InMemoryPrizeRepository
+ */
+
+import type { Logger } from '@gridpilot/shared/application/Logger';
+import type { IPrizeRepository } from '../../../../core/payments/domain/repositories/IPrizeRepository';
+import type { Prize } from '../../../../core/payments/domain/entities/Prize';
+
+const prizes: Map<string, Prize> = new Map();
+
+export class InMemoryPrizeRepository implements IPrizeRepository {
+  constructor(private readonly logger: Logger) {}
+
+  async findById(id: string): Promise<Prize | null> {
+    this.logger.debug('[InMemoryPrizeRepository] findById', { id });
+    return prizes.get(id) || null;
+  }
+
+  async findByLeagueId(leagueId: string): Promise<Prize[]> {
+    this.logger.debug('[InMemoryPrizeRepository] findByLeagueId', { leagueId });
+    return Array.from(prizes.values()).filter(p => p.leagueId === leagueId);
+  }
+
+  async findByLeagueIdAndSeasonId(leagueId: string, seasonId: string): Promise<Prize[]> {
+    this.logger.debug('[InMemoryPrizeRepository] findByLeagueIdAndSeasonId', { leagueId, seasonId });
+    return Array.from(prizes.values()).filter(
+      p => p.leagueId === leagueId && p.seasonId === seasonId
+    );
+  }
+
+  async findByPosition(leagueId: string, seasonId: string, position: number): Promise<Prize | null> {
+    this.logger.debug('[InMemoryPrizeRepository] findByPosition', { leagueId, seasonId, position });
+    return Array.from(prizes.values()).find(
+      p => p.leagueId === leagueId && p.seasonId === seasonId && p.position === position
+    ) || null;
+  }
+
+  async create(prize: Prize): Promise<Prize> {
+    this.logger.debug('[InMemoryPrizeRepository] create', { prize });
+    prizes.set(prize.id, prize);
+    return prize;
+  }
+
+  async update(prize: Prize): Promise<Prize> {
+    this.logger.debug('[InMemoryPrizeRepository] update', { prize });
+    prizes.set(prize.id, prize);
+    return prize;
+  }
+
+  async delete(id: string): Promise<void> {
+    this.logger.debug('[InMemoryPrizeRepository] delete', { id });
+    prizes.delete(id);
+  }
+}

adapters/payments/persistence/inmemory/InMemoryWalletRepository.ts

@@ -0,0 +1,56 @@
+/**
+ * In-Memory Implementation: InMemoryWalletRepository
+ */
+
+import type { Logger } from '@gridpilot/shared/application/Logger';
+import type { IWalletRepository, ITransactionRepository } from '../../../../core/payments/domain/repositories/IWalletRepository';
+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 IWalletRepository {
+  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;
+  }
+}
+
+export class InMemoryTransactionRepository implements ITransactionRepository {
+  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;
+  }
+}

adapters/payments/persistence/inmemory/index.ts

@@ -0,0 +1,4 @@
+export * from './InMemoryPaymentRepository';
+export * from './InMemoryMembershipFeeRepository';
+export * from './InMemoryPrizeRepository';
+export * from './InMemoryWalletRepository';