@opprs/db-prisma 2.2.1-canary.acb3229 → 2.2.1-canary.b943669

package/dist/index.cjs

@@ -21,36 +21,60 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   connect: () => connect,
+  countEntries: () => countEntries,
   countLocations: () => countLocations,
+  countMatches: () => countMatches,
   countPlayers: () => countPlayers,
-  countResults: () => countResults,
+  countRounds: () => countRounds,
+  countStandings: () => countStandings,
   countTournaments: () => countTournaments,
   countUsers: () => countUsers,
+  createEntry: () => createEntry,
   createLocation: () => createLocation,
-  createManyResults: () => createManyResults,
+  createManyEntries: () => createManyEntries,
+  createManyMatches: () => createManyMatches,
+  createManyRounds: () => createManyRounds,
+  createManyStandings: () => createManyStandings,
+  createMatch: () => createMatch,
   createPlayer: () => createPlayer,
-  createResult: () => createResult,
+  createRound: () => createRound,
+  createStanding: () => createStanding,
   createTournament: () => createTournament,
   createUser: () => createUser,
   createUserWithPlayer: () => createUserWithPlayer,
+  deleteEntriesByMatch: () => deleteEntriesByMatch,
+  deleteEntry: () => deleteEntry,
   deleteLocation: () => deleteLocation,
+  deleteMatch: () => deleteMatch,
+  deleteMatchesByRound: () => deleteMatchesByRound,
+  deleteMatchesByTournament: () => deleteMatchesByTournament,
   deletePlayer: () => deletePlayer,
-  deleteResult: () => deleteResult,
-  deleteResultsByTournament: () => deleteResultsByTournament,
+  deleteRound: () => deleteRound,
+  deleteRoundsByTournament: () => deleteRoundsByTournament,
+  deleteStanding: () => deleteStanding,
+  deleteStandingsByTournament: () => deleteStandingsByTournament,
   deleteTournament: () => deleteTournament,
   deleteUser: () => deleteUser,
   disconnect: () => disconnect,
+  findEntries: () => findEntries,
+  findEntryById: () => findEntryById,
+  findEntryByMatchAndPlayer: () => findEntryByMatchAndPlayer,
   findLocationByExternalId: () => findLocationByExternalId,
   findLocationById: () => findLocationById,
   findLocations: () => findLocations,
+  findMatchById: () => findMatchById,
+  findMatches: () => findMatches,
   findPlayerByExternalId: () => findPlayerByExternalId,
   findPlayerById: () => findPlayerById,
   findPlayerByPlayerNumber: () => findPlayerByPlayerNumber,
   findPlayerByUserEmail: () => findPlayerByUserEmail,
   findPlayers: () => findPlayers,
-  findResultById: () => findResultById,
-  findResultByPlayerAndTournament: () => findResultByPlayerAndTournament,
-  findResults: () => findResults,
+  findRoundById: () => findRoundById,
+  findRoundByTournamentAndNumber: () => findRoundByTournamentAndNumber,
+  findRounds: () => findRounds,
+  findStandingById: () => findStandingById,
+  findStandingByPlayerAndTournament: () => findStandingByPlayerAndTournament,
+  findStandings: () => findStandings,
   findTournamentByExternalId: () => findTournamentByExternalId,
   findTournamentById: () => findTournamentById,
   findTournaments: () => findTournaments,
@@ -58,18 +82,34 @@ __export(index_exports, {
   findUserById: () => findUserById,
   findUsers: () => findUsers,
   generateUniquePlayerNumber: () => generateUniquePlayerNumber,
+  getFinalsRounds: () => getFinalsRounds,
+  getFinalsStandings: () => getFinalsStandings,
   getLocationWithTournaments: () => getLocationWithTournaments,
   getMajorTournaments: () => getMajorTournaments,
-  getPlayerResults: () => getPlayerResults,
+  getMatchEntries: () => getMatchEntries,
+  getMatchWithEntries: () => getMatchWithEntries,
+  getMergedStandings: () => getMergedStandings,
+  getPlayerEntries: () => getPlayerEntries,
+  getPlayerEntryStats: () => getPlayerEntryStats,
+  getPlayerStandings: () => getPlayerStandings,
   getPlayerStats: () => getPlayerStats,
   getPlayerTopFinishes: () => getPlayerTopFinishes,
+  getPlayerTournamentEntries: () => getPlayerTournamentEntries,
+  getPlayerTournamentMatches: () => getPlayerTournamentMatches,
   getPlayerWithResults: () => getPlayerWithResults,
+  getQualifyingRounds: () => getQualifyingRounds,
+  getQualifyingStandings: () => getQualifyingStandings,
   getRatedPlayers: () => getRatedPlayers,
   getRecentTournaments: () => getRecentTournaments,
+  getRoundMatches: () => getRoundMatches,
+  getRoundWithMatches: () => getRoundWithMatches,
   getTopPlayersByRanking: () => getTopPlayersByRanking,
   getTopPlayersByRating: () => getTopPlayersByRating,
-  getTournamentResults: () => getTournamentResults,
+  getTournamentMatches: () => getTournamentMatches,
+  getTournamentRounds: () => getTournamentRounds,
+  getTournamentStandings: () => getTournamentStandings,
   getTournamentStats: () => getTournamentStats,
+  getTournamentWithMatches: () => getTournamentWithMatches,
   getTournamentWithResults: () => getTournamentWithResults,
   getTournamentsByBoosterType: () => getTournamentsByBoosterType,
   getTournamentsByDateRange: () => getTournamentsByDateRange,
@@ -83,11 +123,14 @@ __export(index_exports, {
   searchPlayers: () => searchPlayers,
   searchTournaments: () => searchTournaments,
   testConnection: () => testConnection,
+  updateEntry: () => updateEntry,
   updateLocation: () => updateLocation,
+  updateMatch: () => updateMatch,
   updatePlayer: () => updatePlayer,
   updatePlayerRating: () => updatePlayerRating,
-  updateResult: () => updateResult,
-  updateResultPoints: () => updateResultPoints,
+  updateRound: () => updateRound,
+  updateStanding: () => updateStanding,
+  updateStandingPoints: () => updateStandingPoints,
   updateTournament: () => updateTournament,
   updateUser: () => updateUser,
   updateUserRefreshToken: () => updateUserRefreshToken
@@ -243,7 +286,7 @@ async function getPlayerWithResults(id) {
   const player = await prisma.player.findUnique({
     where: { id },
     include: {
-      tournamentResults: {
+      standings: {
         include: {
           tournament: true
         },
@@ -260,7 +303,7 @@ async function getPlayerWithResults(id) {
   }
   return {
     ...player,
-    results: player.tournamentResults
+    results: player.standings
   };
 }
 async function searchPlayers(query, limit = 20) {
@@ -351,13 +394,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" }]
       }
     }
   });
@@ -379,7 +442,7 @@ async function getTournamentStats(id) {
   if (!tournament) {
     return null;
   }
-  const playerCount = tournament.results.length;
+  const playerCount = tournament.standings.length;
   if (playerCount === 0) {
     return {
       tournament,
@@ -390,9 +453,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,
@@ -403,44 +466,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,
@@ -448,45 +831,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;
@@ -500,7 +923,7 @@ async function updateResultPoints(id, linearPoints, dynamicPoints, totalPoints)
     decayMultiplier = 0;
   }
   const decayedPoints = totalPoints * decayMultiplier;
-  return updateResult(id, {
+  return updateStanding(id, {
     linearPoints,
     dynamicPoints,
     totalPoints,
@@ -509,50 +932,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)
     );
@@ -567,9 +990,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,
@@ -821,36 +1244,60 @@ async function getLocationWithTournaments(id) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   connect,
+  countEntries,
   countLocations,
+  countMatches,
   countPlayers,
-  countResults,
+  countRounds,
+  countStandings,
   countTournaments,
   countUsers,
+  createEntry,
   createLocation,
-  createManyResults,
+  createManyEntries,
+  createManyMatches,
+  createManyRounds,
+  createManyStandings,
+  createMatch,
   createPlayer,
-  createResult,
+  createRound,
+  createStanding,
   createTournament,
   createUser,
   createUserWithPlayer,
+  deleteEntriesByMatch,
+  deleteEntry,
   deleteLocation,
+  deleteMatch,
+  deleteMatchesByRound,
+  deleteMatchesByTournament,
   deletePlayer,
-  deleteResult,
-  deleteResultsByTournament,
+  deleteRound,
+  deleteRoundsByTournament,
+  deleteStanding,
+  deleteStandingsByTournament,
   deleteTournament,
   deleteUser,
   disconnect,
+  findEntries,
+  findEntryById,
+  findEntryByMatchAndPlayer,
   findLocationByExternalId,
   findLocationById,
   findLocations,
+  findMatchById,
+  findMatches,
   findPlayerByExternalId,
   findPlayerById,
   findPlayerByPlayerNumber,
   findPlayerByUserEmail,
   findPlayers,
-  findResultById,
-  findResultByPlayerAndTournament,
-  findResults,
+  findRoundById,
+  findRoundByTournamentAndNumber,
+  findRounds,
+  findStandingById,
+  findStandingByPlayerAndTournament,
+  findStandings,
   findTournamentByExternalId,
   findTournamentById,
   findTournaments,
@@ -858,18 +1305,34 @@ async function getLocationWithTournaments(id) {
   findUserById,
   findUsers,
   generateUniquePlayerNumber,
+  getFinalsRounds,
+  getFinalsStandings,
   getLocationWithTournaments,
   getMajorTournaments,
-  getPlayerResults,
+  getMatchEntries,
+  getMatchWithEntries,
+  getMergedStandings,
+  getPlayerEntries,
+  getPlayerEntryStats,
+  getPlayerStandings,
   getPlayerStats,
   getPlayerTopFinishes,
+  getPlayerTournamentEntries,
+  getPlayerTournamentMatches,
   getPlayerWithResults,
+  getQualifyingRounds,
+  getQualifyingStandings,
   getRatedPlayers,
   getRecentTournaments,
+  getRoundMatches,
+  getRoundWithMatches,
   getTopPlayersByRanking,
   getTopPlayersByRating,
-  getTournamentResults,
+  getTournamentMatches,
+  getTournamentRounds,
+  getTournamentStandings,
   getTournamentStats,
+  getTournamentWithMatches,
   getTournamentWithResults,
   getTournamentsByBoosterType,
   getTournamentsByDateRange,
@@ -883,11 +1346,14 @@ async function getLocationWithTournaments(id) {
   searchPlayers,
   searchTournaments,
   testConnection,
+  updateEntry,
   updateLocation,
+  updateMatch,
   updatePlayer,
   updatePlayerRating,
-  updateResult,
-  updateResultPoints,
+  updateRound,
+  updateStanding,
+  updateStandingPoints,
   updateTournament,
   updateUser,
   updateUserRefreshToken