bug: auto-complete bye matches in losers bracket (#133)

Co-authored-by: Flegma <Flegma@users.noreply.github.com>

Author: Flegma

hasura/functions/tournaments/advance_byes_for_tournament.sql

@@ -46,9 +46,46 @@ BEGIN
             WHERE id = v_parent_bracket_id;
         END IF;
 
+        -- Mark the bye bracket as finished so downstream bye resolution
+        -- (e.g. LB R1 brackets) can detect that no loser will arrive
+        UPDATE tournament_brackets
+        SET finished = true
+        WHERE id = bracket.id;
+
         RAISE NOTICE '  Advanced team % from bracket % to parent %', winner_id, bracket.id, v_parent_bracket_id;
     END LOOP;
 
+    -- After all WB byes are resolved, check for dead LB brackets:
+    -- brackets with 0 teams where all feeders are finished (e.g. both WB feeders were byes).
+    -- Process by round so cascading dead byes propagate correctly.
+    DECLARE
+        dead_bracket tournament_brackets%ROWTYPE;
+    BEGIN
+        FOR dead_bracket IN
+            SELECT tb.*
+            FROM tournament_brackets tb
+            JOIN tournament_stages ts ON tb.tournament_stage_id = ts.id
+            WHERE ts.tournament_id = p_tournament_id
+              AND tb.match_id IS NULL
+              AND tb.finished = 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
+            RAISE NOTICE '  Resolving dead bracket % (% R%M%)', dead_bracket.id, dead_bracket.path, dead_bracket.round, dead_bracket.match_number;
+            PERFORM resolve_bracket_bye(dead_bracket);
+        END LOOP;
+    END;
+
     RETURN;
 END;
 $$;

hasura/functions/tournaments/assign_team_to_bracket_slot.sql

@@ -1,11 +1,13 @@
 CREATE OR REPLACE FUNCTION public.assign_team_to_bracket_slot(
     _target_bracket_id uuid,
-    _team_id uuid
+    _team_id uuid,
+    _source_bracket_id uuid DEFAULT NULL
 ) RETURNS VOID
     LANGUAGE plpgsql
 AS $$
 DECLARE
     target_bracket tournament_brackets%ROWTYPE;
+    slot_position int;
 BEGIN
     SELECT * INTO target_bracket
     FROM tournament_brackets
@@ -16,14 +18,48 @@ BEGIN
         RETURN;
     END IF;
 
-    IF target_bracket.tournament_team_id_1 IS NULL THEN
+    -- Determine the correct slot from feeder ordering:
+    -- 1. Loser drops (loser_parent_bracket_id) come before winner feeds (parent_bracket_id)
+    -- 2. Within same type, order by round then match_number
+    -- This matches the bracket generation layout.
+    IF _source_bracket_id IS NOT NULL THEN
+        SELECT pos INTO slot_position
+        FROM (
+            SELECT f.id,
+                   row_number() OVER (
+                       ORDER BY
+                           CASE WHEN f.loser_parent_bracket_id = _target_bracket_id THEN 0 ELSE 1 END,
+                           f.round,
+                           f.match_number
+                   ) AS pos
+            FROM tournament_brackets f
+            WHERE f.parent_bracket_id = _target_bracket_id
+               OR f.loser_parent_bracket_id = _target_bracket_id
+        ) ranked
+        WHERE ranked.id = _source_bracket_id;
+    END IF;
+
+    IF slot_position = 1 THEN
         UPDATE tournament_brackets
         SET tournament_team_id_1 = _team_id
-        WHERE id = _target_bracket_id;
-    ELSIF target_bracket.tournament_team_id_2 IS NULL THEN
+        WHERE id = _target_bracket_id
+          AND tournament_team_id_1 IS NULL;
+    ELSIF slot_position = 2 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;
+    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;
+        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;
+        END IF;
     END IF;
 END;
 $$;

hasura/functions/tournaments/create_round_robin_matches.sql

@@ -14,7 +14,7 @@ DECLARE
     team_count int;
     round_count int;
     matches_per_round int;
-    match_counter int;
+
     round_num int;
     i int;
     k int;
@@ -58,8 +58,6 @@ BEGIN
     RAISE NOTICE 'Creating round robin matches for % teams: % rounds, % matches per round, starting at round %', 
         team_count, round_count, matches_per_round, _start_round;
 
-    match_counter := 0;
-    
     -- Generate round robin matches using rotating algorithm
     FOR round_num IN 1..round_count LOOP
         IF use_team_ids THEN
@@ -110,37 +108,35 @@ BEGIN
                 team_2_id := NULL;
             END IF;
 
-            match_counter := match_counter + 1;
-            
             INSERT INTO tournament_brackets (
-                round, 
-                tournament_stage_id, 
-                match_number, 
-                "group", 
-                team_1_seed, 
-                team_2_seed, 
+                round,
+                tournament_stage_id,
+                match_number,
+                "group",
+                team_1_seed,
+                team_2_seed,
                 path,
                 tournament_team_id_1,
                 tournament_team_id_2
             )
             VALUES (
-                _start_round + round_num - 1, 
-                _stage_id, 
-                match_counter, 
-                _group, 
-                team_1_seed, 
-                team_2_seed, 
+                _start_round + round_num - 1,
+                _stage_id,
+                i,
+                _group,
+                team_1_seed,
+                team_2_seed,
                 'WB',
                 team_1_id,
                 team_2_id
             );
-            
+
             IF use_team_ids THEN
-                RAISE NOTICE 'Created match %: round %, team % vs team %', 
-                    match_counter, _start_round + round_num - 1, team_1_id, team_2_id;
+                RAISE NOTICE 'Created match %: round %, team % vs team %',
+                    i, _start_round + round_num - 1, team_1_id, team_2_id;
             ELSE
-                RAISE NOTICE 'Created match %: round %, seed % vs seed %', 
-                    match_counter, _start_round + round_num - 1, team_1_seed, team_2_seed;
+                RAISE NOTICE 'Created match %: round %, seed % vs seed %',
+                    i, _start_round + round_num - 1, team_1_seed, team_2_seed;
             END IF;
         END LOOP;
     END LOOP;
@@ -161,7 +157,7 @@ BEGIN
         END LOOP;
     END IF;
 
-    RAISE NOTICE 'Created % round robin matches starting at round %', match_counter, _start_round;
+    RAISE NOTICE 'Created % round robin matches starting at round %', round_count * matches_per_round, _start_round;
 END;
 $$;
 

hasura/functions/tournaments/resolve_bracket_bye.sql

@@ -0,0 +1,106 @@
+-- Detects and resolves "runtime byes" in elimination brackets.
+-- A runtime bye occurs when a bracket receives exactly one team but has
+-- no remaining feeder brackets that could provide the second team.
+-- This happens in double-elimination losers brackets after LB R1 pruning:
+-- the pruned LB R1 match can no longer feed its parent LB R2 bracket,
+-- so the WB loser that drops into LB R2 has no opponent.
+CREATE OR REPLACE FUNCTION public.resolve_bracket_bye(
+    _bracket tournament_brackets
+) RETURNS boolean
+    LANGUAGE plpgsql
+AS $$
+DECLARE
+    current_bracket tournament_brackets%ROWTYPE;
+    pending_feeders int;
+    lone_team_id uuid;
+    tournament_id uuid;
+BEGIN
+    -- Re-read from disk: the passed-in row may be stale when called from
+    -- a resume loop where earlier iterations cascaded and already resolved this bracket.
+    SELECT * INTO current_bracket
+    FROM tournament_brackets WHERE id = _bracket.id;
+
+    IF current_bracket IS NULL THEN
+        RETURN false;
+    END IF;
+
+    -- Both teams present: nothing to resolve
+    IF (current_bracket.tournament_team_id_1 IS NOT NULL AND current_bracket.tournament_team_id_2 IS NOT NULL) THEN
+        RETURN false;
+    END IF;
+
+    IF current_bracket.finished = true OR current_bracket.match_id IS NOT NULL THEN
+        RETURN false;
+    END IF;
+
+    -- Check if any feeders can still provide a team.
+    SELECT COUNT(*) INTO pending_feeders
+    FROM tournament_brackets child
+    WHERE (child.parent_bracket_id = current_bracket.id
+           OR child.loser_parent_bracket_id = current_bracket.id)
+      AND child.finished = false;
+
+    IF pending_feeders > 0 THEN
+        RETURN false;
+    END IF;
+
+    lone_team_id := COALESCE(current_bracket.tournament_team_id_1, current_bracket.tournament_team_id_2);
+
+    -- Mark as bye and finished
+    UPDATE tournament_brackets
+    SET bye = true, finished = true
+    WHERE id = current_bracket.id;
+
+    IF lone_team_id IS NOT NULL THEN
+        -- Runtime bye: one team, no pending feeders → advance
+        RAISE NOTICE 'Resolving runtime bye: bracket %, team % advanced to parent %',
+            current_bracket.id, lone_team_id, current_bracket.parent_bracket_id;
+
+        IF current_bracket.parent_bracket_id IS NOT NULL THEN
+            PERFORM public.assign_team_to_bracket_slot(current_bracket.parent_bracket_id, lone_team_id, current_bracket.id);
+        END IF;
+
+        -- A bye produces no loser. Check if the loser_parent bracket is now
+        -- a dead bracket (0 teams, all feeders finished).
+        IF current_bracket.loser_parent_bracket_id IS NOT NULL THEN
+            DECLARE
+                loser_target tournament_brackets%ROWTYPE;
+            BEGIN
+                SELECT * INTO loser_target
+                FROM tournament_brackets WHERE id = current_bracket.loser_parent_bracket_id;
+                IF loser_target IS NOT NULL THEN
+                    PERFORM resolve_bracket_bye(loser_target);
+                END IF;
+            END;
+        END IF;
+    ELSE
+        -- Dead bracket: zero teams, all feeders finished (e.g. all feeders were byes)
+        RAISE NOTICE 'Resolving dead bracket: bracket % has no teams and no pending feeders',
+            current_bracket.id;
+
+        -- Check if parent bracket should now resolve as bye (it lost a feeder)
+        IF current_bracket.parent_bracket_id IS NOT NULL THEN
+            DECLARE
+                parent_bracket tournament_brackets%ROWTYPE;
+            BEGIN
+                SELECT * INTO parent_bracket
+                FROM tournament_brackets WHERE id = current_bracket.parent_bracket_id;
+                IF parent_bracket IS NOT NULL THEN
+                    PERFORM resolve_bracket_bye(parent_bracket);
+                END IF;
+            END;
+        END IF;
+    END IF;
+
+    -- Check if tournament is now complete
+    SELECT ts.tournament_id INTO tournament_id
+    FROM tournament_stages ts
+    WHERE ts.id = current_bracket.tournament_stage_id;
+
+    IF tournament_id IS NOT NULL THEN
+        PERFORM check_tournament_finished(tournament_id);
+    END IF;
+
+    RETURN true;
+END;
+$$;

hasura/functions/tournaments/seed_stage.sql

@@ -166,8 +166,8 @@ BEGIN
                 team_2_seed_val, team_2_id;
         END LOOP;
 
-        update tournament_brackets set bye = (team_1_id IS NULL OR team_2_id IS NULL) 
-              where tournament_stage_id = stage.id and round = 1;
+        update tournament_brackets set bye = (tournament_team_id_1 IS NULL OR tournament_team_id_2 IS NULL)
+              where tournament_stage_id = stage.id and round = 1 and COALESCE(path, 'WB') = 'WB';
     END IF;
 
     IF stage.type != 'RoundRobin' THEN

hasura/functions/tournaments/update_tournament_bracket.sql

@@ -34,11 +34,11 @@ BEGIN
     WHERE id = bracket.id;
 
     IF bracket.parent_bracket_id IS NOT NULL THEN
-        PERFORM public.assign_team_to_bracket_slot(bracket.parent_bracket_id, winning_team_id);
+        PERFORM public.assign_team_to_bracket_slot(bracket.parent_bracket_id, winning_team_id, bracket.id);
     END IF;
 
     IF bracket.loser_parent_bracket_id IS NOT NULL THEN
-        PERFORM public.assign_team_to_bracket_slot(bracket.loser_parent_bracket_id, losing_team_id);
+        PERFORM public.assign_team_to_bracket_slot(bracket.loser_parent_bracket_id, losing_team_id, bracket.id);
     END IF;
 
     SELECT ts.tournament_id, ts.type INTO tournament_id, stage_type

hasura/triggers/tournament_brackets.sql

@@ -9,12 +9,20 @@ BEGIN
      IF OLD.match_id IS NOT NULL THEN
         return NEW;
      END IF;
-     
+
      -- Don't schedule if bracket is already finished
      IF NEW.finished = true THEN
         return NEW;
      END IF;
 
+     -- Only run scheduling logic when team columns actually change.
+     -- Other updates (scheduled_eta, scheduled_at, etc.) should not
+     -- trigger scheduling or bye resolution.
+     IF (OLD.tournament_team_id_1 IS NOT DISTINCT FROM NEW.tournament_team_id_1) AND
+        (OLD.tournament_team_id_2 IS NOT DISTINCT FROM NEW.tournament_team_id_2) THEN
+        RETURN NEW;
+     END IF;
+
      IF NEW.match_id IS NULL THEN
          -- Check if this is a RoundRobin stage
          SELECT ts.type INTO stage_type
@@ -32,6 +40,11 @@ BEGIN
             IF should_auto_schedule(NEW.tournament_stage_id) THEN
                 PERFORM schedule_tournament_match(NEW);
             END IF;
+         -- One team present but not the other: check for runtime bye
+         ELSIF (NEW.tournament_team_id_1 IS NOT NULL) != (NEW.tournament_team_id_2 IS NOT NULL) THEN
+            IF should_auto_schedule(NEW.tournament_stage_id) THEN
+                PERFORM resolve_bracket_bye(NEW);
+            END IF;
          END IF;
      END IF;
 

hasura/triggers/tournaments.sql

@@ -37,6 +37,24 @@ BEGIN
         OLD.status = 'Paused' AND NEW.status = 'Live'
         AND NEW.auto_start
     ) THEN
+        -- Resolve runtime byes first (one team, no pending feeders)
+        -- Process lower rounds first so cascading byes propagate correctly
+        FOR bracket_row IN
+            SELECT tb.*
+            FROM tournament_brackets tb
+            INNER JOIN tournament_stages ts ON ts.id = tb.tournament_stage_id
+            WHERE ts.tournament_id = NEW.id
+              AND tb.match_id IS NULL
+              AND tb.finished = false
+              AND tb.bye = false
+              AND ((tb.tournament_team_id_1 IS NOT NULL AND tb.tournament_team_id_2 IS NULL)
+                OR (tb.tournament_team_id_1 IS NULL AND tb.tournament_team_id_2 IS NOT NULL))
+            ORDER BY tb.round, tb.match_number
+        LOOP
+            PERFORM resolve_bracket_bye(bracket_row);
+        END LOOP;
+
+        -- Then schedule matches with both teams present
         FOR bracket_row IN
             SELECT tb.*
             FROM tournament_brackets tb