@opprs/db-prisma 0.5.2-canary.16741f5

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.16741f5",
+  "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.16741f5"
+  },
+  "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/migrations/20251231075738_init/migration.sql

@@ -0,0 +1,112 @@
+-- CreateEnum
+CREATE TYPE "EventBoosterType" AS ENUM ('NONE', 'CERTIFIED', 'CERTIFIED_PLUS', 'CHAMPIONSHIP_SERIES', 'MAJOR');
+
+-- CreateTable
+CREATE TABLE "Player" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "externalId" TEXT,
+    "name" TEXT,
+    "email" TEXT,
+    "rating" DOUBLE PRECISION NOT NULL DEFAULT 1500,
+    "ratingDeviation" DOUBLE PRECISION NOT NULL DEFAULT 200,
+    "ranking" INTEGER,
+    "isRated" BOOLEAN NOT NULL DEFAULT false,
+    "eventCount" INTEGER NOT NULL DEFAULT 0,
+    "lastRatingUpdate" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "lastEventDate" TIMESTAMP(3),
+
+    CONSTRAINT "Player_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Tournament" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "externalId" TEXT,
+    "name" TEXT NOT NULL,
+    "location" TEXT,
+    "date" TIMESTAMP(3) NOT NULL,
+    "tgpConfig" JSONB,
+    "eventBooster" "EventBoosterType" NOT NULL DEFAULT 'NONE',
+    "allowsOptOut" BOOLEAN NOT NULL DEFAULT false,
+    "baseValue" DOUBLE PRECISION,
+    "tvaRating" DOUBLE PRECISION,
+    "tvaRanking" DOUBLE PRECISION,
+    "totalTVA" DOUBLE PRECISION,
+    "tgp" DOUBLE PRECISION,
+    "eventBoosterMultiplier" DOUBLE PRECISION,
+    "firstPlaceValue" DOUBLE PRECISION,
+
+    CONSTRAINT "Tournament_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "TournamentResult" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "playerId" TEXT NOT NULL,
+    "tournamentId" TEXT NOT NULL,
+    "position" INTEGER NOT NULL,
+    "optedOut" BOOLEAN NOT NULL DEFAULT false,
+    "linearPoints" DOUBLE PRECISION DEFAULT 0,
+    "dynamicPoints" DOUBLE PRECISION DEFAULT 0,
+    "totalPoints" DOUBLE PRECISION,
+    "ageInDays" INTEGER DEFAULT 0,
+    "decayMultiplier" DOUBLE PRECISION DEFAULT 1.0,
+    "decayedPoints" DOUBLE PRECISION,
+    "efficiency" DOUBLE PRECISION,
+
+    CONSTRAINT "TournamentResult_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Player_externalId_key" ON "Player"("externalId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Player_email_key" ON "Player"("email");
+
+-- CreateIndex
+CREATE INDEX "Player_email_idx" ON "Player"("email");
+
+-- CreateIndex
+CREATE INDEX "Player_externalId_idx" ON "Player"("externalId");
+
+-- CreateIndex
+CREATE INDEX "Player_rating_idx" ON "Player"("rating");
+
+-- CreateIndex
+CREATE INDEX "Player_ranking_idx" ON "Player"("ranking");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Tournament_externalId_key" ON "Tournament"("externalId");
+
+-- CreateIndex
+CREATE INDEX "Tournament_date_idx" ON "Tournament"("date");
+
+-- CreateIndex
+CREATE INDEX "Tournament_eventBooster_idx" ON "Tournament"("eventBooster");
+
+-- CreateIndex
+CREATE INDEX "Tournament_externalId_idx" ON "Tournament"("externalId");
+
+-- CreateIndex
+CREATE INDEX "TournamentResult_playerId_idx" ON "TournamentResult"("playerId");
+
+-- CreateIndex
+CREATE INDEX "TournamentResult_tournamentId_idx" ON "TournamentResult"("tournamentId");
+
+-- CreateIndex
+CREATE INDEX "TournamentResult_position_idx" ON "TournamentResult"("position");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "TournamentResult_playerId_tournamentId_key" ON "TournamentResult"("playerId", "tournamentId");
+
+-- AddForeignKey
+ALTER TABLE "TournamentResult" ADD CONSTRAINT "TournamentResult_playerId_fkey" FOREIGN KEY ("playerId") REFERENCES "Player"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "TournamentResult" ADD CONSTRAINT "TournamentResult_tournamentId_fkey" FOREIGN KEY ("tournamentId") REFERENCES "Tournament"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (e.g., Git)
+provider = "postgresql"