@opprs/db-prisma 2.6.0 → 3.0.0

package/dist/index.js

@@ -434,28 +434,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,
@@ -497,323 +475,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 = {
@@ -1496,14 +1157,11 @@ export {
   connect,
   countBlogPosts,
   countBlogTags,
-  countEntries,
   countLocations,
-  countMatches,
   countOpprPlayerRankings,
   countOpprRankingHistory,
   countPlayers,
   countPublishedBlogPosts,
-  countRounds,
   countStandings,
   countTournaments,
   countUserApiKeys,
@@ -1511,17 +1169,11 @@ export {
   createApiKey,
   createBlogPost,
   createBlogTag,
-  createEntry,
   createLocation,
-  createManyEntries,
-  createManyMatches,
-  createManyRounds,
   createManyStandings,
-  createMatch,
   createOpprPlayerRanking,
   createOpprRankingHistory,
   createPlayer,
-  createRound,
   createStanding,
   createTournament,
   createUser,
@@ -1529,16 +1181,9 @@ export {
   deleteApiKey,
   deleteBlogPost,
   deleteBlogTag,
-  deleteEntriesByMatch,
-  deleteEntry,
   deleteLocation,
-  deleteMatch,
-  deleteMatchesByRound,
-  deleteMatchesByTournament,
   deleteOpprPlayerRanking,
   deletePlayer,
-  deleteRound,
-  deleteRoundsByTournament,
   deleteStanding,
   deleteStandingsByTournament,
   deleteTournament,
@@ -1553,14 +1198,9 @@ export {
   findBlogTagById,
   findBlogTagBySlug,
   findBlogTags,
-  findEntries,
-  findEntryById,
-  findEntryByMatchAndPlayer,
   findLocationByExternalId,
   findLocationById,
   findLocations,
-  findMatchById,
-  findMatches,
   findOpprPlayerRankingById,
   findOpprPlayerRankingByPlayerId,
   findOpprPlayerRankings,
@@ -1570,9 +1210,6 @@ export {
   findPlayerByUserEmail,
   findPlayers,
   findPublishedBlogPosts,
-  findRoundById,
-  findRoundByTournamentAndNumber,
-  findRounds,
   findStandingById,
   findStandingByPlayerAndTournament,
   findStandings,
@@ -1585,38 +1222,25 @@ export {
   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,
@@ -1636,13 +1260,10 @@ export {
   updateApiKeyLastUsed,
   updateBlogPost,
   updateBlogTag,
-  updateEntry,
   updateLocation,
-  updateMatch,
   updateOpprPlayerRanking,
   updateOpprRatingAfterTournament,
   updatePlayer,
-  updateRound,
   updateStanding,
   updateStandingPoints,
   updateTournament,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opprs/db-prisma",
-  "version": "2.6.0",
+  "version": "3.0.0",
   "description": "Database backend for OPPR (Open Pinball Player Ranking System) using Prisma and PostgreSQL",
   "keywords": [
     "oppr",
@@ -12,7 +12,7 @@
     "tournament"
   ],
   "author": "Mitch McAffee",
-  "license": "MIT",
+  "license": "AGPL-3.0-or-later",
   "repository": {
     "type": "git",
     "url": "https://github.com/themcaffee/OPPR",
@@ -56,7 +56,7 @@
     "vitest": "^4.0.16"
   },
   "peerDependencies": {
-    "@opprs/core": "^2.2.1"
+    "@opprs/core": "^3.0.0"
   },
   "engines": {
     "node": ">=20.9.0"
@@ -66,6 +66,7 @@
   },
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "postbuild": "cp ../../LICENSE .",
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src --ext .ts",

package/prisma/migrations/20260105020000_add_blog_post_model/migration.sql

@@ -0,0 +1,81 @@
+-- CreateEnum
+CREATE TYPE "PostStatus" AS ENUM ('DRAFT', 'PUBLISHED');
+
+-- CreateTable
+CREATE TABLE "BlogPost" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "title" TEXT NOT NULL,
+    "slug" TEXT NOT NULL,
+    "content" TEXT NOT NULL,
+    "excerpt" VARCHAR(500),
+    "status" "PostStatus" NOT NULL DEFAULT 'DRAFT',
+    "publishedAt" TIMESTAMP(3),
+    "featuredImageUrl" TEXT,
+    "featuredImageAlt" TEXT,
+    "metaTitle" VARCHAR(60),
+    "metaDescription" VARCHAR(160),
+    "ogTitle" TEXT,
+    "ogDescription" TEXT,
+    "ogImageUrl" TEXT,
+    "authorId" TEXT NOT NULL,
+
+    CONSTRAINT "BlogPost_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "BlogTag" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "name" TEXT NOT NULL,
+    "slug" TEXT NOT NULL,
+    "description" TEXT,
+
+    CONSTRAINT "BlogTag_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable (implicit many-to-many join table)
+CREATE TABLE "_BlogPostToTag" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+
+    CONSTRAINT "_BlogPostToTag_AB_pkey" PRIMARY KEY ("A","B")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "BlogPost_slug_key" ON "BlogPost"("slug");
+
+-- CreateIndex
+CREATE INDEX "BlogPost_slug_idx" ON "BlogPost"("slug");
+
+-- CreateIndex
+CREATE INDEX "BlogPost_status_idx" ON "BlogPost"("status");
+
+-- CreateIndex
+CREATE INDEX "BlogPost_publishedAt_idx" ON "BlogPost"("publishedAt");
+
+-- CreateIndex
+CREATE INDEX "BlogPost_authorId_idx" ON "BlogPost"("authorId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "BlogTag_name_key" ON "BlogTag"("name");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "BlogTag_slug_key" ON "BlogTag"("slug");
+
+-- CreateIndex
+CREATE INDEX "BlogTag_slug_idx" ON "BlogTag"("slug");
+
+-- CreateIndex
+CREATE INDEX "_BlogPostToTag_B_index" ON "_BlogPostToTag"("B");
+
+-- AddForeignKey
+ALTER TABLE "BlogPost" ADD CONSTRAINT "BlogPost_authorId_fkey" FOREIGN KEY ("authorId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "_BlogPostToTag" ADD CONSTRAINT "_BlogPostToTag_A_fkey" FOREIGN KEY ("A") REFERENCES "BlogPost"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "_BlogPostToTag" ADD CONSTRAINT "_BlogPostToTag_B_fkey" FOREIGN KEY ("B") REFERENCES "BlogTag"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/migrations/20260109000000_remove_entry_match_round_models/migration.sql

@@ -0,0 +1,26 @@
+-- DropForeignKey
+ALTER TABLE "Entry" DROP CONSTRAINT "Entry_matchId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "Entry" DROP CONSTRAINT "Entry_playerId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "Match" DROP CONSTRAINT "Match_roundId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "Match" DROP CONSTRAINT "Match_tournamentId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "Round" DROP CONSTRAINT "Round_tournamentId_fkey";
+
+-- DropTable
+DROP TABLE "Entry";
+
+-- DropTable
+DROP TABLE "Match";
+
+-- DropTable
+DROP TABLE "Round";
+
+-- DropEnum
+DROP TYPE "MatchResult";

package/prisma/schema.prisma

@@ -27,7 +27,6 @@ model Player {
 
   // Relations
   standings            Standing[]
-  entries              Entry[]
   user                 User?
   organizedTournaments Tournament[] @relation("OrganizedTournaments")
   opprRanking          OpprPlayerRanking?
@@ -76,8 +75,6 @@ model Tournament {
   firstPlaceValue  Float?
 
   // Relations
-  rounds                Round[]
-  matches               Match[]
   standings             Standing[]
   rankingHistoryRecords OpprRankingHistory[]
 
@@ -88,67 +85,6 @@ model Tournament {
   @@index([organizerId])
 }
 
-// Round model - groups matches within a tournament stage
-model Round {
-  id            String     @id @default(cuid())
-  createdAt     DateTime   @default(now())
-  updatedAt     DateTime   @updatedAt
-
-  tournamentId  String
-  tournament    Tournament @relation(fields: [tournamentId], references: [id], onDelete: Cascade)
-
-  number        Int        // Round number within the stage (1, 2, 3...)
-  name          String?    // Optional name (e.g., "Quarterfinals", "Semifinal")
-  isFinals      Boolean    @default(false)
-
-  // Relations
-  matches       Match[]
-
-  @@unique([tournamentId, number, isFinals])
-  @@index([tournamentId])
-  @@index([tournamentId, isFinals])
-}
-
-// Match model - a single game with 1-4 players
-model Match {
-  id            String     @id @default(cuid())
-  createdAt     DateTime   @default(now())
-  updatedAt     DateTime   @updatedAt
-
-  tournamentId  String
-  tournament    Tournament @relation(fields: [tournamentId], references: [id], onDelete: Cascade)
-  roundId       String?
-  round         Round?     @relation(fields: [roundId], references: [id], onDelete: SetNull)
-
-  number        Int?       // Match number within the round
-  machineName   String?    // Machine played on
-
-  // Relations
-  entries       Entry[]
-
-  @@index([tournamentId])
-  @@index([roundId])
-}
-
-// Entry model - a player's participation in a match
-model Entry {
-  id            String      @id @default(cuid())
-  createdAt     DateTime    @default(now())
-  updatedAt     DateTime    @updatedAt
-
-  matchId       String
-  match         Match       @relation(fields: [matchId], references: [id], onDelete: Cascade)
-  playerId      String
-  player        Player      @relation(fields: [playerId], references: [id], onDelete: Cascade)
-
-  result        MatchResult // WIN, LOSS, TIE
-  position      Int?        // Position within the match (1st, 2nd, 3rd, 4th for group games)
-
-  @@unique([matchId, playerId])
-  @@index([matchId])
-  @@index([playerId])
-}
-
 // Standing model - final position for qualifying or finals
 model Standing {
   id               String     @id @default(cuid())
@@ -180,13 +116,6 @@ model Standing {
   @@index([position])
 }
 
-// Enum for match results
-enum MatchResult {
-  WIN
-  LOSS
-  TIE
-}
-
 // Enum for event booster types
 enum EventBoosterType {
   NONE