fix: allow deletion of cancelled tournaments with match demos (#103)

Co-authored-by: Flegma <Flegma@users.noreply.github.com>
Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com>

Author: Flegma

hasura/metadata/actions.graphql

@@ -54,6 +54,12 @@ type Mutation {
   ): SuccessOutput
 }
 
+type Mutation {
+  deleteTournament(
+    tournament_id: uuid!
+  ): SuccessOutput
+}
+
 type Mutation {
   deleteServerItem(
     node_id: String!

hasura/metadata/actions.yaml

@@ -67,6 +67,14 @@ actions:
       forward_client_headers: true
     permissions:
       - role: administrator
+  - name: deleteTournament
+    definition:
+      kind: synchronous
+      handler: '{{HASURA_GRAPHQL_ACTIONS_HOOK}}'
+      forward_client_headers: true
+    permissions:
+      - role: user
+    comment: Delete a tournament and clean up demo files
   - name: deleteServerItem
     definition:
       kind: synchronous

hasura/metadata/databases/default/tables/public_tournaments.yaml

@@ -358,10 +358,3 @@ update_permissions:
         is_organizer:
           _eq: true
     comment: ""
-delete_permissions:
-  - role: user
-    permission:
-      filter:
-        is_organizer:
-          _eq: true
-    comment: ""

hasura/triggers/tournament_teams.sql

@@ -32,9 +32,10 @@ BEGIN
     SELECT status
     INTO tournament_status
     FROM tournaments
-    WHERE id = NEW.tournament_id;
+    WHERE id = OLD.tournament_id;
 
-    IF tournament_status = 'Cancelled' OR tournament_status = 'CancelledMinTeams' OR tournament_status = 'Finished' THEN
+    -- If tournament doesn't exist (cascade delete), allow the team removal
+    IF tournament_status IS NOT NULL AND tournament_status IN ('Cancelled', 'CancelledMinTeams', 'Finished') THEN
         RAISE EXCEPTION 'Cannot leave an active tournament' USING ERRCODE = '22000';
     END IF;
 

src/app.module.ts

@@ -43,6 +43,7 @@ import { K8sModule } from "./k8s/k8s.module";
 import { FileManagerModule } from "./file-manager/file-manager.module";
 import { BrandingModule } from "./branding/branding.module";
 import { FixturesModule } from "./fixtures/fixtures.module";
+import { TournamentsModule } from "./tournaments/tournaments.module";
 
 @Module({
   imports: [
@@ -126,6 +127,7 @@ import { FixturesModule } from "./fixtures/fixtures.module";
     FileManagerModule,
     BrandingModule,
     FixturesModule,
+    TournamentsModule,
   ],
   providers: [loggerFactory()],
   controllers: [AppController, QuickConnectController],

src/tournaments/tournaments.controller.ts

@@ -0,0 +1,143 @@
+import { Controller, Logger } from "@nestjs/common";
+import { HasuraAction } from "../hasura/hasura.controller";
+import { HasuraService } from "../hasura/hasura.service";
+import { S3Service } from "../s3/s3.service";
+import { User } from "../auth/types/User";
+
+@Controller("tournaments")
+export class TournamentsController {
+  constructor(
+    private readonly logger: Logger,
+    private readonly hasura: HasuraService,
+    private readonly s3: S3Service,
+  ) {}
+
+  @HasuraAction()
+  public async deleteTournament(data: {
+    user: User;
+    tournament_id: string;
+  }) {
+    const { tournament_id } = data;
+    this.logger.log(`[${tournament_id}] deleting tournament`);
+
+    // Query with user context for authorization checks
+    const { tournaments_by_pk } = await this.hasura.query(
+      {
+        tournaments_by_pk: {
+          __args: {
+            id: tournament_id,
+          },
+          id: true,
+          status: true,
+          is_organizer: true,
+        },
+      },
+      data.user.steam_id,
+    );
+
+    if (!tournaments_by_pk) {
+      throw Error("tournament not found");
+    }
+
+    if (!tournaments_by_pk.is_organizer) {
+      throw Error("not the tournament organizer");
+    }
+
+    if (tournaments_by_pk.status === "Live") {
+      throw Error("cannot delete a live tournament");
+    }
+
+    // Query as admin to access demo file paths
+    const { tournaments_by_pk: tournament } = await this.hasura.query({
+      tournaments_by_pk: {
+        __args: {
+          id: tournament_id,
+        },
+        stages: {
+          brackets: {
+            match: {
+              id: true,
+              match_maps: {
+                demos: {
+                  id: true,
+                  file: true,
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const demos: Array<{ id: string; file: string }> = [];
+    const matchIds: string[] = [];
+
+    for (const stage of tournament.stages || []) {
+      for (const bracket of stage.brackets || []) {
+        if (!bracket.match) {
+          continue;
+        }
+        matchIds.push(bracket.match.id);
+        for (const matchMap of bracket.match.match_maps || []) {
+          for (const demo of matchMap.demos || []) {
+            demos.push(demo);
+          }
+        }
+      }
+    }
+
+    for (const demo of demos) {
+      try {
+        await this.s3.remove(demo.file);
+        await this.hasura.mutation({
+          delete_match_map_demos_by_pk: {
+            __args: {
+              id: demo.id,
+            },
+            __typename: true,
+          },
+        });
+      } catch (error) {
+        this.logger.error(
+          `[${tournament_id}] failed to clean up demo ${demo.id}`,
+          error,
+        );
+      }
+    }
+
+    for (const matchId of matchIds) {
+      try {
+        await this.hasura.mutation({
+          delete_matches_by_pk: {
+            __args: {
+              id: matchId,
+            },
+            __typename: true,
+          },
+        });
+      } catch (error) {
+        this.logger.error(
+          `[${tournament_id}] failed to delete match ${matchId}`,
+          error,
+        );
+      }
+    }
+
+    await this.hasura.mutation({
+      delete_tournaments_by_pk: {
+        __args: {
+          id: tournament_id,
+        },
+        __typename: true,
+      },
+    });
+
+    this.logger.log(
+      `[${tournament_id}] tournament deleted, cleaned up ${demos.length} demo files across ${matchIds.length} matches`,
+    );
+
+    return {
+      success: true,
+    };
+  }
+}

src/tournaments/tournaments.module.ts

@@ -0,0 +1,12 @@
+import { Module } from "@nestjs/common";
+import { TournamentsController } from "./tournaments.controller";
+import { HasuraModule } from "../hasura/hasura.module";
+import { S3Module } from "../s3/s3.module";
+import { loggerFactory } from "../utilities/LoggerFactory";
+
+@Module({
+  imports: [HasuraModule, S3Module],
+  controllers: [TournamentsController],
+  providers: [loggerFactory()],
+})
+export class TournamentsModule {}