diff --git a/app/components/scoring/NbaBracketLayout.tsx b/app/components/scoring/NbaBracketLayout.tsx index f446ab8..167925f 100644 --- a/app/components/scoring/NbaBracketLayout.tsx +++ b/app/components/scoring/NbaBracketLayout.tsx @@ -108,6 +108,8 @@ export function NbaBracketLayout({ ownershipMap={ownershipMap} userParticipantIds={userParticipantIds} firstScoringRoundIdx={scoringRoundIdx} + feeders={feeders} + template={template} /> diff --git a/app/components/scoring/__tests__/NbaBracketLayout.test.tsx b/app/components/scoring/__tests__/NbaBracketLayout.test.tsx new file mode 100644 index 0000000..17e213e --- /dev/null +++ b/app/components/scoring/__tests__/NbaBracketLayout.test.tsx @@ -0,0 +1,116 @@ +import { describe, it, expect } from "vitest"; +import { render, within } from "@testing-library/react"; +import { NbaBracketLayout } from "../NbaBracketLayout"; +import { buildFeederMap } from "~/lib/bracket-layout"; +import type { BracketTemplate } from "~/lib/bracket-templates"; +import type { BracketMatch } from "../BracketTreeView"; + +/** + * NbaBracketLayout renders a desktop view and a mobile pager side by side, hidden from + * each other by Tailwind breakpoints. Both need `feeders` and `template` — without them + * bracketGeometry falls back to index-derived positions and an unplayed slot reads "TBD" + * where the feeder graph would name the game it is waiting on. + */ + +const TEMPLATE: BracketTemplate = { + id: "test_conf_4", + name: "Two-conference test bracket", + totalTeams: 4, + scoringStartsAtRound: "Final", + rounds: [ + { name: "Semis", matchCount: 2, feedsInto: "Final", isScoring: false }, + { name: "Final", matchCount: 1, feedsInto: null, isScoring: true }, + ], + conferenceGroups: [ + { name: "East", roundMatchNumbers: { Semis: [1] } }, + { name: "West", roundMatchNumbers: { Semis: [2] } }, + ], +}; + +const ROUNDS = ["Semis", "Final"]; + +function match( + round: string, + matchNumber: number, + overrides: Partial = {} +): BracketMatch { + return { + id: `${round}-${matchNumber}`, + round, + matchNumber, + participant1Id: null, + participant2Id: null, + winnerId: null, + loserId: null, + isComplete: false, + participant1Score: null, + participant2Score: null, + ...overrides, + } as BracketMatch; +} + +/** Semis are played; the Final's two slots are still empty. */ +const MATCHES_BY_ROUND = new Map([ + [ + "Semis", + [ + match("Semis", 1, { participant1Id: "p1", participant2Id: "p2" }), + match("Semis", 2, { participant1Id: "p3", participant2Id: "p4" }), + ], + ], + ["Final", [match("Final", 1)]], +]); + +function renderLayout(withGraph: boolean) { + const { container } = render( + + ); + + // Both panes render in jsdom — media queries are class-based, not applied — so scope + // each assertion to the pane it is about. + const mobile = container.querySelector(".md\\:hidden"); + const desktop = container.querySelector(".md\\:flex"); + if (!mobile || !desktop) throw new Error("Expected both a mobile and a desktop pane"); + return { mobile, desktop }; +} + +describe("NbaBracketLayout", () => { + it("names the feeding game in the mobile pager", () => { + // Only slots filled by advancement get a label; a directly seeded slot with no + // participant still reads "TBD", which is why this asserts on the Final's slots. + const { mobile } = renderLayout(true); + + expect(within(mobile).getAllByText(/Winner of/).length).toBe(2); + }); + + it("shows the mobile pager the same slot labels as the desktop view", () => { + const { mobile, desktop } = renderLayout(true); + + const labels = (pane: HTMLElement) => + within(pane) + .getAllByText(/Winner of/) + .map((el) => el.textContent) + .toSorted(); + + expect(labels(mobile)).toEqual(labels(desktop)); + }); + + it("falls back to TBD when the feeder graph is unavailable", () => { + // Guards the assertions above: without feeders/template there is nothing to name a + // slot with, which is exactly the state the mobile pane was stuck in. + const { mobile } = renderLayout(false); + + expect(within(mobile).queryByText(/Winner of/)).toBeNull(); + expect(within(mobile).getAllByText("TBD").length).toBeGreaterThan(0); + }); +}); diff --git a/app/models/participant-result.ts b/app/models/participant-result.ts index 4e36257..6da1065 100644 --- a/app/models/participant-result.ts +++ b/app/models/participant-result.ts @@ -1,4 +1,4 @@ -import { eq, and } from "drizzle-orm"; +import { eq, and, inArray } from "drizzle-orm"; import { database } from "~/database/context"; import * as schema from "~/database/schema"; @@ -104,6 +104,33 @@ export async function deleteParticipantResultsBySportsSeasonId( .where(eq(schema.seasonParticipantResults.sportsSeasonId, sportsSeasonId)); } +/** + * Delete the results of specific participants within one sports season. + * + * The season-wide delete above is too blunt for a single bracket: results are keyed by + * sports season, not by event, so wiping the season takes every other event's placements + * with it. Scoping to the participants a bracket actually holds lets reprocess-bracket + * rebuild that bracket from scratch while leaving the rest of the season alone. + * + * No-ops on an empty id list — `inArray` with no values is not a valid SQL predicate. + */ +export async function deleteParticipantResultsForParticipants( + sportsSeasonId: string, + participantIds: string[], + providedDb?: ReturnType +): Promise { + if (participantIds.length === 0) return; + const db = providedDb || database(); + await db + .delete(schema.seasonParticipantResults) + .where( + and( + eq(schema.seasonParticipantResults.sportsSeasonId, sportsSeasonId), + inArray(schema.seasonParticipantResults.participantId, participantIds) + ) + ); +} + /** * Set result for a participant in a sports season * Points are calculated on-demand based on each fantasy league's scoring rules diff --git a/app/routes/__tests__/admin.sports-seasons.bracket.generate.test.ts b/app/routes/__tests__/admin.sports-seasons.bracket.generate.test.ts new file mode 100644 index 0000000..2c84ccc --- /dev/null +++ b/app/routes/__tests__/admin.sports-seasons.bracket.generate.test.ts @@ -0,0 +1,203 @@ +/** + * generate-bracket banks the floors a seeding guarantees before anyone plays (an AFL + * top-4 seed cannot finish below the 5th-6th tier). Those floors only reach + * teamStandings.totalPoints through a standings recalculation, so the action has to be + * sure one ran — markEliminatedAndAnnounce runs one for its Discord announcement in some + * cases but not others. + */ + +import { beforeEach, describe, expect, it, vi } from "vitest"; +import { generateBracketFromTemplate } from "~/models/playoff-match"; +import { + findParticipantResultsBySportsSeasonId, + setParticipantResult, +} from "~/models/participant-result"; +import { + applyBracketEntryFloors, + recalculateAffectedLeagues, +} from "~/models/scoring-calculator"; +import { getScoringEventById, updateScoringEvent } from "~/models/scoring-event"; +import { findParticipantsBySportsSeasonId } from "~/models/season-participant"; +import { action } from "../admin.sports-seasons.$id.events.$eventId.bracket.server"; + +vi.mock("~/database/context", () => ({ database: vi.fn(() => ({})) })); +vi.mock("~/models/scoring-event", async (importOriginal) => ({ + ...(await importOriginal()), + getScoringEventById: vi.fn(), + updateScoringEvent: vi.fn(), + isReadOnlySibling: vi.fn(() => false), +})); +vi.mock("~/models/playoff-match", async (importOriginal) => ({ + ...(await importOriginal()), + generateBracketFromTemplate: vi.fn(), +})); +vi.mock("~/models/participant-result", async (importOriginal) => ({ + ...(await importOriginal()), + findParticipantResultsBySportsSeasonId: vi.fn(), + setParticipantResult: vi.fn(), +})); +vi.mock("~/models/scoring-calculator", async (importOriginal) => ({ + ...(await importOriginal()), + applyBracketEntryFloors: vi.fn(), + recalculateAffectedLeagues: vi.fn(), +})); +vi.mock("~/models/season-participant", async (importOriginal) => ({ + ...(await importOriginal()), + findParticipantsBySportsSeasonId: vi.fn(), +})); + +const params = { id: "season-1", eventId: "event-1" }; + +const EVENT = { + id: "event-1", + name: "AFL Finals", + sportsSeasonId: "season-1", + isQualifyingEvent: false, + bracketTemplateId: "afl_10", +}; + +/** afl_10 takes exactly 10 seeded participants. */ +const SEEDED = Array.from({ length: 10 }, (_, i) => `seed-${i + 1}`); + +function generateRequest(): Request { + const body = new FormData(); + body.set("intent", "generate-bracket"); + body.set("templateId", "afl_10"); + SEEDED.forEach((id, i) => body.set(`participant${i}`, id)); + return new Request("http://localhost/generate", { method: "POST", body }); +} + +const run = (request: Request) => + (action as unknown as (args: { request: Request; params: typeof params }) => Promise<{ + error?: string; + success?: string; + }>)({ request, params }); + +/** + * @param extras participants in the season beyond the 10 seeded into the bracket — + * these are the ones generate-bracket marks eliminated. + * @param withExistingResults ids that already carry a result row, so + * markEliminatedAndAnnounce treats them as not newly eliminated. + */ +function setSeason(extras: string[], withExistingResults: string[] = []) { + vi.mocked(findParticipantsBySportsSeasonId).mockResolvedValue( + [...SEEDED, ...extras].map((id) => ({ id })) as unknown as Awaited< + ReturnType + > + ); + vi.mocked(findParticipantResultsBySportsSeasonId).mockResolvedValue( + withExistingResults.map((participantId) => ({ participantId })) as unknown as Awaited< + ReturnType + > + ); +} + +describe("generate-bracket entry-floor standings recalculation", () => { + beforeEach(() => { + vi.clearAllMocks(); + vi.mocked(getScoringEventById).mockResolvedValue( + EVENT as unknown as Awaited> + ); + vi.mocked(generateBracketFromTemplate).mockResolvedValue( + undefined as unknown as Awaited> + ); + vi.mocked(updateScoringEvent).mockResolvedValue( + undefined as unknown as Awaited> + ); + vi.mocked(setParticipantResult).mockResolvedValue( + undefined as unknown as Awaited> + ); + vi.mocked(recalculateAffectedLeagues).mockResolvedValue( + undefined as unknown as Awaited> + ); + // afl_10 seeds 1-4 into the Qualifying Finals, whose entry floor is the 5th-6th tier. + vi.mocked(applyBracketEntryFloors).mockResolvedValue(4); + }); + + it("recalculates when every eliminated team already had a result row", async () => { + // The second run of a generation: the first wrote position 0 for the non-bracket + // participants, so nobody is *newly* eliminated and the announcement is skipped. + // The floors banked moments ago would never reach the standings. + setSeason(["extra-1"], ["extra-1"]); + + const result = await run(generateRequest()); + + expect(result.success).toBeDefined(); + expect(recalculateAffectedLeagues).toHaveBeenCalledTimes(1); + expect(recalculateAffectedLeagues).toHaveBeenCalledWith( + "season-1", + expect.anything(), + expect.objectContaining({ skipDiscord: true }) + ); + }); + + it("recalculates for a qualifying event, which never announces eliminations", async () => { + vi.mocked(getScoringEventById).mockResolvedValue( + { ...EVENT, isQualifyingEvent: true } as unknown as Awaited< + ReturnType + > + ); + setSeason(["extra-1"]); + + await run(generateRequest()); + + expect(recalculateAffectedLeagues).toHaveBeenCalledTimes(1); + expect(recalculateAffectedLeagues).toHaveBeenCalledWith( + "season-1", + expect.anything(), + expect.objectContaining({ skipDiscord: true }) + ); + }); + + it("recalculates when the bracket field is the whole season", async () => { + setSeason([]); + + await run(generateRequest()); + + expect(recalculateAffectedLeagues).toHaveBeenCalledTimes(1); + }); + + it("recalculates when the elimination announcement threw", async () => { + // The announcement is best-effort and its failure is swallowed — but a failed recalc + // is exactly when the floors still need one. + setSeason(["extra-1"]); + vi.mocked(recalculateAffectedLeagues) + .mockRejectedValueOnce(new Error("discord down")) + .mockResolvedValue(undefined as unknown as Awaited>); + + const result = await run(generateRequest()); + + expect(result.success).toBeDefined(); + expect(recalculateAffectedLeagues).toHaveBeenCalledTimes(2); + expect(recalculateAffectedLeagues).toHaveBeenLastCalledWith( + "season-1", + expect.anything(), + expect.objectContaining({ skipDiscord: true }) + ); + }); + + it("does not recalculate twice when the announcement already did", async () => { + setSeason(["extra-1"]); + + await run(generateRequest()); + + expect(recalculateAffectedLeagues).toHaveBeenCalledTimes(1); + // The announcing call, not the floor fallback. + expect(recalculateAffectedLeagues).toHaveBeenCalledWith( + "season-1", + expect.anything(), + expect.objectContaining({ eliminatedParticipantIds: ["extra-1"] }) + ); + }); + + it("does not recalculate at all when no floors were banked", async () => { + // A template that guarantees nothing at seeding: no floors, nobody to eliminate, + // so there is nothing for a recalculation to pick up. + vi.mocked(applyBracketEntryFloors).mockResolvedValue(0); + setSeason([]); + + await run(generateRequest()); + + expect(recalculateAffectedLeagues).not.toHaveBeenCalled(); + }); +}); diff --git a/app/routes/__tests__/admin.sports-seasons.bracket.reprocess.test.ts b/app/routes/__tests__/admin.sports-seasons.bracket.reprocess.test.ts new file mode 100644 index 0000000..a7101de --- /dev/null +++ b/app/routes/__tests__/admin.sports-seasons.bracket.reprocess.test.ts @@ -0,0 +1,208 @@ +/** + * reprocess-bracket rebuilds a bracket's placements from scratch. What it wipes first + * decides whether the clear-bracket → regenerate → reprocess repair path actually works, + * and whether it takes the rest of the season's placements down with it. + */ + +import { beforeEach, describe, expect, it, vi } from "vitest"; +import { findPlayoffMatchesByEventId } from "~/models/playoff-match"; +import { + deleteParticipantResultsBySportsSeasonId, + deleteParticipantResultsForParticipants, + setParticipantResult, +} from "~/models/participant-result"; +import { + applyBracketEntryFloors, + processMatchResult, + processQualifyingBracketEvent, + recalculateAffectedLeagues, +} from "~/models/scoring-calculator"; +import { getScoringEventById } from "~/models/scoring-event"; +import { findParticipantsBySportsSeasonId } from "~/models/season-participant"; +import { findSportsSeasonById } from "~/models/sports-season"; +import { action } from "../admin.sports-seasons.$id.events.$eventId.bracket.server"; + +vi.mock("~/database/context", () => ({ database: vi.fn(() => ({})) })); +vi.mock("~/models/scoring-event", async (importOriginal) => ({ + ...(await importOriginal()), + getScoringEventById: vi.fn(), + updateScoringEvent: vi.fn(), + isReadOnlySibling: vi.fn(() => false), +})); +vi.mock("~/models/playoff-match", async (importOriginal) => ({ + ...(await importOriginal()), + findPlayoffMatchesByEventId: vi.fn(), +})); +vi.mock("~/models/participant-result", async (importOriginal) => ({ + ...(await importOriginal()), + deleteParticipantResultsBySportsSeasonId: vi.fn(), + deleteParticipantResultsForParticipants: vi.fn(), + setParticipantResult: vi.fn(), +})); +vi.mock("~/models/scoring-calculator", async (importOriginal) => ({ + ...(await importOriginal()), + applyBracketEntryFloors: vi.fn(), + processMatchResult: vi.fn(), + recalculateAffectedLeagues: vi.fn(), + processQualifyingBracketEvent: vi.fn(), + finalizeQualifyingPoints: vi.fn(), +})); +vi.mock("~/models/season-participant", async (importOriginal) => ({ + ...(await importOriginal()), + findParticipantsBySportsSeasonId: vi.fn(), +})); +vi.mock("~/models/sports-season", async (importOriginal) => ({ + ...(await importOriginal()), + findSportsSeasonById: vi.fn(), +})); + +const params = { id: "season-1", eventId: "event-1" }; + +const EVENT = { + id: "event-1", + name: "AFL Finals", + sportsSeasonId: "season-1", + isQualifyingEvent: false, + isPrimary: false, + tournamentId: null, + bracketTemplateId: "afl_10", +}; + +function reprocessRequest(): Request { + const body = new FormData(); + body.set("intent", "reprocess-bracket"); + return new Request("http://localhost/reprocess", { method: "POST", body }); +} + +/** A seeded, unplayed bracket slot. */ +function slot(matchNumber: number, participant1Id: string, participant2Id: string) { + return { + id: `m-${matchNumber}`, + round: "Qualifying Finals", + matchNumber, + participant1Id, + participant2Id, + winnerId: null, + loserId: null, + isComplete: false, + isScoring: true, + }; +} + +const run = (request: Request) => + (action as unknown as (args: { request: Request; params: typeof params }) => Promise<{ + error?: string; + success?: string; + }>)({ request, params }); + +function setEvent(overrides: Partial = {}) { + vi.mocked(getScoringEventById).mockResolvedValue( + { ...EVENT, ...overrides } as unknown as Awaited> + ); +} + +function setMatches(matches: ReturnType[]) { + vi.mocked(findPlayoffMatchesByEventId).mockResolvedValue( + matches as unknown as Awaited> + ); +} + +describe("reprocess-bracket", () => { + beforeEach(() => { + vi.clearAllMocks(); + setEvent(); + vi.mocked(applyBracketEntryFloors).mockResolvedValue(4); + vi.mocked(findParticipantsBySportsSeasonId).mockResolvedValue( + [] as unknown as Awaited> + ); + vi.mocked(setParticipantResult).mockResolvedValue( + undefined as unknown as Awaited> + ); + vi.mocked(recalculateAffectedLeagues).mockResolvedValue( + undefined as unknown as Awaited> + ); + vi.mocked(processMatchResult).mockResolvedValue( + undefined as unknown as Awaited> + ); + vi.mocked(processQualifyingBracketEvent).mockResolvedValue( + undefined as unknown as Awaited> + ); + vi.mocked(findSportsSeasonById).mockResolvedValue( + { qualifyingPointsFinalized: false } as unknown as Awaited< + ReturnType + > + ); + }); + + it("clears placements even when no match has been played", async () => { + // The clear-bracket → regenerate → reprocess repair path lands here: the freshly + // re-seeded bracket has nothing completed, yet the discarded bracket's finalized + // placements are exactly what has to go. Skipping the wipe leaves them permanently, + // because upsertParticipantResult refuses to un-finalize a result. + setMatches([slot(1, "p1", "p2"), slot(2, "p3", "p4")]); + + const result = await run(reprocessRequest()); + + expect(result.success).toBeDefined(); + expect(deleteParticipantResultsForParticipants).toHaveBeenCalledTimes(1); + const [sportsSeasonId, ids] = vi.mocked(deleteParticipantResultsForParticipants).mock.calls[0]; + expect(sportsSeasonId).toBe("season-1"); + expect([...ids].toSorted()).toEqual(["p1", "p2", "p3", "p4"]); + }); + + it("scopes the wipe to this bracket, never the whole season", async () => { + // A season-wide delete would take every other event's placements with it, with only + // this bracket's replay able to rebuild them. + setMatches([slot(1, "p1", "p2")]); + + await run(reprocessRequest()); + + expect(deleteParticipantResultsBySportsSeasonId).not.toHaveBeenCalled(); + const [, ids] = vi.mocked(deleteParticipantResultsForParticipants).mock.calls[0]; + expect(ids).not.toContain("p3"); + }); + + it("passes each participant once when a team appears in more than one slot", async () => { + setMatches([slot(1, "p1", "p2"), slot(2, "p1", "p3")]); + + await run(reprocessRequest()); + + const [, ids] = vi.mocked(deleteParticipantResultsForParticipants).mock.calls[0]; + expect(ids).toHaveLength(3); + expect([...ids].toSorted()).toEqual(["p1", "p2", "p3"]); + }); + + it("skips empty slots rather than passing nulls through", async () => { + setMatches([ + { ...slot(1, "p1", "p2"), participant2Id: null as unknown as string }, + ]); + + await run(reprocessRequest()); + + const [, ids] = vi.mocked(deleteParticipantResultsForParticipants).mock.calls[0]; + expect(ids).toEqual(["p1"]); + }); + + it("still takes the season-wide delete for a qualifying event", async () => { + // Qualifying seasons have no legitimate per-major fantasy placements — those come + // from finalizeQualifyingPoints across all majors — so that path wipes the season + // on purpose and rebuilds QP from the bracket. + setEvent({ isQualifyingEvent: true }); + setMatches([slot(1, "p1", "p2")]); + + await run(reprocessRequest()); + + expect(deleteParticipantResultsBySportsSeasonId).toHaveBeenCalledWith("season-1", {}); + expect(deleteParticipantResultsForParticipants).not.toHaveBeenCalled(); + }); + + it("rejects an event with no bracket rather than wiping anything", async () => { + setMatches([]); + + const result = await run(reprocessRequest()); + + expect(result.error).toContain("No bracket to reprocess"); + expect(deleteParticipantResultsForParticipants).not.toHaveBeenCalled(); + expect(deleteParticipantResultsBySportsSeasonId).not.toHaveBeenCalled(); + }); +}); diff --git a/app/routes/admin.sports-seasons.$id.events.$eventId.bracket.server.ts b/app/routes/admin.sports-seasons.$id.events.$eventId.bracket.server.ts index fcae69b..bb8c04e 100644 --- a/app/routes/admin.sports-seasons.$id.events.$eventId.bracket.server.ts +++ b/app/routes/admin.sports-seasons.$id.events.$eventId.bracket.server.ts @@ -44,6 +44,7 @@ import { setParticipantResult, findParticipantResultsBySportsSeasonId, deleteParticipantResultsBySportsSeasonId, + deleteParticipantResultsForParticipants, } from "~/models/participant-result"; import { findSeasonSportsBySportsSeasonId } from "~/models/season-sport"; import { createDailySnapshot } from "~/models/standings"; @@ -171,7 +172,7 @@ async function scoreQualifyingBracket( /** * Mark the given participants as eliminated (finalPosition = 0) and, for fantasy * (non-qualifying) events, announce the teams newly eliminated by this run to the - * affected leagues' Discord channels. Returns the number of participants marked. + * affected leagues' Discord channels. * * "Newly eliminated" = participants with no prior result row, so re-running a * generation step never re-announces the same teams. The announcement is a @@ -179,11 +180,18 @@ async function scoreQualifyingBracket( * the eliminations themselves are already committed. eventId is deliberately * omitted from the recalc call so the announcement doesn't pull in unrelated * completed matches as "Scored Matches". + * + * Returns the number of participants marked alongside whether a standings recalculation + * actually ran. The caller banks entry floors before calling this and needs them to + * reach teamStandings.totalPoints; it cannot infer that from the participant count, + * because the recalc is skipped for qualifying events, when every eliminated team + * already had a result row (the second run of a generation), and when the announcement + * threw. `recalculated` reports the fact rather than making the caller re-derive it. */ async function markEliminatedAndAnnounce( event: { id: string; name: string | null; sportsSeasonId: string; isQualifyingEvent: boolean }, participantIds: string[] -): Promise { +): Promise<{ markedCount: number; recalculated: boolean }> { const existingResults = await findParticipantResultsBySportsSeasonId(event.sportsSeasonId); const alreadyHadResult = new Set(existingResults.map((r) => r.participantId)); const newlyEliminatedIds = participantIds.filter((id) => !alreadyHadResult.has(id)); @@ -192,6 +200,8 @@ async function markEliminatedAndAnnounce( await setParticipantResult(participantId, event.sportsSeasonId, 0); } + let recalculated = false; + // QPs (e.g. tennis/CS2 majors) don't get elimination announcements. if (!event.isQualifyingEvent && newlyEliminatedIds.length > 0) { try { @@ -199,12 +209,13 @@ async function markEliminatedAndAnnounce( eventName: event.name ?? undefined, eliminatedParticipantIds: newlyEliminatedIds, }); + recalculated = true; } catch (err) { logger.error("[Eliminations] Discord announcement failed:", err); } } - return participantIds.length; + return { markedCount: participantIds.length, recalculated }; } export async function action({ request, params }: Route.ActionArgs) { @@ -423,14 +434,17 @@ export async function action({ request, params }: Route.ActionArgs) { const toEliminate = allParticipants .filter((p) => !participantsInBracket.has(p.id)) .map((p) => p.id); - const eliminatedCount = await markEliminatedAndAnnounce(event, toEliminate); - logger.log(`[BracketGeneration] Marked ${eliminatedCount} participants as eliminated`); + const { markedCount, recalculated } = await markEliminatedAndAnnounce(event, toEliminate); + logger.log(`[BracketGeneration] Marked ${markedCount} participants as eliminated`); - // markEliminatedAndAnnounce recalculates standings only when it actually - // eliminated somebody. When the bracket field is the whole season (nothing to - // eliminate) the entry floors above would never reach teamStandings.totalPoints, - // so recalculate here. skipDiscord: seeding floors are not a result to announce. - if (toEliminate.length === 0 && entryFloorCount > 0) { + // The floors banked above only reach teamStandings.totalPoints via a recalc, and + // markEliminatedAndAnnounce runs one for its announcement in some cases but not + // others: not for a qualifying event, not when every eliminated team already had + // a result row (the second run of a generation, since the first wrote 0 for all + // of them), not when there was nobody to eliminate, and not when the announcement + // threw. Drive off what it reports rather than re-deriving it from toEliminate. + // skipDiscord: seeding floors are not a result to announce. + if (entryFloorCount > 0 && !recalculated) { await recalculateAffectedLeagues(event.sportsSeasonId, database(), { eventName: event.name ?? undefined, skipDiscord: true, @@ -910,19 +924,31 @@ export async function action({ request, params }: Route.ActionArgs) { return { error: "No bracket to reprocess" }; } - // Delete ALL results for this sports season and rebuild from scratch. - // Only deleting partial rows leaves stale finalized rows that block - // the "never un-finalize" guard in upsertParticipantResult. + // Wipe this bracket's participants' results and rebuild from scratch. Deleting + // only the partial rows would leave stale finalized ones, which the "never + // un-finalize" guard in upsertParticipantResult then refuses to correct. // - // seasonParticipantResults is keyed by sports season, not by event, so this - // wipes every event's placements in the season and only the replay below can - // rebuild them (the same hazard clear-bracket documents). With nothing to - // replay there is nothing to rebuild from, so skip it entirely: applying entry - // floors and re-marking eliminations below is additive and needs no wipe. + // Scoped to the participants this bracket actually holds, not the whole season: + // seasonParticipantResults is keyed by sports season, not by event, so a + // season-wide delete takes every other event's placements with it and only this + // bracket's replay could rebuild them (the hazard clear-bracket documents). + // + // Unconditional, because zero completed matches is precisely the clear-bracket → + // regenerate → reprocess repair path: the discarded bracket's finalized + // placements are exactly what needs clearing, and there is always something to + // rebuild from — the entry floors below, then the replay. const db = database(); - if (completed.length > 0) { - await deleteParticipantResultsBySportsSeasonId(event.sportsSeasonId, db); + // Reused further down to decide who is *not* in the bracket and so eliminated. + const bracketParticipantIds = new Set(); + for (const match of matches) { + if (match.participant1Id) bracketParticipantIds.add(match.participant1Id); + if (match.participant2Id) bracketParticipantIds.add(match.participant2Id); } + await deleteParticipantResultsForParticipants( + event.sportsSeasonId, + [...bracketParticipantIds], + db + ); // Re-bank the seeding-derived floors the delete above wipes (e.g. the AFL // top-4's 5th-6th tier). Done before the replay so real match results overwrite @@ -968,11 +994,6 @@ export async function action({ request, params }: Route.ActionArgs) { // Mark participants NOT in any bracket match as eliminated (finalPosition = 0). // This covers teams that didn't make the playoffs/play-in tournament. const allParticipants = await findParticipantsBySportsSeasonId(params.id); - const bracketParticipantIds = new Set(); - for (const match of matches) { - if (match.participant1Id) bracketParticipantIds.add(match.participant1Id); - if (match.participant2Id) bracketParticipantIds.add(match.participant2Id); - } let eliminatedCount = 0; for (const participant of allParticipants) { if (!bracketParticipantIds.has(participant.id)) { @@ -1178,7 +1199,10 @@ export async function action({ request, params }: Route.ActionArgs) { const toEliminate = allParticipants .filter((p) => !uniqueParticipants.has(p.id)) .map((p) => p.id); - const eliminatedCount = await markEliminatedAndAnnounce(groupsEvent, toEliminate); + const { markedCount: eliminatedCount } = await markEliminatedAndAnnounce( + groupsEvent, + toEliminate + ); return { success: `Groups and knockout bracket structure created successfully${eliminatedCount > 0 ? ` (${eliminatedCount} participant(s) not in any group marked as eliminated)` : ""}`,