@opprs/db-prisma 0.5.2-canary.6782466

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mitch McAffee
+
+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:
+
+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.

package/README.md

@@ -0,0 +1,85 @@
+# @opprs/db-prisma
+
+PostgreSQL persistence layer for the Open Pinball Player Ranking System (OPPRS) using Prisma ORM.
+
+## Installation
+
+```bash
+pnpm add @opprs/db-prisma @prisma/client
+```
+
+## Quick Start
+
+### 1. Configure database connection
+
+```bash
+# Set DATABASE_URL in your environment
+DATABASE_URL="postgresql://user:password@localhost:5432/opprs?schema=public"
+```
+
+### 2. Generate Prisma client and run migrations
+
+```bash
+pnpm --filter @opprs/db-prisma run db:generate
+pnpm --filter @opprs/db-prisma run db:migrate
+```
+
+### 3. Use in your code
+
+```typescript
+import {
+  prisma,
+  createPlayer,
+  createTournament,
+  createResult,
+  getPlayerStats,
+} from '@opprs/db-prisma';
+
+// Create a player
+const player = await createPlayer({
+  name: 'Alice Champion',
+  email: 'alice@example.com',
+  rating: 1500,
+  isRated: true,
+});
+
+// Create a tournament and record results
+const tournament = await createTournament({
+  name: 'Spring Championship 2024',
+  date: new Date('2024-03-15'),
+  location: 'Portland, OR',
+  eventBooster: 'CERTIFIED',
+  tgpConfig: {
+    qualifying: { type: 'limited', meaningfulGames: 7 },
+    finals: { formatType: 'match-play', meaningfulGames: 15, fourPlayerGroups: true },
+  },
+});
+
+await createResult({
+  playerId: player.id,
+  tournamentId: tournament.id,
+  position: 1,
+  totalPoints: 87.5,
+});
+
+// Get player statistics
+const stats = await getPlayerStats(player.id);
+```
+
+## Features
+
+- **PostgreSQL + Prisma ORM** - Type-safe database queries and migrations
+- **Query Helpers** - High-level functions for players, tournaments, and results
+- **Time Decay** - Automatic point depreciation calculations
+- **Player Statistics** - Comprehensive performance metrics
+- **Seed Data** - Sample data for development and testing
+
+## Documentation
+
+For complete API reference, database schema, and integration examples, see the [Database (Prisma) documentation](../../docs/db-prisma.md).
+
+Full documentation site: [OPPRS Documentation](https://thatguyinabeanie.github.io/OPPR/)
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,573 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  connect: () => connect,
+  countPlayers: () => countPlayers,
+  countResults: () => countResults,
+  countTournaments: () => countTournaments,
+  createManyResults: () => createManyResults,
+  createPlayer: () => createPlayer,
+  createResult: () => createResult,
+  createTournament: () => createTournament,
+  deletePlayer: () => deletePlayer,
+  deleteResult: () => deleteResult,
+  deleteResultsByTournament: () => deleteResultsByTournament,
+  deleteTournament: () => deleteTournament,
+  disconnect: () => disconnect,
+  findPlayerByEmail: () => findPlayerByEmail,
+  findPlayerByExternalId: () => findPlayerByExternalId,
+  findPlayerById: () => findPlayerById,
+  findPlayers: () => findPlayers,
+  findResultById: () => findResultById,
+  findResultByPlayerAndTournament: () => findResultByPlayerAndTournament,
+  findResults: () => findResults,
+  findTournamentByExternalId: () => findTournamentByExternalId,
+  findTournamentById: () => findTournamentById,
+  findTournaments: () => findTournaments,
+  getMajorTournaments: () => getMajorTournaments,
+  getPlayerResults: () => getPlayerResults,
+  getPlayerStats: () => getPlayerStats,
+  getPlayerTopFinishes: () => getPlayerTopFinishes,
+  getPlayerWithResults: () => getPlayerWithResults,
+  getRatedPlayers: () => getRatedPlayers,
+  getRecentTournaments: () => getRecentTournaments,
+  getTopPlayersByRanking: () => getTopPlayersByRanking,
+  getTopPlayersByRating: () => getTopPlayersByRating,
+  getTournamentResults: () => getTournamentResults,
+  getTournamentStats: () => getTournamentStats,
+  getTournamentWithResults: () => getTournamentWithResults,
+  getTournamentsByBoosterType: () => getTournamentsByBoosterType,
+  getTournamentsByDateRange: () => getTournamentsByDateRange,
+  prisma: () => prisma,
+  recalculateTimeDecay: () => recalculateTimeDecay,
+  searchPlayers: () => searchPlayers,
+  searchTournaments: () => searchTournaments,
+  testConnection: () => testConnection,
+  updatePlayer: () => updatePlayer,
+  updatePlayerRating: () => updatePlayerRating,
+  updateResult: () => updateResult,
+  updateResultPoints: () => updateResultPoints,
+  updateTournament: () => updateTournament
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_client = require("@prisma/client");
+var globalForPrisma = globalThis;
+var prisma = globalForPrisma.prisma ?? new import_client.PrismaClient({
+  log: process.env.NODE_ENV === "development" ? ["query", "error", "warn"] : ["error"]
+});
+if (process.env.NODE_ENV !== "production") {
+  globalForPrisma.prisma = prisma;
+}
+async function disconnect() {
+  await prisma.$disconnect();
+}
+async function connect() {
+  await prisma.$connect();
+}
+async function testConnection() {
+  try {
+    await prisma.$queryRaw`SELECT 1`;
+    return true;
+  } catch (error) {
+    console.error("Database connection test failed:", error);
+    return false;
+  }
+}
+
+// src/players.ts
+async function createPlayer(data) {
+  return prisma.player.create({
+    data
+  });
+}
+async function findPlayerById(id, include) {
+  return prisma.player.findUnique({
+    where: { id },
+    include
+  });
+}
+async function findPlayerByExternalId(externalId, include) {
+  return prisma.player.findUnique({
+    where: { externalId },
+    include
+  });
+}
+async function findPlayerByEmail(email, include) {
+  return prisma.player.findUnique({
+    where: { email },
+    include
+  });
+}
+async function findPlayers(options = {}) {
+  return prisma.player.findMany({
+    take: options.take,
+    skip: options.skip,
+    where: options.where,
+    orderBy: options.orderBy,
+    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 }
+  });
+}
+async function countPlayers(where) {
+  return prisma.player.count({ where });
+}
+async function getPlayerWithResults(id) {
+  const player = await prisma.player.findUnique({
+    where: { id },
+    include: {
+      tournamentResults: {
+        include: {
+          tournament: true
+        },
+        orderBy: {
+          tournament: {
+            date: "desc"
+          }
+        }
+      }
+    }
+  });
+  if (!player) {
+    return null;
+  }
+  return {
+    ...player,
+    results: player.tournamentResults
+  };
+}
+async function searchPlayers(query, limit = 20) {
+  return findPlayers({
+    take: limit,
+    where: {
+      OR: [
+        { name: { contains: query, mode: "insensitive" } },
+        { email: { contains: query, mode: "insensitive" } }
+      ]
+    }
+  });
+}
+
+// src/tournaments.ts
+async function createTournament(data) {
+  return prisma.tournament.create({
+    data: {
+      ...data,
+      eventBooster: data.eventBooster ?? "NONE"
+    }
+  });
+}
+async function findTournamentById(id, include) {
+  return prisma.tournament.findUnique({
+    where: { id },
+    include
+  });
+}
+async function findTournamentByExternalId(externalId, include) {
+  return prisma.tournament.findUnique({
+    where: { externalId },
+    include
+  });
+}
+async function findTournaments(options = {}) {
+  return prisma.tournament.findMany({
+    take: options.take,
+    skip: options.skip,
+    where: options.where,
+    orderBy: options.orderBy,
+    include: options.include
+  });
+}
+async function getRecentTournaments(limit = 20, include) {
+  return findTournaments({
+    take: limit,
+    orderBy: { date: "desc" },
+    include
+  });
+}
+async function getTournamentsByDateRange(startDate, endDate, options = {}) {
+  return findTournaments({
+    ...options,
+    where: {
+      date: {
+        gte: startDate,
+        lte: endDate
+      }
+    }
+  });
+}
+async function getTournamentsByBoosterType(boosterType, options = {}) {
+  return findTournaments({
+    ...options,
+    where: { eventBooster: boosterType }
+  });
+}
+async function getMajorTournaments(limit) {
+  return findTournaments({
+    take: limit,
+    where: { eventBooster: "MAJOR" },
+    orderBy: { date: "desc" }
+  });
+}
+async function updateTournament(id, data) {
+  return prisma.tournament.update({
+    where: { id },
+    data
+  });
+}
+async function deleteTournament(id) {
+  return prisma.tournament.delete({
+    where: { id }
+  });
+}
+async function countTournaments(where) {
+  return prisma.tournament.count({ where });
+}
+async function getTournamentWithResults(id) {
+  return prisma.tournament.findUnique({
+    where: { id },
+    include: {
+      results: {
+        include: {
+          player: true
+        },
+        orderBy: {
+          position: "asc"
+        }
+      }
+    }
+  });
+}
+async function searchTournaments(query, limit = 20) {
+  return findTournaments({
+    take: limit,
+    where: {
+      OR: [
+        { name: { contains: query, mode: "insensitive" } },
+        { location: { contains: query, mode: "insensitive" } }
+      ]
+    },
+    orderBy: { date: "desc" }
+  });
+}
+async function getTournamentStats(id) {
+  const tournament = await getTournamentWithResults(id);
+  if (!tournament) {
+    return null;
+  }
+  const playerCount = tournament.results.length;
+  if (playerCount === 0) {
+    return {
+      tournament,
+      playerCount: 0,
+      averagePoints: 0,
+      averageEfficiency: 0,
+      highestPoints: 0,
+      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);
+  return {
+    tournament,
+    playerCount,
+    averagePoints: totalPoints / playerCount,
+    averageEfficiency: totalEfficiency / playerCount,
+    highestPoints: Math.max(...allPoints),
+    lowestPoints: Math.min(...allPoints)
+  };
+}
+
+// src/results.ts
+async function createResult(data) {
+  const resultData = {
+    ...data,
+    decayedPoints: data.decayedPoints ?? data.totalPoints ?? 0
+  };
+  return prisma.tournamentResult.create({
+    data: resultData
+  });
+}
+async function createManyResults(data) {
+  const resultsData = data.map((item) => ({
+    ...item,
+    decayedPoints: item.decayedPoints ?? item.totalPoints ?? 0
+  }));
+  return prisma.tournamentResult.createMany({
+    data: resultsData
+  });
+}
+async function findResultById(id, include) {
+  return prisma.tournamentResult.findUnique({
+    where: { id },
+    include
+  });
+}
+async function findResultByPlayerAndTournament(playerId, tournamentId, include) {
+  return prisma.tournamentResult.findUnique({
+    where: {
+      playerId_tournamentId: {
+        playerId,
+        tournamentId
+      }
+    },
+    include
+  });
+}
+async function findResults(options = {}) {
+  return prisma.tournamentResult.findMany({
+    take: options.take,
+    skip: options.skip,
+    where: options.where,
+    orderBy: options.orderBy,
+    include: options.include
+  });
+}
+async function getPlayerResults(playerId, options = {}) {
+  return findResults({
+    ...options,
+    where: { playerId },
+    include: { tournament: true, ...options.include },
+    orderBy: { tournament: { date: "desc" } }
+  });
+}
+async function getTournamentResults(tournamentId, options = {}) {
+  return findResults({
+    ...options,
+    where: { tournamentId },
+    include: { player: true, ...options.include },
+    orderBy: { position: "asc" }
+  });
+}
+async function getPlayerTopFinishes(playerId, limit = 15) {
+  return findResults({
+    where: { playerId },
+    take: limit,
+    include: { tournament: true },
+    orderBy: { decayedPoints: "desc" }
+  });
+}
+async function updateResult(id, data) {
+  return prisma.tournamentResult.update({
+    where: { id },
+    data
+  });
+}
+async function updateResultPoints(id, linearPoints, dynamicPoints, totalPoints) {
+  const result = await findResultById(id, {
+    tournament: true
+  });
+  if (!result) {
+    throw new Error(`Result with id ${id} not found`);
+  }
+  const now = /* @__PURE__ */ new Date();
+  const tournamentDate = result.tournament.date;
+  const ageInDays = Math.floor((now.getTime() - tournamentDate.getTime()) / (1e3 * 60 * 60 * 24));
+  const ageInYears = ageInDays / 365;
+  let decayMultiplier = 0;
+  if (ageInYears < 1) {
+    decayMultiplier = 1;
+  } else if (ageInYears < 2) {
+    decayMultiplier = 0.75;
+  } else if (ageInYears < 3) {
+    decayMultiplier = 0.5;
+  } else {
+    decayMultiplier = 0;
+  }
+  const decayedPoints = totalPoints * decayMultiplier;
+  return updateResult(id, {
+    linearPoints,
+    dynamicPoints,
+    totalPoints,
+    ageInDays,
+    decayMultiplier,
+    decayedPoints
+  });
+}
+async function deleteResult(id) {
+  return prisma.tournamentResult.delete({
+    where: { id }
+  });
+}
+async function deleteResultsByTournament(tournamentId) {
+  return prisma.tournamentResult.deleteMany({
+    where: { tournamentId }
+  });
+}
+async function countResults(where) {
+  return prisma.tournamentResult.count({ where });
+}
+async function getPlayerStats(playerId) {
+  const results = await getPlayerResults(playerId);
+  if (results.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;
+  return {
+    totalEvents: results.length,
+    totalPoints,
+    totalDecayedPoints,
+    averagePoints: totalPoints / results.length,
+    averagePosition,
+    averageFinish: averagePosition,
+    averageEfficiency,
+    firstPlaceFinishes,
+    topThreeFinishes,
+    bestFinish: Math.min(...results.map((r) => r.position)),
+    highestPoints: Math.max(...results.map((r) => r.totalPoints || 0))
+  };
+}
+async function recalculateTimeDecay(referenceDate = /* @__PURE__ */ new Date()) {
+  const results = await findResults({
+    include: { tournament: true }
+  });
+  const updates = results.map((result) => {
+    const tournamentDate = result.tournament.date;
+    const ageInDays = Math.floor(
+      (referenceDate.getTime() - tournamentDate.getTime()) / (1e3 * 60 * 60 * 24)
+    );
+    const ageInYears = ageInDays / 365;
+    let decayMultiplier = 0;
+    if (ageInYears < 1) {
+      decayMultiplier = 1;
+    } else if (ageInYears < 2) {
+      decayMultiplier = 0.75;
+    } else if (ageInYears < 3) {
+      decayMultiplier = 0.5;
+    } else {
+      decayMultiplier = 0;
+    }
+    const decayedPoints = (result.totalPoints || 0) * decayMultiplier;
+    return prisma.tournamentResult.update({
+      where: { id: result.id },
+      data: {
+        ageInDays,
+        decayMultiplier,
+        decayedPoints
+      }
+    });
+  });
+  return Promise.all(updates);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  connect,
+  countPlayers,
+  countResults,
+  countTournaments,
+  createManyResults,
+  createPlayer,
+  createResult,
+  createTournament,
+  deletePlayer,
+  deleteResult,
+  deleteResultsByTournament,
+  deleteTournament,
+  disconnect,
+  findPlayerByEmail,
+  findPlayerByExternalId,
+  findPlayerById,
+  findPlayers,
+  findResultById,
+  findResultByPlayerAndTournament,
+  findResults,
+  findTournamentByExternalId,
+  findTournamentById,
+  findTournaments,
+  getMajorTournaments,
+  getPlayerResults,
+  getPlayerStats,
+  getPlayerTopFinishes,
+  getPlayerWithResults,
+  getRatedPlayers,
+  getRecentTournaments,
+  getTopPlayersByRanking,
+  getTopPlayersByRating,
+  getTournamentResults,
+  getTournamentStats,
+  getTournamentWithResults,
+  getTournamentsByBoosterType,
+  getTournamentsByDateRange,
+  prisma,
+  recalculateTimeDecay,
+  searchPlayers,
+  searchTournaments,
+  testConnection,
+  updatePlayer,
+  updatePlayerRating,
+  updateResult,
+  updateResultPoints,
+  updateTournament
+});