@opprs/db-prisma 2.2.1 → 2.5.0

package/prisma/seed.ts

@@ -13,51 +13,45 @@ async function main() {
   const playerData = [
     {
       externalId: 'player-1',
+      playerNumber: 10001,
       name: 'Alice Champion',
-      rating: 1850,
-      ratingDeviation: 50,
-      ranking: 5,
-      isRated: true,
       eventCount: 25,
     },
     {
       externalId: 'player-2',
+      playerNumber: 10002,
       name: 'Bob Wizard',
-      rating: 1750,
-      ratingDeviation: 60,
-      ranking: 12,
-      isRated: true,
       eventCount: 18,
     },
     {
       externalId: 'player-3',
+      playerNumber: 10003,
       name: 'Charlie Flipper',
-      rating: 1650,
-      ratingDeviation: 75,
-      ranking: 28,
-      isRated: true,
       eventCount: 12,
     },
     {
       externalId: 'player-4',
+      playerNumber: 10004,
       name: 'Diana Tilt',
-      rating: 1550,
-      ratingDeviation: 100,
-      ranking: 45,
-      isRated: true,
       eventCount: 8,
     },
     {
       externalId: 'player-5',
+      playerNumber: 10005,
       name: 'Eve Plunger',
-      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],
@@ -90,27 +84,129 @@ async function main() {
 
   console.log(`✓ Created ${await prisma.player.count()} players`);
 
-  // Create test user for e2e tests (linked to Alice Champion)
-  console.log('Creating test user...');
-  const testPassword = 'TestPassword123!';
-  const passwordHash = await bcrypt.hash(testPassword, BCRYPT_SALT_ROUNDS);
+  // 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: 'e2e-test@example.com' },
+    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: {
-      passwordHash,
-      role: 'USER',
-      playerId: player1.id,
+      name: 'Add-a-Ball Amusements',
+      city: 'Seattle',
+      state: 'WA',
+      country: 'USA',
     },
     create: {
-      email: 'e2e-test@example.com',
-      passwordHash,
-      role: 'USER',
-      playerId: player1.id,
+      externalId: 'location-3',
+      name: 'Add-a-Ball Amusements',
+      city: 'Seattle',
+      state: 'WA',
+      country: 'USA',
     },
   });
 
-  console.log(`✓ Created test user (e2e-test@example.com / ${testPassword})`);
+  console.log(`✓ Created ${await prisma.location.count()} locations`);
 
   // Create sample tournaments (using upsert for idempotency)
   console.log('Creating tournaments...');
@@ -118,7 +214,7 @@ async function main() {
   const tournament1Data = {
     externalId: 'tournament-1',
     name: 'World Pinball Championship 2024',
-    location: 'Las Vegas, NV',
+    locationId: location1.id,
     date: new Date('2024-03-15'),
     eventBooster: EventBoosterType.MAJOR,
     allowsOptOut: false,
@@ -154,7 +250,7 @@ async function main() {
   const tournament2Data = {
     externalId: 'tournament-2',
     name: 'Spring Classics 2024',
-    location: 'Portland, OR',
+    locationId: location2.id,
     date: new Date('2024-04-20'),
     eventBooster: EventBoosterType.CERTIFIED,
     allowsOptOut: true,
@@ -188,7 +284,7 @@ async function main() {
   const tournament3Data = {
     externalId: 'tournament-3',
     name: 'Monthly League Finals',
-    location: 'Seattle, WA',
+    locationId: location3.id,
     date: new Date('2024-05-10'),
     eventBooster: EventBoosterType.NONE,
     allowsOptOut: false,
@@ -221,11 +317,11 @@ async function main() {
 
   console.log(`✓ Created ${await prisma.tournament.count()} tournaments`);
 
-  // Create tournament results (delete existing first for idempotency)
-  console.log('Creating tournament results...');
+  // Create tournament standings (delete existing first for idempotency)
+  console.log('Creating tournament standings...');
 
-  // Delete existing results for seeded tournaments
-  await prisma.tournamentResult.deleteMany({
+  // Delete existing standings for seeded tournaments
+  await prisma.standing.deleteMany({
     where: {
       tournamentId: {
         in: [tournament1.id, tournament2.id, tournament3.id],
@@ -233,13 +329,14 @@ async function main() {
     },
   });
 
-  // 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,
@@ -252,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,
@@ -264,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,
@@ -276,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,
@@ -287,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,
@@ -306,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,
@@ -318,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,
@@ -330,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,
@@ -341,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,
@@ -360,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,
@@ -372,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,
@@ -383,16 +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()