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

package/dist/index.cjs

@@ -20,15 +20,26 @@ 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,
+  countPublishedBlogPosts: () => countPublishedBlogPosts,
   countRounds: () => countRounds,
   countStandings: () => countStandings,
   countTournaments: () => countTournaments,
+  countUserApiKeys: () => countUserApiKeys,
   countUsers: () => countUsers,
+  createApiKey: () => createApiKey,
+  createBlogPost: () => createBlogPost,
+  createBlogTag: () => createBlogTag,
   createEntry: () => createEntry,
   createLocation: () => createLocation,
   createManyEntries: () => createManyEntries,
@@ -36,18 +47,24 @@ __export(index_exports, {
   createManyRounds: () => createManyRounds,
   createManyStandings: () => createManyStandings,
   createMatch: () => createMatch,
+  createOpprPlayerRanking: () => createOpprPlayerRanking,
+  createOpprRankingHistory: () => createOpprRankingHistory,
   createPlayer: () => createPlayer,
   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,
   deleteRound: () => deleteRound,
   deleteRoundsByTournament: () => deleteRoundsByTournament,
@@ -55,7 +72,16 @@ __export(index_exports, {
   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,
@@ -64,11 +90,15 @@ __export(index_exports, {
   findLocations: () => findLocations,
   findMatchById: () => findMatchById,
   findMatches: () => findMatches,
+  findOpprPlayerRankingById: () => findOpprPlayerRankingById,
+  findOpprPlayerRankingByPlayerId: () => findOpprPlayerRankingByPlayerId,
+  findOpprPlayerRankings: () => findOpprPlayerRankings,
   findPlayerByExternalId: () => findPlayerByExternalId,
   findPlayerById: () => findPlayerById,
   findPlayerByPlayerNumber: () => findPlayerByPlayerNumber,
   findPlayerByUserEmail: () => findPlayerByUserEmail,
   findPlayers: () => findPlayers,
+  findPublishedBlogPosts: () => findPublishedBlogPosts,
   findRoundById: () => findRoundById,
   findRoundByTournamentAndNumber: () => findRoundByTournamentAndNumber,
   findRounds: () => findRounds,
@@ -82,13 +112,19 @@ __export(index_exports, {
   findUserById: () => findUserById,
   findUsers: () => findUsers,
   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,
@@ -99,12 +135,12 @@ __export(index_exports, {
   getPlayerWithResults: () => getPlayerWithResults,
   getQualifyingRounds: () => getQualifyingRounds,
   getQualifyingStandings: () => getQualifyingStandings,
-  getRatedPlayers: () => getRatedPlayers,
+  getRatedOpprPlayers: () => getRatedOpprPlayers,
   getRecentTournaments: () => getRecentTournaments,
   getRoundMatches: () => getRoundMatches,
   getRoundWithMatches: () => getRoundWithMatches,
-  getTopPlayersByRanking: () => getTopPlayersByRanking,
-  getTopPlayersByRating: () => getTopPlayersByRating,
+  getTopPlayersByOpprRanking: () => getTopPlayersByOpprRanking,
+  getTopPlayersByOpprRating: () => getTopPlayersByOpprRating,
   getTournamentMatches: () => getTournamentMatches,
   getTournamentRounds: () => getTournamentRounds,
   getTournamentStandings: () => getTournamentStandings,
@@ -113,27 +149,35 @@ __export(index_exports, {
   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,
   updateRound: () => updateRound,
   updateStanding: () => updateStanding,
   updateStandingPoints: () => updateStandingPoints,
   updateTournament: () => updateTournament,
   updateUser: () => updateUser,
-  updateUserRefreshToken: () => updateUserRefreshToken
+  updateUserRefreshToken: () => updateUserRefreshToken,
+  updateWorldRankings: () => updateWorldRankings
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -232,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 }
@@ -315,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({
@@ -1029,10 +1243,6 @@ async function createUserWithPlayer(userData, playerData) {
             id: true,
             playerNumber: true,
             name: true,
-            rating: true,
-            ratingDeviation: true,
-            ranking: true,
-            isRated: true,
             eventCount: true
           }
         }
@@ -1062,10 +1272,6 @@ async function getUserWithPlayer(id) {
           id: true,
           playerNumber: true,
           name: true,
-          rating: true,
-          ratingDeviation: true,
-          ranking: true,
-          isRated: true,
           eventCount: true
         }
       }
@@ -1085,10 +1291,6 @@ async function getUserByEmailWithPlayer(email) {
           id: true,
           playerNumber: true,
           name: true,
-          rating: true,
-          ratingDeviation: true,
-          ranking: true,
-          isRated: true,
           eventCount: true
         }
       }
@@ -1131,10 +1333,6 @@ async function findUsers(params) {
           id: true,
           playerNumber: true,
           name: true,
-          rating: true,
-          ratingDeviation: true,
-          ranking: true,
-          isRated: true,
           eventCount: true
         }
       }
@@ -1163,10 +1361,6 @@ async function linkPlayerToUser(userId, playerId) {
             id: true,
             playerNumber: true,
             name: true,
-            rating: true,
-            ratingDeviation: true,
-            ranking: true,
-            isRated: true,
             eventCount: true
           }
         }
@@ -1176,6 +1370,65 @@ async function linkPlayerToUser(userId, playerId) {
   });
 }
 
+// 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({
@@ -1241,17 +1494,207 @@ async function getLocationWithTournaments(id) {
     }
   });
 }
+
+// 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,
+  countPublishedBlogPosts,
   countRounds,
   countStandings,
   countTournaments,
+  countUserApiKeys,
   countUsers,
+  createApiKey,
+  createBlogPost,
+  createBlogTag,
   createEntry,
   createLocation,
   createManyEntries,
@@ -1259,18 +1702,24 @@ async function getLocationWithTournaments(id) {
   createManyRounds,
   createManyStandings,
   createMatch,
+  createOpprPlayerRanking,
+  createOpprRankingHistory,
   createPlayer,
   createRound,
   createStanding,
   createTournament,
   createUser,
   createUserWithPlayer,
+  deleteApiKey,
+  deleteBlogPost,
+  deleteBlogTag,
   deleteEntriesByMatch,
   deleteEntry,
   deleteLocation,
   deleteMatch,
   deleteMatchesByRound,
   deleteMatchesByTournament,
+  deleteOpprPlayerRanking,
   deletePlayer,
   deleteRound,
   deleteRoundsByTournament,
@@ -1278,7 +1727,16 @@ async function getLocationWithTournaments(id) {
   deleteStandingsByTournament,
   deleteTournament,
   deleteUser,
+  deleteUserApiKey,
   disconnect,
+  findApiKeyById,
+  findApiKeysByPrefix,
+  findBlogPostById,
+  findBlogPostBySlug,
+  findBlogPosts,
+  findBlogTagById,
+  findBlogTagBySlug,
+  findBlogTags,
   findEntries,
   findEntryById,
   findEntryByMatchAndPlayer,
@@ -1287,11 +1745,15 @@ async function getLocationWithTournaments(id) {
   findLocations,
   findMatchById,
   findMatches,
+  findOpprPlayerRankingById,
+  findOpprPlayerRankingByPlayerId,
+  findOpprPlayerRankings,
   findPlayerByExternalId,
   findPlayerById,
   findPlayerByPlayerNumber,
   findPlayerByUserEmail,
   findPlayers,
+  findPublishedBlogPosts,
   findRoundById,
   findRoundByTournamentAndNumber,
   findRounds,
@@ -1305,13 +1767,19 @@ async function getLocationWithTournaments(id) {
   findUserById,
   findUsers,
   generateUniquePlayerNumber,
+  getBlogTagWithPostCount,
+  getBlogTagsWithPostCounts,
   getFinalsRounds,
   getFinalsStandings,
+  getLatestOpprRankingHistory,
   getLocationWithTournaments,
   getMajorTournaments,
   getMatchEntries,
   getMatchWithEntries,
   getMergedStandings,
+  getOpprRankingHistory,
+  getOpprRankingHistoryByDateRange,
+  getOrCreateOpprPlayerRanking,
   getPlayerEntries,
   getPlayerEntryStats,
   getPlayerStandings,
@@ -1322,12 +1790,12 @@ async function getLocationWithTournaments(id) {
   getPlayerWithResults,
   getQualifyingRounds,
   getQualifyingStandings,
-  getRatedPlayers,
+  getRatedOpprPlayers,
   getRecentTournaments,
   getRoundMatches,
   getRoundWithMatches,
-  getTopPlayersByRanking,
-  getTopPlayersByRating,
+  getTopPlayersByOpprRanking,
+  getTopPlayersByOpprRating,
   getTournamentMatches,
   getTournamentRounds,
   getTournamentStandings,
@@ -1336,25 +1804,33 @@ async function getLocationWithTournaments(id) {
   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,
   updateRound,
   updateStanding,
   updateStandingPoints,
   updateTournament,
   updateUser,
-  updateUserRefreshToken
+  updateUserRefreshToken,
+  updateWorldRankings
 });