@opprs/db-prisma 2.2.1-canary.ccb79aa → 2.2.1-canary.cd8b178

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opprs/db-prisma",
-  "version": "2.2.1-canary.ccb79aa",
+  "version": "2.2.1-canary.cd8b178",
   "description": "Database backend for OPPR (Open Pinball Player Ranking System) using Prisma and PostgreSQL",
   "keywords": [
     "oppr",
@@ -56,7 +56,7 @@
     "vitest": "^4.0.16"
   },
   "peerDependencies": {
-    "@opprs/core": "^2.2.1-canary.ccb79aa"
+    "@opprs/core": "^2.2.1-canary.cd8b178"
   },
   "engines": {
     "node": ">=20.9.0"

package/prisma/migrations/20260104092800_add_location_model_and_tournament_fields/migration.sql

@@ -0,0 +1,45 @@
+-- CreateTable
+CREATE TABLE "Location" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "externalId" TEXT,
+    "name" TEXT NOT NULL,
+    "address" TEXT,
+    "city" TEXT,
+    "state" TEXT,
+    "country" TEXT,
+
+    CONSTRAINT "Location_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Location_externalId_key" ON "Location"("externalId");
+
+-- CreateIndex
+CREATE INDEX "Location_externalId_idx" ON "Location"("externalId");
+
+-- CreateIndex
+CREATE INDEX "Location_name_idx" ON "Location"("name");
+
+-- CreateIndex
+CREATE INDEX "Location_city_idx" ON "Location"("city");
+
+-- AlterTable: Add new columns to Tournament
+ALTER TABLE "Tournament" ADD COLUMN "description" VARCHAR(2000);
+ALTER TABLE "Tournament" ADD COLUMN "locationId" TEXT;
+ALTER TABLE "Tournament" ADD COLUMN "organizerId" TEXT;
+
+-- DropColumn: Remove old location string column (replaced by Location relation)
+ALTER TABLE "Tournament" DROP COLUMN IF EXISTS "location";
+
+-- CreateIndex for new Tournament columns
+CREATE INDEX "Tournament_locationId_idx" ON "Tournament"("locationId");
+
+CREATE INDEX "Tournament_organizerId_idx" ON "Tournament"("organizerId");
+
+-- AddForeignKey: Tournament -> Location
+ALTER TABLE "Tournament" ADD CONSTRAINT "Tournament_locationId_fkey" FOREIGN KEY ("locationId") REFERENCES "Location"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey: Tournament -> Player (organizer)
+ALTER TABLE "Tournament" ADD CONSTRAINT "Tournament_organizerId_fkey" FOREIGN KEY ("organizerId") REFERENCES "Player"("id") ON DELETE SET NULL ON UPDATE CASCADE;

package/prisma/migrations/20260104210034_add_policy_acceptance_fields/migration.sql

@@ -0,0 +1,19 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `email` on the `Player` table. All the data in the column will be lost.
+
+*/
+-- DropIndex
+DROP INDEX "Player_email_idx";
+
+-- DropIndex
+DROP INDEX "Player_email_key";
+
+-- AlterTable
+ALTER TABLE "Player" DROP COLUMN "email";
+
+-- AlterTable
+ALTER TABLE "User" ADD COLUMN     "codeOfConductAcceptedAt" TIMESTAMP(3),
+ADD COLUMN     "privacyPolicyAcceptedAt" TIMESTAMP(3),
+ADD COLUMN     "tosAcceptedAt" TIMESTAMP(3);

package/prisma/migrations/20260104231435_split_entries_standings/migration.sql

@@ -0,0 +1,137 @@
+/*
+  Warnings:
+
+  - You are about to drop the `TournamentResult` table. If the table is not empty, all the data it contains will be lost.
+
+*/
+-- CreateEnum
+CREATE TYPE "MatchResult" AS ENUM ('WIN', 'LOSS', 'TIE');
+
+-- DropForeignKey
+ALTER TABLE "TournamentResult" DROP CONSTRAINT "TournamentResult_playerId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "TournamentResult" DROP CONSTRAINT "TournamentResult_tournamentId_fkey";
+
+-- DropTable
+DROP TABLE "TournamentResult";
+
+-- CreateTable
+CREATE TABLE "Round" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "tournamentId" TEXT NOT NULL,
+    "number" INTEGER NOT NULL,
+    "name" TEXT,
+    "isFinals" BOOLEAN NOT NULL DEFAULT false,
+
+    CONSTRAINT "Round_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Match" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "tournamentId" TEXT NOT NULL,
+    "roundId" TEXT,
+    "number" INTEGER,
+    "machineName" TEXT,
+
+    CONSTRAINT "Match_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Entry" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "matchId" TEXT NOT NULL,
+    "playerId" TEXT NOT NULL,
+    "result" "MatchResult" NOT NULL,
+    "position" INTEGER,
+
+    CONSTRAINT "Entry_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Standing" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "tournamentId" TEXT NOT NULL,
+    "playerId" TEXT NOT NULL,
+    "position" INTEGER NOT NULL,
+    "isFinals" BOOLEAN NOT NULL DEFAULT false,
+    "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 "Standing_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "Round_tournamentId_idx" ON "Round"("tournamentId");
+
+-- CreateIndex
+CREATE INDEX "Round_tournamentId_isFinals_idx" ON "Round"("tournamentId", "isFinals");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Round_tournamentId_number_isFinals_key" ON "Round"("tournamentId", "number", "isFinals");
+
+-- CreateIndex
+CREATE INDEX "Match_tournamentId_idx" ON "Match"("tournamentId");
+
+-- CreateIndex
+CREATE INDEX "Match_roundId_idx" ON "Match"("roundId");
+
+-- CreateIndex
+CREATE INDEX "Entry_matchId_idx" ON "Entry"("matchId");
+
+-- CreateIndex
+CREATE INDEX "Entry_playerId_idx" ON "Entry"("playerId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Entry_matchId_playerId_key" ON "Entry"("matchId", "playerId");
+
+-- CreateIndex
+CREATE INDEX "Standing_playerId_idx" ON "Standing"("playerId");
+
+-- CreateIndex
+CREATE INDEX "Standing_tournamentId_idx" ON "Standing"("tournamentId");
+
+-- CreateIndex
+CREATE INDEX "Standing_tournamentId_isFinals_idx" ON "Standing"("tournamentId", "isFinals");
+
+-- CreateIndex
+CREATE INDEX "Standing_position_idx" ON "Standing"("position");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Standing_playerId_tournamentId_isFinals_key" ON "Standing"("playerId", "tournamentId", "isFinals");
+
+-- AddForeignKey
+ALTER TABLE "Round" ADD CONSTRAINT "Round_tournamentId_fkey" FOREIGN KEY ("tournamentId") REFERENCES "Tournament"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Match" ADD CONSTRAINT "Match_tournamentId_fkey" FOREIGN KEY ("tournamentId") REFERENCES "Tournament"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Match" ADD CONSTRAINT "Match_roundId_fkey" FOREIGN KEY ("roundId") REFERENCES "Round"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Entry" ADD CONSTRAINT "Entry_matchId_fkey" FOREIGN KEY ("matchId") REFERENCES "Match"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Entry" ADD CONSTRAINT "Entry_playerId_fkey" FOREIGN KEY ("playerId") REFERENCES "Player"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Standing" ADD CONSTRAINT "Standing_tournamentId_fkey" FOREIGN KEY ("tournamentId") REFERENCES "Tournament"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Standing" ADD CONSTRAINT "Standing_playerId_fkey" FOREIGN KEY ("playerId") REFERENCES "Player"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/migrations/20260105000000_add_oppr_ranking_models/migration.sql

@@ -0,0 +1,108 @@
+-- CreateEnum
+CREATE TYPE "OpprRankingChangeType" AS ENUM ('INITIAL', 'TOURNAMENT_RESULT', 'RANKING_REFRESH', 'RD_DECAY', 'MANUAL_ADJUSTMENT');
+
+-- CreateTable
+CREATE TABLE "OpprPlayerRanking" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "playerId" TEXT NOT NULL,
+    "rating" DOUBLE PRECISION NOT NULL DEFAULT 1500,
+    "ratingDeviation" DOUBLE PRECISION NOT NULL DEFAULT 200,
+    "lastRatingUpdate" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "ranking" INTEGER,
+    "isRated" BOOLEAN NOT NULL DEFAULT false,
+
+    CONSTRAINT "OpprPlayerRanking_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "OpprRankingHistory" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "opprPlayerRankingId" TEXT NOT NULL,
+    "rating" DOUBLE PRECISION NOT NULL,
+    "ratingDeviation" DOUBLE PRECISION NOT NULL,
+    "ranking" INTEGER,
+    "isRated" BOOLEAN NOT NULL,
+    "changeType" "OpprRankingChangeType" NOT NULL,
+    "tournamentId" TEXT,
+    "notes" VARCHAR(500),
+
+    CONSTRAINT "OpprRankingHistory_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "OpprPlayerRanking_playerId_key" ON "OpprPlayerRanking"("playerId");
+
+-- CreateIndex
+CREATE INDEX "OpprPlayerRanking_playerId_idx" ON "OpprPlayerRanking"("playerId");
+
+-- CreateIndex
+CREATE INDEX "OpprPlayerRanking_rating_idx" ON "OpprPlayerRanking"("rating");
+
+-- CreateIndex
+CREATE INDEX "OpprPlayerRanking_ranking_idx" ON "OpprPlayerRanking"("ranking");
+
+-- CreateIndex
+CREATE INDEX "OpprPlayerRanking_isRated_idx" ON "OpprPlayerRanking"("isRated");
+
+-- CreateIndex
+CREATE INDEX "OpprRankingHistory_opprPlayerRankingId_idx" ON "OpprRankingHistory"("opprPlayerRankingId");
+
+-- CreateIndex
+CREATE INDEX "OpprRankingHistory_createdAt_idx" ON "OpprRankingHistory"("createdAt");
+
+-- CreateIndex
+CREATE INDEX "OpprRankingHistory_tournamentId_idx" ON "OpprRankingHistory"("tournamentId");
+
+-- CreateIndex
+CREATE INDEX "OpprRankingHistory_opprPlayerRankingId_createdAt_idx" ON "OpprRankingHistory"("opprPlayerRankingId", "createdAt");
+
+-- AddForeignKey
+ALTER TABLE "OpprPlayerRanking" ADD CONSTRAINT "OpprPlayerRanking_playerId_fkey" FOREIGN KEY ("playerId") REFERENCES "Player"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "OpprRankingHistory" ADD CONSTRAINT "OpprRankingHistory_opprPlayerRankingId_fkey" FOREIGN KEY ("opprPlayerRankingId") REFERENCES "OpprPlayerRanking"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "OpprRankingHistory" ADD CONSTRAINT "OpprRankingHistory_tournamentId_fkey" FOREIGN KEY ("tournamentId") REFERENCES "Tournament"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- Migrate existing Player rating data to OpprPlayerRanking
+INSERT INTO "OpprPlayerRanking" ("id", "createdAt", "updatedAt", "playerId", "rating", "ratingDeviation", "lastRatingUpdate", "ranking", "isRated")
+SELECT
+    gen_random_uuid()::text,
+    NOW(),
+    NOW(),
+    "id",
+    "rating",
+    "ratingDeviation",
+    "lastRatingUpdate",
+    "ranking",
+    "isRated"
+FROM "Player";
+
+-- Create initial history records for all migrated rankings
+INSERT INTO "OpprRankingHistory" ("id", "createdAt", "opprPlayerRankingId", "rating", "ratingDeviation", "ranking", "isRated", "changeType", "notes")
+SELECT
+    gen_random_uuid()::text,
+    NOW(),
+    opr."id",
+    opr."rating",
+    opr."ratingDeviation",
+    opr."ranking",
+    opr."isRated",
+    'INITIAL',
+    'Migrated from Player model'
+FROM "OpprPlayerRanking" opr;
+
+-- Drop old indexes from Player table
+DROP INDEX IF EXISTS "Player_rating_idx";
+DROP INDEX IF EXISTS "Player_ranking_idx";
+
+-- Remove old columns from Player table
+ALTER TABLE "Player" DROP COLUMN "rating";
+ALTER TABLE "Player" DROP COLUMN "ratingDeviation";
+ALTER TABLE "Player" DROP COLUMN "ranking";
+ALTER TABLE "Player" DROP COLUMN "isRated";
+ALTER TABLE "Player" DROP COLUMN "lastRatingUpdate";

package/prisma/schema.prisma

@@ -21,25 +21,19 @@ model Player {
   playerNumber     Int      @unique // 5-digit unique identifier (10000-99999)
   name             String?
 
-  // 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
+  // General player statistics
   eventCount       Int      @default(0)     // Number of events participated
-
-  // Timestamps for rating calculations
-  lastRatingUpdate DateTime @default(now())
   lastEventDate    DateTime?
 
   // Relations
-  tournamentResults TournamentResult[]
-  user              User?
+  standings            Standing[]
+  entries              Entry[]
+  user                 User?
+  organizedTournaments Tournament[] @relation("OrganizedTournaments")
+  opprRanking          OpprPlayerRanking?
 
   @@index([externalId])
   @@index([playerNumber])
-  @@index([rating])
-  @@index([ranking])
 }
 
 // Tournament model - represents a pinball tournament event
@@ -51,9 +45,17 @@ model Tournament {
   // Tournament identification
   externalId       String?  @unique // External ID from OPPR or other systems
   name             String
-  location         String?
+  description      String?  @db.VarChar(2000)
   date             DateTime
 
+  // Location relation
+  locationId       String?
+  location         Location? @relation(fields: [locationId], references: [id], onDelete: SetNull)
+
+  // Organizer relation
+  organizerId      String?
+  organizer        Player?   @relation("OrganizedTournaments", fields: [organizerId], references: [id], onDelete: SetNull)
+
   // Tournament configuration (stored as JSON)
   // Contains TGPConfig structure from OPPR
   tgpConfig        Json?
@@ -72,48 +74,117 @@ model Tournament {
   firstPlaceValue  Float?
 
   // Relations
-  results          TournamentResult[]
+  rounds                Round[]
+  matches               Match[]
+  standings             Standing[]
+  rankingHistoryRecords OpprRankingHistory[]
 
   @@index([date])
   @@index([eventBooster])
   @@index([externalId])
+  @@index([locationId])
+  @@index([organizerId])
 }
 
-// Tournament Result - junction table linking players to tournaments
-model TournamentResult {
-  id               String   @id @default(cuid())
-  createdAt        DateTime @default(now())
-  updatedAt        DateTime @updatedAt
+// 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
-  playerId         String
-  player           Player     @relation(fields: [playerId], references: [id], onDelete: Cascade)
-  tournamentId     String
-  tournament       Tournament @relation(fields: [tournamentId], references: [id], onDelete: Cascade)
+  matches       Match[]
 
-  // Result data
-  position         Int      // Finishing position (1 = first place)
-  optedOut         Boolean  @default(false)
+  @@unique([tournamentId, number, isFinals])
+  @@index([tournamentId])
+  @@index([tournamentId, isFinals])
+}
 
-  // Points awarded
-  linearPoints     Float?   @default(0) // Linear distribution points
-  dynamicPoints    Float?   @default(0) // Dynamic distribution points
-  totalPoints      Float?   // Total points (linear + dynamic)
+// Match model - a single game with 1-4 players
+model Match {
+  id            String     @id @default(cuid())
+  createdAt     DateTime   @default(now())
+  updatedAt     DateTime   @updatedAt
 
-  // 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)
+  tournamentId  String
+  tournament    Tournament @relation(fields: [tournamentId], references: [id], onDelete: Cascade)
+  roundId       String?
+  round         Round?     @relation(fields: [roundId], references: [id], onDelete: SetNull)
 
-  // Efficiency tracking
-  efficiency       Float?   // Performance efficiency percentage
+  number        Int?       // Match number within the round
+  machineName   String?    // Machine played on
+
+  // Relations
+  entries       Entry[]
 
-  @@unique([playerId, tournamentId])
+  @@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())
+  createdAt        DateTime   @default(now())
+  updatedAt        DateTime   @updatedAt
+
+  tournamentId     String
+  tournament       Tournament @relation(fields: [tournamentId], references: [id], onDelete: Cascade)
+  playerId         String
+  player           Player     @relation(fields: [playerId], references: [id], onDelete: Cascade)
+
+  position         Int        // Finishing position (1 = first place)
+  isFinals         Boolean    @default(false)
+  optedOut         Boolean    @default(false)
+
+  // Points (calculated from merged standings)
+  linearPoints     Float?     @default(0)
+  dynamicPoints    Float?     @default(0)
+  totalPoints      Float?
+  ageInDays        Int?       @default(0)
+  decayMultiplier  Float?     @default(1.0)
+  decayedPoints    Float?
+  efficiency       Float?
+
+  @@unique([playerId, tournamentId, isFinals])
   @@index([playerId])
   @@index([tournamentId])
+  @@index([tournamentId, isFinals])
   @@index([position])
 }
 
+// Enum for match results
+enum MatchResult {
+  WIN
+  LOSS
+  TIE
+}
+
 // Enum for event booster types
 enum EventBoosterType {
   NONE
@@ -149,5 +220,122 @@ model User {
   // Session management (for token revocation)
   refreshTokenHash String?
 
+  // Policy acceptance timestamps (null = not accepted)
+  tosAcceptedAt           DateTime?
+  privacyPolicyAcceptedAt DateTime?
+  codeOfConductAcceptedAt DateTime?
+
+  // API Keys
+  apiKeys          ApiKey[]
+
   @@index([email])
 }
+
+// ApiKey model - represents an API key for programmatic access
+model ApiKey {
+  id           String    @id @default(cuid())
+  createdAt    DateTime  @default(now())
+  updatedAt    DateTime  @updatedAt
+
+  // Key identification
+  name         String    // User-provided name (e.g., "CI Pipeline", "Mobile App")
+  keyPrefix    String    // First 14 characters of the key for display/lookup
+  keyHash      String    // bcrypt hash of the full key
+
+  // Ownership
+  userId       String
+  user         User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  // Lifecycle
+  expiresAt    DateTime? // Optional expiration date
+  lastUsedAt   DateTime? // Updated on each successful authentication
+
+  @@index([userId])
+  @@index([keyPrefix])
+}
+
+// Location model - represents a venue where tournaments are held
+model Location {
+  id            String   @id @default(cuid())
+  createdAt     DateTime @default(now())
+  updatedAt     DateTime @updatedAt
+
+  externalId    String?  @unique
+  name          String
+  address       String?
+  city          String?
+  state         String?
+  country       String?
+
+  // Relations
+  tournaments   Tournament[]
+
+  @@index([externalId])
+  @@index([name])
+  @@index([city])
+}
+
+// OPPR Player Ranking - OPPR-specific rating and ranking data
+// Separated from Player to allow for future alternative ranking systems
+model OpprPlayerRanking {
+  id               String   @id @default(cuid())
+  createdAt        DateTime @default(now())
+  updatedAt        DateTime @updatedAt
+
+  // Relation to Player (one-to-one)
+  playerId         String   @unique
+  player           Player   @relation(fields: [playerId], references: [id], onDelete: Cascade)
+
+  // Glicko Rating fields
+  rating           Float    @default(1500) // Glicko rating
+  ratingDeviation  Float    @default(200)  // Rating uncertainty (RD)
+  lastRatingUpdate DateTime @default(now())
+
+  // World Ranking fields
+  ranking          Int?                     // World ranking position (1 = best)
+  isRated          Boolean  @default(false) // Has 5+ events (eligible for ranking)
+
+  // Relations
+  history          OpprRankingHistory[]
+
+  @@index([playerId])
+  @@index([rating])
+  @@index([ranking])
+  @@index([isRated])
+}
+
+// OPPR Ranking History - Historical record of ranking/rating changes
+model OpprRankingHistory {
+  id                    String   @id @default(cuid())
+  createdAt             DateTime @default(now())
+
+  // Relation to OpprPlayerRanking
+  opprPlayerRankingId   String
+  opprPlayerRanking     OpprPlayerRanking @relation(fields: [opprPlayerRankingId], references: [id], onDelete: Cascade)
+
+  // Snapshot of values at this point in time
+  rating                Float
+  ratingDeviation       Float
+  ranking               Int?
+  isRated               Boolean
+
+  // Context for the change
+  changeType            OpprRankingChangeType
+  tournamentId          String?
+  tournament            Tournament? @relation(fields: [tournamentId], references: [id], onDelete: SetNull)
+  notes                 String?  @db.VarChar(500)
+
+  @@index([opprPlayerRankingId])
+  @@index([createdAt])
+  @@index([tournamentId])
+  @@index([opprPlayerRankingId, createdAt])
+}
+
+// Enum for tracking what caused the ranking change
+enum OpprRankingChangeType {
+  INITIAL           // First ranking record created
+  TOURNAMENT_RESULT // Rating updated after tournament
+  RANKING_REFRESH   // Periodic ranking recalculation
+  RD_DECAY          // RD increased due to inactivity
+  MANUAL_ADJUSTMENT // Administrative correction
+}