init

src/lib/pocketbase/services/players.ts

@@ -0,0 +1,46 @@
+import type { Player, PlayerInput, PlayerUpdateInput } from '@/features/players/types';
+import { transformPlayer } from '@/lib/pocketbase/util/transform-types';
+import PocketBase from 'pocketbase';
+
+export function createPlayersService(pb: PocketBase) {
+  return {
+    async getPlayerByAuthId(authId: string): Promise<Player | null> {
+      const result = await pb.collection('players').getList<Player>(1, 1, {
+        filter: `auth_id = "${authId}"`
+      });
+      return result.items[0] ? transformPlayer(result.items[0]) : null;
+    },
+
+    async getPlayer(id: string): Promise<Player | null> {
+      const result = await pb.collection('players').getOne(id, {
+        expand: 'teams'
+      });
+      return transformPlayer(result);
+    },
+
+    async listPlayers(): Promise<Player[]> {
+      const result = await pb.collection('players').getFullList<Player>({
+        fields: 'id,first_name,last_name'
+      });
+      return result.map(transformPlayer);
+    },
+
+    async createPlayer(data: PlayerInput): Promise<Player> {
+      const result = await pb.collection('players').create<Player>(data);
+      return transformPlayer(result);
+    },
+
+    async updatePlayer(id: string, data: PlayerUpdateInput): Promise<Player> {
+      const result = await pb.collection('players').update<Player>(id, data);
+      return transformPlayer(result);
+    },
+
+    async getUnassociatedPlayers(): Promise<Player[]> {
+      const result = await pb.collection('players').getFullList<Player>({
+        filter: 'auth_id = ""',
+        fields: 'id,first_name,last_name'
+      });
+      return result.map(transformPlayer);
+    }
+  };
+}

src/lib/pocketbase/services/teams.ts

@@ -0,0 +1,20 @@
+import { logger } from "@/lib/logger";
+import PocketBase from "pocketbase";
+import { transformTeam } from "@/lib/pocketbase/util/transform-types";
+import { Team } from "@/features/teams/types";
+
+export function createTeamsService(pb: PocketBase) {
+  return {
+    async getTeam(id: string): Promise<Team | null> {
+      try {
+        logger.info('PocketBase | Getting team', id);
+        const result = await pb.collection('teams').getOne(id, {
+          expand: 'players, tournaments'
+        });
+        return transformTeam(result);
+      } catch {
+        return null;
+      }
+    },
+  };
+}

src/lib/pocketbase/services/tournaments.ts

@@ -0,0 +1,57 @@
+import { logger } from "@/lib/logger";
+import type { Tournament, TournamentInput, TournamentUpdateInput } from "@/features/tournaments/types";
+import PocketBase from "pocketbase";
+import { transformTournament } from "@/lib/pocketbase/util/transform-types";
+import { BracketGenerator } from "@/features/bracket/bracket";
+
+export function createTournamentsService(pb: PocketBase) {
+  return {
+    async getTournament(id: string): Promise<Tournament | null> {
+      try {
+        const generator = new BracketGenerator(12, true);
+        
+        console.log("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-")
+        console.log('Winners Bracket:');
+        generator.bracket.forEach((round, i) => {
+          console.log(`Round ${i}:`);
+          round.forEach(match => {
+            console.log('-', match);
+          });
+        });
+
+        console.log('\nLosers Bracket:');
+        generator.losersBracket.forEach((round, i) => {
+          console.log(`Round ${i}:`);
+          round.forEach(match => {
+            console.log('-', match);
+          });
+        });
+
+        logger.info('PocketBase | Getting tournament', id);
+        const result = await pb.collection('tournaments').getOne(id, {
+          expand: 'teams, teams.players'
+        });
+        return transformTournament(result);
+      } catch {
+        return null;
+      }
+    },
+    async listTournaments(): Promise<Tournament[]> {
+      const result = await pb.collection('tournaments').getFullList<Tournament>({
+        fields: 'id,name,start_time,end_time,logo_url,created',
+        sort: '-created'
+      });
+
+      console.log(result)
+      return result.map(transformTournament);
+    },
+    async createTournament(data: TournamentInput): Promise<Tournament> {
+      const result = await pb.collection('tournaments').create<Tournament>(data);
+      return transformTournament(result);
+    },
+    async updateTournament(id: string, data: TournamentUpdateInput): Promise<Tournament> {
+      const result = await pb.collection('tournaments').update<Tournament>(id, data);
+      return transformTournament(result);
+    },
+  };
+}