bug: fix tournament bugs in swiss , slot saftey , seeding order scheduling eerrors and orpahed brackets

Author: lukepolo

hasura/functions/tournaments/assign_team_to_bracket_slot.sql

@@ -9,10 +9,14 @@ DECLARE
     target_bracket tournament_brackets%ROWTYPE;
     slot_position int;
 BEGIN
+    -- Lock the target row so concurrent callers (e.g. two feeder matches
+    -- finishing simultaneously) serialize on the same bracket. Combined with
+    -- the IS NULL guards on the UPDATEs below, this prevents either caller
+    -- from overwriting a team the other just placed.
     SELECT * INTO target_bracket
     FROM tournament_brackets
     WHERE id = _target_bracket_id
-    LIMIT 1;
+    FOR UPDATE;
 
     IF target_bracket IS NULL OR _team_id IS NULL THEN
         RETURN;
@@ -44,36 +48,45 @@ BEGIN
         WHERE ranked.id = _source_bracket_id;
     END IF;
 
+    -- Every UPDATE carries an IS NULL guard as defense-in-depth alongside the
+    -- row lock, so a slot can never be overwritten even if a caller bypasses
+    -- the lock (e.g. direct mutation outside this function).
     IF slot_position = 1 THEN
         IF target_bracket.tournament_team_id_1 IS NULL THEN
             UPDATE tournament_brackets
             SET tournament_team_id_1 = _team_id
-            WHERE id = _target_bracket_id;
+            WHERE id = _target_bracket_id
+              AND tournament_team_id_1 IS NULL;
         ELSIF target_bracket.tournament_team_id_2 IS NULL THEN
             UPDATE tournament_brackets
             SET tournament_team_id_2 = _team_id
-            WHERE id = _target_bracket_id;
+            WHERE id = _target_bracket_id
+              AND tournament_team_id_2 IS NULL;
         END IF;
     ELSIF slot_position = 2 THEN
         IF target_bracket.tournament_team_id_2 IS NULL THEN
             UPDATE tournament_brackets
             SET tournament_team_id_2 = _team_id
-            WHERE id = _target_bracket_id;
+            WHERE id = _target_bracket_id
+              AND tournament_team_id_2 IS NULL;
         ELSIF target_bracket.tournament_team_id_1 IS NULL THEN
             UPDATE tournament_brackets
             SET tournament_team_id_1 = _team_id
-            WHERE id = _target_bracket_id;
+            WHERE id = _target_bracket_id
+              AND tournament_team_id_1 IS NULL;
         END IF;
     ELSE
         -- Fallback: first empty slot (for callers without source bracket)
         IF target_bracket.tournament_team_id_1 IS NULL THEN
             UPDATE tournament_brackets
             SET tournament_team_id_1 = _team_id
-            WHERE id = _target_bracket_id;
+            WHERE id = _target_bracket_id
+              AND tournament_team_id_1 IS NULL;
         ELSIF target_bracket.tournament_team_id_2 IS NULL THEN
             UPDATE tournament_brackets
             SET tournament_team_id_2 = _team_id
-            WHERE id = _target_bracket_id;
+            WHERE id = _target_bracket_id
+              AND tournament_team_id_2 IS NULL;
         END IF;
     END IF;
 END;

hasura/functions/tournaments/assign_teams_to_swiss_pools.sql

@@ -41,10 +41,23 @@ BEGIN
                 RAISE NOTICE '  Pool %-% (group %): % teams', 
                     pool_record.wins, pool_record.losses, pool_group, team_count;
 
+            -- Filter out any teams already used by an earlier pool iteration.
+            -- pool_record.team_ids is a stale snapshot from when the outer
+            -- FOR...SELECT was materialized (used_teams was empty then), so a
+            -- team borrowed by an earlier pool could otherwise be paired twice.
+            SELECT COALESCE(array_agg(t), ARRAY[]::uuid[]) INTO teams_to_pair
+            FROM unnest(pool_record.team_ids) AS t
+            WHERE NOT (t = ANY(used_teams));
+
+            team_count := COALESCE(array_length(teams_to_pair, 1), 0);
+
+            IF team_count = 0 THEN
+                CONTINUE;
+            END IF;
+
             -- Handle odd number of teams
             adjacent_team_id := NULL;
-            teams_to_pair := pool_record.team_ids;
-            
+
             IF team_count % 2 != 0 THEN
                 -- Find a team from an adjacent pool
                 adjacent_team_id := find_adjacent_swiss_team(_stage_id, pool_record.wins, pool_record.losses, used_teams);

hasura/functions/tournaments/check_tournament_finished.sql

@@ -5,7 +5,37 @@ AS $$
 DECLARE
     total_brackets int;
     unfinished_brackets int;
+    orphan tournament_brackets%ROWTYPE;
 BEGIN
+    -- Sweep any orphaned brackets (no teams, no pending feeders, bye=false,
+    -- finished=false) and let resolve_bracket_bye mark them bye/finished.
+    -- Without this, an orphaned bracket would be counted as "unfinished"
+    -- below and the tournament would hang indefinitely.
+    FOR orphan IN
+        SELECT tb.*
+        FROM tournament_brackets tb
+        INNER JOIN tournament_stages ts ON ts.id = tb.tournament_stage_id
+        WHERE ts.tournament_id = _tournament_id
+          AND tb.finished = false
+          AND tb.bye = false
+          AND tb.tournament_team_id_1 IS NULL
+          AND tb.tournament_team_id_2 IS NULL
+          AND NOT EXISTS (
+              SELECT 1 FROM tournament_brackets child
+              WHERE (child.parent_bracket_id = tb.id
+                     OR child.loser_parent_bracket_id = tb.id)
+                AND child.finished = false
+          )
+          AND EXISTS (
+              SELECT 1 FROM tournament_brackets child
+              WHERE child.parent_bracket_id = tb.id
+                 OR child.loser_parent_bracket_id = tb.id
+          )
+        ORDER BY tb.round, tb.match_number
+    LOOP
+        PERFORM resolve_bracket_bye(orphan);
+    END LOOP;
+
     select count(*) into total_brackets
     from tournament_brackets tb
     inner join tournament_stages ts on ts.id = tb.tournament_stage_id

hasura/functions/tournaments/schedule_tournament_match.sql

@@ -21,15 +21,19 @@ CREATE OR REPLACE FUNCTION public.schedule_tournament_match(bracket public.tourn
 
     -- If bracket is already finished, don't try to schedule it
     IF bracket.finished = true THEN
+        RAISE NOTICE 'schedule_tournament_match: bracket % already finished, skipping', bracket.id;
         RETURN NULL;
     END IF;
-    
+
     IF bracket.tournament_team_id_1 IS NULL AND bracket.tournament_team_id_2 IS NULL THEN
+        RAISE NOTICE 'schedule_tournament_match: bracket % has no teams, skipping', bracket.id;
         RETURN NULL;
     END IF;
 
      -- For all other cases, we require two teams to schedule a match
      IF bracket.tournament_team_id_1 IS NULL OR bracket.tournament_team_id_2 IS NULL THEN
+         RAISE NOTICE 'schedule_tournament_match: bracket % missing one team (t1=%, t2=%), skipping',
+             bracket.id, bracket.tournament_team_id_1, bracket.tournament_team_id_2;
          RETURN NULL;
      END IF;
 
@@ -63,6 +67,7 @@ CREATE OR REPLACE FUNCTION public.schedule_tournament_match(bracket public.tourn
         FROM match_options mo WHERE mo.id = _match_options_id;
 
         IF _match_mode = 'admin' THEN
+            RAISE NOTICE 'schedule_tournament_match: bracket % is admin-mode, skipping auto-schedule', bracket.id;
             RETURN NULL;
         END IF;
     END;

hasura/views/v_team_stage_results.sql

@@ -270,8 +270,11 @@ ORDER BY
         THEN (COALESCE(ass.rounds_won, 0)::float / ass.rounds_lost::float)
         ELSE COALESCE(ass.rounds_won, 0)::float
     END DESC,
-    CASE 
-        WHEN COALESCE(tkd.total_deaths, 0) > 0 
+    CASE
+        WHEN COALESCE(tkd.total_deaths, 0) > 0
         THEN (COALESCE(tkd.total_kills, 0)::float / tkd.total_deaths::float)
         ELSE COALESCE(tkd.total_kills, 0)::float
-    END DESC;
+    END DESC,
+    -- Deterministic final tiebreaker so identical stats produce a stable
+    -- ordering across calls (e.g. for OFFSET-based seeding in seed_stage).
+    ass.team_id ASC;