fix adapters

adapters/payments/persistence/inmemory/InMemoryMembershipFeeRepository.test.ts

@@ -0,0 +1,102 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Logger } from '@core/shared/application/Logger';
+import type { MembershipFee } from '@core/payments/domain/entities/MembershipFee';
+import { MembershipFeeType } from '@core/payments/domain/entities/MembershipFee';
+import type { MemberPayment } from '@core/payments/domain/entities/MemberPayment';
+import { MemberPaymentStatus } from '@core/payments/domain/entities/MemberPayment';
+import { InMemoryMemberPaymentRepository, InMemoryMembershipFeeRepository } from './InMemoryMembershipFeeRepository';
+
+describe('InMemoryMembershipFeeRepository', () => {
+  let feeRepo: InMemoryMembershipFeeRepository;
+  let paymentRepo: InMemoryMemberPaymentRepository;
+  let logger: Logger;
+
+  beforeEach(() => {
+    logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+
+    feeRepo = new InMemoryMembershipFeeRepository(logger);
+    paymentRepo = new InMemoryMemberPaymentRepository(logger);
+  });
+
+  it('creates and finds membership fees', async () => {
+    const fee: MembershipFee = {
+      id: 'fee-1',
+      leagueId: 'league-1',
+      type: MembershipFeeType.SEASON,
+      amount: 100,
+      enabled: true,
+      createdAt: new Date('2025-01-01T00:00:00.000Z'),
+      updatedAt: new Date('2025-01-01T00:00:00.000Z'),
+    };
+
+    await feeRepo.create(fee);
+
+    expect((await feeRepo.findById('fee-1'))?.id).toBe('fee-1');
+    expect((await feeRepo.findByLeagueId('league-1'))?.id).toBe('fee-1');
+
+    const updated = await feeRepo.update({
+      ...fee,
+      amount: 120,
+      updatedAt: new Date('2025-01-02T00:00:00.000Z'),
+    });
+    expect(updated.amount).toBe(120);
+  });
+
+  it('creates and queries member payments by league via fee lookup', async () => {
+    const fee1: MembershipFee = {
+      id: 'fee-a',
+      leagueId: 'league-a',
+      type: MembershipFeeType.SEASON,
+      amount: 100,
+      enabled: true,
+      createdAt: new Date('2025-01-01T00:00:00.000Z'),
+      updatedAt: new Date('2025-01-01T00:00:00.000Z'),
+    };
+    const fee2: MembershipFee = {
+      id: 'fee-b',
+      leagueId: 'league-b',
+      type: MembershipFeeType.SEASON,
+      amount: 50,
+      enabled: true,
+      createdAt: new Date('2025-01-01T00:00:00.000Z'),
+      updatedAt: new Date('2025-01-01T00:00:00.000Z'),
+    };
+
+    await feeRepo.create(fee1);
+    await feeRepo.create(fee2);
+
+    const p1: MemberPayment = {
+      id: 'mp-1',
+      feeId: 'fee-a',
+      driverId: 'driver-1',
+      amount: 100,
+      platformFee: 5,
+      netAmount: 95,
+      status: MemberPaymentStatus.PENDING,
+      dueDate: new Date('2025-02-01T00:00:00.000Z'),
+    };
+    const p2: MemberPayment = {
+      id: 'mp-2',
+      feeId: 'fee-b',
+      driverId: 'driver-1',
+      amount: 50,
+      platformFee: 2.5,
+      netAmount: 47.5,
+      status: MemberPaymentStatus.PENDING,
+      dueDate: new Date('2025-02-01T00:00:00.000Z'),
+    };
+
+    await paymentRepo.create(p1);
+    await paymentRepo.create(p2);
+
+    expect((await paymentRepo.findByFeeIdAndDriverId('fee-a', 'driver-1'))?.id).toBe('mp-1');
+
+    const leagueAPayments = await paymentRepo.findByLeagueIdAndDriverId('league-a', 'driver-1', feeRepo);
+    expect(leagueAPayments.map(p => p.id)).toEqual(['mp-1']);
+  });
+});

adapters/payments/persistence/inmemory/InMemoryPaymentRepository.test.ts

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Logger } from '@core/shared/application/Logger';
+import type { Payment } from '@core/payments/domain/entities/Payment';
+import { PaymentType, PaymentStatus, PayerType } from '@core/payments/domain/entities/Payment';
+import { InMemoryPaymentRepository } from './InMemoryPaymentRepository';
+
+describe('InMemoryPaymentRepository', () => {
+  let repository: InMemoryPaymentRepository;
+  let logger: Logger;
+
+  beforeEach(() => {
+    logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+    repository = new InMemoryPaymentRepository(logger);
+  });
+
+  it('creates and finds by filters', async () => {
+    const payment: Payment = {
+      id: 'pay-1',
+      type: PaymentType.SPONSORSHIP,
+      amount: 100,
+      platformFee: 5,
+      netAmount: 95,
+      payerId: 'sponsor-1',
+      payerType: PayerType.SPONSOR,
+      leagueId: 'league-1',
+      status: PaymentStatus.PENDING,
+      createdAt: new Date('2025-01-01T00:00:00.000Z'),
+    };
+
+    await repository.create(payment);
+
+    expect((await repository.findById('pay-1'))?.id).toBe('pay-1');
+    expect((await repository.findByLeagueId('league-1')).length).toBeGreaterThanOrEqual(1);
+    expect((await repository.findByPayerId('sponsor-1')).length).toBeGreaterThanOrEqual(1);
+    expect((await repository.findByType(PaymentType.SPONSORSHIP)).length).toBeGreaterThanOrEqual(1);
+
+    const filtered = await repository.findByFilters({ leagueId: 'league-1', payerId: 'sponsor-1', type: PaymentType.SPONSORSHIP });
+    expect(filtered.map(p => p.id)).toContain('pay-1');
+  });
+
+  it('updates', async () => {
+    const payment: Payment = {
+      id: 'pay-2',
+      type: PaymentType.MEMBERSHIP_FEE,
+      amount: 50,
+      platformFee: 2.5,
+      netAmount: 47.5,
+      payerId: 'driver-1',
+      payerType: PayerType.DRIVER,
+      leagueId: 'league-2',
+      status: PaymentStatus.PENDING,
+      createdAt: new Date('2025-01-02T00:00:00.000Z'),
+    };
+
+    await repository.create(payment);
+    const updated = await repository.update({ ...payment, status: PaymentStatus.COMPLETED, completedAt: new Date('2025-01-03T00:00:00.000Z') });
+    expect(updated.status).toBe(PaymentStatus.COMPLETED);
+  });
+});

adapters/payments/persistence/inmemory/InMemoryPrizeRepository.test.ts

@@ -0,0 +1,45 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Logger } from '@core/shared/application/Logger';
+import type { Prize } from '@core/payments/domain/entities/Prize';
+import { PrizeType } from '@core/payments/domain/entities/Prize';
+import { InMemoryPrizeRepository } from './InMemoryPrizeRepository';
+
+describe('InMemoryPrizeRepository', () => {
+  let repository: InMemoryPrizeRepository;
+  let logger: Logger;
+
+  beforeEach(() => {
+    logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+    repository = new InMemoryPrizeRepository(logger);
+  });
+
+  it('creates and queries prizes', async () => {
+    const prize: Prize = {
+      id: 'prize-1',
+      leagueId: 'league-1',
+      seasonId: 'season-1',
+      position: 1,
+      name: 'First Place',
+      amount: 100,
+      type: PrizeType.CASH,
+      description: 'First place',
+      awarded: false,
+      createdAt: new Date('2025-01-01T00:00:00.000Z'),
+    };
+
+    await repository.create(prize);
+
+    expect((await repository.findById('prize-1'))?.id).toBe('prize-1');
+    expect((await repository.findByLeagueId('league-1')).map(p => p.id)).toContain('prize-1');
+    expect((await repository.findByLeagueIdAndSeasonId('league-1', 'season-1')).map(p => p.id)).toContain('prize-1');
+    expect((await repository.findByPosition('league-1', 'season-1', 1))?.id).toBe('prize-1');
+
+    await repository.delete('prize-1');
+    expect(await repository.findById('prize-1')).toBeNull();
+  });
+});

adapters/payments/persistence/inmemory/InMemoryWalletRepository.test.ts

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Logger } from '@core/shared/application/Logger';
+import type { Wallet, Transaction } from '@core/payments/domain/entities/Wallet';
+import { TransactionType } from '@core/payments/domain/entities/Wallet';
+import { InMemoryTransactionRepository, InMemoryWalletRepository } from './InMemoryWalletRepository';
+
+describe('InMemoryWalletRepository', () => {
+  let walletRepo: InMemoryWalletRepository;
+  let txRepo: InMemoryTransactionRepository;
+  let logger: Logger;
+
+  beforeEach(() => {
+    logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+
+    walletRepo = new InMemoryWalletRepository(logger);
+    txRepo = new InMemoryTransactionRepository(logger);
+  });
+
+  it('creates and finds wallets', async () => {
+    const wallet: Wallet = {
+      id: 'wallet-1',
+      leagueId: 'league-1',
+      balance: 0,
+      totalRevenue: 0,
+      totalPlatformFees: 0,
+      totalWithdrawn: 0,
+      currency: 'USD',
+      createdAt: new Date('2025-01-01T00:00:00.000Z'),
+    };
+
+    await walletRepo.create(wallet);
+
+    expect((await walletRepo.findById('wallet-1'))?.id).toBe('wallet-1');
+    expect((await walletRepo.findByLeagueId('league-1'))?.id).toBe('wallet-1');
+
+    const updated = await walletRepo.update({ ...wallet, balance: 10 });
+    expect(updated.balance).toBe(10);
+  });
+
+  it('creates and queries transactions', async () => {
+    const tx: Transaction = {
+      id: 'tx-1',
+      walletId: 'wallet-2',
+      type: TransactionType.DEPOSIT,
+      amount: 25,
+      description: 'Test deposit',
+      createdAt: new Date('2025-01-02T00:00:00.000Z'),
+    };
+
+    await txRepo.create(tx);
+
+    expect((await txRepo.findById('tx-1'))?.id).toBe('tx-1');
+    expect((await txRepo.findByWalletId('wallet-2')).map(t => t.id)).toContain('tx-1');
+  });
+});