@opprs/db-prisma 0.5.2-canary.760356d

package/dist/index.d.cts

@@ -0,0 +1,608 @@
+import * as _prisma_client_runtime_library from '@prisma/client/runtime/library';
+import * as _prisma_client from '@prisma/client';
+import { PrismaClient, Player, Prisma, EventBoosterType, Tournament, TournamentResult } from '@prisma/client';
+export { EventBoosterType, Player, Prisma, Tournament, TournamentResult } from '@prisma/client';
+
+declare const prisma: PrismaClient<_prisma_client.Prisma.PrismaClientOptions, never, _prisma_client_runtime_library.DefaultArgs>;
+/**
+ * Disconnects from the database
+ * Useful for graceful shutdowns
+ */
+declare function disconnect(): Promise<void>;
+/**
+ * Connects to the database
+ * Usually not needed as Prisma connects automatically
+ */
+declare function connect(): Promise<void>;
+/**
+ * Tests the database connection
+ * @returns true if connection is successful
+ */
+declare function testConnection(): Promise<boolean>;
+
+/**
+ * Input for creating a new player
+ */
+interface CreatePlayerInput {
+    externalId?: string;
+    name?: string;
+    email?: string;
+    rating?: number;
+    ratingDeviation?: number;
+    ranking?: number;
+    isRated?: boolean;
+    eventCount?: number;
+}
+/**
+ * Input for updating a player
+ */
+interface UpdatePlayerInput {
+    name?: string;
+    email?: string;
+    rating?: number;
+    ratingDeviation?: number;
+    ranking?: number;
+    isRated?: boolean;
+    eventCount?: number;
+    lastRatingUpdate?: Date;
+    lastEventDate?: Date;
+}
+/**
+ * Options for querying players
+ */
+interface FindPlayersOptions {
+    take?: number;
+    skip?: number;
+    orderBy?: Prisma.PlayerOrderByWithRelationInput;
+    where?: Prisma.PlayerWhereInput;
+    include?: Prisma.PlayerInclude;
+}
+/**
+ * Creates a new player
+ */
+declare function createPlayer(data: CreatePlayerInput): Promise<Player>;
+/**
+ * Finds a player by ID
+ */
+declare function findPlayerById(id: string, include?: Prisma.PlayerInclude): Promise<Player | null>;
+/**
+ * Finds a player by external ID
+ */
+declare function findPlayerByExternalId(externalId: string, include?: Prisma.PlayerInclude): Promise<Player | null>;
+/**
+ * Finds a player by email
+ */
+declare function findPlayerByEmail(email: string, include?: Prisma.PlayerInclude): Promise<Player | null>;
+/**
+ * Finds multiple players with optional filters
+ */
+declare function findPlayers(options?: FindPlayersOptions): Promise<Player[]>;
+/**
+ * Gets all rated players (has 5+ events)
+ */
+declare function getRatedPlayers(options?: Omit<FindPlayersOptions, 'where'>): Promise<Player[]>;
+/**
+ * Gets top players by rating
+ */
+declare function getTopPlayersByRating(limit?: number): Promise<Player[]>;
+/**
+ * Gets top players by ranking
+ */
+declare function getTopPlayersByRanking(limit?: number): Promise<Player[]>;
+/**
+ * Updates a player
+ */
+declare function updatePlayer(id: string, data: UpdatePlayerInput): Promise<Player>;
+/**
+ * Updates player rating after a tournament
+ */
+declare function updatePlayerRating(id: string, rating: number, ratingDeviation: number, eventCount?: number): Promise<Player>;
+/**
+ * Deletes a player
+ */
+declare function deletePlayer(id: string): Promise<Player>;
+/**
+ * Counts total players
+ */
+declare function countPlayers(where?: Prisma.PlayerWhereInput): Promise<number>;
+/**
+ * Gets player with their tournament results
+ */
+declare function getPlayerWithResults(id: string): Promise<{
+    results: ({
+        tournament: {
+            name: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            externalId: string | null;
+            location: string | null;
+            date: Date;
+            tgpConfig: Prisma.JsonValue | null;
+            eventBooster: _prisma_client.$Enums.EventBoosterType;
+            allowsOptOut: boolean;
+            baseValue: number | null;
+            tvaRating: number | null;
+            tvaRanking: number | null;
+            totalTVA: number | null;
+            tgp: number | null;
+            eventBoosterMultiplier: number | null;
+            firstPlaceValue: number | null;
+        };
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        playerId: string;
+        tournamentId: string;
+        position: number;
+        optedOut: boolean;
+        linearPoints: number | null;
+        dynamicPoints: number | null;
+        totalPoints: number | null;
+        ageInDays: number | null;
+        decayMultiplier: number | null;
+        decayedPoints: number | null;
+        efficiency: number | null;
+    })[];
+    tournamentResults: ({
+        tournament: {
+            name: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            externalId: string | null;
+            location: string | null;
+            date: Date;
+            tgpConfig: Prisma.JsonValue | null;
+            eventBooster: _prisma_client.$Enums.EventBoosterType;
+            allowsOptOut: boolean;
+            baseValue: number | null;
+            tvaRating: number | null;
+            tvaRanking: number | null;
+            totalTVA: number | null;
+            tgp: number | null;
+            eventBoosterMultiplier: number | null;
+            firstPlaceValue: number | null;
+        };
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        playerId: string;
+        tournamentId: string;
+        position: number;
+        optedOut: boolean;
+        linearPoints: number | null;
+        dynamicPoints: number | null;
+        totalPoints: number | null;
+        ageInDays: number | null;
+        decayMultiplier: number | null;
+        decayedPoints: number | null;
+        efficiency: number | null;
+    })[];
+    name: string | null;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    externalId: string | null;
+    email: string | null;
+    rating: number;
+    ratingDeviation: number;
+    ranking: number | null;
+    isRated: boolean;
+    eventCount: number;
+    lastRatingUpdate: Date;
+    lastEventDate: Date | null;
+} | null>;
+/**
+ * Searches players by name or email
+ */
+declare function searchPlayers(query: string, limit?: number): Promise<Player[]>;
+
+/**
+ * Input for creating a new tournament
+ */
+interface CreateTournamentInput {
+    externalId?: string;
+    name: string;
+    location?: string;
+    date: Date;
+    tgpConfig?: Prisma.InputJsonValue;
+    eventBooster?: EventBoosterType;
+    allowsOptOut?: boolean;
+    baseValue?: number;
+    tvaRating?: number;
+    tvaRanking?: number;
+    totalTVA?: number;
+    tgp?: number;
+    eventBoosterMultiplier?: number;
+    firstPlaceValue?: number;
+}
+/**
+ * Input for updating a tournament
+ */
+interface UpdateTournamentInput {
+    name?: string;
+    location?: string;
+    date?: Date;
+    tgpConfig?: Prisma.InputJsonValue;
+    eventBooster?: EventBoosterType;
+    allowsOptOut?: boolean;
+    baseValue?: number;
+    tvaRating?: number;
+    tvaRanking?: number;
+    totalTVA?: number;
+    tgp?: number;
+    eventBoosterMultiplier?: number;
+    firstPlaceValue?: number;
+}
+/**
+ * Options for querying tournaments
+ */
+interface FindTournamentsOptions {
+    take?: number;
+    skip?: number;
+    orderBy?: Prisma.TournamentOrderByWithRelationInput;
+    where?: Prisma.TournamentWhereInput;
+    include?: Prisma.TournamentInclude;
+}
+/**
+ * Creates a new tournament
+ */
+declare function createTournament(data: CreateTournamentInput): Promise<Tournament>;
+/**
+ * Finds a tournament by ID
+ */
+declare function findTournamentById(id: string, include?: Prisma.TournamentInclude): Promise<Tournament | null>;
+/**
+ * Finds a tournament by external ID
+ */
+declare function findTournamentByExternalId(externalId: string, include?: Prisma.TournamentInclude): Promise<Tournament | null>;
+/**
+ * Finds multiple tournaments with optional filters
+ */
+declare function findTournaments(options?: FindTournamentsOptions): Promise<Tournament[]>;
+/**
+ * Gets recent tournaments
+ */
+declare function getRecentTournaments(limit?: number, include?: Prisma.TournamentInclude): Promise<Tournament[]>;
+/**
+ * Gets tournaments by date range
+ */
+declare function getTournamentsByDateRange(startDate: Date, endDate: Date, options?: Omit<FindTournamentsOptions, 'where'>): Promise<Tournament[]>;
+/**
+ * Gets tournaments by event booster type
+ */
+declare function getTournamentsByBoosterType(boosterType: EventBoosterType, options?: Omit<FindTournamentsOptions, 'where'>): Promise<Tournament[]>;
+/**
+ * Gets major tournaments
+ */
+declare function getMajorTournaments(limit?: number): Promise<Tournament[]>;
+/**
+ * Updates a tournament
+ */
+declare function updateTournament(id: string, data: UpdateTournamentInput): Promise<Tournament>;
+/**
+ * Deletes a tournament and all its results
+ */
+declare function deleteTournament(id: string): Promise<Tournament>;
+/**
+ * Counts total tournaments
+ */
+declare function countTournaments(where?: Prisma.TournamentWhereInput): Promise<number>;
+/**
+ * Gets tournament with all results and player details
+ */
+declare function getTournamentWithResults(id: string): Promise<({
+    results: ({
+        player: {
+            name: string | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            externalId: string | null;
+            email: string | null;
+            rating: number;
+            ratingDeviation: number;
+            ranking: number | null;
+            isRated: boolean;
+            eventCount: number;
+            lastRatingUpdate: Date;
+            lastEventDate: Date | null;
+        };
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        playerId: string;
+        tournamentId: string;
+        position: number;
+        optedOut: boolean;
+        linearPoints: number | null;
+        dynamicPoints: number | null;
+        totalPoints: number | null;
+        ageInDays: number | null;
+        decayMultiplier: number | null;
+        decayedPoints: number | null;
+        efficiency: number | null;
+    })[];
+} & {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    externalId: string | null;
+    location: string | null;
+    date: Date;
+    tgpConfig: Prisma.JsonValue | null;
+    eventBooster: _prisma_client.$Enums.EventBoosterType;
+    allowsOptOut: boolean;
+    baseValue: number | null;
+    tvaRating: number | null;
+    tvaRanking: number | null;
+    totalTVA: number | null;
+    tgp: number | null;
+    eventBoosterMultiplier: number | null;
+    firstPlaceValue: number | null;
+}) | null>;
+/**
+ * Searches tournaments by name or location
+ */
+declare function searchTournaments(query: string, limit?: number): Promise<Tournament[]>;
+/**
+ * Gets tournament statistics
+ */
+declare function getTournamentStats(id: string): Promise<{
+    tournament: {
+        results: ({
+            player: {
+                name: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                externalId: string | null;
+                email: string | null;
+                rating: number;
+                ratingDeviation: number;
+                ranking: number | null;
+                isRated: boolean;
+                eventCount: number;
+                lastRatingUpdate: Date;
+                lastEventDate: Date | null;
+            };
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            playerId: string;
+            tournamentId: string;
+            position: number;
+            optedOut: boolean;
+            linearPoints: number | null;
+            dynamicPoints: number | null;
+            totalPoints: number | null;
+            ageInDays: number | null;
+            decayMultiplier: number | null;
+            decayedPoints: number | null;
+            efficiency: number | null;
+        })[];
+    } & {
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        externalId: string | null;
+        location: string | null;
+        date: Date;
+        tgpConfig: Prisma.JsonValue | null;
+        eventBooster: _prisma_client.$Enums.EventBoosterType;
+        allowsOptOut: boolean;
+        baseValue: number | null;
+        tvaRating: number | null;
+        tvaRanking: number | null;
+        totalTVA: number | null;
+        tgp: number | null;
+        eventBoosterMultiplier: number | null;
+        firstPlaceValue: number | null;
+    };
+    playerCount: number;
+    averagePoints: number;
+    averageEfficiency: number;
+    highestPoints: number;
+    lowestPoints: number;
+} | null>;
+
+/**
+ * Input for creating a tournament result
+ */
+interface CreateResultInput {
+    playerId: string;
+    tournamentId: string;
+    position: number;
+    optedOut?: boolean;
+    linearPoints?: number;
+    dynamicPoints?: number;
+    totalPoints?: number;
+    ageInDays?: number;
+    decayMultiplier?: number;
+    decayedPoints?: number;
+    efficiency?: number;
+}
+/**
+ * Input for updating a tournament result
+ */
+interface UpdateResultInput {
+    position?: number;
+    optedOut?: boolean;
+    linearPoints?: number;
+    dynamicPoints?: number;
+    totalPoints?: number;
+    ageInDays?: number;
+    decayMultiplier?: number;
+    decayedPoints?: number;
+    efficiency?: number;
+}
+/**
+ * Options for querying results
+ */
+interface FindResultsOptions {
+    take?: number;
+    skip?: number;
+    orderBy?: Prisma.TournamentResultOrderByWithRelationInput;
+    where?: Prisma.TournamentResultWhereInput;
+    include?: Prisma.TournamentResultInclude;
+}
+/**
+ * Creates a new tournament result
+ */
+declare function createResult(data: CreateResultInput): Promise<TournamentResult>;
+/**
+ * Creates multiple tournament results at once
+ */
+declare function createManyResults(data: CreateResultInput[]): Promise<Prisma.BatchPayload>;
+/**
+ * Finds a result by ID
+ */
+declare function findResultById(id: string, include?: Prisma.TournamentResultInclude): Promise<TournamentResult | null>;
+/**
+ * Finds a result by player and tournament
+ */
+declare function findResultByPlayerAndTournament(playerId: string, tournamentId: string, include?: Prisma.TournamentResultInclude): Promise<TournamentResult | null>;
+/**
+ * Finds multiple results with optional filters
+ */
+declare function findResults(options?: FindResultsOptions): Promise<TournamentResult[]>;
+/**
+ * Gets all results for a specific player
+ */
+declare function getPlayerResults(playerId: string, options?: Omit<FindResultsOptions, 'where'>): Promise<TournamentResult[]>;
+/**
+ * Gets all results for a specific tournament
+ */
+declare function getTournamentResults(tournamentId: string, options?: Omit<FindResultsOptions, 'where'>): Promise<TournamentResult[]>;
+/**
+ * Gets top N finishes for a player
+ */
+declare function getPlayerTopFinishes(playerId: string, limit?: number): Promise<TournamentResult[]>;
+/**
+ * Updates a tournament result
+ */
+declare function updateResult(id: string, data: UpdateResultInput): Promise<TournamentResult>;
+/**
+ * Updates result points and decay information
+ */
+declare function updateResultPoints(id: string, linearPoints: number, dynamicPoints: number, totalPoints: number): Promise<TournamentResult>;
+/**
+ * Deletes a tournament result
+ */
+declare function deleteResult(id: string): Promise<TournamentResult>;
+/**
+ * Deletes all results for a tournament
+ */
+declare function deleteResultsByTournament(tournamentId: string): Promise<Prisma.BatchPayload>;
+/**
+ * Counts total results
+ */
+declare function countResults(where?: Prisma.TournamentResultWhereInput): Promise<number>;
+/**
+ * Gets player statistics across all tournaments
+ */
+declare function getPlayerStats(playerId: string): Promise<{
+    totalEvents: number;
+    totalPoints: number;
+    totalDecayedPoints: number;
+    averagePoints: number;
+    averagePosition: number;
+    averageFinish: number;
+    averageEfficiency: number;
+    firstPlaceFinishes: number;
+    topThreeFinishes: number;
+    bestFinish: number;
+    highestPoints: number;
+} | null>;
+/**
+ * Calculates and updates time decay for all results
+ * Based on OPPR time decay rules:
+ * - 0-1 years: 100%
+ * - 1-2 years: 75%
+ * - 2-3 years: 50%
+ * - 3+ years: 0%
+ */
+declare function recalculateTimeDecay(referenceDate?: Date): Promise<{
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    playerId: string;
+    tournamentId: string;
+    position: number;
+    optedOut: boolean;
+    linearPoints: number | null;
+    dynamicPoints: number | null;
+    totalPoints: number | null;
+    ageInDays: number | null;
+    decayMultiplier: number | null;
+    decayedPoints: number | null;
+    efficiency: number | null;
+}[]>;
+
+/**
+ * Re-export Prisma generated types
+ */
+
+/**
+ * Player with full tournament results
+ */
+interface PlayerWithResults {
+    player: Player;
+    results: TournamentResultWithTournament[];
+    stats: PlayerStatistics;
+}
+/**
+ * Tournament result with tournament details
+ */
+interface TournamentResultWithTournament {
+    id: string;
+    position: number;
+    totalPoints: number;
+    decayedPoints: number;
+    tournament: {
+        id: string;
+        name: string;
+        date: Date;
+        eventBooster: EventBoosterType;
+    };
+}
+/**
+ * Player statistics
+ */
+interface PlayerStatistics {
+    totalEvents: number;
+    totalPoints: number;
+    totalDecayedPoints: number;
+    averagePosition: number;
+    averageEfficiency: number;
+    firstPlaceFinishes: number;
+    topThreeFinishes: number;
+    bestFinish: number;
+    highestPoints: number;
+}
+/**
+ * Tournament statistics
+ */
+interface TournamentStatistics {
+    totalPlayers: number;
+    totalPoints: number;
+    averagePosition: number;
+    highestPoints: number;
+    lowestPoints: number;
+}
+/**
+ * Database connection status
+ */
+interface ConnectionStatus {
+    connected: boolean;
+    error?: string;
+}
+
+export { type ConnectionStatus, type CreatePlayerInput, type CreateResultInput, type CreateTournamentInput, type FindPlayersOptions, type FindResultsOptions, type FindTournamentsOptions, type PlayerStatistics, type PlayerWithResults, type TournamentResultWithTournament, type TournamentStatistics, type UpdatePlayerInput, type UpdateResultInput, type UpdateTournamentInput, 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 };