Feature/bulk refunds

apps/api/src/database/types.ts

@@ -223,6 +223,18 @@ export type PaymentRowWithDetails = WithCompositions<
 	{ paymentDetails: RegistrationFeeRow[] }
 >
 
+export type PaymentWithPlayerDetails = {
+	paymentId: number
+	paymentCode: string
+	paymentAmount: string
+	playerName: string
+	fees: {
+		registrationFeeId: number
+		amount: string
+		isPaid: number
+	}[]
+}
+
 // =============================================================================
 // Common Composition Patterns - Scores
 // =============================================================================

apps/api/src/registration/controllers/admin-registration.controller.ts

@@ -1,3 +1,6 @@
+import { Observable } from "rxjs"
+import { map } from "rxjs/operators"
+
 import {
 	Body,
 	Controller,
@@ -8,10 +11,12 @@ import {
 	ParseIntPipe,
 	Post,
 	Query,
+	Sse,
 } from "@nestjs/common"
 import type {
 	AdminRegistration,
 	AvailableSlotGroup,
+	BulkRefundPreview,
 	RefundRequest,
 	PlayerQuery,
 	RegisteredPlayer,
@@ -27,6 +32,7 @@ import type {
 
 import { Admin } from "../../auth"
 import { AdminRegistrationService } from "../services/admin-registration.service"
+import { BulkRefundProgressTracker } from "../services/bulk-refund-progress-tracker"
 import { PlayerService } from "../services/player.service"
 import { RefundService } from "../services/refund.service"
 import { RegistrationService } from "../services/registration.service"
@@ -42,6 +48,7 @@ export class AdminRegistrationController {
 		@Inject(PlayerService) private readonly adminRegisterService: PlayerService,
 		@Inject(RefundService) private readonly refundService: RefundService,
 		@Inject(RegistrationService) private readonly registrationService: RegistrationService,
+		@Inject(BulkRefundProgressTracker) private readonly progressTracker: BulkRefundProgressTracker,
 	) {}
 
 	@Get("players")
@@ -189,4 +196,34 @@ export class AdminRegistrationController {
 		await this.refundService.processRefunds(refundRequests, issuerId)
 		return { success: true }
 	}
+
+	@Get(":eventId/bulk-refund-preview")
+	async getBulkRefundPreview(
+		@Param("eventId", ParseIntPipe) eventId: number,
+	): Promise<BulkRefundPreview> {
+		return this.refundService.getBulkRefundPreview(eventId)
+	}
+
+	@Sse(":eventId/bulk-refund")
+	bulkRefund(@Param("eventId", ParseIntPipe) eventId: number): Observable<{ data: string }> {
+		// Check if operation is already running
+		const existing = this.progressTracker.getProgressObservable(eventId)
+		if (existing) {
+			return existing.pipe(
+				map((progress) => ({
+					data: JSON.stringify(progress),
+				})),
+			)
+		}
+
+		// Start new bulk refund and return progress stream
+		const issuerId = 1 // TODO: change issuer to a string
+		const observable = this.refundService.processBulkRefundsStream(eventId, issuerId)
+
+		return observable.pipe(
+			map((progress) => ({
+				data: JSON.stringify(progress),
+			})),
+		)
+	}
 }

apps/api/src/registration/index.ts

@@ -11,6 +11,7 @@ export { PaymentsService } from "./services/payments.service"
 export { RegistrationService } from "./services/registration.service"
 export { CleanupService } from "./services/cleanup.service"
 export { RefundService } from "./services/refund.service"
+export { BulkRefundProgressTracker } from "./services/bulk-refund-progress-tracker"
 export { RegistrationRepository } from "./repositories/registration.repository"
 export { PaymentsRepository } from "./repositories/payments.repository"
 export { RegistrationCleanupCron } from "./cron/registration-cleanup.cron"

apps/api/src/registration/registration.module.ts

@@ -21,6 +21,7 @@ import {
 	RefundService,
 	PlayerService,
 	CleanupService,
+	BulkRefundProgressTracker,
 } from "./"
 
 @Module({
@@ -39,6 +40,7 @@ import {
 	],
 	providers: [
 		AdminRegistrationService,
+		BulkRefundProgressTracker,
 		CleanupService,
 		PaymentsRepository,
 		PaymentsService,
@@ -52,6 +54,7 @@ import {
 	],
 	exports: [
 		AdminRegistrationService,
+		BulkRefundProgressTracker,
 		CleanupService,
 		PaymentsService,
 		PlayerService,

apps/api/src/registration/repositories/payments.repository.ts

@@ -1,11 +1,13 @@
-import { eq, inArray } from "drizzle-orm"
+import { and, eq, inArray, like } from "drizzle-orm"
 
 import { Inject, Injectable } from "@nestjs/common"
 
 import {
 	DrizzleService,
 	payment,
 	PaymentRowWithDetails,
+	PaymentWithPlayerDetails,
+	player,
 	refund,
 	registrationFee,
 	registrationSlot,
@@ -70,6 +72,62 @@ export class PaymentsRepository {
 		}
 	}
 
+	async findConfirmedPaymentsByEventWithDetails(
+		eventId: number,
+	): Promise<PaymentWithPlayerDetails[]> {
+		const results = await this.drizzle.db
+			.select({
+				paymentId: payment.id,
+				paymentCode: payment.paymentCode,
+				paymentAmount: payment.paymentAmount,
+				playerFirstName: player.firstName,
+				playerLastName: player.lastName,
+				registrationFeeId: registrationFee.id,
+				feeAmount: registrationFee.amount,
+				isPaid: registrationFee.isPaid,
+			})
+			.from(payment)
+			.innerJoin(registrationFee, eq(payment.id, registrationFee.paymentId))
+			.innerJoin(registrationSlot, eq(registrationFee.registrationSlotId, registrationSlot.id))
+			.innerJoin(player, eq(registrationSlot.playerId, player.id))
+			.where(
+				and(
+					eq(payment.eventId, eventId),
+					eq(payment.confirmed, 1),
+					like(payment.paymentCode, "pi_%"),
+				),
+			)
+
+		// Group by payment ID
+		const paymentsMap = new Map<number, PaymentWithPlayerDetails>()
+		for (const row of results) {
+			const existing = paymentsMap.get(row.paymentId)
+			if (existing) {
+				existing.fees.push({
+					registrationFeeId: row.registrationFeeId,
+					amount: row.feeAmount,
+					isPaid: row.isPaid,
+				})
+			} else {
+				paymentsMap.set(row.paymentId, {
+					paymentId: row.paymentId,
+					paymentCode: row.paymentCode,
+					paymentAmount: row.paymentAmount,
+					playerName: `${row.playerFirstName} ${row.playerLastName}`,
+					fees: [
+						{
+							registrationFeeId: row.registrationFeeId,
+							amount: row.feeAmount,
+							isPaid: row.isPaid,
+						},
+					],
+				})
+			}
+		}
+
+		return Array.from(paymentsMap.values())
+	}
+
 	async createPayment(data: PaymentInsert): Promise<number> {
 		const [result] = await this.drizzle.db.insert(payment).values(data)
 		return Number(result.insertId)

apps/api/src/registration/services/bulk-refund-progress-tracker.ts

@@ -0,0 +1,122 @@
+import { Observable, Subject } from "rxjs"
+
+import { Injectable, Logger } from "@nestjs/common"
+import { BulkRefundProgressEvent, BulkRefundResponse } from "@repo/domain/types"
+
+const PROGRESS_CLEANUP_MS = 5 * 60 * 1000 // 5 minutes
+
+@Injectable()
+export class BulkRefundProgressTracker {
+	private readonly logger = new Logger(BulkRefundProgressTracker.name)
+
+	private readonly activeOperations = new Map<number, Subject<BulkRefundProgressEvent>>()
+
+	/**
+	 * Start tracking a new bulk refund operation and return the progress subject
+	 */
+	startTracking(eventId: number): Subject<BulkRefundProgressEvent> {
+		if (this.activeOperations.has(eventId)) {
+			throw new Error(`Bulk refund operation already in progress for event ${eventId}`)
+		}
+
+		const subject = new Subject<BulkRefundProgressEvent>()
+		this.activeOperations.set(eventId, subject)
+
+		// Auto-cleanup after timeout
+		setTimeout(() => {
+			this.cleanupOperation(eventId)
+		}, PROGRESS_CLEANUP_MS)
+
+		return subject
+	}
+
+	/**
+	 * Get the progress observable for an active operation
+	 */
+	getProgressObservable(eventId: number): Observable<BulkRefundProgressEvent> | null {
+		return this.activeOperations.get(eventId)?.asObservable() ?? null
+	}
+
+	/**
+	 * Emit progress update for a payment being processed
+	 */
+	emitProgress(eventId: number, current: number, total: number, playerName: string): void {
+		const subject = this.activeOperations.get(eventId)
+		if (subject) {
+			subject.next({
+				status: "processing",
+				current,
+				total,
+				playerName,
+			})
+		}
+	}
+
+	/**
+	 * Mark operation as complete with final results
+	 */
+	completeOperation(eventId: number, result: BulkRefundResponse): void {
+		const subject = this.activeOperations.get(eventId)
+		if (subject) {
+			subject.next({
+				status: "complete",
+				current: result.refundedCount + result.failedCount,
+				total: result.refundedCount + result.failedCount + result.skippedCount,
+				result,
+			})
+		}
+
+		// Cleanup after short delay to allow final event to be sent
+		setTimeout(() => {
+			this.cleanupOperation(eventId)
+		}, 1000)
+	}
+
+	/**
+	 * Mark operation as failed with error
+	 */
+	errorOperation(eventId: number, error: string): void {
+		const subject = this.activeOperations.get(eventId)
+		if (subject) {
+			subject.next({
+				status: "error",
+				current: 0,
+				total: 0,
+				error,
+			})
+		}
+
+		// Cleanup after short delay
+		setTimeout(() => {
+			this.cleanupOperation(eventId)
+		}, 1000)
+	}
+
+	/**
+	 * Check if an operation is currently active
+	 */
+	isOperationActive(eventId: number): boolean {
+		return this.activeOperations.has(eventId)
+	}
+
+	/**
+	 * Clean up resources for an operation
+	 */
+	private cleanupOperation(eventId: number): void {
+		const subject = this.activeOperations.get(eventId)
+		if (subject) {
+			subject.complete()
+			this.activeOperations.delete(eventId)
+			this.logger.debug(`Cleaned up bulk refund operation for event ${eventId}`)
+		}
+	}
+
+	/**
+	 * Force cleanup of all operations (for testing/shutdown)
+	 */
+	cleanupAll(): void {
+		for (const eventId of this.activeOperations.keys()) {
+			this.cleanupOperation(eventId)
+		}
+	}
+}