@opprs/db-prisma 2.6.0 → 3.0.0

package/LICENSE

@@ -1,21 +1,15 @@
-MIT License
+OPPRS - pinball tournament software
+Copyright (C) 2026 Mitch McAffee
 
-Copyright (c) 2025 Mitch McAffee
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.

package/dist/index.cjs

@@ -25,14 +25,11 @@ __export(index_exports, {
   connect: () => connect,
   countBlogPosts: () => countBlogPosts,
   countBlogTags: () => countBlogTags,
-  countEntries: () => countEntries,
   countLocations: () => countLocations,
-  countMatches: () => countMatches,
   countOpprPlayerRankings: () => countOpprPlayerRankings,
   countOpprRankingHistory: () => countOpprRankingHistory,
   countPlayers: () => countPlayers,
   countPublishedBlogPosts: () => countPublishedBlogPosts,
-  countRounds: () => countRounds,
   countStandings: () => countStandings,
   countTournaments: () => countTournaments,
   countUserApiKeys: () => countUserApiKeys,
@@ -40,17 +37,11 @@ __export(index_exports, {
   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,
-  createRound: () => createRound,
   createStanding: () => createStanding,
   createTournament: () => createTournament,
   createUser: () => createUser,
@@ -58,16 +49,9 @@ __export(index_exports, {
   deleteApiKey: () => deleteApiKey,
   deleteBlogPost: () => deleteBlogPost,
   deleteBlogTag: () => deleteBlogTag,
-  deleteEntriesByMatch: () => deleteEntriesByMatch,
-  deleteEntry: () => deleteEntry,
   deleteLocation: () => deleteLocation,
-  deleteMatch: () => deleteMatch,
-  deleteMatchesByRound: () => deleteMatchesByRound,
-  deleteMatchesByTournament: () => deleteMatchesByTournament,
   deleteOpprPlayerRanking: () => deleteOpprPlayerRanking,
   deletePlayer: () => deletePlayer,
-  deleteRound: () => deleteRound,
-  deleteRoundsByTournament: () => deleteRoundsByTournament,
   deleteStanding: () => deleteStanding,
   deleteStandingsByTournament: () => deleteStandingsByTournament,
   deleteTournament: () => deleteTournament,
@@ -82,14 +66,9 @@ __export(index_exports, {
   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,
@@ -99,9 +78,6 @@ __export(index_exports, {
   findPlayerByUserEmail: () => findPlayerByUserEmail,
   findPlayers: () => findPlayers,
   findPublishedBlogPosts: () => findPublishedBlogPosts,
-  findRoundById: () => findRoundById,
-  findRoundByTournamentAndNumber: () => findRoundByTournamentAndNumber,
-  findRounds: () => findRounds,
   findStandingById: () => findStandingById,
   findStandingByPlayerAndTournament: () => findStandingByPlayerAndTournament,
   findStandings: () => findStandings,
@@ -114,38 +90,25 @@ __export(index_exports, {
   generateUniquePlayerNumber: () => generateUniquePlayerNumber,
   getBlogTagWithPostCount: () => getBlogTagWithPostCount,
   getBlogTagsWithPostCounts: () => getBlogTagsWithPostCounts,
-  getFinalsRounds: () => getFinalsRounds,
   getFinalsStandings: () => getFinalsStandings,
   getLatestOpprRankingHistory: () => getLatestOpprRankingHistory,
   getLocationWithTournaments: () => getLocationWithTournaments,
   getMajorTournaments: () => getMajorTournaments,
-  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,
-  getQualifyingRounds: () => getQualifyingRounds,
   getQualifyingStandings: () => getQualifyingStandings,
   getRatedOpprPlayers: () => getRatedOpprPlayers,
   getRecentTournaments: () => getRecentTournaments,
-  getRoundMatches: () => getRoundMatches,
-  getRoundWithMatches: () => getRoundWithMatches,
   getTopPlayersByOpprRanking: () => getTopPlayersByOpprRanking,
   getTopPlayersByOpprRating: () => getTopPlayersByOpprRating,
-  getTournamentMatches: () => getTournamentMatches,
-  getTournamentRounds: () => getTournamentRounds,
   getTournamentStandings: () => getTournamentStandings,
   getTournamentStats: () => getTournamentStats,
-  getTournamentWithMatches: () => getTournamentWithMatches,
   getTournamentWithResults: () => getTournamentWithResults,
   getTournamentsByBoosterType: () => getTournamentsByBoosterType,
   getTournamentsByDateRange: () => getTournamentsByDateRange,
@@ -165,13 +128,10 @@ __export(index_exports, {
   updateApiKeyLastUsed: () => updateApiKeyLastUsed,
   updateBlogPost: () => updateBlogPost,
   updateBlogTag: () => updateBlogTag,
-  updateEntry: () => updateEntry,
   updateLocation: () => updateLocation,
-  updateMatch: () => updateMatch,
   updateOpprPlayerRanking: () => updateOpprPlayerRanking,
   updateOpprRatingAfterTournament: () => updateOpprRatingAfterTournament,
   updatePlayer: () => updatePlayer,
-  updateRound: () => updateRound,
   updateStanding: () => updateStanding,
   updateStandingPoints: () => updateStandingPoints,
   updateTournament: () => updateTournament,
@@ -617,28 +577,6 @@ async function getTournamentWithResults(id) {
     }
   });
 }
-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" }]
-      }
-    }
-  });
-}
 async function searchTournaments(query, limit = 20) {
   return findTournaments({
     take: limit,
@@ -680,323 +618,6 @@ async function getTournamentStats(id) {
   };
 }
 
-// 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 = {
@@ -1680,14 +1301,11 @@ async function getBlogTagsWithPostCounts() {
   connect,
   countBlogPosts,
   countBlogTags,
-  countEntries,
   countLocations,
-  countMatches,
   countOpprPlayerRankings,
   countOpprRankingHistory,
   countPlayers,
   countPublishedBlogPosts,
-  countRounds,
   countStandings,
   countTournaments,
   countUserApiKeys,
@@ -1695,17 +1313,11 @@ async function getBlogTagsWithPostCounts() {
   createApiKey,
   createBlogPost,
   createBlogTag,
-  createEntry,
   createLocation,
-  createManyEntries,
-  createManyMatches,
-  createManyRounds,
   createManyStandings,
-  createMatch,
   createOpprPlayerRanking,
   createOpprRankingHistory,
   createPlayer,
-  createRound,
   createStanding,
   createTournament,
   createUser,
@@ -1713,16 +1325,9 @@ async function getBlogTagsWithPostCounts() {
   deleteApiKey,
   deleteBlogPost,
   deleteBlogTag,
-  deleteEntriesByMatch,
-  deleteEntry,
   deleteLocation,
-  deleteMatch,
-  deleteMatchesByRound,
-  deleteMatchesByTournament,
   deleteOpprPlayerRanking,
   deletePlayer,
-  deleteRound,
-  deleteRoundsByTournament,
   deleteStanding,
   deleteStandingsByTournament,
   deleteTournament,
@@ -1737,14 +1342,9 @@ async function getBlogTagsWithPostCounts() {
   findBlogTagById,
   findBlogTagBySlug,
   findBlogTags,
-  findEntries,
-  findEntryById,
-  findEntryByMatchAndPlayer,
   findLocationByExternalId,
   findLocationById,
   findLocations,
-  findMatchById,
-  findMatches,
   findOpprPlayerRankingById,
   findOpprPlayerRankingByPlayerId,
   findOpprPlayerRankings,
@@ -1754,9 +1354,6 @@ async function getBlogTagsWithPostCounts() {
   findPlayerByUserEmail,
   findPlayers,
   findPublishedBlogPosts,
-  findRoundById,
-  findRoundByTournamentAndNumber,
-  findRounds,
   findStandingById,
   findStandingByPlayerAndTournament,
   findStandings,
@@ -1769,38 +1366,25 @@ async function getBlogTagsWithPostCounts() {
   generateUniquePlayerNumber,
   getBlogTagWithPostCount,
   getBlogTagsWithPostCounts,
-  getFinalsRounds,
   getFinalsStandings,
   getLatestOpprRankingHistory,
   getLocationWithTournaments,
   getMajorTournaments,
-  getMatchEntries,
-  getMatchWithEntries,
   getMergedStandings,
   getOpprRankingHistory,
   getOpprRankingHistoryByDateRange,
   getOrCreateOpprPlayerRanking,
-  getPlayerEntries,
-  getPlayerEntryStats,
   getPlayerStandings,
   getPlayerStats,
   getPlayerTopFinishes,
-  getPlayerTournamentEntries,
-  getPlayerTournamentMatches,
   getPlayerWithResults,
-  getQualifyingRounds,
   getQualifyingStandings,
   getRatedOpprPlayers,
   getRecentTournaments,
-  getRoundMatches,
-  getRoundWithMatches,
   getTopPlayersByOpprRanking,
   getTopPlayersByOpprRating,
-  getTournamentMatches,
-  getTournamentRounds,
   getTournamentStandings,
   getTournamentStats,
-  getTournamentWithMatches,
   getTournamentWithResults,
   getTournamentsByBoosterType,
   getTournamentsByDateRange,
@@ -1820,13 +1404,10 @@ async function getBlogTagsWithPostCounts() {
   updateApiKeyLastUsed,
   updateBlogPost,
   updateBlogTag,
-  updateEntry,
   updateLocation,
-  updateMatch,
   updateOpprPlayerRanking,
   updateOpprRatingAfterTournament,
   updatePlayer,
-  updateRound,
   updateStanding,
   updateStandingPoints,
   updateTournament,