Merge branch 'bugfix/7-tournament-schedule-tests': Schedule generation, clickable matchups, and test fixes

Resolved conflict in common-steps.ts by combining player schedule step definitions
(from bugfix/9 merge) with tournament schedule step definitions (from bugfix/7).

src/app/admin/tournaments/[id]/entry/page.tsx

@@ -73,7 +73,7 @@ export default function TournamentEntryPage({ params }: { params: Promise<{ id:
   const [team1Score, setTeam1Score] = useState("")
   const [team2Score, setTeam2Score] = useState("")
 
-  // Parse params and validate tournamentId
+  // Parse params and validate tournamentId, check for matchup query param
   useEffect(() => {
     async function parseParams() {
       const { id } = await params
@@ -87,6 +87,26 @@ export default function TournamentEntryPage({ params }: { params: Promise<{ id:
     parseParams()
   }, [params, router])
 
+  // Handle pre-selection of matchup from query param
+  useEffect(() => {
+    if (schedule && selectedMatchupId === null) {
+      const searchParams = new URLSearchParams(window.location.search)
+      const matchupIdParam = searchParams.get('matchup')
+      if (matchupIdParam) {
+        const matchupId = parseInt(matchupIdParam, 10)
+        // Find which round contains this matchup
+        for (const round of schedule.rounds) {
+          const matchup = round.matchups.find(m => m.id === matchupId)
+          if (matchup) {
+            setSelectedRoundId(round.id)
+            setSelectedMatchupId(matchupId)
+            break
+          }
+        }
+      }
+    }
+  }, [schedule, selectedMatchupId])
+
   // Load tournament, schedule, and matches
   useEffect(() => {
     if (tournamentId) {

src/app/admin/tournaments/[id]/schedule/page.tsx

@@ -2,6 +2,8 @@ import { prisma } from "@/lib/prisma"
 import Navigation from "@/components/Navigation"
 import Link from "next/link"
 import { notFound } from "next/navigation"
+import { ScheduleGenerator } from "@/components/ScheduleGenerator"
+import { ScheduleDisplay } from "@/components/ScheduleDisplay"
 
 interface PageProps {
   params: Promise<{
@@ -9,7 +11,9 @@ interface PageProps {
   }>
 }
 
+// Force dynamic rendering and revalidate on each request
 export const dynamic = "force-dynamic"
+export const revalidate = 0
 
 export default async function TournamentSchedulePage({ params }: PageProps) {
   const { id } = await params
@@ -19,6 +23,7 @@ export default async function TournamentSchedulePage({ params }: PageProps) {
     notFound()
   }
 
+  console.log(`[Schedule Page] Fetching tournament ${tournamentId}`);
   const tournament = await prisma.event.findUnique({
     where: { id: tournamentId },
     include: {
@@ -27,13 +32,35 @@ export default async function TournamentSchedulePage({ params }: PageProps) {
           player: true,
         },
       },
+      rounds: {
+        orderBy: { roundNumber: "asc" },
+        include: {
+          bracketMatchups: {
+            orderBy: { bracketPosition: "asc" },
+            include: {
+              player1P1: true,
+              player1P2: true,
+              player2P1: true,
+              player2P2: true,
+              match: true,
+            },
+          },
+        },
+      },
     },
   })
+  console.log(`[Schedule Page] Tournament ${tournamentId} has ${tournament?.rounds?.length || 0} rounds`);
+  if (tournament?.rounds && tournament.rounds.length > 0) {
+    console.log(`[Schedule Page] First round:`, JSON.stringify(tournament.rounds[0]));
+  }
 
   if (!tournament) {
     notFound()
   }
 
+  const teamCount = tournament.participants.length
+  const existingRounds = tournament.rounds.length
+
   return (
     <div className="min-h-screen bg-gray-50">
       <Navigation />
@@ -53,22 +80,33 @@ export default async function TournamentSchedulePage({ params }: PageProps) {
             Schedule - {tournament.name}
           </h1>
 
-          <div className="bg-white shadow rounded-lg p-6">
+          <div className="bg-white shadow rounded-lg p-6 mb-6">
             <div className="flex justify-between items-center mb-6">
               <h2 className="text-xl font-bold text-gray-900">
                 Tournament Schedule
               </h2>
-              <button className="bg-green-600 text-white px-4 py-2 rounded-md text-sm font-medium hover:bg-green-700">
-                Generate Schedule
-              </button>
             </div>
 
-            <p className="text-gray-500">
-              No schedule has been generated yet. Click "Generate Schedule" to create round matchups.
-            </p>
+            <div id="schedule-display">
+              {existingRounds > 0 ? (
+                <ScheduleDisplay rounds={tournament.rounds} tournamentId={tournamentId} />
+              ) : (
+                <p className="text-gray-500 mb-6">
+                  No schedule has been generated yet. Click "Generate Schedule" to create round matchups.
+                </p>
+              )}
+            </div>
+
+            <div className="mt-6 pt-6 border-t border-gray-200">
+              <ScheduleGenerator
+                tournamentId={tournamentId}
+                teamCount={teamCount}
+                existingRounds={existingRounds}
+              />
+            </div>
           </div>
         </div>
       </main>
     </div>
   )
-}
+}

src/app/api/tournaments/[id]/schedule/route.ts

@@ -1,4 +1,5 @@
 import { NextResponse } from "next/server";
+import { revalidatePath } from "next/cache";
 import { prisma } from "@/lib/prisma";
 import { canManageTournament } from "@/lib/permissions";
 import { generateRoundRobin, validateScheduleInput, generateVariableRoundRobin, expectedRounds } from "@/lib/schedule-generator";
@@ -78,11 +79,15 @@ export async function GET(_request: Request, { params }: RouteParams) {
  * Creates TournamentRound and BracketMatchup records.
  */
 export async function POST(_request: Request, { params }: RouteParams) {
+  console.log(`[Schedule API] POST handler started`);
   try {
     const { id } = await params;
     const tournamentId = parseInt(id);
 
+    console.log(`[Schedule API] POST /api/tournaments/${tournamentId}/schedule`);
+    
     if (isNaN(tournamentId)) {
+      console.log(`[Schedule API] Invalid tournament ID: ${id}`);
       return NextResponse.json(
         { error: "Invalid tournament ID" },
         { status: 400 }
@@ -90,6 +95,7 @@ export async function POST(_request: Request, { params }: RouteParams) {
     }
 
     const permission = await canManageTournament(tournamentId);
+    console.log(`[Schedule API] Permission check: ${permission.allowed}, reason: ${permission.reason}`);
     if (!permission.allowed) {
       return NextResponse.json(
         { error: permission.reason || "Not authorized to manage this tournament" },
@@ -98,6 +104,7 @@ export async function POST(_request: Request, { params }: RouteParams) {
     }
 
     // Check tournament exists
+    console.log(`[Schedule API] Looking up tournament ${tournamentId}`);
     const tournament = await prisma.event.findUnique({
       where: { id: tournamentId },
       include: {
@@ -111,14 +118,17 @@ export async function POST(_request: Request, { params }: RouteParams) {
     });
 
     if (!tournament) {
+      console.log(`[Schedule API] Tournament ${tournamentId} not found`);
       return NextResponse.json(
         { error: "Tournament not found" },
         { status: 404 }
       );
     }
+    console.log(`[Schedule API] Found tournament ${tournamentId} with ${tournament.participants.length} participants and ${tournament.rounds.length} existing rounds`);
 
     // Check if schedule already exists and delete it
     if (tournament.rounds.length > 0) {
+      console.log(`[Schedule API] Deleting ${tournament.rounds.length} existing rounds`);
       // Delete existing rounds and matchups before regenerating
       await prisma.bracketMatchup.deleteMany({
         where: { eventId: tournamentId },
@@ -135,6 +145,8 @@ export async function POST(_request: Request, { params }: RouteParams) {
       currentElo: p.player.currentElo,
     }));
 
+    console.log(`[Schedule API] Got ${participants.length} participants`);
+
     // Check minimum participants
     if (participants.length < 2) {
       return NextResponse.json(
@@ -147,20 +159,24 @@ export async function POST(_request: Request, { params }: RouteParams) {
     const teamDurability = tournament.teamDurability || "permanent";
     const partnerRotation = (tournament.partnerRotation || "none") as 'none' | 'minimize_repeat' | 'maximize_even' | 'elo_based';
     const allowByes = tournament.allowByes ?? true;
+    console.log(`[Schedule API] Team durability: ${teamDurability}, partner rotation: ${partnerRotation}, allow byes: ${allowByes}`);
 
     // Determine number of teams from participants
     const tempResult = generateTeams(participants, partnerRotation, allowByes);
     const teamCount = tempResult.teams.length;
-    
+    console.log(`[Schedule API] Generated ${teamCount} teams from ${participants.length} participants`);
+
     if (teamCount < 2) {
+      console.log(`[Schedule API] Not enough teams: ${teamCount}`);
       return NextResponse.json(
-        { error: "At least 2 teams (4 players) are required to generate a schedule" },
+        { error: "At least 2 teams are required to generate a schedule" },
         { status: 400 }
       );
     }
 
-    // Calculate number of rounds needed
+    // Calculate expected rounds
     const numRounds = expectedRounds(teamCount);
+    console.log(`[Schedule API] Expected rounds: ${numRounds}`);
 
     if (teamDurability === "permanent") {
       // ============================================
@@ -186,11 +202,14 @@ export async function POST(_request: Request, { params }: RouteParams) {
 
       // Generate schedule using fixed teams
       const schedule = generateRoundRobin(teamPairings);
+      console.log(`[Schedule API] Generated ${schedule.length} rounds for ${teamCount} teams (fixed)`);
 
       // Create rounds and matchups in a transaction
+      console.log(`[Schedule API] About to create ${schedule.length} rounds in transaction`);
       const created = await prisma.$transaction(
-        schedule.map((round) =>
-          prisma.tournamentRound.create({
+        schedule.map((round) => {
+          console.log(`[Schedule API] Creating round ${round.roundNumber} with ${round.matchups.length} matchups`);
+          return prisma.tournamentRound.create({
             data: {
               eventId: tournamentId,
               roundNumber: round.roundNumber,
@@ -218,8 +237,17 @@ export async function POST(_request: Request, { params }: RouteParams) {
               },
             },
           })
-        )
+        })
       );
+      
+      console.log(`[Schedule API] Transaction complete. Created ${created.length} rounds`);
+      console.log(`[Schedule API] Verifying in database:`);
+      for (const round of created) {
+        console.log(`[Schedule API]   Round ${round.roundNumber}: id=${round.id}, eventId=${round.eventId}`);
+      }
+
+      revalidatePath(`/admin/tournaments/${tournamentId}/schedule`);
+      console.log(`[Schedule API] revalidatePath called for /admin/tournaments/${tournamentId}/schedule`);
 
       return NextResponse.json({
         success: true,
@@ -295,6 +323,8 @@ export async function POST(_request: Request, { params }: RouteParams) {
         )
       );
 
+      revalidatePath(`/admin/tournaments/${tournamentId}/schedule`);
+
       return NextResponse.json({
         success: true,
         roundsCreated: created.length,

src/components/MatchEditor.tsx

@@ -1,6 +1,7 @@
 "use client"
 
 import { useState } from "react"
+import { useRouter } from "next/navigation"
 import type { Player, Match } from "@prisma/client"
 
 interface MatchEditorProps {
@@ -40,6 +41,7 @@ export default function MatchEditor({
   prefilledP4,
   prefilledRound,
 }: MatchEditorProps) {
+  const router = useRouter()
   // Check if players are prefilled from URL params
   const hasPrefilledPlayers = prefilledP1 && prefilledP2 && prefilledP3 && prefilledP4;
   
@@ -170,9 +172,9 @@ export default function MatchEditor({
         isCasual: false,
       })
 
-      // Reload the page to show updated matches
+      // Refresh the page to show updated matches
       setTimeout(() => {
-        window.location.reload()
+        router.refresh()
       }, 1000)
     } catch {
       setError("An error occurred. Please try again.")

src/components/Navigation.tsx

@@ -52,7 +52,7 @@ export default function Navigation() {
         <div className="flex justify-between h-16">
           <div className="flex items-center min-w-0 overflow-hidden">
             <Link 
-              href="/wordmark-redirect" 
+              href="/" 
               className="text-xl font-bold text-gray-900 no-underline flex-shrink-0"
             >
               EuchreCamp

src/components/RecalculateEloButton.tsx

@@ -1,8 +1,10 @@
 "use client"
 
 import { useState } from "react"
+import { useRouter } from "next/navigation"
 
 export function RecalculateEloButton() {
+  const router = useRouter()
   const [isLoading, setIsLoading] = useState(false)
 
   const handleClick = async () => {
@@ -33,7 +35,7 @@ export function RecalculateEloButton() {
       
       if (data.success) {
         alert(`Recalculation completed: ${JSON.stringify(data.data)}`)
-        window.location.reload()
+        router.refresh()
       } else {
         alert(`Error: ${data.error}`)
       }

src/components/ScheduleDisplay.tsx

@@ -0,0 +1,90 @@
+"use client"
+
+import Link from "next/link"
+
+interface Player {
+  id: number
+  name: string
+}
+
+interface BracketMatchup {
+  id: number
+  player1P1: Player | null
+  player1P2: Player | null
+  player2P1: Player | null
+  player2P2: Player | null
+  match: { id: number } | null
+  bracketPosition: number | null
+  status: string
+}
+
+interface TournamentRound {
+  id: number
+  roundNumber: number
+  status: string
+  bracketMatchups: BracketMatchup[]
+}
+
+interface ScheduleDisplayProps {
+  rounds: TournamentRound[]
+  tournamentId: number
+}
+
+export function ScheduleDisplay({ rounds, tournamentId }: ScheduleDisplayProps) {
+  return (
+    <div className="space-y-6">
+      {rounds.map((round) => (
+        <div key={round.id} className="bg-white rounded-lg shadow p-4">
+          <div className="flex items-center justify-between mb-4">
+            <h3 className="text-lg font-semibold">Round {round.roundNumber}</h3>
+            <span className={`text-sm px-2 py-1 rounded ${
+              round.status === 'completed' ? 'bg-green-100 text-green-800' : 'bg-gray-100 text-gray-600'
+            }`}>
+              {round.status}
+            </span>
+          </div>
+          <div className="space-y-2">
+            {round.bracketMatchups.map((matchup) => {
+              const content = (
+                <div className="p-3 border border-gray-200 rounded hover:border-green-500 transition-colors">
+                  <div className="flex justify-between items-center">
+                    <div className="flex-1">
+                      <p className="text-sm text-gray-500">
+                        Match {matchup.bracketPosition || matchup.id}
+                      </p>
+                      <p className="font-medium">
+                        {matchup.player1P1?.name || 'TBD'} & {matchup.player1P2?.name || 'TBD'}
+                      </p>
+                      <p className="text-sm text-gray-500">vs</p>
+                      <p className="font-medium">
+                        {matchup.player2P1?.name || 'TBD'} & {matchup.player2P2?.name || 'TBD'}
+                      </p>
+                    </div>
+                    <div className="text-right">
+                      {matchup.match ? (
+                        <span className="text-sm text-green-600">Completed</span>
+                      ) : (
+                        <span className="text-sm text-gray-400">Pending</span>
+                      )}
+                    </div>
+                  </div>
+                </div>
+              )
+
+              return (
+                <Link
+                  key={matchup.id}
+                  href={`/admin/tournaments/${tournamentId}/entry?matchup=${matchup.id}`}
+                  className="block hover:bg-gray-100 rounded-md transition-colors"
+                  data-testid="matchup"
+                >
+                  {content}
+                </Link>
+              )
+            })}
+          </div>
+        </div>
+      ))}
+    </div>
+  )
+}

src/components/ScheduleGenerator.tsx

@@ -1,6 +1,7 @@
 "use client"
 
 import { useState } from "react"
+import { useRouter } from "next/navigation"
 
 interface ScheduleGeneratorProps {
   tournamentId: number
@@ -9,6 +10,7 @@ interface ScheduleGeneratorProps {
 }
 
 export function ScheduleGenerator({ tournamentId, teamCount, existingRounds }: ScheduleGeneratorProps) {
+  const router = useRouter()
   const [isGenerating, setIsGenerating] = useState(false)
   const [error, setError] = useState("")
   const [result, setResult] = useState<{
@@ -47,11 +49,9 @@ export function ScheduleGenerator({ tournamentId, teamCount, existingRounds }: S
         matchupsCreated: data.matchupsCreated,
       })
       setIsGenerating(false)
-
-      // Reload to show the schedule
-      setTimeout(() => {
-        window.location.reload()
-      }, 1500)
+      
+      // Re-fetch the schedule data from the server
+      router.refresh()
     } catch {
       setError("An error occurred. Please try again.")
       setIsGenerating(false)
@@ -86,7 +86,7 @@ export function ScheduleGenerator({ tournamentId, teamCount, existingRounds }: S
         return
       }
 
-      window.location.reload()
+      router.refresh()
     } catch {
       setError("An error occurred. Please try again.")
       setIsGenerating(false)