@opprs/db-prisma 2.1.0 → 2.2.1-canary.090cc41

package/prisma/seed.ts

@@ -1,189 +1,342 @@
 import { PrismaClient, EventBoosterType } from '@prisma/client';
+import bcrypt from 'bcrypt';
 
 const prisma = new PrismaClient();
 
+const BCRYPT_SALT_ROUNDS = 12;
+
 async function main() {
   console.log('🌱 Seeding database...');
 
-  // Create sample players
+  // Create sample players (using upsert for idempotency)
   console.log('Creating players...');
-  const player1 = await prisma.player.create({
-    data: {
+  const playerData = [
+    {
       externalId: 'player-1',
+      playerNumber: 10001,
       name: 'Alice Champion',
-      email: 'alice@example.com',
-      rating: 1850,
-      ratingDeviation: 50,
-      ranking: 5,
-      isRated: true,
       eventCount: 25,
     },
-  });
-
-  const player2 = await prisma.player.create({
-    data: {
+    {
       externalId: 'player-2',
+      playerNumber: 10002,
       name: 'Bob Wizard',
-      email: 'bob@example.com',
-      rating: 1750,
-      ratingDeviation: 60,
-      ranking: 12,
-      isRated: true,
       eventCount: 18,
     },
-  });
-
-  const player3 = await prisma.player.create({
-    data: {
+    {
       externalId: 'player-3',
+      playerNumber: 10003,
       name: 'Charlie Flipper',
-      email: 'charlie@example.com',
-      rating: 1650,
-      ratingDeviation: 75,
-      ranking: 28,
-      isRated: true,
       eventCount: 12,
     },
-  });
-
-  const player4 = await prisma.player.create({
-    data: {
+    {
       externalId: 'player-4',
+      playerNumber: 10004,
       name: 'Diana Tilt',
-      email: 'diana@example.com',
-      rating: 1550,
-      ratingDeviation: 100,
-      ranking: 45,
-      isRated: true,
       eventCount: 8,
     },
-  });
-
-  const player5 = await prisma.player.create({
-    data: {
+    {
       externalId: 'player-5',
+      playerNumber: 10005,
       name: 'Eve Plunger',
-      email: 'eve@example.com',
-      rating: 1300,
-      ratingDeviation: 150,
-      ranking: null,
-      isRated: false,
       eventCount: 3,
     },
+  ];
+
+  // OPPR ranking data for each player
+  const rankingData = [
+    { rating: 1850, ratingDeviation: 50, ranking: 5, isRated: true },
+    { rating: 1750, ratingDeviation: 60, ranking: 12, isRated: true },
+    { rating: 1650, ratingDeviation: 75, ranking: 28, isRated: true },
+    { rating: 1550, ratingDeviation: 100, ranking: 45, isRated: true },
+    { rating: 1300, ratingDeviation: 150, ranking: null, isRated: false },
+  ];
+
+  const player1 = await prisma.player.upsert({
+    where: { externalId: 'player-1' },
+    update: playerData[0],
+    create: playerData[0],
+  });
+
+  const player2 = await prisma.player.upsert({
+    where: { externalId: 'player-2' },
+    update: playerData[1],
+    create: playerData[1],
+  });
+
+  const player3 = await prisma.player.upsert({
+    where: { externalId: 'player-3' },
+    update: playerData[2],
+    create: playerData[2],
+  });
+
+  const player4 = await prisma.player.upsert({
+    where: { externalId: 'player-4' },
+    update: playerData[3],
+    create: playerData[3],
+  });
+
+  const player5 = await prisma.player.upsert({
+    where: { externalId: 'player-5' },
+    update: playerData[4],
+    create: playerData[4],
   });
 
   console.log(`✓ Created ${await prisma.player.count()} players`);
 
-  // Create sample tournaments
+  // Create OPPR rankings for each player
+  console.log('Creating OPPR rankings...');
+  const players = [player1, player2, player3, player4, player5];
+  for (let i = 0; i < players.length; i++) {
+    await prisma.opprPlayerRanking.upsert({
+      where: { playerId: players[i].id },
+      update: rankingData[i],
+      create: { playerId: players[i].id, ...rankingData[i] },
+    });
+  }
+  console.log(`✓ Created ${await prisma.opprPlayerRanking.count()} OPPR rankings`);
+
+  // Seed users from environment variables (development only)
+  const seedAdminEmail = process.env.SEED_ADMIN_EMAIL;
+  const seedAdminPassword = process.env.SEED_ADMIN_PASSWORD;
+  const seedTestEmail = process.env.SEED_TEST_EMAIL;
+  const seedTestPassword = process.env.SEED_TEST_PASSWORD;
+
+  // Create admin user if credentials provided
+  if (seedAdminEmail && seedAdminPassword) {
+    console.log('Creating admin user...');
+    const adminPasswordHash = await bcrypt.hash(seedAdminPassword, BCRYPT_SALT_ROUNDS);
+    await prisma.user.upsert({
+      where: { email: seedAdminEmail },
+      update: { passwordHash: adminPasswordHash, role: 'ADMIN' },
+      create: { email: seedAdminEmail, passwordHash: adminPasswordHash, role: 'ADMIN' },
+    });
+    console.log(`✓ Created admin user (${seedAdminEmail})`);
+  } else {
+    console.log('⏭ Skipping admin user (SEED_ADMIN_EMAIL/SEED_ADMIN_PASSWORD not set)');
+  }
+
+  // Create test user if credentials provided (linked to Alice Champion)
+  if (seedTestEmail && seedTestPassword) {
+    console.log('Creating test user...');
+    const testPasswordHash = await bcrypt.hash(seedTestPassword, BCRYPT_SALT_ROUNDS);
+    await prisma.user.upsert({
+      where: { email: seedTestEmail },
+      update: { passwordHash: testPasswordHash, role: 'USER', playerId: player1.id },
+      create: { email: seedTestEmail, passwordHash: testPasswordHash, role: 'USER', playerId: player1.id },
+    });
+    console.log(`✓ Created test user (${seedTestEmail}) linked to ${player1.name}`);
+  } else {
+    console.log('⏭ Skipping test user (SEED_TEST_EMAIL/SEED_TEST_PASSWORD not set)');
+  }
+
+  // Create admin user
+  console.log('Creating admin user...');
+  const adminPassword = 'AdminPassword123!';
+  const adminPasswordHash = await bcrypt.hash(adminPassword, BCRYPT_SALT_ROUNDS);
+
+  await prisma.user.upsert({
+    where: { email: 'admin@example.com' },
+    update: {
+      passwordHash: adminPasswordHash,
+      role: 'ADMIN',
+    },
+    create: {
+      email: 'admin@example.com',
+      passwordHash: adminPasswordHash,
+      role: 'ADMIN',
+    },
+  });
+
+  console.log(`✓ Created admin user (admin@example.com / ${adminPassword})`);
+
+  // Create sample locations (using upsert for idempotency)
+  console.log('Creating locations...');
+
+  const location1 = await prisma.location.upsert({
+    where: { externalId: 'location-1' },
+    update: {
+      name: 'Las Vegas Convention Center',
+      city: 'Las Vegas',
+      state: 'NV',
+      country: 'USA',
+    },
+    create: {
+      externalId: 'location-1',
+      name: 'Las Vegas Convention Center',
+      city: 'Las Vegas',
+      state: 'NV',
+      country: 'USA',
+    },
+  });
+
+  const location2 = await prisma.location.upsert({
+    where: { externalId: 'location-2' },
+    update: {
+      name: 'Ground Kontrol',
+      address: '115 NW 5th Ave',
+      city: 'Portland',
+      state: 'OR',
+      country: 'USA',
+    },
+    create: {
+      externalId: 'location-2',
+      name: 'Ground Kontrol',
+      address: '115 NW 5th Ave',
+      city: 'Portland',
+      state: 'OR',
+      country: 'USA',
+    },
+  });
+
+  const location3 = await prisma.location.upsert({
+    where: { externalId: 'location-3' },
+    update: {
+      name: 'Add-a-Ball Amusements',
+      city: 'Seattle',
+      state: 'WA',
+      country: 'USA',
+    },
+    create: {
+      externalId: 'location-3',
+      name: 'Add-a-Ball Amusements',
+      city: 'Seattle',
+      state: 'WA',
+      country: 'USA',
+    },
+  });
+
+  console.log(`✓ Created ${await prisma.location.count()} locations`);
+
+  // Create sample tournaments (using upsert for idempotency)
   console.log('Creating tournaments...');
 
-  // Major Championship Tournament
-  const tournament1 = await prisma.tournament.create({
-    data: {
-      externalId: 'tournament-1',
-      name: 'World Pinball Championship 2024',
-      location: 'Las Vegas, NV',
-      date: new Date('2024-03-15'),
-      eventBooster: EventBoosterType.MAJOR,
-      allowsOptOut: false,
-      tgpConfig: {
-        qualifying: {
-          type: 'limited',
-          meaningfulGames: 12,
-          fourPlayerGroups: true,
-        },
-        finals: {
-          formatType: 'match-play',
-          meaningfulGames: 20,
-          fourPlayerGroups: true,
-          finalistCount: 16,
-        },
-        ballCountAdjustment: 1.0,
+  const tournament1Data = {
+    externalId: 'tournament-1',
+    name: 'World Pinball Championship 2024',
+    locationId: location1.id,
+    date: new Date('2024-03-15'),
+    eventBooster: EventBoosterType.MAJOR,
+    allowsOptOut: false,
+    tgpConfig: {
+      qualifying: {
+        type: 'limited',
+        meaningfulGames: 12,
+        fourPlayerGroups: true,
+      },
+      finals: {
+        formatType: 'match-play',
+        meaningfulGames: 20,
+        fourPlayerGroups: true,
+        finalistCount: 16,
       },
-      baseValue: 32.0,
-      tvaRating: 25.0,
-      tvaRanking: 50.0,
-      totalTVA: 75.0,
-      tgp: 1.92,
-      eventBoosterMultiplier: 2.0,
-      firstPlaceValue: 411.84,
+      ballCountAdjustment: 1.0,
     },
+    baseValue: 32.0,
+    tvaRating: 25.0,
+    tvaRanking: 50.0,
+    totalTVA: 75.0,
+    tgp: 1.92,
+    eventBoosterMultiplier: 2.0,
+    firstPlaceValue: 411.84,
+  };
+
+  const tournament1 = await prisma.tournament.upsert({
+    where: { externalId: 'tournament-1' },
+    update: tournament1Data,
+    create: tournament1Data,
   });
 
-  // Certified Tournament
-  const tournament2 = await prisma.tournament.create({
-    data: {
-      externalId: 'tournament-2',
-      name: 'Spring Classics 2024',
-      location: 'Portland, OR',
-      date: new Date('2024-04-20'),
-      eventBooster: EventBoosterType.CERTIFIED,
-      allowsOptOut: true,
-      tgpConfig: {
-        qualifying: {
-          type: 'limited',
-          meaningfulGames: 7,
-        },
-        finals: {
-          formatType: 'double-elimination',
-          meaningfulGames: 15,
-          fourPlayerGroups: false,
-          finalistCount: 8,
-        },
+  const tournament2Data = {
+    externalId: 'tournament-2',
+    name: 'Spring Classics 2024',
+    locationId: location2.id,
+    date: new Date('2024-04-20'),
+    eventBooster: EventBoosterType.CERTIFIED,
+    allowsOptOut: true,
+    tgpConfig: {
+      qualifying: {
+        type: 'limited',
+        meaningfulGames: 7,
+      },
+      finals: {
+        formatType: 'double-elimination',
+        meaningfulGames: 15,
+        fourPlayerGroups: false,
+        finalistCount: 8,
       },
-      baseValue: 28.0,
-      tvaRating: 18.5,
-      tvaRanking: 32.0,
-      totalTVA: 50.5,
-      tgp: 0.88,
-      eventBoosterMultiplier: 1.25,
-      firstPlaceValue: 87.28,
     },
+    baseValue: 28.0,
+    tvaRating: 18.5,
+    tvaRanking: 32.0,
+    totalTVA: 50.5,
+    tgp: 0.88,
+    eventBoosterMultiplier: 1.25,
+    firstPlaceValue: 87.28,
+  };
+
+  const tournament2 = await prisma.tournament.upsert({
+    where: { externalId: 'tournament-2' },
+    update: tournament2Data,
+    create: tournament2Data,
   });
 
-  // Local Tournament
-  const tournament3 = await prisma.tournament.create({
-    data: {
-      externalId: 'tournament-3',
-      name: 'Monthly League Finals',
-      location: 'Seattle, WA',
-      date: new Date('2024-05-10'),
-      eventBooster: EventBoosterType.NONE,
-      allowsOptOut: false,
-      tgpConfig: {
-        qualifying: {
-          type: 'none',
-          meaningfulGames: 0,
-        },
-        finals: {
-          formatType: 'match-play',
-          meaningfulGames: 10,
-          fourPlayerGroups: true,
-          finalistCount: 8,
-        },
+  const tournament3Data = {
+    externalId: 'tournament-3',
+    name: 'Monthly League Finals',
+    locationId: location3.id,
+    date: new Date('2024-05-10'),
+    eventBooster: EventBoosterType.NONE,
+    allowsOptOut: false,
+    tgpConfig: {
+      qualifying: {
+        type: 'none',
+        meaningfulGames: 0,
+      },
+      finals: {
+        formatType: 'match-play',
+        meaningfulGames: 10,
+        fourPlayerGroups: true,
+        finalistCount: 8,
       },
-      baseValue: 15.0,
-      tvaRating: 8.5,
-      tvaRanking: 12.0,
-      totalTVA: 20.5,
-      tgp: 0.80,
-      eventBoosterMultiplier: 1.0,
-      firstPlaceValue: 28.4,
     },
+    baseValue: 15.0,
+    tvaRating: 8.5,
+    tvaRanking: 12.0,
+    totalTVA: 20.5,
+    tgp: 0.80,
+    eventBoosterMultiplier: 1.0,
+    firstPlaceValue: 28.4,
+  };
+
+  const tournament3 = await prisma.tournament.upsert({
+    where: { externalId: 'tournament-3' },
+    update: tournament3Data,
+    create: tournament3Data,
   });
 
   console.log(`✓ Created ${await prisma.tournament.count()} tournaments`);
 
-  // Create tournament results
-  console.log('Creating tournament results...');
+  // Create tournament standings (delete existing first for idempotency)
+  console.log('Creating tournament standings...');
+
+  // Delete existing standings for seeded tournaments
+  await prisma.standing.deleteMany({
+    where: {
+      tournamentId: {
+        in: [tournament1.id, tournament2.id, tournament3.id],
+      },
+    },
+  });
 
-  // World Championship results
-  await prisma.tournamentResult.createMany({
+  // World Championship standings
+  await prisma.standing.createMany({
     data: [
       {
         playerId: player1.id,
         tournamentId: tournament1.id,
         position: 1,
+        isFinals: true,
         totalPoints: 411.84,
         linearPoints: 41.18,
         dynamicPoints: 370.66,
@@ -196,6 +349,7 @@ async function main() {
         playerId: player2.id,
         tournamentId: tournament1.id,
         position: 2,
+        isFinals: true,
         totalPoints: 298.45,
         linearPoints: 41.18,
         dynamicPoints: 257.27,
@@ -208,6 +362,7 @@ async function main() {
         playerId: player3.id,
         tournamentId: tournament1.id,
         position: 3,
+        isFinals: true,
         totalPoints: 215.32,
         linearPoints: 41.18,
         dynamicPoints: 174.14,
@@ -220,6 +375,7 @@ async function main() {
         playerId: player4.id,
         tournamentId: tournament1.id,
         position: 5,
+        isFinals: true,
         totalPoints: 125.18,
         linearPoints: 41.18,
         dynamicPoints: 84.00,
@@ -231,13 +387,14 @@ async function main() {
     ],
   });
 
-  // Spring Classics results
-  await prisma.tournamentResult.createMany({
+  // Spring Classics standings
+  await prisma.standing.createMany({
     data: [
       {
         playerId: player2.id,
         tournamentId: tournament2.id,
         position: 1,
+        isFinals: true,
         totalPoints: 87.28,
         linearPoints: 8.73,
         dynamicPoints: 78.55,
@@ -250,6 +407,7 @@ async function main() {
         playerId: player1.id,
         tournamentId: tournament2.id,
         position: 2,
+        isFinals: true,
         totalPoints: 63.25,
         linearPoints: 8.73,
         dynamicPoints: 54.52,
@@ -262,6 +420,7 @@ async function main() {
         playerId: player4.id,
         tournamentId: tournament2.id,
         position: 3,
+        isFinals: true,
         totalPoints: 45.67,
         linearPoints: 8.73,
         dynamicPoints: 36.94,
@@ -274,6 +433,7 @@ async function main() {
         playerId: player5.id,
         tournamentId: tournament2.id,
         position: 6,
+        isFinals: true,
         totalPoints: 18.52,
         linearPoints: 8.73,
         dynamicPoints: 9.79,
@@ -285,13 +445,14 @@ async function main() {
     ],
   });
 
-  // Monthly League results
-  await prisma.tournamentResult.createMany({
+  // Monthly League standings
+  await prisma.standing.createMany({
     data: [
       {
         playerId: player3.id,
         tournamentId: tournament3.id,
         position: 1,
+        isFinals: true,
         totalPoints: 28.4,
         linearPoints: 2.84,
         dynamicPoints: 25.56,
@@ -304,6 +465,7 @@ async function main() {
         playerId: player4.id,
         tournamentId: tournament3.id,
         position: 2,
+        isFinals: true,
         totalPoints: 20.58,
         linearPoints: 2.84,
         dynamicPoints: 17.74,
@@ -316,6 +478,7 @@ async function main() {
         playerId: player5.id,
         tournamentId: tournament3.id,
         position: 3,
+        isFinals: true,
         totalPoints: 14.85,
         linearPoints: 2.84,
         dynamicPoints: 12.01,
@@ -327,15 +490,18 @@ async function main() {
     ],
   });
 
-  console.log(`✓ Created ${await prisma.tournamentResult.count()} tournament results`);
+  console.log(`✓ Created ${await prisma.standing.count()} tournament standings`);
 
   console.log('');
   console.log('✅ Database seeded successfully!');
   console.log('');
   console.log('Summary:');
   console.log(`  - ${await prisma.player.count()} players`);
+  console.log(`  - ${await prisma.opprPlayerRanking.count()} OPPR rankings`);
+  console.log(`  - ${await prisma.user.count()} users`);
+  console.log(`  - ${await prisma.location.count()} locations`);
   console.log(`  - ${await prisma.tournament.count()} tournaments`);
-  console.log(`  - ${await prisma.tournamentResult.count()} tournament results`);
+  console.log(`  - ${await prisma.standing.count()} standings`);
 }
 
 main()