@opprs/db-prisma 2.2.1-canary.5b08a34 → 2.2.1-canary.73ad5c6

package/dist/index.cjs

@@ -20,18 +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,
@@ -47,6 +55,9 @@ __export(index_exports, {
   createTournament: () => createTournament,
   createUser: () => createUser,
   createUserWithPlayer: () => createUserWithPlayer,
+  deleteApiKey: () => deleteApiKey,
+  deleteBlogPost: () => deleteBlogPost,
+  deleteBlogTag: () => deleteBlogTag,
   deleteEntriesByMatch: () => deleteEntriesByMatch,
   deleteEntry: () => deleteEntry,
   deleteLocation: () => deleteLocation,
@@ -61,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,
@@ -78,6 +98,7 @@ __export(index_exports, {
   findPlayerByPlayerNumber: () => findPlayerByPlayerNumber,
   findPlayerByUserEmail: () => findPlayerByUserEmail,
   findPlayers: () => findPlayers,
+  findPublishedBlogPosts: () => findPublishedBlogPosts,
   findRoundById: () => findRoundById,
   findRoundByTournamentAndNumber: () => findRoundByTournamentAndNumber,
   findRounds: () => findRounds,
@@ -91,6 +112,8 @@ __export(index_exports, {
   findUserById: () => findUserById,
   findUsers: () => findUsers,
   generateUniquePlayerNumber: () => generateUniquePlayerNumber,
+  getBlogTagWithPostCount: () => getBlogTagWithPostCount,
+  getBlogTagsWithPostCounts: () => getBlogTagsWithPostCounts,
   getFinalsRounds: () => getFinalsRounds,
   getFinalsStandings: () => getFinalsStandings,
   getLatestOpprRankingHistory: () => getLatestOpprRankingHistory,
@@ -126,16 +149,22 @@ __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,
@@ -1341,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({
@@ -1406,20 +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,
@@ -1435,6 +1710,9 @@ async function getLocationWithTournaments(id) {
   createTournament,
   createUser,
   createUserWithPlayer,
+  deleteApiKey,
+  deleteBlogPost,
+  deleteBlogTag,
   deleteEntriesByMatch,
   deleteEntry,
   deleteLocation,
@@ -1449,7 +1727,16 @@ async function getLocationWithTournaments(id) {
   deleteStandingsByTournament,
   deleteTournament,
   deleteUser,
+  deleteUserApiKey,
   disconnect,
+  findApiKeyById,
+  findApiKeysByPrefix,
+  findBlogPostById,
+  findBlogPostBySlug,
+  findBlogPosts,
+  findBlogTagById,
+  findBlogTagBySlug,
+  findBlogTags,
   findEntries,
   findEntryById,
   findEntryByMatchAndPlayer,
@@ -1466,6 +1753,7 @@ async function getLocationWithTournaments(id) {
   findPlayerByPlayerNumber,
   findPlayerByUserEmail,
   findPlayers,
+  findPublishedBlogPosts,
   findRoundById,
   findRoundByTournamentAndNumber,
   findRounds,
@@ -1479,6 +1767,8 @@ async function getLocationWithTournaments(id) {
   findUserById,
   findUsers,
   generateUniquePlayerNumber,
+  getBlogTagWithPostCount,
+  getBlogTagsWithPostCounts,
   getFinalsRounds,
   getFinalsStandings,
   getLatestOpprRankingHistory,
@@ -1514,16 +1804,22 @@ 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,