Improvement/tournament creation (#96)

Co-authored-by: Luke Policinski <luke@lukepolo.com>

Author: Flegma

generated/schema.graphql

@@ -951,8 +951,8 @@ BEGIN
       now() - interval '7 days'
     );
 
-    INSERT INTO tournament_stages (id, tournament_id, type, "order", min_teams, max_teams, match_options_id)
-    VALUES (t2_stage_id, tournament_ids[2], 'SingleElimination', 1, 4, 8, t2_options_id);
+    INSERT INTO tournament_stages (id, tournament_id, type, "order", min_teams, max_teams, match_options_id, third_place_match, decider_best_of)
+    VALUES (t2_stage_id, tournament_ids[2], 'SingleElimination', 1, 4, 8, t2_options_id, true, 1);
 
     -- Register all 6 teams
     FOR t IN 1..6 LOOP
@@ -1286,8 +1286,8 @@ BEGIN
       now() - interval '2 days'
     );
 
-    INSERT INTO tournament_stages (id, tournament_id, type, "order", min_teams, max_teams, match_options_id)
-    VALUES (t3_stage_id, tournament_ids[3], 'SingleElimination', 1, 4, 16, t3_options_id);
+    INSERT INTO tournament_stages (id, tournament_id, type, "order", min_teams, max_teams, match_options_id, default_best_of)
+    VALUES (t3_stage_id, tournament_ids[3], 'SingleElimination', 1, 4, 16, t3_options_id, 3);
 
     -- Register 2 teams so far
     FOR t IN 1..2 LOOP
@@ -1367,12 +1367,12 @@ BEGIN
     );
 
     -- Stage 1: Round Robin (2 groups of 4)
-    INSERT INTO tournament_stages (id, tournament_id, type, "order", min_teams, max_teams, match_options_id)
-    VALUES (t4_stage1_id, tournament_ids[4], 'RoundRobin', 1, 8, 8, t4_rr_options_id);
+    INSERT INTO tournament_stages (id, tournament_id, type, "order", min_teams, max_teams, match_options_id, groups)
+    VALUES (t4_stage1_id, tournament_ids[4], 'RoundRobin', 1, 8, 8, t4_rr_options_id, 2);
 
     -- Stage 2: Double Elimination (top 2 from each group = 4 teams)
-    INSERT INTO tournament_stages (id, tournament_id, type, "order", min_teams, max_teams, match_options_id)
-    VALUES (t4_stage2_id, tournament_ids[4], 'DoubleElimination', 2, 4, 4, t4_de_options_id);
+    INSERT INTO tournament_stages (id, tournament_id, type, "order", min_teams, max_teams, match_options_id, default_best_of, settings)
+    VALUES (t4_stage2_id, tournament_ids[4], 'DoubleElimination', 2, 4, 4, t4_de_options_id, 3, '{"round_best_of": {"GF": 5}}');
 
     -- Register all 8 teams
     FOR t IN 1..8 LOOP

generated/schema.ts

@@ -0,0 +1,49 @@
+CREATE OR REPLACE FUNCTION clone_match_options_with_best_of(
+    _match_options_id uuid,
+    _target_best_of int
+)
+RETURNS uuid AS $$
+DECLARE
+    match_options_record match_options%ROWTYPE;
+    cloned_id uuid;
+BEGIN
+    IF _match_options_id IS NULL THEN
+        RETURN NULL;
+    END IF;
+
+    SELECT * INTO match_options_record
+    FROM match_options
+    WHERE id = _match_options_id;
+
+    IF NOT FOUND THEN
+        RETURN NULL;
+    END IF;
+
+    -- If target best_of matches, no clone needed
+    IF _target_best_of = match_options_record.best_of THEN
+        RETURN _match_options_id;
+    END IF;
+
+    -- Clone with new best_of
+    INSERT INTO match_options (
+        overtime, knife_round, mr, best_of, coaches, number_of_substitutes,
+        map_veto, timeout_setting, tech_timeout_setting, map_pool_id, type,
+        regions, prefer_dedicated_server, invite_code, lobby_access,
+        region_veto, ready_setting, check_in_setting, default_models, tv_delay
+    ) VALUES (
+        match_options_record.overtime, match_options_record.knife_round,
+        match_options_record.mr, _target_best_of,
+        match_options_record.coaches, match_options_record.number_of_substitutes,
+        match_options_record.map_veto, match_options_record.timeout_setting,
+        match_options_record.tech_timeout_setting, match_options_record.map_pool_id,
+        match_options_record.type, match_options_record.regions,
+        match_options_record.prefer_dedicated_server, match_options_record.invite_code,
+        match_options_record.lobby_access, match_options_record.region_veto,
+        match_options_record.ready_setting, match_options_record.check_in_setting,
+        match_options_record.default_models, match_options_record.tv_delay
+    )
+    RETURNING id INTO cloned_id;
+
+    RETURN cloned_id;
+END;
+$$ LANGUAGE plpgsql;

generated/types.ts

@@ -26,7 +26,6 @@ DECLARE
     k int;                   -- WB round feeding this LB round (for FEED rounds)
 
     -- Grand Final
-    grand_finals_match_options_id uuid;
     gf_id uuid;
     lb_final_id uuid;
 BEGIN
@@ -154,36 +153,10 @@ BEGIN
 
         -- Grand Finals: WB winner vs LB winner
         IF wb_rounds > 0 AND _next_stage_max_teams = 1 THEN
-            grand_finals_match_options_id := update_match_options_best_of(_stage_id);
-
-            INSERT INTO tournament_brackets(round, tournament_stage_id, match_number, "group", path, match_options_id)
-            VALUES (wb_rounds + 1, _stage_id, 1, g, 'WB', grand_finals_match_options_id)
+            INSERT INTO tournament_brackets(round, tournament_stage_id, match_number, "group", path)
+            VALUES (wb_rounds + 1, _stage_id, 1, g, 'WB')
             RETURNING id INTO gf_id;
 
-            -- Apply decider to WB Final (last WB round)
-            IF grand_finals_match_options_id IS NOT NULL THEN
-                UPDATE tournament_brackets
-                SET match_options_id = grand_finals_match_options_id
-                WHERE tournament_stage_id = _stage_id
-                  AND path = 'WB'
-                  AND round = wb_rounds
-                  AND "group" = g;
-
-                RAISE NOTICE 'DE decider: applied decider match_options to WB Final (round %, group %)', wb_rounds, g;
-            END IF;
-
-            -- Apply decider to LB Final (last LB round)
-            IF lb_rounds > 0 AND grand_finals_match_options_id IS NOT NULL THEN
-                UPDATE tournament_brackets
-                SET match_options_id = grand_finals_match_options_id
-                WHERE tournament_stage_id = _stage_id
-                  AND path = 'LB'
-                  AND round = lb_rounds
-                  AND "group" = loser_group_num;
-
-                RAISE NOTICE 'DE decider: applied decider match_options to LB Final (round %, group %)', lb_rounds, loser_group_num;
-            END IF;
-
             IF lb_rounds > 0 THEN
                 SELECT id INTO lb_final_id
                 FROM tournament_brackets

hasura/fixtures/fixtures.sql

@@ -15,9 +15,6 @@ DECLARE
     seed_1 int;
     seed_2 int;
     bracket_idx int;
-    match_options_id uuid;
-    is_elimination_match boolean;
-    is_advancement_match boolean;
 BEGIN
     -- Valve-style Swiss system: teams need 3 wins to advance or 3 losses to be eliminated
     -- Max rounds formula: 2 × wins_needed - 1
@@ -184,19 +181,6 @@ BEGIN
                         wins, losses, pool_group, matches_needed, ROUND(matches_calc, 2);
                 END;
 
-                -- Check if this is an elimination or advancement match
-                -- Elimination: losses = wins_needed - 1 (next loss eliminates)
-                -- Advancement: wins = wins_needed - 1 (next win advances)
-                is_elimination_match := (losses = wins_needed - 1);
-                is_advancement_match := (wins = wins_needed - 1);
-                
-                -- Get match_options_id, creating a new one with best_of=3 if it's elimination/advancement
-                IF is_elimination_match OR is_advancement_match THEN
-                    match_options_id := update_match_options_best_of(_stage_id);
-                ELSE
-                    match_options_id := NULL;
-                END IF;
-                
                 -- Create placeholder matches for this pool
                 -- Each pool gets its own match_number sequence starting from 1
                 FOR match_num IN 1..matches_needed LOOP
@@ -205,16 +189,14 @@ BEGIN
                         tournament_stage_id,
                         match_number,
                         "group",
-                        path,
-                        match_options_id
+                        path
                     )
                     VALUES (
                         round_num,
                         _stage_id,
                         match_num,
                         pool_group,
-                        'WB',
-                        match_options_id
+                        'WB'
                     );
                     matches_created := matches_created + 1;
                 END LOOP;

hasura/functions/tournaments/clone_match_options_with_best_of.sql

@@ -0,0 +1,62 @@
+CREATE OR REPLACE FUNCTION get_bracket_best_of(
+    _stage_id uuid,
+    _path text,
+    _round int
+)
+RETURNS int AS $$
+DECLARE
+    _stage tournament_stages;
+    _round_key text;
+    _round_best_of int;
+BEGIN
+    SELECT * INTO _stage
+    FROM tournament_stages
+    WHERE id = _stage_id;
+
+    IF NOT FOUND THEN
+        RETURN 1;
+    END IF;
+
+    -- Build the lookup key based on stage type
+    IF _stage.type = 'Swiss' THEN
+        -- For Swiss, the "round" is encoded as wins*100+losses in the group field
+        -- But when called from schedule_tournament_match, we pass the bracket's group as round
+        -- The caller should pass the appropriate key: "regular", "advancement", or "elimination"
+        -- This function receives path as the swiss match type key
+        _round_key := _path;
+    ELSE
+        -- For SE/DE: key is "path:round" e.g. "WB:1", "LB:3", "GF"
+        IF _path = 'WB' AND _stage.type = 'DoubleElimination' THEN
+            -- Check if this is the Grand Final round (WB round > ceil(log2(teams)))
+            DECLARE
+                _wb_rounds int;
+                _teams_per_group int;
+            BEGIN
+                SELECT CEIL(LOG(CEIL(ts.max_teams::float / ts.groups)::numeric) / LOG(2))::int
+                INTO _wb_rounds
+                FROM tournament_stages ts
+                WHERE ts.id = _stage_id;
+
+                IF _round > _wb_rounds THEN
+                    _round_key := 'GF';
+                ELSE
+                    _round_key := _path || ':' || _round::text;
+                END IF;
+            END;
+        ELSE
+            _round_key := _path || ':' || _round::text;
+        END IF;
+    END IF;
+
+    -- Look up in settings JSONB
+    IF _stage.settings IS NOT NULL AND _stage.settings ? 'round_best_of' THEN
+        _round_best_of := (_stage.settings->'round_best_of'->>_round_key)::int;
+        IF _round_best_of IS NOT NULL THEN
+            RETURN _round_best_of;
+        END IF;
+    END IF;
+
+    -- Fall back to default_best_of
+    RETURN _stage.default_best_of;
+END;
+$$ LANGUAGE plpgsql;

hasura/functions/tournaments/generate_double_elimination_bracket.sql

@@ -12,6 +12,8 @@ CREATE OR REPLACE FUNCTION public.schedule_tournament_match(bracket public.tourn
      feeders_with_team int := 0;
      winner_id UUID;
      _match_options_id UUID;
+     _round_best_of int;
+     _swiss_match_type text;
  BEGIN
    	IF bracket.match_id IS NOT NULL THEN
    	 RETURN bracket.match_id;
@@ -44,7 +46,7 @@ CREATE OR REPLACE FUNCTION public.schedule_tournament_match(bracket public.tourn
      INNER JOIN tournaments t ON t.id = ts.tournament_id
      WHERE tb.id = bracket.id;
 
-     -- Check bracket first (decider overrides), then stage, then tournament
+     -- Check bracket first (organizer overrides), then stage, then tournament
      IF bracket.match_options_id IS NOT NULL THEN
          _match_options_id := bracket.match_options_id;
      ELSIF stage.match_options_id IS NOT NULL THEN
@@ -53,6 +55,45 @@ CREATE OR REPLACE FUNCTION public.schedule_tournament_match(bracket public.tourn
          _match_options_id := tournament.match_options_id;
      END IF;
 
+     -- Per-round best_of resolution (only when bracket has no custom match_options)
+     IF bracket.match_options_id IS NULL THEN
+         IF stage.type = 'Swiss' THEN
+             -- Swiss: decode group (wins*100+losses) to determine match type
+             DECLARE
+                 _wins int;
+                 _losses int;
+                 _wins_needed int := 3;
+             BEGIN
+                 _wins := (bracket."group" / 100)::int;
+                 _losses := (bracket."group" % 100)::int;
+                 IF _wins = _wins_needed - 1 THEN
+                     _swiss_match_type := 'advancement';
+                 ELSIF _losses = _wins_needed - 1 THEN
+                     _swiss_match_type := 'elimination';
+                 ELSE
+                     _swiss_match_type := 'regular';
+                 END IF;
+                 _round_best_of := get_bracket_best_of(stage.id, _swiss_match_type, bracket.round);
+             END;
+         ELSE
+             _round_best_of := get_bracket_best_of(stage.id, bracket.path, bracket.round);
+         END IF;
+
+         -- If round best_of differs from the resolved match_options, clone with new best_of
+         IF _round_best_of IS NOT NULL THEN
+             DECLARE
+                 _current_best_of int;
+             BEGIN
+                 SELECT mo.best_of INTO _current_best_of
+                 FROM match_options mo WHERE mo.id = _match_options_id;
+
+                 IF _current_best_of IS DISTINCT FROM _round_best_of THEN
+                     _match_options_id := clone_match_options_with_best_of(_match_options_id, _round_best_of);
+                 END IF;
+             END;
+         END IF;
+     END IF;
+
      -- Create the match first
      INSERT INTO matches (
          status,

hasura/functions/tournaments/generate_swiss_bracket.sql

@@ -294,59 +294,35 @@ BEGIN
             RAISE NOTICE '  => Linking matches within stage %', stage."order";
             PERFORM link_tournament_stage_matches(stage.id);
 
-            -- SE decider: apply decider best_of to final and optionally create 3rd place match
-            IF stage.decider_best_of IS NOT NULL THEN
+            -- 3rd place match: create if enabled and there are at least 2 rounds (semifinals exist)
+            IF stage.third_place_match = true AND total_rounds >= 2 THEN
                 DECLARE
-                    _decider_match_options_id uuid;
-                    _final_bracket_id uuid;
                     _third_place_id uuid;
                     _semi_record RECORD;
                 BEGIN
-                    _decider_match_options_id := update_match_options_best_of(stage.id);
+                    INSERT INTO tournament_brackets (
+                        round, tournament_stage_id, match_number, "group", path
+                    ) VALUES (
+                        total_rounds, stage.id, 2, 1, 'WB'
+                    )
+                    RETURNING id INTO _third_place_id;
 
-                    -- Apply decider match_options to the final (last round, match 1)
-                    SELECT id INTO _final_bracket_id
-                    FROM tournament_brackets
-                    WHERE tournament_stage_id = stage.id
-                      AND path = 'WB'
-                      AND round = total_rounds
-                      AND match_number = 1
-                    LIMIT 1;
+                    RAISE NOTICE '  => 3rd place: created bracket % in round %', _third_place_id, total_rounds;
 
-                    IF _final_bracket_id IS NOT NULL AND _decider_match_options_id IS NOT NULL THEN
+                    -- Set loser_parent_bracket_id on semifinal brackets to route losers to 3rd place match
+                    FOR _semi_record IN
+                        SELECT id FROM tournament_brackets
+                        WHERE tournament_stage_id = stage.id
+                          AND path = 'WB'
+                          AND round = total_rounds - 1
+                        ORDER BY match_number ASC
+                    LOOP
                         UPDATE tournament_brackets
-                        SET match_options_id = _decider_match_options_id
-                        WHERE id = _final_bracket_id;
+                        SET loser_parent_bracket_id = _third_place_id
+                        WHERE id = _semi_record.id;
 
-                        RAISE NOTICE '  => SE decider: applied decider match_options to final bracket %', _final_bracket_id;
-                    END IF;
-
-                    -- Create 3rd place match if there are at least 2 rounds (semifinals exist)
-                    IF total_rounds >= 2 THEN
-                        INSERT INTO tournament_brackets (
-                            round, tournament_stage_id, match_number, "group", path, match_options_id
-                        ) VALUES (
-                            total_rounds, stage.id, 2, 1, 'WB', _decider_match_options_id
-                        )
-                        RETURNING id INTO _third_place_id;
-
-                        RAISE NOTICE '  => SE decider: created 3rd place bracket % in round %', _third_place_id, total_rounds;
-
-                        -- Set loser_parent_bracket_id on semifinal brackets to route losers to 3rd place match
-                        FOR _semi_record IN
-                            SELECT id FROM tournament_brackets
-                            WHERE tournament_stage_id = stage.id
-                              AND path = 'WB'
-                              AND round = total_rounds - 1
-                            ORDER BY match_number ASC
-                        LOOP
-                            UPDATE tournament_brackets
-                            SET loser_parent_bracket_id = _third_place_id
-                            WHERE id = _semi_record.id;
-
-                            RAISE NOTICE '  => SE decider: set semifinal % loser -> 3rd place %', _semi_record.id, _third_place_id;
-                        END LOOP;
-                    END IF;
+                        RAISE NOTICE '  => 3rd place: set semifinal % loser -> 3rd place %', _semi_record.id, _third_place_id;
+                    END LOOP;
                 END;
             END IF;
         END IF;