570 lines
17 KiB
TypeScript
570 lines
17 KiB
TypeScript
import { superTokensAdminFunctionMiddleware } from "@/utils/supertokens";
|
|
import { createServerFn } from "@tanstack/react-start";
|
|
import { pbAdmin } from "@/lib/pocketbase/client";
|
|
import { logger } from "@/lib/logger";
|
|
import { z } from "zod";
|
|
import { toServerResult } from "@/lib/tanstack-query/utils/to-server-result";
|
|
import brackets from "@/features/bracket/utils";
|
|
import { Match, MatchInput } from "@/features/matches/types";
|
|
import { serverEvents } from "@/lib/events/emitter";
|
|
import { superTokensFunctionMiddleware } from "@/utils/supertokens";
|
|
import { PlayerInfo } from "../players/types";
|
|
import { serverFnLoggingMiddleware } from "@/utils/activities";
|
|
|
|
const orderedTeamsSchema = z.object({
|
|
tournamentId: z.string(),
|
|
orderedTeamIds: z.array(z.string()),
|
|
});
|
|
|
|
export const generateTournamentBracket = createServerFn()
|
|
.inputValidator(orderedTeamsSchema)
|
|
.middleware([superTokensAdminFunctionMiddleware, serverFnLoggingMiddleware])
|
|
.handler(async ({ data: { tournamentId, orderedTeamIds } }) =>
|
|
toServerResult(async () => {
|
|
logger.info("Generating tournament bracket", {
|
|
tournamentId,
|
|
teamCount: orderedTeamIds.length,
|
|
});
|
|
|
|
const tournament = await pbAdmin.getTournament(tournamentId);
|
|
if (!tournament) {
|
|
throw new Error("Tournament not found");
|
|
}
|
|
|
|
if (tournament.matches && tournament.matches.length > 0) {
|
|
throw new Error("Tournament already has matches generated");
|
|
}
|
|
|
|
const teamCount = orderedTeamIds.length;
|
|
if (!Object.keys(brackets).includes(teamCount.toString())) {
|
|
throw new Error(`Bracket not available for ${teamCount} teams`);
|
|
}
|
|
|
|
const bracketTemplate = brackets[
|
|
teamCount as keyof typeof brackets
|
|
] as any;
|
|
|
|
const seedToTeamId = new Map<number, string>();
|
|
orderedTeamIds.forEach((teamId, index) => {
|
|
seedToTeamId.set(index + 1, teamId);
|
|
});
|
|
|
|
const matchInputs: MatchInput[] = [];
|
|
|
|
bracketTemplate.winners.forEach((round: any[]) => {
|
|
round.forEach((match: any) => {
|
|
const matchInput: MatchInput = {
|
|
lid: match.lid,
|
|
round: match.round,
|
|
order: match.order || 0,
|
|
reset: match.reset || false,
|
|
bye: match.bye || false,
|
|
home_cups: 0,
|
|
away_cups: 0,
|
|
ot_count: 0,
|
|
home_from_lid: match.home_from_lid === null ? -1 : match.home_from_lid,
|
|
away_from_lid: match.away_from_lid === null ? -1 : match.away_from_lid,
|
|
home_from_loser: match.home_from_loser || false,
|
|
away_from_loser: match.away_from_loser || false,
|
|
is_losers_bracket: false,
|
|
status: "tbd",
|
|
tournament: tournamentId,
|
|
};
|
|
|
|
if (match.home_seed) {
|
|
const teamId = seedToTeamId.get(match.home_seed);
|
|
if (teamId) {
|
|
matchInput.home = teamId;
|
|
matchInput.home_seed = match.home_seed;
|
|
}
|
|
}
|
|
|
|
if (match.away_seed) {
|
|
const teamId = seedToTeamId.get(match.away_seed);
|
|
if (teamId) {
|
|
matchInput.away = teamId;
|
|
matchInput.away_seed = match.away_seed;
|
|
}
|
|
}
|
|
|
|
if (matchInput.home && matchInput.away) {
|
|
matchInput.status = "ready";
|
|
}
|
|
|
|
matchInputs.push(matchInput);
|
|
});
|
|
});
|
|
|
|
bracketTemplate.losers.forEach((round: any[]) => {
|
|
round.forEach((match: any) => {
|
|
const matchInput: MatchInput = {
|
|
lid: match.lid,
|
|
round: match.round,
|
|
order: match.order || 0,
|
|
reset: match.reset || false,
|
|
bye: match.bye || false,
|
|
home_cups: 0,
|
|
away_cups: 0,
|
|
ot_count: 0,
|
|
home_from_lid: match.home_from_lid === null ? -1 : match.home_from_lid,
|
|
away_from_lid: match.away_from_lid === null ? -1 : match.away_from_lid,
|
|
home_from_loser: match.home_from_loser || false,
|
|
away_from_loser: match.away_from_loser || false,
|
|
is_losers_bracket: true,
|
|
status: "tbd",
|
|
tournament: tournamentId,
|
|
};
|
|
|
|
matchInputs.push(matchInput);
|
|
});
|
|
});
|
|
|
|
const createdMatches = await pbAdmin.createMatches(matchInputs);
|
|
|
|
const matchIds = createdMatches.map((match) => match.id);
|
|
await pbAdmin.updateTournamentMatches(tournamentId, matchIds);
|
|
|
|
logger.info("Tournament bracket generated", {
|
|
tournamentId,
|
|
matchCount: createdMatches.length,
|
|
});
|
|
|
|
return {
|
|
tournament,
|
|
matchCount: createdMatches.length,
|
|
matches: createdMatches,
|
|
};
|
|
})
|
|
);
|
|
|
|
export const startMatch = createServerFn()
|
|
.inputValidator(z.string())
|
|
.middleware([superTokensAdminFunctionMiddleware, serverFnLoggingMiddleware])
|
|
.handler(async ({ data }) =>
|
|
toServerResult(async () => {
|
|
logger.info("Starting match", data);
|
|
|
|
let match = await pbAdmin.getMatch(data);
|
|
if (!match) {
|
|
throw new Error("Match not found");
|
|
}
|
|
|
|
match = await pbAdmin.updateMatch(data, {
|
|
start_time: new Date().toISOString(),
|
|
status: "started",
|
|
});
|
|
|
|
serverEvents.emit("match", {
|
|
type: "match",
|
|
matchId: match.id,
|
|
tournamentId: match.tournament.id
|
|
});
|
|
|
|
return match;
|
|
})
|
|
);
|
|
|
|
export const populateKnockoutBracket = createServerFn()
|
|
.inputValidator(z.object({
|
|
tournamentId: z.string(),
|
|
}))
|
|
.middleware([superTokensAdminFunctionMiddleware, serverFnLoggingMiddleware])
|
|
.handler(async ({ data: { tournamentId } }) =>
|
|
toServerResult(async () => {
|
|
const tournament = await pbAdmin.getTournament(tournamentId);
|
|
if (!tournament) {
|
|
throw new Error("Tournament not found");
|
|
}
|
|
|
|
if (!tournament.group_config) {
|
|
throw new Error("Tournament must have group_config");
|
|
}
|
|
|
|
return await populateKnockoutBracketInternal(tournamentId, tournament.group_config);
|
|
})
|
|
);
|
|
|
|
async function populateKnockoutBracketInternal(tournamentId: string, groupConfig: { num_groups: number; advance_per_group: number }) {
|
|
logger.info('Populating knockout bracket', { tournamentId });
|
|
|
|
const groups = await pbAdmin.getGroupsByTournament(tournamentId);
|
|
if (!groups || groups.length === 0) {
|
|
throw new Error("No groups found for tournament");
|
|
}
|
|
|
|
const qualifiedTeams: { teamId: string; groupOrder: number; rank: number }[] = [];
|
|
|
|
for (const group of groups) {
|
|
logger.info('Processing group', {
|
|
groupId: group.id,
|
|
groupOrder: group.order,
|
|
teamsCount: group.teams?.length,
|
|
teams: group.teams
|
|
});
|
|
|
|
const groupMatches = await pbAdmin.getMatchesByGroup(group.id);
|
|
const completedMatches = groupMatches.filter(m => m.status === "ended");
|
|
|
|
const standings = new Map<string, { teamId: string; wins: number; losses: number; cups_for: number; cups_against: number; cup_differential: number }>();
|
|
|
|
for (const team of group.teams || []) {
|
|
// group.teams can be either team objects or just team ID strings
|
|
const teamId = typeof team === 'string' ? team : team.id;
|
|
standings.set(teamId, {
|
|
teamId,
|
|
wins: 0,
|
|
losses: 0,
|
|
cups_for: 0,
|
|
cups_against: 0,
|
|
cup_differential: 0,
|
|
});
|
|
}
|
|
|
|
for (const match of completedMatches) {
|
|
if (!match.home || !match.away) continue;
|
|
|
|
const homeStanding = standings.get(match.home.id);
|
|
const awayStanding = standings.get(match.away.id);
|
|
|
|
if (homeStanding && awayStanding) {
|
|
homeStanding.cups_for += match.home_cups;
|
|
homeStanding.cups_against += match.away_cups;
|
|
awayStanding.cups_for += match.away_cups;
|
|
awayStanding.cups_against += match.home_cups;
|
|
|
|
if (match.home_cups > match.away_cups) {
|
|
homeStanding.wins++;
|
|
awayStanding.losses++;
|
|
} else {
|
|
awayStanding.wins++;
|
|
homeStanding.losses++;
|
|
}
|
|
|
|
homeStanding.cup_differential = homeStanding.cups_for - homeStanding.cups_against;
|
|
awayStanding.cup_differential = awayStanding.cups_for - awayStanding.cups_against;
|
|
}
|
|
}
|
|
|
|
const sortedStandings = Array.from(standings.values()).sort((a, b) => {
|
|
if (b.wins !== a.wins) return b.wins - a.wins;
|
|
if (b.cup_differential !== a.cup_differential) return b.cup_differential - a.cup_differential;
|
|
return b.cups_for - a.cups_for;
|
|
});
|
|
|
|
const topTeams = sortedStandings.slice(0, groupConfig.advance_per_group);
|
|
logger.info('Top teams from group', {
|
|
groupId: group.id,
|
|
topTeams: topTeams.map(t => ({ teamId: t.teamId, wins: t.wins, cupDiff: t.cup_differential }))
|
|
});
|
|
|
|
topTeams.forEach((standing, index) => {
|
|
qualifiedTeams.push({
|
|
teamId: standing.teamId,
|
|
groupOrder: group.order,
|
|
rank: index + 1,
|
|
});
|
|
});
|
|
}
|
|
|
|
logger.info('Qualified teams', { qualifiedTeams });
|
|
|
|
const orderedTeamIds: string[] = [];
|
|
const maxRank = groupConfig.advance_per_group;
|
|
|
|
for (let rank = 1; rank <= maxRank; rank++) {
|
|
const teamsAtRank = qualifiedTeams
|
|
.filter(t => t.rank === rank)
|
|
.sort((a, b) => a.groupOrder - b.groupOrder);
|
|
orderedTeamIds.push(...teamsAtRank.map(t => t.teamId));
|
|
}
|
|
|
|
logger.info('Ordered team IDs', { orderedTeamIds });
|
|
|
|
const tournament = await pbAdmin.getTournament(tournamentId);
|
|
const knockoutMatches = (tournament.matches || [])
|
|
.filter((m: Match) => m.round >= 0 && m.lid >= 0)
|
|
.sort((a: Match, b: Match) => a.lid - b.lid);
|
|
|
|
const seedToTeamId = new Map<number, string>();
|
|
orderedTeamIds.forEach((teamId, index) => {
|
|
seedToTeamId.set(index + 1, teamId);
|
|
});
|
|
|
|
logger.info('Seed to team mapping', {
|
|
seedToTeamId: Array.from(seedToTeamId.entries()),
|
|
orderedTeamIds
|
|
});
|
|
|
|
let updatedCount = 0;
|
|
for (const match of knockoutMatches) {
|
|
if (match.round === 0) {
|
|
const updates: any = {};
|
|
|
|
if (match.home_seed) {
|
|
const teamId = seedToTeamId.get(match.home_seed);
|
|
logger.info('Looking up home seed', {
|
|
matchId: match.id,
|
|
home_seed: match.home_seed,
|
|
teamId
|
|
});
|
|
if (teamId) {
|
|
updates.home = teamId;
|
|
}
|
|
}
|
|
|
|
if (match.away_seed) {
|
|
const teamId = seedToTeamId.get(match.away_seed);
|
|
logger.info('Looking up away seed', {
|
|
matchId: match.id,
|
|
away_seed: match.away_seed,
|
|
teamId
|
|
});
|
|
if (teamId) {
|
|
updates.away = teamId;
|
|
}
|
|
}
|
|
|
|
if (updates.home && updates.away) {
|
|
updates.status = "ready";
|
|
} else if (updates.home || updates.away) {
|
|
updates.status = "tbd";
|
|
}
|
|
|
|
if (Object.keys(updates).length > 0) {
|
|
logger.info('Updating match', { matchId: match.id, updates });
|
|
await pbAdmin.updateMatch(match.id, updates);
|
|
updatedCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
logger.info('Updated matches', { updatedCount, totalKnockoutMatches: knockoutMatches.length });
|
|
|
|
await pbAdmin.updateTournament(tournamentId, {
|
|
phase: "knockout"
|
|
});
|
|
|
|
logger.info('Knockout bracket populated successfully', { tournamentId });
|
|
}
|
|
|
|
const endMatchSchema = z.object({
|
|
matchId: z.string(),
|
|
home_cups: z.number(),
|
|
away_cups: z.number(),
|
|
ot_count: z.number(),
|
|
});
|
|
export const endMatch = createServerFn()
|
|
.inputValidator(endMatchSchema)
|
|
.middleware([superTokensAdminFunctionMiddleware, serverFnLoggingMiddleware])
|
|
.handler(async ({ data: { matchId, home_cups, away_cups, ot_count } }) =>
|
|
toServerResult(async () => {
|
|
logger.info("Ending match", matchId);
|
|
|
|
let match = await pbAdmin.getMatch(matchId);
|
|
if (!match) {
|
|
throw new Error("Match not found");
|
|
}
|
|
|
|
match = await pbAdmin.updateMatch(matchId, {
|
|
end_time: new Date().toISOString(),
|
|
status: "ended",
|
|
home_cups,
|
|
away_cups,
|
|
ot_count,
|
|
});
|
|
|
|
if (match.lid === -1) {
|
|
serverEvents.emit("match", {
|
|
type: "match",
|
|
matchId: match.id,
|
|
tournamentId: match.tournament.id
|
|
});
|
|
return match;
|
|
}
|
|
|
|
const matchWinner = home_cups > away_cups ? match.home : match.away;
|
|
const matchLoser = home_cups < away_cups ? match.home : match.away;
|
|
if (!matchWinner || !matchLoser) throw new Error("Something went wrong");
|
|
|
|
const { winner, loser } = await pbAdmin.getChildMatches(matchId);
|
|
|
|
if (winner && winner.reset) {
|
|
const awayTeamWon = match.away === matchWinner;
|
|
|
|
if (!awayTeamWon) {
|
|
logger.info("Deleting reset match", {
|
|
resetMatchId: winner.id,
|
|
currentMatchId: match.id,
|
|
reason: "not necessary",
|
|
});
|
|
|
|
await pbAdmin.deleteMatch(winner.id);
|
|
return match;
|
|
}
|
|
}
|
|
|
|
if (winner) {
|
|
await pbAdmin.updateMatch(winner.id, {
|
|
[winner.home_from_lid === match.lid ? "home" : "away"]: matchWinner.id,
|
|
status:
|
|
(winner.home_from_lid === match.lid && winner.away) ||
|
|
(winner.away_from_lid === match.lid && winner.home)
|
|
? "ready"
|
|
: "tbd",
|
|
});
|
|
}
|
|
|
|
if (loser) {
|
|
await pbAdmin.updateMatch(loser.id, {
|
|
[loser.home_from_lid === match.lid ? "home" : "away"]: matchLoser.id,
|
|
status:
|
|
(loser.home_from_lid === match.lid && loser.away) ||
|
|
(loser.away_from_lid === match.lid && loser.home)
|
|
? "ready"
|
|
: "tbd",
|
|
});
|
|
}
|
|
|
|
serverEvents.emit("match", {
|
|
type: "match",
|
|
matchId: match.id,
|
|
tournamentId: match.tournament.id
|
|
});
|
|
|
|
return match;
|
|
})
|
|
);
|
|
|
|
const toggleReactionSchema = z.object({
|
|
matchId: z.string(),
|
|
emoji: z.string(),
|
|
});
|
|
|
|
export const toggleMatchReaction = createServerFn()
|
|
.inputValidator(toggleReactionSchema)
|
|
.middleware([superTokensFunctionMiddleware])
|
|
.handler(async ({ data: { matchId, emoji }, context }) =>
|
|
toServerResult(async () => {
|
|
const user = await pbAdmin.getPlayerByAuthId(context.userAuthId);
|
|
const userId = user?.id;
|
|
if (!userId) return;
|
|
|
|
const match = await pbAdmin.getMatch(matchId);
|
|
if (!match) {
|
|
throw new Error("Match not found");
|
|
}
|
|
|
|
const existingReaction = await pbAdmin.getUserReaction(matchId, userId, emoji);
|
|
if (existingReaction) {
|
|
await pbAdmin.deleteReaction(existingReaction.id);
|
|
logger.info("Removed reaction", { matchId, emoji, userId });
|
|
} else {
|
|
await pbAdmin.createReaction(matchId, userId, emoji);
|
|
logger.info("Added reaction", { matchId, emoji, userId });
|
|
}
|
|
|
|
const all = await pbAdmin.getReactionsForMatch(matchId);
|
|
|
|
const reactionsByEmoji = all.reduce((acc, reaction) => {
|
|
const emoji = reaction.emoji;
|
|
if (!acc[emoji]) {
|
|
acc[emoji] = {
|
|
emoji,
|
|
count: 0,
|
|
players: [],
|
|
};
|
|
}
|
|
acc[emoji].count++;
|
|
acc[emoji].players.push({
|
|
id: reaction?.player?.id,
|
|
first_name: reaction.player?.first_name,
|
|
last_name: reaction.player?.last_name,
|
|
});
|
|
return acc;
|
|
}, {} as Record<string, any>);
|
|
|
|
const reactions = Object.values(reactionsByEmoji);
|
|
|
|
serverEvents.emit("reaction", {
|
|
type: "reaction",
|
|
matchId,
|
|
reactions,
|
|
});
|
|
|
|
return reactions as Reaction[]
|
|
})
|
|
);
|
|
|
|
export interface Reaction {
|
|
emoji: string;
|
|
count: number;
|
|
players: PlayerInfo[];
|
|
}
|
|
export const getMatchReactions = createServerFn()
|
|
.inputValidator(z.string())
|
|
.middleware([superTokensFunctionMiddleware])
|
|
.handler(async ({ data: matchId, context }) =>
|
|
toServerResult(async () => {
|
|
const match = await pbAdmin.getMatch(matchId);
|
|
if (!match) {
|
|
throw new Error("Match not found");
|
|
}
|
|
|
|
const all = await pbAdmin.getReactionsForMatch(matchId);
|
|
|
|
const reactionsByEmoji = all.reduce((acc, reaction) => {
|
|
const emoji = reaction.emoji;
|
|
if (!acc[emoji]) {
|
|
acc[emoji] = {
|
|
emoji,
|
|
count: 0,
|
|
players: [],
|
|
};
|
|
}
|
|
acc[emoji].count++;
|
|
acc[emoji].players.push({
|
|
id: reaction?.player?.id,
|
|
first_name: reaction.player?.first_name,
|
|
last_name: reaction.player?.last_name,
|
|
});
|
|
return acc;
|
|
}, {} as Record<string, any>);
|
|
|
|
const reactions = Object.values(reactionsByEmoji);
|
|
|
|
return reactions as Reaction[]
|
|
})
|
|
);
|
|
|
|
const matchesBetweenPlayersSchema = z.object({
|
|
player1Id: z.string(),
|
|
player2Id: z.string(),
|
|
});
|
|
|
|
export const getMatchesBetweenPlayers = createServerFn()
|
|
.inputValidator(matchesBetweenPlayersSchema)
|
|
.middleware([superTokensFunctionMiddleware])
|
|
.handler(async ({ data: { player1Id, player2Id } }) =>
|
|
toServerResult(async () => {
|
|
logger.info("Getting matches between players", { player1Id, player2Id });
|
|
const matches = await pbAdmin.getMatchesBetweenPlayers(player1Id, player2Id);
|
|
return matches;
|
|
})
|
|
);
|
|
|
|
const matchesBetweenTeamsSchema = z.object({
|
|
team1Id: z.string(),
|
|
team2Id: z.string(),
|
|
});
|
|
|
|
export const getMatchesBetweenTeams = createServerFn()
|
|
.inputValidator(matchesBetweenTeamsSchema)
|
|
.middleware([superTokensFunctionMiddleware])
|
|
.handler(async ({ data: { team1Id, team2Id } }) =>
|
|
toServerResult(async () => {
|
|
logger.info("Getting matches between teams", { team1Id, team2Id });
|
|
const matches = await pbAdmin.getMatchesBetweenTeams(team1Id, team2Id);
|
|
return matches;
|
|
})
|
|
);
|