@opprs/db-prisma 0.5.2-canary.8e722bf

package/dist/index.js

@@ -0,0 +1,500 @@
+// src/client.ts
+import { PrismaClient } from "@prisma/client";
+var globalForPrisma = globalThis;
+var prisma = globalForPrisma.prisma ?? new 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);
+}
+export {
+  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
+};

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@opprs/db-prisma",
+  "version": "0.5.2-canary.8e722bf",
+  "description": "Database backend for OPPR (Open Pinball Player Ranking System) using Prisma and PostgreSQL",
+  "keywords": [
+    "oppr",
+    "pinball",
+    "ranking",
+    "database",
+    "prisma",
+    "postgresql",
+    "tournament"
+  ],
+  "author": "Mitch McAffee",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/themcaffee/OPPR",
+    "directory": "packages/db-prisma"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "prisma",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@prisma/client": "^6.2.0"
+  },
+  "devDependencies": {
+    "@testcontainers/postgresql": "^11.11.0",
+    "@types/node": "^22.10.5",
+    "@typescript-eslint/eslint-plugin": "^8.19.1",
+    "@typescript-eslint/parser": "^8.19.1",
+    "@vitest/coverage-v8": "^4.0.16",
+    "@vitest/ui": "^4.0.16",
+    "eslint": "^9.17.0",
+    "prettier": "^3.4.2",
+    "prisma": "^6.2.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^4.0.16"
+  },
+  "peerDependencies": {
+    "@opprs/core": "^0.5.2-canary.8e722bf"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "prisma": {
+    "seed": "tsx prisma/seed.ts"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "db:generate": "prisma generate",
+    "db:push": "prisma db push",
+    "db:migrate": "prisma migrate dev",
+    "db:migrate:prod": "prisma migrate deploy",
+    "db:studio": "prisma studio",
+    "db:seed": "tsx prisma/seed.ts",
+    "db:reset": "prisma migrate reset"
+  }
+}

package/prisma/schema.prisma

@@ -0,0 +1,123 @@
+// Prisma schema for OPPR Database
+// Documentation: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+// Player model - represents a pinball player
+model Player {
+  id               String   @id @default(cuid())
+  createdAt        DateTime @default(now())
+  updatedAt        DateTime @updatedAt
+
+  // Player identification
+  externalId       String?  @unique // External ID from OPPR or other systems
+  name             String?
+  email            String?  @unique
+
+  // OPPR Rating fields
+  rating           Float    @default(1500) // Glicko rating
+  ratingDeviation  Float    @default(200)  // Rating uncertainty (RD)
+  ranking          Int?                     // World ranking position
+  isRated          Boolean  @default(false) // Has 5+ events
+  eventCount       Int      @default(0)     // Number of events participated
+
+  // Timestamps for rating calculations
+  lastRatingUpdate DateTime @default(now())
+  lastEventDate    DateTime?
+
+  // Relations
+  tournamentResults TournamentResult[]
+
+  @@index([email])
+  @@index([externalId])
+  @@index([rating])
+  @@index([ranking])
+}
+
+// Tournament model - represents a pinball tournament event
+model Tournament {
+  id               String   @id @default(cuid())
+  createdAt        DateTime @default(now())
+  updatedAt        DateTime @updatedAt
+
+  // Tournament identification
+  externalId       String?  @unique // External ID from OPPR or other systems
+  name             String
+  location         String?
+  date             DateTime
+
+  // Tournament configuration (stored as JSON)
+  // Contains TGPConfig structure from OPPR
+  tgpConfig        Json?
+
+  // Event classification
+  eventBooster     EventBoosterType @default(NONE)
+  allowsOptOut     Boolean          @default(false)
+
+  // Tournament value calculations (can be calculated or cached)
+  baseValue        Float?
+  tvaRating        Float?
+  tvaRanking       Float?
+  totalTVA         Float?
+  tgp              Float?
+  eventBoosterMultiplier Float?
+  firstPlaceValue  Float?
+
+  // Relations
+  results          TournamentResult[]
+
+  @@index([date])
+  @@index([eventBooster])
+  @@index([externalId])
+}
+
+// Tournament Result - junction table linking players to tournaments
+model TournamentResult {
+  id               String   @id @default(cuid())
+  createdAt        DateTime @default(now())
+  updatedAt        DateTime @updatedAt
+
+  // Relations
+  playerId         String
+  player           Player     @relation(fields: [playerId], references: [id], onDelete: Cascade)
+  tournamentId     String
+  tournament       Tournament @relation(fields: [tournamentId], references: [id], onDelete: Cascade)
+
+  // Result data
+  position         Int      // Finishing position (1 = first place)
+  optedOut         Boolean  @default(false)
+
+  // Points awarded
+  linearPoints     Float?   @default(0) // Linear distribution points
+  dynamicPoints    Float?   @default(0) // Dynamic distribution points
+  totalPoints      Float?   // Total points (linear + dynamic)
+
+  // Time decay tracking
+  ageInDays        Int?     @default(0) // Age of event in days at calculation time
+  decayMultiplier  Float?   @default(1.0) // Time decay multiplier (1.0, 0.75, 0.5, or 0.0)
+  decayedPoints    Float?   // Points after applying decay (defaults to totalPoints via application logic)
+
+  // Efficiency tracking
+  efficiency       Float?   // Performance efficiency percentage
+
+  @@unique([playerId, tournamentId])
+  @@index([playerId])
+  @@index([tournamentId])
+  @@index([position])
+}
+
+// Enum for event booster types
+enum EventBoosterType {
+  NONE
+  CERTIFIED
+  CERTIFIED_PLUS
+  CHAMPIONSHIP_SERIES
+  MAJOR
+}