@opprs/db-prisma 2.2.1 → 2.5.0

package/dist/index.cjs

@@ -20,65 +20,164 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  MAX_API_KEYS_PER_USER: () => MAX_API_KEYS_PER_USER,
+  applyRDDecayForInactivePlayers: () => applyRDDecayForInactivePlayers,
   connect: () => connect,
+  countBlogPosts: () => countBlogPosts,
+  countBlogTags: () => countBlogTags,
+  countEntries: () => countEntries,
+  countLocations: () => countLocations,
+  countMatches: () => countMatches,
+  countOpprPlayerRankings: () => countOpprPlayerRankings,
+  countOpprRankingHistory: () => countOpprRankingHistory,
   countPlayers: () => countPlayers,
-  countResults: () => countResults,
+  countPublishedBlogPosts: () => countPublishedBlogPosts,
+  countRounds: () => countRounds,
+  countStandings: () => countStandings,
   countTournaments: () => countTournaments,
+  countUserApiKeys: () => countUserApiKeys,
   countUsers: () => countUsers,
-  createManyResults: () => createManyResults,
+  createApiKey: () => createApiKey,
+  createBlogPost: () => createBlogPost,
+  createBlogTag: () => createBlogTag,
+  createEntry: () => createEntry,
+  createLocation: () => createLocation,
+  createManyEntries: () => createManyEntries,
+  createManyMatches: () => createManyMatches,
+  createManyRounds: () => createManyRounds,
+  createManyStandings: () => createManyStandings,
+  createMatch: () => createMatch,
+  createOpprPlayerRanking: () => createOpprPlayerRanking,
+  createOpprRankingHistory: () => createOpprRankingHistory,
   createPlayer: () => createPlayer,
-  createResult: () => createResult,
+  createRound: () => createRound,
+  createStanding: () => createStanding,
   createTournament: () => createTournament,
   createUser: () => createUser,
   createUserWithPlayer: () => createUserWithPlayer,
+  deleteApiKey: () => deleteApiKey,
+  deleteBlogPost: () => deleteBlogPost,
+  deleteBlogTag: () => deleteBlogTag,
+  deleteEntriesByMatch: () => deleteEntriesByMatch,
+  deleteEntry: () => deleteEntry,
+  deleteLocation: () => deleteLocation,
+  deleteMatch: () => deleteMatch,
+  deleteMatchesByRound: () => deleteMatchesByRound,
+  deleteMatchesByTournament: () => deleteMatchesByTournament,
+  deleteOpprPlayerRanking: () => deleteOpprPlayerRanking,
   deletePlayer: () => deletePlayer,
-  deleteResult: () => deleteResult,
-  deleteResultsByTournament: () => deleteResultsByTournament,
+  deleteRound: () => deleteRound,
+  deleteRoundsByTournament: () => deleteRoundsByTournament,
+  deleteStanding: () => deleteStanding,
+  deleteStandingsByTournament: () => deleteStandingsByTournament,
   deleteTournament: () => deleteTournament,
   deleteUser: () => deleteUser,
+  deleteUserApiKey: () => deleteUserApiKey,
   disconnect: () => disconnect,
+  findApiKeyById: () => findApiKeyById,
+  findApiKeysByPrefix: () => findApiKeysByPrefix,
+  findBlogPostById: () => findBlogPostById,
+  findBlogPostBySlug: () => findBlogPostBySlug,
+  findBlogPosts: () => findBlogPosts,
+  findBlogTagById: () => findBlogTagById,
+  findBlogTagBySlug: () => findBlogTagBySlug,
+  findBlogTags: () => findBlogTags,
+  findEntries: () => findEntries,
+  findEntryById: () => findEntryById,
+  findEntryByMatchAndPlayer: () => findEntryByMatchAndPlayer,
+  findLocationByExternalId: () => findLocationByExternalId,
+  findLocationById: () => findLocationById,
+  findLocations: () => findLocations,
+  findMatchById: () => findMatchById,
+  findMatches: () => findMatches,
+  findOpprPlayerRankingById: () => findOpprPlayerRankingById,
+  findOpprPlayerRankingByPlayerId: () => findOpprPlayerRankingByPlayerId,
+  findOpprPlayerRankings: () => findOpprPlayerRankings,
   findPlayerByExternalId: () => findPlayerByExternalId,
   findPlayerById: () => findPlayerById,
+  findPlayerByPlayerNumber: () => findPlayerByPlayerNumber,
   findPlayerByUserEmail: () => findPlayerByUserEmail,
   findPlayers: () => findPlayers,
-  findResultById: () => findResultById,
-  findResultByPlayerAndTournament: () => findResultByPlayerAndTournament,
-  findResults: () => findResults,
+  findPublishedBlogPosts: () => findPublishedBlogPosts,
+  findRoundById: () => findRoundById,
+  findRoundByTournamentAndNumber: () => findRoundByTournamentAndNumber,
+  findRounds: () => findRounds,
+  findStandingById: () => findStandingById,
+  findStandingByPlayerAndTournament: () => findStandingByPlayerAndTournament,
+  findStandings: () => findStandings,
   findTournamentByExternalId: () => findTournamentByExternalId,
   findTournamentById: () => findTournamentById,
   findTournaments: () => findTournaments,
   findUserByEmail: () => findUserByEmail,
   findUserById: () => findUserById,
   findUsers: () => findUsers,
+  generateUniquePlayerNumber: () => generateUniquePlayerNumber,
+  getBlogTagWithPostCount: () => getBlogTagWithPostCount,
+  getBlogTagsWithPostCounts: () => getBlogTagsWithPostCounts,
+  getFinalsRounds: () => getFinalsRounds,
+  getFinalsStandings: () => getFinalsStandings,
+  getLatestOpprRankingHistory: () => getLatestOpprRankingHistory,
+  getLocationWithTournaments: () => getLocationWithTournaments,
   getMajorTournaments: () => getMajorTournaments,
-  getPlayerResults: () => getPlayerResults,
+  getMatchEntries: () => getMatchEntries,
+  getMatchWithEntries: () => getMatchWithEntries,
+  getMergedStandings: () => getMergedStandings,
+  getOpprRankingHistory: () => getOpprRankingHistory,
+  getOpprRankingHistoryByDateRange: () => getOpprRankingHistoryByDateRange,
+  getOrCreateOpprPlayerRanking: () => getOrCreateOpprPlayerRanking,
+  getPlayerEntries: () => getPlayerEntries,
+  getPlayerEntryStats: () => getPlayerEntryStats,
+  getPlayerStandings: () => getPlayerStandings,
   getPlayerStats: () => getPlayerStats,
   getPlayerTopFinishes: () => getPlayerTopFinishes,
+  getPlayerTournamentEntries: () => getPlayerTournamentEntries,
+  getPlayerTournamentMatches: () => getPlayerTournamentMatches,
   getPlayerWithResults: () => getPlayerWithResults,
-  getRatedPlayers: () => getRatedPlayers,
+  getQualifyingRounds: () => getQualifyingRounds,
+  getQualifyingStandings: () => getQualifyingStandings,
+  getRatedOpprPlayers: () => getRatedOpprPlayers,
   getRecentTournaments: () => getRecentTournaments,
-  getTopPlayersByRanking: () => getTopPlayersByRanking,
-  getTopPlayersByRating: () => getTopPlayersByRating,
-  getTournamentResults: () => getTournamentResults,
+  getRoundMatches: () => getRoundMatches,
+  getRoundWithMatches: () => getRoundWithMatches,
+  getTopPlayersByOpprRanking: () => getTopPlayersByOpprRanking,
+  getTopPlayersByOpprRating: () => getTopPlayersByOpprRating,
+  getTournamentMatches: () => getTournamentMatches,
+  getTournamentRounds: () => getTournamentRounds,
+  getTournamentStandings: () => getTournamentStandings,
   getTournamentStats: () => getTournamentStats,
+  getTournamentWithMatches: () => getTournamentWithMatches,
   getTournamentWithResults: () => getTournamentWithResults,
   getTournamentsByBoosterType: () => getTournamentsByBoosterType,
   getTournamentsByDateRange: () => getTournamentsByDateRange,
+  getUserApiKeys: () => getUserApiKeys,
   getUserByEmailWithPlayer: () => getUserByEmailWithPlayer,
   getUserWithPlayer: () => getUserWithPlayer,
+  isValidPlayerNumber: () => isValidPlayerNumber,
   linkPlayerToUser: () => linkPlayerToUser,
   prisma: () => prisma,
   recalculateTimeDecay: () => recalculateTimeDecay,
+  searchBlogPosts: () => searchBlogPosts,
+  searchBlogTags: () => searchBlogTags,
+  searchLocations: () => searchLocations,
   searchPlayers: () => searchPlayers,
   searchTournaments: () => searchTournaments,
   testConnection: () => testConnection,
+  updateApiKeyLastUsed: () => updateApiKeyLastUsed,
+  updateBlogPost: () => updateBlogPost,
+  updateBlogTag: () => updateBlogTag,
+  updateEntry: () => updateEntry,
+  updateLocation: () => updateLocation,
+  updateMatch: () => updateMatch,
+  updateOpprPlayerRanking: () => updateOpprPlayerRanking,
+  updateOpprRatingAfterTournament: () => updateOpprRatingAfterTournament,
   updatePlayer: () => updatePlayer,
-  updatePlayerRating: () => updatePlayerRating,
-  updateResult: () => updateResult,
-  updateResultPoints: () => updateResultPoints,
+  updateRound: () => updateRound,
+  updateStanding: () => updateStanding,
+  updateStandingPoints: () => updateStandingPoints,
   updateTournament: () => updateTournament,
   updateUser: () => updateUser,
-  updateUserRefreshToken: () => updateUserRefreshToken
+  updateUserRefreshToken: () => updateUserRefreshToken,
+  updateWorldRankings: () => updateWorldRankings
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -107,10 +206,40 @@ async function testConnection() {
   }
 }
 
+// src/player-number.ts
+var MIN_PLAYER_NUMBER = 1e4;
+var MAX_PLAYER_NUMBER = 99999;
+var MAX_RETRIES = 10;
+function generateRandomPlayerNumber() {
+  return Math.floor(Math.random() * (MAX_PLAYER_NUMBER - MIN_PLAYER_NUMBER + 1)) + MIN_PLAYER_NUMBER;
+}
+async function generateUniquePlayerNumber() {
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    const candidate = generateRandomPlayerNumber();
+    const existing = await prisma.player.findUnique({
+      where: { playerNumber: candidate },
+      select: { id: true }
+    });
+    if (!existing) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Failed to generate unique player number after ${MAX_RETRIES} attempts. Consider increasing the number range or implementing a different allocation strategy.`
+  );
+}
+function isValidPlayerNumber(playerNumber) {
+  return Number.isInteger(playerNumber) && playerNumber >= MIN_PLAYER_NUMBER && playerNumber <= MAX_PLAYER_NUMBER;
+}
+
 // src/players.ts
 async function createPlayer(data) {
+  const playerNumber = data.playerNumber ?? await generateUniquePlayerNumber();
   return prisma.player.create({
-    data
+    data: {
+      ...data,
+      playerNumber
+    }
   });
 }
 async function findPlayerById(id, include) {
@@ -125,6 +254,12 @@ async function findPlayerByExternalId(externalId, include) {
     include
   });
 }
+async function findPlayerByPlayerNumber(playerNumber, include) {
+  return prisma.player.findUnique({
+    where: { playerNumber },
+    include
+  });
+}
 async function findPlayerByUserEmail(email, include) {
   const user = await prisma.user.findUnique({
     where: { email },
@@ -141,48 +276,12 @@ async function findPlayers(options = {}) {
     include: options.include
   });
 }
-async function getRatedPlayers(options = {}) {
-  return findPlayers({
-    ...options,
-    where: { isRated: true }
-  });
-}
-async function getTopPlayersByRating(limit = 50) {
-  return findPlayers({
-    take: limit,
-    orderBy: { rating: "desc" },
-    where: { isRated: true }
-  });
-}
-async function getTopPlayersByRanking(limit = 50) {
-  return findPlayers({
-    take: limit,
-    orderBy: { ranking: "asc" },
-    where: {
-      isRated: true,
-      ranking: { not: null }
-    }
-  });
-}
 async function updatePlayer(id, data) {
   return prisma.player.update({
     where: { id },
     data
   });
 }
-async function updatePlayerRating(id, rating, ratingDeviation, eventCount) {
-  const updateData = {
-    rating,
-    ratingDeviation,
-    lastRatingUpdate: /* @__PURE__ */ new Date(),
-    lastEventDate: /* @__PURE__ */ new Date()
-  };
-  if (eventCount !== void 0) {
-    updateData.eventCount = eventCount;
-    updateData.isRated = eventCount >= 5;
-  }
-  return updatePlayer(id, updateData);
-}
 async function deletePlayer(id) {
   return prisma.player.delete({
     where: { id }
@@ -195,7 +294,7 @@ async function getPlayerWithResults(id) {
   const player = await prisma.player.findUnique({
     where: { id },
     include: {
-      tournamentResults: {
+      standings: {
         include: {
           tournament: true
         },
@@ -212,7 +311,7 @@ async function getPlayerWithResults(id) {
   }
   return {
     ...player,
-    results: player.tournamentResults
+    results: player.standings
   };
 }
 async function searchPlayers(query, limit = 20) {
@@ -224,6 +323,212 @@ async function searchPlayers(query, limit = 20) {
   });
 }
 
+// src/oppr-rankings.ts
+async function getOrCreateOpprPlayerRanking(playerId) {
+  const existing = await prisma.opprPlayerRanking.findUnique({
+    where: { playerId }
+  });
+  if (existing) return existing;
+  return prisma.opprPlayerRanking.create({
+    data: { playerId }
+  });
+}
+async function createOpprPlayerRanking(data) {
+  return prisma.opprPlayerRanking.create({
+    data
+  });
+}
+async function findOpprPlayerRankingById(id, include) {
+  return prisma.opprPlayerRanking.findUnique({
+    where: { id },
+    include
+  });
+}
+async function findOpprPlayerRankingByPlayerId(playerId, include) {
+  return prisma.opprPlayerRanking.findUnique({
+    where: { playerId },
+    include
+  });
+}
+async function findOpprPlayerRankings(options = {}) {
+  return prisma.opprPlayerRanking.findMany({
+    take: options.take,
+    skip: options.skip,
+    where: options.where,
+    orderBy: options.orderBy,
+    include: options.include
+  });
+}
+async function getTopPlayersByOpprRating(limit = 50) {
+  return prisma.opprPlayerRanking.findMany({
+    take: limit,
+    where: { isRated: true },
+    orderBy: { rating: "desc" },
+    include: { player: true }
+  });
+}
+async function getTopPlayersByOpprRanking(limit = 50) {
+  return prisma.opprPlayerRanking.findMany({
+    take: limit,
+    where: {
+      isRated: true,
+      ranking: { not: null }
+    },
+    orderBy: { ranking: "asc" },
+    include: { player: true }
+  });
+}
+async function getRatedOpprPlayers(options = {}) {
+  return prisma.opprPlayerRanking.findMany({
+    ...options,
+    where: { isRated: true },
+    include: { player: true, ...options.include }
+  });
+}
+async function updateOpprPlayerRanking(playerId, data) {
+  return prisma.opprPlayerRanking.update({
+    where: { playerId },
+    data: {
+      ...data,
+      lastRatingUpdate: data.lastRatingUpdate ?? /* @__PURE__ */ new Date()
+    }
+  });
+}
+async function updateOpprRatingAfterTournament(playerId, newRating, newRD, tournamentId, eventCount) {
+  const ranking = await getOrCreateOpprPlayerRanking(playerId);
+  const isRated = eventCount !== void 0 ? eventCount >= 5 : ranking.isRated;
+  const updated = await prisma.opprPlayerRanking.update({
+    where: { playerId },
+    data: {
+      rating: newRating,
+      ratingDeviation: newRD,
+      lastRatingUpdate: /* @__PURE__ */ new Date(),
+      isRated
+    }
+  });
+  await createOpprRankingHistory({
+    opprPlayerRankingId: ranking.id,
+    rating: newRating,
+    ratingDeviation: newRD,
+    ranking: updated.ranking ?? void 0,
+    isRated,
+    changeType: "TOURNAMENT_RESULT",
+    tournamentId
+  });
+  return updated;
+}
+async function updateWorldRankings(rankings) {
+  await prisma.$transaction(async (tx) => {
+    for (const { playerId, ranking } of rankings) {
+      const opprRanking = await tx.opprPlayerRanking.findUnique({
+        where: { playerId }
+      });
+      if (opprRanking) {
+        await tx.opprPlayerRanking.update({
+          where: { playerId },
+          data: { ranking }
+        });
+        await tx.opprRankingHistory.create({
+          data: {
+            opprPlayerRankingId: opprRanking.id,
+            rating: opprRanking.rating,
+            ratingDeviation: opprRanking.ratingDeviation,
+            ranking,
+            isRated: opprRanking.isRated,
+            changeType: "RANKING_REFRESH"
+          }
+        });
+      }
+    }
+  });
+}
+async function applyRDDecayForInactivePlayers(thresholdDays = 30, decayPerDay = 0.3, maxRD = 200) {
+  const cutoffDate = /* @__PURE__ */ new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - thresholdDays);
+  const inactivePlayers = await prisma.opprPlayerRanking.findMany({
+    where: {
+      lastRatingUpdate: { lt: cutoffDate },
+      ratingDeviation: { lt: maxRD }
+    }
+  });
+  let updatedCount = 0;
+  await prisma.$transaction(async (tx) => {
+    for (const ranking of inactivePlayers) {
+      const daysSinceUpdate = Math.floor(
+        (Date.now() - ranking.lastRatingUpdate.getTime()) / (1e3 * 60 * 60 * 24)
+      );
+      const newRD = Math.min(ranking.ratingDeviation + daysSinceUpdate * decayPerDay, maxRD);
+      await tx.opprPlayerRanking.update({
+        where: { id: ranking.id },
+        data: { ratingDeviation: newRD }
+      });
+      await tx.opprRankingHistory.create({
+        data: {
+          opprPlayerRankingId: ranking.id,
+          rating: ranking.rating,
+          ratingDeviation: newRD,
+          ranking: ranking.ranking,
+          isRated: ranking.isRated,
+          changeType: "RD_DECAY",
+          notes: `RD increased from ${ranking.ratingDeviation.toFixed(1)} to ${newRD.toFixed(1)} due to ${daysSinceUpdate} days of inactivity`
+        }
+      });
+      updatedCount++;
+    }
+  });
+  return updatedCount;
+}
+async function deleteOpprPlayerRanking(playerId) {
+  return prisma.opprPlayerRanking.delete({
+    where: { playerId }
+  });
+}
+async function countOpprPlayerRankings(where) {
+  return prisma.opprPlayerRanking.count({ where });
+}
+async function createOpprRankingHistory(data) {
+  return prisma.opprRankingHistory.create({
+    data
+  });
+}
+async function getOpprRankingHistory(playerId, limit) {
+  const ranking = await findOpprPlayerRankingByPlayerId(playerId);
+  if (!ranking) return [];
+  return prisma.opprRankingHistory.findMany({
+    where: { opprPlayerRankingId: ranking.id },
+    orderBy: { createdAt: "desc" },
+    take: limit,
+    include: { tournament: true }
+  });
+}
+async function getOpprRankingHistoryByDateRange(playerId, startDate, endDate) {
+  const ranking = await findOpprPlayerRankingByPlayerId(playerId);
+  if (!ranking) return [];
+  return prisma.opprRankingHistory.findMany({
+    where: {
+      opprPlayerRankingId: ranking.id,
+      createdAt: {
+        gte: startDate,
+        lte: endDate
+      }
+    },
+    orderBy: { createdAt: "asc" },
+    include: { tournament: true }
+  });
+}
+async function getLatestOpprRankingHistory(playerId) {
+  const ranking = await findOpprPlayerRankingByPlayerId(playerId);
+  if (!ranking) return null;
+  return prisma.opprRankingHistory.findFirst({
+    where: { opprPlayerRankingId: ranking.id },
+    orderBy: { createdAt: "desc" },
+    include: { tournament: true }
+  });
+}
+async function countOpprRankingHistory(where) {
+  return prisma.opprRankingHistory.count({ where });
+}
+
 // src/tournaments.ts
 async function createTournament(data) {
   return prisma.tournament.create({
@@ -303,13 +608,33 @@ async function getTournamentWithResults(id) {
   return prisma.tournament.findUnique({
     where: { id },
     include: {
-      results: {
+      standings: {
         include: {
           player: true
         },
-        orderBy: {
-          position: "asc"
-        }
+        orderBy: [{ isFinals: "desc" }, { position: "asc" }]
+      }
+    }
+  });
+}
+async function getTournamentWithMatches(id) {
+  return prisma.tournament.findUnique({
+    where: { id },
+    include: {
+      rounds: {
+        include: {
+          matches: {
+            include: {
+              entries: {
+                include: {
+                  player: true
+                }
+              }
+            },
+            orderBy: { number: "asc" }
+          }
+        },
+        orderBy: [{ isFinals: "asc" }, { number: "asc" }]
       }
     }
   });
@@ -320,7 +645,7 @@ async function searchTournaments(query, limit = 20) {
     where: {
       OR: [
         { name: { contains: query, mode: "insensitive" } },
-        { location: { contains: query, mode: "insensitive" } }
+        { location: { name: { contains: query, mode: "insensitive" } } }
       ]
     },
     orderBy: { date: "desc" }
@@ -331,7 +656,7 @@ async function getTournamentStats(id) {
   if (!tournament) {
     return null;
   }
-  const playerCount = tournament.results.length;
+  const playerCount = tournament.standings.length;
   if (playerCount === 0) {
     return {
       tournament,
@@ -342,9 +667,9 @@ async function getTournamentStats(id) {
       lowestPoints: 0
     };
   }
-  const totalPoints = tournament.results.reduce((sum, r) => sum + (r.totalPoints || 0), 0);
-  const totalEfficiency = tournament.results.reduce((sum, r) => sum + (r.efficiency || 0), 0);
-  const allPoints = tournament.results.map((r) => r.totalPoints || 0);
+  const totalPoints = tournament.standings.reduce((sum, s) => sum + (s.totalPoints || 0), 0);
+  const totalEfficiency = tournament.standings.reduce((sum, s) => sum + (s.efficiency || 0), 0);
+  const allPoints = tournament.standings.map((s) => s.totalPoints || 0);
   return {
     tournament,
     playerCount,
@@ -355,44 +680,364 @@ async function getTournamentStats(id) {
   };
 }
 
-// src/results.ts
-async function createResult(data) {
-  const resultData = {
+// src/rounds.ts
+async function createRound(data) {
+  return prisma.round.create({
+    data: {
+      ...data,
+      isFinals: data.isFinals ?? false
+    }
+  });
+}
+async function createManyRounds(data) {
+  const roundsData = data.map((item) => ({
+    ...item,
+    isFinals: item.isFinals ?? false
+  }));
+  return prisma.round.createMany({
+    data: roundsData
+  });
+}
+async function findRoundById(id, include) {
+  return prisma.round.findUnique({
+    where: { id },
+    include
+  });
+}
+async function findRoundByTournamentAndNumber(tournamentId, number, isFinals, include) {
+  return prisma.round.findUnique({
+    where: {
+      tournamentId_number_isFinals: {
+        tournamentId,
+        number,
+        isFinals
+      }
+    },
+    include
+  });
+}
+async function findRounds(options = {}) {
+  return prisma.round.findMany({
+    take: options.take,
+    skip: options.skip,
+    where: options.where,
+    orderBy: options.orderBy,
+    include: options.include
+  });
+}
+async function getTournamentRounds(tournamentId, options = {}) {
+  return findRounds({
+    ...options,
+    where: { tournamentId },
+    orderBy: options.orderBy ?? [{ isFinals: "asc" }, { number: "asc" }]
+  });
+}
+async function getQualifyingRounds(tournamentId, options = {}) {
+  return findRounds({
+    ...options,
+    where: { tournamentId, isFinals: false },
+    orderBy: options.orderBy ?? { number: "asc" }
+  });
+}
+async function getFinalsRounds(tournamentId, options = {}) {
+  return findRounds({
+    ...options,
+    where: { tournamentId, isFinals: true },
+    orderBy: options.orderBy ?? { number: "asc" }
+  });
+}
+async function updateRound(id, data) {
+  return prisma.round.update({
+    where: { id },
+    data
+  });
+}
+async function deleteRound(id) {
+  return prisma.round.delete({
+    where: { id }
+  });
+}
+async function deleteRoundsByTournament(tournamentId) {
+  return prisma.round.deleteMany({
+    where: { tournamentId }
+  });
+}
+async function countRounds(where) {
+  return prisma.round.count({ where });
+}
+async function getRoundWithMatches(id) {
+  return prisma.round.findUnique({
+    where: { id },
+    include: {
+      matches: {
+        include: {
+          entries: {
+            include: {
+              player: true
+            }
+          }
+        },
+        orderBy: {
+          number: "asc"
+        }
+      }
+    }
+  });
+}
+
+// src/matches.ts
+async function createMatch(data) {
+  return prisma.match.create({
+    data
+  });
+}
+async function createManyMatches(data) {
+  return prisma.match.createMany({
+    data
+  });
+}
+async function findMatchById(id, include) {
+  return prisma.match.findUnique({
+    where: { id },
+    include
+  });
+}
+async function findMatches(options = {}) {
+  return prisma.match.findMany({
+    take: options.take,
+    skip: options.skip,
+    where: options.where,
+    orderBy: options.orderBy,
+    include: options.include
+  });
+}
+async function getTournamentMatches(tournamentId, options = {}) {
+  return findMatches({
+    ...options,
+    where: { tournamentId },
+    orderBy: options.orderBy ?? { number: "asc" }
+  });
+}
+async function getRoundMatches(roundId, options = {}) {
+  return findMatches({
+    ...options,
+    where: { roundId },
+    orderBy: options.orderBy ?? { number: "asc" }
+  });
+}
+async function updateMatch(id, data) {
+  return prisma.match.update({
+    where: { id },
+    data
+  });
+}
+async function deleteMatch(id) {
+  return prisma.match.delete({
+    where: { id }
+  });
+}
+async function deleteMatchesByTournament(tournamentId) {
+  return prisma.match.deleteMany({
+    where: { tournamentId }
+  });
+}
+async function deleteMatchesByRound(roundId) {
+  return prisma.match.deleteMany({
+    where: { roundId }
+  });
+}
+async function countMatches(where) {
+  return prisma.match.count({ where });
+}
+async function getMatchWithEntries(id) {
+  return prisma.match.findUnique({
+    where: { id },
+    include: {
+      entries: {
+        include: {
+          player: true
+        },
+        orderBy: {
+          position: "asc"
+        }
+      },
+      round: true
+    }
+  });
+}
+async function getPlayerTournamentMatches(playerId, tournamentId, include) {
+  return findMatches({
+    where: {
+      tournamentId,
+      entries: {
+        some: {
+          playerId
+        }
+      }
+    },
+    include: include ?? {
+      entries: {
+        include: {
+          player: true
+        }
+      },
+      round: true
+    },
+    orderBy: [{ round: { number: "asc" } }, { number: "asc" }]
+  });
+}
+
+// src/entries.ts
+async function createEntry(data) {
+  return prisma.entry.create({
+    data
+  });
+}
+async function createManyEntries(data) {
+  return prisma.entry.createMany({
+    data
+  });
+}
+async function findEntryById(id, include) {
+  return prisma.entry.findUnique({
+    where: { id },
+    include
+  });
+}
+async function findEntryByMatchAndPlayer(matchId, playerId, include) {
+  return prisma.entry.findUnique({
+    where: {
+      matchId_playerId: {
+        matchId,
+        playerId
+      }
+    },
+    include
+  });
+}
+async function findEntries(options = {}) {
+  return prisma.entry.findMany({
+    take: options.take,
+    skip: options.skip,
+    where: options.where,
+    orderBy: options.orderBy,
+    include: options.include
+  });
+}
+async function getMatchEntries(matchId, options = {}) {
+  return findEntries({
+    ...options,
+    where: { matchId },
+    include: options.include ?? { player: true },
+    orderBy: options.orderBy ?? { position: "asc" }
+  });
+}
+async function getPlayerEntries(playerId, options = {}) {
+  return findEntries({
+    ...options,
+    where: { playerId },
+    include: options.include ?? { match: { include: { round: true, tournament: true } } }
+  });
+}
+async function getPlayerTournamentEntries(playerId, tournamentId, include) {
+  return findEntries({
+    where: {
+      playerId,
+      match: {
+        tournamentId
+      }
+    },
+    include: include ?? {
+      match: {
+        include: {
+          round: true,
+          entries: {
+            include: {
+              player: true
+            }
+          }
+        }
+      }
+    }
+  });
+}
+async function updateEntry(id, data) {
+  return prisma.entry.update({
+    where: { id },
+    data
+  });
+}
+async function deleteEntry(id) {
+  return prisma.entry.delete({
+    where: { id }
+  });
+}
+async function deleteEntriesByMatch(matchId) {
+  return prisma.entry.deleteMany({
+    where: { matchId }
+  });
+}
+async function countEntries(where) {
+  return prisma.entry.count({ where });
+}
+async function getPlayerEntryStats(playerId) {
+  const entries = await getPlayerEntries(playerId);
+  if (entries.length === 0) {
+    return null;
+  }
+  const wins = entries.filter((e) => e.result === "WIN").length;
+  const losses = entries.filter((e) => e.result === "LOSS").length;
+  const ties = entries.filter((e) => e.result === "TIE").length;
+  return {
+    totalMatches: entries.length,
+    wins,
+    losses,
+    ties,
+    winRate: wins / entries.length
+  };
+}
+
+// src/standings.ts
+async function createStanding(data) {
+  const standingData = {
     ...data,
+    isFinals: data.isFinals ?? false,
     decayedPoints: data.decayedPoints ?? data.totalPoints ?? 0
   };
-  return prisma.tournamentResult.create({
-    data: resultData
+  return prisma.standing.create({
+    data: standingData
   });
 }
-async function createManyResults(data) {
-  const resultsData = data.map((item) => ({
+async function createManyStandings(data) {
+  const standingsData = data.map((item) => ({
     ...item,
+    isFinals: item.isFinals ?? false,
     decayedPoints: item.decayedPoints ?? item.totalPoints ?? 0
   }));
-  return prisma.tournamentResult.createMany({
-    data: resultsData
+  return prisma.standing.createMany({
+    data: standingsData
   });
 }
-async function findResultById(id, include) {
-  return prisma.tournamentResult.findUnique({
+async function findStandingById(id, include) {
+  return prisma.standing.findUnique({
     where: { id },
     include
   });
 }
-async function findResultByPlayerAndTournament(playerId, tournamentId, include) {
-  return prisma.tournamentResult.findUnique({
+async function findStandingByPlayerAndTournament(playerId, tournamentId, isFinals, include) {
+  return prisma.standing.findUnique({
     where: {
-      playerId_tournamentId: {
+      playerId_tournamentId_isFinals: {
         playerId,
-        tournamentId
+        tournamentId,
+        isFinals
       }
     },
     include
   });
 }
-async function findResults(options = {}) {
-  return prisma.tournamentResult.findMany({
+async function findStandings(options = {}) {
+  return prisma.standing.findMany({
     take: options.take,
     skip: options.skip,
     where: options.where,
@@ -400,45 +1045,85 @@ async function findResults(options = {}) {
     include: options.include
   });
 }
-async function getPlayerResults(playerId, options = {}) {
-  return findResults({
+async function getPlayerStandings(playerId, options = {}) {
+  return findStandings({
     ...options,
     where: { playerId },
     include: { tournament: true, ...options.include },
     orderBy: { tournament: { date: "desc" } }
   });
 }
-async function getTournamentResults(tournamentId, options = {}) {
-  return findResults({
+async function getTournamentStandings(tournamentId, options = {}) {
+  return findStandings({
     ...options,
     where: { tournamentId },
     include: { player: true, ...options.include },
-    orderBy: { position: "asc" }
+    orderBy: options.orderBy ?? { position: "asc" }
+  });
+}
+async function getQualifyingStandings(tournamentId, options = {}) {
+  return findStandings({
+    ...options,
+    where: { tournamentId, isFinals: false },
+    include: { player: true, ...options.include },
+    orderBy: options.orderBy ?? { position: "asc" }
   });
 }
+async function getFinalsStandings(tournamentId, options = {}) {
+  return findStandings({
+    ...options,
+    where: { tournamentId, isFinals: true },
+    include: { player: true, ...options.include },
+    orderBy: options.orderBy ?? { position: "asc" }
+  });
+}
+async function getMergedStandings(tournamentId) {
+  const [finals, qualifying] = await Promise.all([
+    findStandings({
+      where: { tournamentId, isFinals: true },
+      orderBy: { position: "asc" },
+      include: { player: true }
+    }),
+    findStandings({
+      where: { tournamentId, isFinals: false },
+      orderBy: { position: "asc" },
+      include: { player: true }
+    })
+  ]);
+  const finalistIds = new Set(finals.map((s) => s.playerId));
+  const nonFinalists = qualifying.filter((s) => !finalistIds.has(s.playerId));
+  return [
+    ...finals.map((s) => ({ ...s, mergedPosition: s.position, isFinalist: true })),
+    ...nonFinalists.map((s, i) => ({
+      ...s,
+      mergedPosition: finals.length + i + 1,
+      isFinalist: false
+    }))
+  ];
+}
 async function getPlayerTopFinishes(playerId, limit = 15) {
-  return findResults({
+  return findStandings({
     where: { playerId },
     take: limit,
     include: { tournament: true },
     orderBy: { decayedPoints: "desc" }
   });
 }
-async function updateResult(id, data) {
-  return prisma.tournamentResult.update({
+async function updateStanding(id, data) {
+  return prisma.standing.update({
     where: { id },
     data
   });
 }
-async function updateResultPoints(id, linearPoints, dynamicPoints, totalPoints) {
-  const result = await findResultById(id, {
+async function updateStandingPoints(id, linearPoints, dynamicPoints, totalPoints) {
+  const standing = await findStandingById(id, {
     tournament: true
   });
-  if (!result) {
-    throw new Error(`Result with id ${id} not found`);
+  if (!standing) {
+    throw new Error(`Standing with id ${id} not found`);
   }
   const now = /* @__PURE__ */ new Date();
-  const tournamentDate = result.tournament.date;
+  const tournamentDate = standing.tournament.date;
   const ageInDays = Math.floor((now.getTime() - tournamentDate.getTime()) / (1e3 * 60 * 60 * 24));
   const ageInYears = ageInDays / 365;
   let decayMultiplier = 0;
@@ -452,7 +1137,7 @@ async function updateResultPoints(id, linearPoints, dynamicPoints, totalPoints)
     decayMultiplier = 0;
   }
   const decayedPoints = totalPoints * decayMultiplier;
-  return updateResult(id, {
+  return updateStanding(id, {
     linearPoints,
     dynamicPoints,
     totalPoints,
@@ -461,50 +1146,50 @@ async function updateResultPoints(id, linearPoints, dynamicPoints, totalPoints)
     decayedPoints
   });
 }
-async function deleteResult(id) {
-  return prisma.tournamentResult.delete({
+async function deleteStanding(id) {
+  return prisma.standing.delete({
     where: { id }
   });
 }
-async function deleteResultsByTournament(tournamentId) {
-  return prisma.tournamentResult.deleteMany({
+async function deleteStandingsByTournament(tournamentId) {
+  return prisma.standing.deleteMany({
     where: { tournamentId }
   });
 }
-async function countResults(where) {
-  return prisma.tournamentResult.count({ where });
+async function countStandings(where) {
+  return prisma.standing.count({ where });
 }
 async function getPlayerStats(playerId) {
-  const results = await getPlayerResults(playerId);
-  if (results.length === 0) {
+  const standings = await getPlayerStandings(playerId);
+  if (standings.length === 0) {
     return null;
   }
-  const totalPoints = results.reduce((sum, r) => sum + (r.totalPoints || 0), 0);
-  const totalDecayedPoints = results.reduce((sum, r) => sum + (r.decayedPoints || 0), 0);
-  const averagePosition = results.reduce((sum, r) => sum + r.position, 0) / results.length;
-  const averageEfficiency = results.reduce((sum, r) => sum + (r.efficiency || 0), 0) / results.length;
-  const firstPlaceFinishes = results.filter((r) => r.position === 1).length;
-  const topThreeFinishes = results.filter((r) => r.position <= 3).length;
+  const totalPoints = standings.reduce((sum, s) => sum + (s.totalPoints || 0), 0);
+  const totalDecayedPoints = standings.reduce((sum, s) => sum + (s.decayedPoints || 0), 0);
+  const averagePosition = standings.reduce((sum, s) => sum + s.position, 0) / standings.length;
+  const averageEfficiency = standings.reduce((sum, s) => sum + (s.efficiency || 0), 0) / standings.length;
+  const firstPlaceFinishes = standings.filter((s) => s.position === 1).length;
+  const topThreeFinishes = standings.filter((s) => s.position <= 3).length;
   return {
-    totalEvents: results.length,
+    totalEvents: standings.length,
     totalPoints,
     totalDecayedPoints,
-    averagePoints: totalPoints / results.length,
+    averagePoints: totalPoints / standings.length,
     averagePosition,
     averageFinish: averagePosition,
     averageEfficiency,
     firstPlaceFinishes,
     topThreeFinishes,
-    bestFinish: Math.min(...results.map((r) => r.position)),
-    highestPoints: Math.max(...results.map((r) => r.totalPoints || 0))
+    bestFinish: Math.min(...standings.map((s) => s.position)),
+    highestPoints: Math.max(...standings.map((s) => s.totalPoints || 0))
   };
 }
 async function recalculateTimeDecay(referenceDate = /* @__PURE__ */ new Date()) {
-  const results = await findResults({
+  const standings = await findStandings({
     include: { tournament: true }
   });
-  const updates = results.map((result) => {
-    const tournamentDate = result.tournament.date;
+  const updates = standings.map((standing) => {
+    const tournamentDate = standing.tournament.date;
     const ageInDays = Math.floor(
       (referenceDate.getTime() - tournamentDate.getTime()) / (1e3 * 60 * 60 * 24)
     );
@@ -519,9 +1204,9 @@ async function recalculateTimeDecay(referenceDate = /* @__PURE__ */ new Date())
     } else {
       decayMultiplier = 0;
     }
-    const decayedPoints = (result.totalPoints || 0) * decayMultiplier;
-    return prisma.tournamentResult.update({
-      where: { id: result.id },
+    const decayedPoints = (standing.totalPoints || 0) * decayMultiplier;
+    return prisma.standing.update({
+      where: { id: standing.id },
       data: {
         ageInDays,
         decayMultiplier,
@@ -540,9 +1225,11 @@ async function createUser(data) {
 }
 async function createUserWithPlayer(userData, playerData) {
   return prisma.$transaction(async (tx) => {
+    const playerNumber = await generateUniquePlayerNumber();
     const player = await tx.player.create({
       data: {
-        name: playerData.name
+        name: playerData.name,
+        playerNumber
       }
     });
     const user = await tx.user.create({
@@ -554,11 +1241,8 @@ async function createUserWithPlayer(userData, playerData) {
         player: {
           select: {
             id: true,
+            playerNumber: true,
             name: true,
-            rating: true,
-            ratingDeviation: true,
-            ranking: true,
-            isRated: true,
             eventCount: true
           }
         }
@@ -586,11 +1270,8 @@ async function getUserWithPlayer(id) {
       player: {
         select: {
           id: true,
+          playerNumber: true,
           name: true,
-          rating: true,
-          ratingDeviation: true,
-          ranking: true,
-          isRated: true,
           eventCount: true
         }
       }
@@ -608,11 +1289,8 @@ async function getUserByEmailWithPlayer(email) {
       player: {
         select: {
           id: true,
+          playerNumber: true,
           name: true,
-          rating: true,
-          ratingDeviation: true,
-          ranking: true,
-          isRated: true,
           eventCount: true
         }
       }
@@ -653,11 +1331,8 @@ async function findUsers(params) {
       player: {
         select: {
           id: true,
+          playerNumber: true,
           name: true,
-          rating: true,
-          ratingDeviation: true,
-          ranking: true,
-          isRated: true,
           eventCount: true
         }
       }
@@ -684,11 +1359,8 @@ async function linkPlayerToUser(userId, playerId) {
         player: {
           select: {
             id: true,
+            playerNumber: true,
             name: true,
-            rating: true,
-            ratingDeviation: true,
-            ranking: true,
-            isRated: true,
             eventCount: true
           }
         }
@@ -697,65 +1369,468 @@ async function linkPlayerToUser(userId, playerId) {
     return user;
   });
 }
+
+// src/api-keys.ts
+var MAX_API_KEYS_PER_USER = 5;
+async function createApiKey(data) {
+  return prisma.apiKey.create({ data });
+}
+async function findApiKeyById(id) {
+  return prisma.apiKey.findUnique({ where: { id } });
+}
+async function findApiKeysByPrefix(keyPrefix) {
+  const keys = await prisma.apiKey.findMany({
+    where: { keyPrefix },
+    include: {
+      user: {
+        select: {
+          id: true,
+          email: true,
+          role: true
+        }
+      }
+    }
+  });
+  return keys;
+}
+async function getUserApiKeys(userId) {
+  return prisma.apiKey.findMany({
+    where: { userId },
+    select: {
+      id: true,
+      name: true,
+      keyPrefix: true,
+      expiresAt: true,
+      lastUsedAt: true,
+      createdAt: true
+    },
+    orderBy: { createdAt: "desc" }
+  });
+}
+async function countUserApiKeys(userId) {
+  return prisma.apiKey.count({ where: { userId } });
+}
+async function updateApiKeyLastUsed(id) {
+  await prisma.apiKey.update({
+    where: { id },
+    data: { lastUsedAt: /* @__PURE__ */ new Date() }
+  });
+}
+async function deleteApiKey(id) {
+  return prisma.apiKey.delete({ where: { id } });
+}
+async function deleteUserApiKey(id, userId) {
+  const key = await prisma.apiKey.findFirst({
+    where: { id, userId }
+  });
+  if (!key) {
+    return null;
+  }
+  return prisma.apiKey.delete({ where: { id } });
+}
+
+// src/locations.ts
+async function createLocation(data) {
+  return prisma.location.create({
+    data
+  });
+}
+async function findLocationById(id, include) {
+  return prisma.location.findUnique({
+    where: { id },
+    include
+  });
+}
+async function findLocationByExternalId(externalId, include) {
+  return prisma.location.findUnique({
+    where: { externalId },
+    include
+  });
+}
+async function findLocations(options = {}) {
+  return prisma.location.findMany({
+    take: options.take,
+    skip: options.skip,
+    where: options.where,
+    orderBy: options.orderBy,
+    include: options.include
+  });
+}
+async function searchLocations(query, limit = 20) {
+  return findLocations({
+    take: limit,
+    where: {
+      OR: [
+        { name: { contains: query, mode: "insensitive" } },
+        { city: { contains: query, mode: "insensitive" } }
+      ]
+    },
+    orderBy: { name: "asc" }
+  });
+}
+async function updateLocation(id, data) {
+  return prisma.location.update({
+    where: { id },
+    data
+  });
+}
+async function deleteLocation(id) {
+  return prisma.location.delete({
+    where: { id }
+  });
+}
+async function countLocations(where) {
+  return prisma.location.count({ where });
+}
+async function getLocationWithTournaments(id) {
+  return prisma.location.findUnique({
+    where: { id },
+    include: {
+      tournaments: {
+        orderBy: {
+          date: "desc"
+        }
+      }
+    }
+  });
+}
+
+// src/blog-posts.ts
+var defaultInclude = {
+  author: {
+    select: { id: true, email: true }
+  },
+  tags: {
+    select: { id: true, name: true, slug: true }
+  }
+};
+async function createBlogPost(data) {
+  const { tagIds, ...postData } = data;
+  return prisma.blogPost.create({
+    data: {
+      ...postData,
+      tags: tagIds?.length ? { connect: tagIds.map((id) => ({ id })) } : void 0
+    },
+    include: defaultInclude
+  });
+}
+async function findBlogPostById(id) {
+  return prisma.blogPost.findUnique({
+    where: { id },
+    include: defaultInclude
+  });
+}
+async function findBlogPostBySlug(slug) {
+  return prisma.blogPost.findUnique({
+    where: { slug },
+    include: defaultInclude
+  });
+}
+async function findBlogPosts(options = {}) {
+  return prisma.blogPost.findMany({
+    take: options.take,
+    skip: options.skip,
+    where: options.where,
+    orderBy: options.orderBy ?? { createdAt: "desc" },
+    include: options.include ?? defaultInclude
+  });
+}
+async function findPublishedBlogPosts(options = {}) {
+  const { tagSlug, ...restOptions } = options;
+  const where = {
+    status: "PUBLISHED",
+    publishedAt: { not: null },
+    ...tagSlug && {
+      tags: {
+        some: { slug: tagSlug }
+      }
+    }
+  };
+  return findBlogPosts({
+    ...restOptions,
+    where,
+    orderBy: options.orderBy ?? { publishedAt: "desc" }
+  });
+}
+async function searchBlogPosts(query, limit = 20, publishedOnly = true) {
+  const where = {
+    OR: [
+      { title: { contains: query, mode: "insensitive" } },
+      { excerpt: { contains: query, mode: "insensitive" } }
+    ],
+    ...publishedOnly && {
+      status: "PUBLISHED",
+      publishedAt: { not: null }
+    }
+  };
+  return findBlogPosts({
+    take: limit,
+    where,
+    orderBy: { publishedAt: "desc" }
+  });
+}
+async function updateBlogPost(id, data) {
+  const { tagIds, ...postData } = data;
+  return prisma.blogPost.update({
+    where: { id },
+    data: {
+      ...postData,
+      // If tagIds is provided, replace all tags
+      ...tagIds !== void 0 && {
+        tags: {
+          set: tagIds.map((tagId) => ({ id: tagId }))
+        }
+      }
+    },
+    include: defaultInclude
+  });
+}
+async function deleteBlogPost(id) {
+  return prisma.blogPost.delete({
+    where: { id }
+  });
+}
+async function countBlogPosts(where) {
+  return prisma.blogPost.count({ where });
+}
+async function countPublishedBlogPosts(tagSlug) {
+  return countBlogPosts({
+    status: "PUBLISHED",
+    publishedAt: { not: null },
+    ...tagSlug && {
+      tags: {
+        some: { slug: tagSlug }
+      }
+    }
+  });
+}
+
+// src/blog-tags.ts
+async function createBlogTag(data) {
+  return prisma.blogTag.create({
+    data
+  });
+}
+async function findBlogTagById(id) {
+  return prisma.blogTag.findUnique({
+    where: { id }
+  });
+}
+async function findBlogTagBySlug(slug) {
+  return prisma.blogTag.findUnique({
+    where: { slug }
+  });
+}
+async function findBlogTags(options = {}) {
+  return prisma.blogTag.findMany({
+    take: options.take,
+    skip: options.skip,
+    where: options.where,
+    orderBy: options.orderBy ?? { name: "asc" },
+    include: options.include
+  });
+}
+async function searchBlogTags(query, limit = 20) {
+  return findBlogTags({
+    take: limit,
+    where: {
+      name: { contains: query, mode: "insensitive" }
+    },
+    orderBy: { name: "asc" }
+  });
+}
+async function updateBlogTag(id, data) {
+  return prisma.blogTag.update({
+    where: { id },
+    data
+  });
+}
+async function deleteBlogTag(id) {
+  return prisma.blogTag.delete({
+    where: { id }
+  });
+}
+async function countBlogTags(where) {
+  return prisma.blogTag.count({ where });
+}
+async function getBlogTagWithPostCount(id) {
+  return prisma.blogTag.findUnique({
+    where: { id },
+    include: {
+      _count: {
+        select: { posts: true }
+      }
+    }
+  });
+}
+async function getBlogTagsWithPostCounts() {
+  return prisma.blogTag.findMany({
+    include: {
+      _count: {
+        select: { posts: true }
+      }
+    },
+    orderBy: { name: "asc" }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MAX_API_KEYS_PER_USER,
+  applyRDDecayForInactivePlayers,
   connect,
+  countBlogPosts,
+  countBlogTags,
+  countEntries,
+  countLocations,
+  countMatches,
+  countOpprPlayerRankings,
+  countOpprRankingHistory,
   countPlayers,
-  countResults,
+  countPublishedBlogPosts,
+  countRounds,
+  countStandings,
   countTournaments,
+  countUserApiKeys,
   countUsers,
-  createManyResults,
+  createApiKey,
+  createBlogPost,
+  createBlogTag,
+  createEntry,
+  createLocation,
+  createManyEntries,
+  createManyMatches,
+  createManyRounds,
+  createManyStandings,
+  createMatch,
+  createOpprPlayerRanking,
+  createOpprRankingHistory,
   createPlayer,
-  createResult,
+  createRound,
+  createStanding,
   createTournament,
   createUser,
   createUserWithPlayer,
+  deleteApiKey,
+  deleteBlogPost,
+  deleteBlogTag,
+  deleteEntriesByMatch,
+  deleteEntry,
+  deleteLocation,
+  deleteMatch,
+  deleteMatchesByRound,
+  deleteMatchesByTournament,
+  deleteOpprPlayerRanking,
   deletePlayer,
-  deleteResult,
-  deleteResultsByTournament,
+  deleteRound,
+  deleteRoundsByTournament,
+  deleteStanding,
+  deleteStandingsByTournament,
   deleteTournament,
   deleteUser,
+  deleteUserApiKey,
   disconnect,
+  findApiKeyById,
+  findApiKeysByPrefix,
+  findBlogPostById,
+  findBlogPostBySlug,
+  findBlogPosts,
+  findBlogTagById,
+  findBlogTagBySlug,
+  findBlogTags,
+  findEntries,
+  findEntryById,
+  findEntryByMatchAndPlayer,
+  findLocationByExternalId,
+  findLocationById,
+  findLocations,
+  findMatchById,
+  findMatches,
+  findOpprPlayerRankingById,
+  findOpprPlayerRankingByPlayerId,
+  findOpprPlayerRankings,
   findPlayerByExternalId,
   findPlayerById,
+  findPlayerByPlayerNumber,
   findPlayerByUserEmail,
   findPlayers,
-  findResultById,
-  findResultByPlayerAndTournament,
-  findResults,
+  findPublishedBlogPosts,
+  findRoundById,
+  findRoundByTournamentAndNumber,
+  findRounds,
+  findStandingById,
+  findStandingByPlayerAndTournament,
+  findStandings,
   findTournamentByExternalId,
   findTournamentById,
   findTournaments,
   findUserByEmail,
   findUserById,
   findUsers,
+  generateUniquePlayerNumber,
+  getBlogTagWithPostCount,
+  getBlogTagsWithPostCounts,
+  getFinalsRounds,
+  getFinalsStandings,
+  getLatestOpprRankingHistory,
+  getLocationWithTournaments,
   getMajorTournaments,
-  getPlayerResults,
+  getMatchEntries,
+  getMatchWithEntries,
+  getMergedStandings,
+  getOpprRankingHistory,
+  getOpprRankingHistoryByDateRange,
+  getOrCreateOpprPlayerRanking,
+  getPlayerEntries,
+  getPlayerEntryStats,
+  getPlayerStandings,
   getPlayerStats,
   getPlayerTopFinishes,
+  getPlayerTournamentEntries,
+  getPlayerTournamentMatches,
   getPlayerWithResults,
-  getRatedPlayers,
+  getQualifyingRounds,
+  getQualifyingStandings,
+  getRatedOpprPlayers,
   getRecentTournaments,
-  getTopPlayersByRanking,
-  getTopPlayersByRating,
-  getTournamentResults,
+  getRoundMatches,
+  getRoundWithMatches,
+  getTopPlayersByOpprRanking,
+  getTopPlayersByOpprRating,
+  getTournamentMatches,
+  getTournamentRounds,
+  getTournamentStandings,
   getTournamentStats,
+  getTournamentWithMatches,
   getTournamentWithResults,
   getTournamentsByBoosterType,
   getTournamentsByDateRange,
+  getUserApiKeys,
   getUserByEmailWithPlayer,
   getUserWithPlayer,
+  isValidPlayerNumber,
   linkPlayerToUser,
   prisma,
   recalculateTimeDecay,
+  searchBlogPosts,
+  searchBlogTags,
+  searchLocations,
   searchPlayers,
   searchTournaments,
   testConnection,
+  updateApiKeyLastUsed,
+  updateBlogPost,
+  updateBlogTag,
+  updateEntry,
+  updateLocation,
+  updateMatch,
+  updateOpprPlayerRanking,
+  updateOpprRatingAfterTournament,
   updatePlayer,
-  updatePlayerRating,
-  updateResult,
-  updateResultPoints,
+  updateRound,
+  updateStanding,
+  updateStandingPoints,
   updateTournament,
   updateUser,
-  updateUserRefreshToken
+  updateUserRefreshToken,
+  updateWorldRankings
 });