dubs-server 1.0.0

package/scripts/regenerate-epl-images.js

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+/**
+ * Regenerate EPL Matchup Images Script
+ *
+ * Regenerates ALL EPL matchup images in S3 with the latest team name overrides.
+ * Forces overwrite of existing images and updates database URLs with cache-busting.
+ *
+ * Usage:
+ *   node scripts/regenerate-epl-images.js                    # Process all EPL games
+ *   node scripts/regenerate-epl-images.js --dry-run          # Preview without making changes
+ *   node scripts/regenerate-epl-images.js --limit 10         # Process only 10 games
+ *   node scripts/regenerate-epl-images.js --game-id sport-xxx  # Process specific game
+ */
+
+require('dotenv').config();
+const { Pool } = require('pg');
+
+// Lazy load services
+let matchupImageService = null;
+let s3Service = null;
+
+function getMatchupImageService() {
+  if (!matchupImageService) {
+    try {
+      matchupImageService = require('../services/matchupImageService');
+      console.log('✅ Matchup image service loaded');
+    } catch (err) {
+      console.error('❌ Failed to load matchup image service:', err.message);
+      console.error('   Install canvas: npm install canvas');
+      process.exit(1);
+    }
+  }
+  return matchupImageService;
+}
+
+function getS3Service() {
+  if (!s3Service) {
+    try {
+      const S3Service = require('../services/s3Service');
+      s3Service = new S3Service();
+      if (!s3Service.isConfigured()) {
+        console.error('❌ S3 credentials not configured');
+        console.error('   Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in .env');
+        process.exit(1);
+      }
+      console.log('✅ S3 service loaded');
+    } catch (err) {
+      console.error('❌ Failed to load S3 service:', err.message);
+      process.exit(1);
+    }
+  }
+  return s3Service;
+}
+
+// Database connection
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  ssl: process.env.DATABASE_URL?.includes('amazonaws') || process.env.DATABASE_URL?.includes('heroku')
+    ? { rejectUnauthorized: false }
+    : false
+});
+
+// Track which team combos we've already processed (to avoid regenerating same image multiple times)
+const processedCombos = new Set();
+
+async function processGame(game, dryRun = false) {
+  const service = getMatchupImageService();
+  const s3 = getS3Service();
+
+  const sportsEvent = game.sports_event;
+  const homeTeam = sportsEvent?.strHomeTeam;
+  const awayTeam = sportsEvent?.strAwayTeam;
+  const league = 'EPL'; // Force EPL
+
+  if (!homeTeam || !awayTeam) {
+    console.log(`  ⚠️ Skipping ${game.game_id} - missing team names`);
+    return { skipped: true };
+  }
+
+  // Create a combo key to avoid regenerating the same image
+  const comboKey = s3.getMatchupImageKey(awayTeam, homeTeam, league);
+  const alreadyProcessed = processedCombos.has(comboKey);
+
+  console.log(`  📝 ${homeTeam} vs ${awayTeam}`);
+
+  if (dryRun) {
+    console.log(`  🔍 DRY RUN - Would regenerate image for ${comboKey}`);
+    return { success: true, dryRun: true };
+  }
+
+  try {
+    let publicUrl;
+
+    if (alreadyProcessed) {
+      // Image already regenerated in this run, just get the URL
+      const cacheBuster = Date.now();
+      publicUrl = `https://${s3.bucketName}.s3.${s3.region}.amazonaws.com/${comboKey}?v=${cacheBuster}`;
+      console.log(`  ♻️  Reusing already regenerated image`);
+    } else {
+      // Generate new image
+      const result = await service.generateMatchupImage({
+        homeTeam,
+        awayTeam,
+        league,
+        width: 600,
+        height: 315
+      });
+
+      // Upload to S3 with forceOverwrite = true
+      const uploadResult = await s3.uploadMatchupImage(awayTeam, homeTeam, league, result.buffer, true);
+      publicUrl = uploadResult.publicUrl;
+
+      // Mark this combo as processed
+      processedCombos.add(comboKey);
+
+      console.log(`  🔄 Regenerated: ${comboKey}`);
+    }
+
+    // Update database with new URL (includes cache-buster)
+    await pool.query(`
+      UPDATE games
+      SET matchup_image_url = $1, updated_at = NOW()
+      WHERE game_id = $2
+    `, [publicUrl, game.game_id]);
+
+    console.log(`  ✅ Updated: ${game.game_id}`);
+    return { success: true, url: publicUrl, regenerated: !alreadyProcessed };
+
+  } catch (err) {
+    console.error(`  ❌ Failed: ${err.message}`);
+    return { error: err.message };
+  }
+}
+
+async function main() {
+  console.log('');
+  console.log('🎨 EPL Matchup Image Regeneration Script');
+  console.log('=========================================');
+  console.log('');
+
+  // Parse arguments
+  const args = process.argv.slice(2);
+  let limit = null;
+  let gameId = null;
+  let dryRun = false;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--limit' && args[i + 1]) {
+      limit = parseInt(args[i + 1], 10);
+    }
+    if (args[i] === '--game-id' && args[i + 1]) {
+      gameId = args[i + 1];
+    }
+    if (args[i] === '--dry-run') {
+      dryRun = true;
+    }
+  }
+
+  if (dryRun) {
+    console.log('🔍 DRY RUN MODE - No changes will be made');
+    console.log('');
+  }
+
+  // Initialize services
+  getMatchupImageService();
+  if (!dryRun) {
+    getS3Service();
+  }
+
+  try {
+    // Query for EPL games
+    let query;
+    let params;
+
+    if (gameId) {
+      query = `
+        SELECT game_id, sports_event
+        FROM games
+        WHERE game_id = $1 AND game_mode = 4
+      `;
+      params = [gameId];
+    } else {
+      // Get ALL EPL games (including those with existing matchup images)
+      query = `
+        SELECT game_id, sports_event
+        FROM games
+        WHERE game_mode = 4
+          AND sports_event IS NOT NULL
+          AND (
+            sports_event->>'strLeague' ILIKE '%premier%'
+            OR sports_event->>'strLeague' = 'EPL'
+          )
+        ORDER BY created_at DESC
+        ${limit ? `LIMIT ${limit}` : ''}
+      `;
+      params = [];
+    }
+
+    const result = await pool.query(query, params);
+    const games = result.rows;
+
+    console.log(`📊 Found ${games.length} EPL games to process`);
+    console.log('');
+
+    if (games.length === 0) {
+      console.log('✅ No EPL games found!');
+      process.exit(0);
+    }
+
+    // Collect unique team combinations
+    const uniqueCombos = new Set();
+    for (const game of games) {
+      const s3 = dryRun ? null : getS3Service();
+      const sportsEvent = game.sports_event;
+      if (sportsEvent?.strHomeTeam && sportsEvent?.strAwayTeam) {
+        // Use a simple key for counting
+        const key = `${sportsEvent.strAwayTeam}_${sportsEvent.strHomeTeam}`;
+        uniqueCombos.add(key);
+      }
+    }
+    console.log(`🔢 Unique team combinations: ${uniqueCombos.size}`);
+    console.log('');
+
+    // Process games
+    let processed = 0;
+    let succeeded = 0;
+    let failed = 0;
+    let skipped = 0;
+    let regenerated = 0;
+
+    for (const game of games) {
+      console.log(`[${processed + 1}/${games.length}] ${game.game_id}`);
+
+      const result = await processGame(game, dryRun);
+      processed++;
+
+      if (result.success) {
+        succeeded++;
+        if (result.regenerated) regenerated++;
+      }
+      else if (result.skipped) skipped++;
+      else failed++;
+
+      // Small delay to avoid rate limiting
+      if (!dryRun) {
+        await new Promise(r => setTimeout(r, 100));
+      }
+    }
+
+    console.log('');
+    console.log('📊 Summary');
+    console.log('==========');
+    console.log(`  Total processed: ${processed}`);
+    console.log(`  ✅ Succeeded:    ${succeeded}`);
+    console.log(`  🔄 Regenerated:  ${regenerated} unique images`);
+    console.log(`  ⚠️  Skipped:      ${skipped}`);
+    console.log(`  ❌ Failed:       ${failed}`);
+    console.log('');
+
+    if (dryRun) {
+      console.log('🔍 DRY RUN complete - no changes were made');
+      console.log('   Run without --dry-run to apply changes');
+    }
+
+    process.exit(failed > 0 ? 1 : 0);
+
+  } catch (err) {
+    console.error('❌ Fatal error:', err);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+main().catch(err => {
+  console.error('❌ Unhandled error:', err);
+  process.exit(1);
+});

package/scripts/resize-s3-matchup-images.js

@@ -0,0 +1,374 @@
+#!/usr/bin/env node
+/**
+ * Resize S3 Matchup Images Script
+ * 
+ * Converts existing PNG matchup images on S3 to JPEG for better compression.
+ * Resizes images larger than 600x315 down to 600x315 (maintains full quality).
+ * Images already at or below 600x315 are just converted to JPEG without resizing.
+ * Processes both us-east-1 (dev) and us-east-2 (prod) buckets.
+ * 
+ * Usage:
+ *   node scripts/resize-s3-matchup-images.js              # Dry run (preview only)
+ *   node scripts/resize-s3-matchup-images.js --execute    # Actually convert and upload
+ *   node scripts/resize-s3-matchup-images.js --limit 5    # Process only 5 images per bucket
+ *   node scripts/resize-s3-matchup-images.js --execute --limit 10  # Convert 10 images per bucket
+ */
+
+require('dotenv').config();
+const { S3Client, ListObjectsV2Command, GetObjectCommand, PutObjectCommand } = require('@aws-sdk/client-s3');
+const sharp = require('sharp');
+
+// Configuration - processes both buckets
+const BUCKETS = [
+  { name: 'dubs-avatars-dev', region: 'us-east-1' },
+  { name: 'dubs-avatars-prod', region: 'us-east-2' },
+];
+const MATCHUPS_PREFIX = 'matchups/';
+
+// Target size for optimization (images larger than this will be resized down)
+const TARGET_WIDTH = 600;
+const TARGET_HEIGHT = 315;
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const EXECUTE_MODE = args.includes('--execute');
+const limitIndex = args.indexOf('--limit');
+const LIMIT = limitIndex !== -1 ? parseInt(args[limitIndex + 1], 10) : null;
+
+// Initialize S3 client
+function getS3Client(region) {
+  if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_SECRET_ACCESS_KEY) {
+    console.error('❌ AWS credentials not set');
+    console.error('   Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in .env');
+    process.exit(1);
+  }
+
+  return new S3Client({
+    region: region,
+    credentials: {
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    },
+  });
+}
+
+/**
+ * List all matchup images in the bucket
+ */
+async function listMatchupImages(s3Client, bucketName) {
+  const images = [];
+  let continuationToken = null;
+
+  console.log(`📂 Listing images in s3://${bucketName}/${MATCHUPS_PREFIX}...`);
+
+  do {
+    const command = new ListObjectsV2Command({
+      Bucket: bucketName,
+      Prefix: MATCHUPS_PREFIX,
+      ContinuationToken: continuationToken,
+    });
+
+    const response = await s3Client.send(command);
+    
+    if (response.Contents) {
+      for (const obj of response.Contents) {
+        // Only process PNG files
+        if (obj.Key.endsWith('.png')) {
+          images.push({
+            key: obj.Key,
+            size: obj.Size,
+            lastModified: obj.LastModified,
+          });
+        }
+      }
+    }
+
+    continuationToken = response.NextContinuationToken;
+  } while (continuationToken);
+
+  return images;
+}
+
+/**
+ * Download image from S3
+ */
+async function downloadImage(s3Client, bucketName, key) {
+  const command = new GetObjectCommand({
+    Bucket: bucketName,
+    Key: key,
+  });
+
+  const response = await s3Client.send(command);
+  
+  // Convert stream to buffer
+  const chunks = [];
+  for await (const chunk of response.Body) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+
+/**
+ * Convert image to JPEG and resize if larger than target size
+ * If image is already at or below 600x315, just converts to JPEG without resizing
+ */
+async function resizeImage(imageBuffer) {
+  // Get original dimensions
+  const metadata = await sharp(imageBuffer).metadata();
+  const originalWidth = metadata.width;
+  const originalHeight = metadata.height;
+  
+  // Check if image is already at or below target size (no resize needed)
+  const isAlreadyOptimal = originalWidth <= TARGET_WIDTH && originalHeight <= TARGET_HEIGHT;
+  
+  let newWidth, newHeight;
+  if (isAlreadyOptimal) {
+    // Already optimal size, just convert to JPEG without resizing
+    newWidth = originalWidth;
+    newHeight = originalHeight;
+  } else {
+    // Image is larger than target, resize down to target size
+    newWidth = TARGET_WIDTH;
+    newHeight = TARGET_HEIGHT;
+  }
+
+  // Convert to JPEG (resize only if needed)
+  let processedBuffer = sharp(imageBuffer);
+  
+  if (!isAlreadyOptimal) {
+    processedBuffer = processedBuffer.resize(newWidth, newHeight, {
+      fit: 'inside',
+      withoutEnlargement: true,
+    });
+  }
+  
+  const resizedBuffer = await processedBuffer
+    .jpeg({
+      quality: 85, // Good balance between quality and file size
+      mozjpeg: true, // Use mozjpeg encoder for better compression
+    })
+    .toBuffer();
+
+  return {
+    buffer: resizedBuffer,
+    originalWidth,
+    originalHeight,
+    newWidth,
+    newHeight,
+    wasAlreadyResized: isAlreadyOptimal,
+  };
+}
+
+/**
+ * Upload resized image back to S3
+ * Converts PNG keys to JPEG keys
+ */
+async function uploadImage(s3Client, bucketName, key, imageBuffer) {
+  // Convert .png extension to .jpg
+  const newKey = key.replace(/\.png$/i, '.jpg');
+  
+  const command = new PutObjectCommand({
+    Bucket: bucketName,
+    Key: newKey,
+    Body: imageBuffer,
+    ContentType: 'image/jpeg',
+    CacheControl: 'public, max-age=31536000',
+  });
+
+  await s3Client.send(command);
+  
+  return newKey;
+}
+
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+
+/**
+ * Process images for a single bucket
+ */
+async function processBucket(bucketName, region) {
+  console.log('');
+  console.log('🖼️  S3 Matchup Image Resizer');
+  console.log('============================');
+  console.log('');
+  console.log(`📍 Target: s3://${bucketName}/${MATCHUPS_PREFIX}`);
+  console.log(`📍 Region: ${region}`);
+  console.log(`📍 Target size: ${TARGET_WIDTH}x${TARGET_HEIGHT} (full quality)`);
+  console.log(`📍 Format: PNG → JPEG (better compression)`);
+  console.log(`📍 Mode: ${EXECUTE_MODE ? '🔥 EXECUTE (will modify images!)' : '👀 DRY RUN (preview only)'}`);
+  if (LIMIT) console.log(`📍 Limit: ${LIMIT} images`);
+  console.log('');
+
+  const s3Client = getS3Client(region);
+
+  // List all matchup images
+  let images = await listMatchupImages(s3Client, bucketName);
+  console.log(`📊 Found ${images.length} matchup images`);
+
+  if (images.length === 0) {
+    console.log('✅ No images to process!');
+    return {
+      processed: 0,
+      succeeded: 0,
+      failed: 0,
+      totalOriginalSize: 0,
+      totalNewSize: 0,
+    };
+  }
+
+  // Apply limit if specified
+  if (LIMIT && images.length > LIMIT) {
+    console.log(`📊 Limiting to ${LIMIT} images`);
+    images = images.slice(0, LIMIT);
+  }
+
+  console.log('');
+
+  // Process each image
+  let processed = 0;
+  let succeeded = 0;
+  let failed = 0;
+  let totalOriginalSize = 0;
+  let totalNewSize = 0;
+
+  for (const image of images) {
+    processed++;
+    const progress = `[${processed}/${images.length}]`;
+    
+    try {
+      console.log(`${progress} Processing: ${image.key}`);
+      console.log(`        Original size: ${formatBytes(image.size)}`);
+
+      // Download the image
+      const originalBuffer = await downloadImage(s3Client, bucketName, image.key);
+      totalOriginalSize += originalBuffer.length;
+
+      // Resize the image
+      const result = await resizeImage(originalBuffer);
+      totalNewSize += result.buffer.length;
+
+      const sizeSaved = originalBuffer.length - result.buffer.length;
+      const percentSaved = ((sizeSaved / originalBuffer.length) * 100).toFixed(1);
+
+      if (result.wasAlreadyResized) {
+        console.log(`        Dimensions: ${result.originalWidth}x${result.originalHeight} (already optimal size, converting to JPEG)`);
+      } else {
+        console.log(`        Dimensions: ${result.originalWidth}x${result.originalHeight} → ${result.newWidth}x${result.newHeight}`);
+      }
+      console.log(`        Format: PNG → JPEG`);
+      console.log(`        New size: ${formatBytes(result.buffer.length)} (saved ${formatBytes(sizeSaved)}, ${percentSaved}%)`);
+
+      if (EXECUTE_MODE) {
+        // Upload the resized and converted image
+        const newKey = await uploadImage(s3Client, bucketName, image.key, result.buffer);
+        console.log(`        ✅ Uploaded as: ${newKey}`);
+      } else {
+        console.log(`        ⏸️  Skipped (dry run)`);
+      }
+
+      succeeded++;
+    } catch (err) {
+      console.error(`        ❌ Failed: ${err.message}`);
+      failed++;
+    }
+
+    console.log('');
+
+    // Small delay to avoid rate limiting
+    await new Promise(r => setTimeout(r, 50));
+  }
+
+  // Summary for this bucket
+  console.log('');
+  console.log(`📊 Summary for ${bucketName}`);
+  console.log('==========');
+  console.log(`  Total processed: ${processed}`);
+  console.log(`  ✅ Succeeded:    ${succeeded}`);
+  console.log(`  ❌ Failed:       ${failed}`);
+  console.log('');
+  console.log(`  📦 Original total size: ${formatBytes(totalOriginalSize)}`);
+  console.log(`  📦 New total size:      ${formatBytes(totalNewSize)}`);
+  if (totalOriginalSize > 0) {
+    console.log(`  💾 Total saved:         ${formatBytes(totalOriginalSize - totalNewSize)} (${((1 - totalNewSize / totalOriginalSize) * 100).toFixed(1)}%)`);
+  }
+  console.log('');
+
+  return {
+    processed,
+    succeeded,
+    failed,
+    totalOriginalSize,
+    totalNewSize,
+  };
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  console.log('');
+  console.log('🖼️  S3 Matchup Image Resizer - Multi-Bucket');
+  console.log('============================================');
+  console.log('');
+  console.log(`📍 Processing ${BUCKETS.length} buckets:`);
+  BUCKETS.forEach(bucket => {
+    console.log(`   - ${bucket.name} (${bucket.region})`);
+  });
+  console.log(`📍 Target size: ${TARGET_WIDTH}x${TARGET_HEIGHT} (full quality)`);
+  console.log(`📍 Format: PNG → JPEG (better compression)`);
+  console.log(`📍 Mode: ${EXECUTE_MODE ? '🔥 EXECUTE (will modify images!)' : '👀 DRY RUN (preview only)'}`);
+  if (LIMIT) console.log(`📍 Limit: ${LIMIT} images per bucket`);
+  console.log('');
+
+  // Process each bucket
+  const allResults = [];
+  for (const bucket of BUCKETS) {
+    const result = await processBucket(bucket.name, bucket.region);
+    allResults.push({ bucket: bucket.name, region: bucket.region, ...result });
+    
+    // Add separator between buckets
+    if (bucket !== BUCKETS[BUCKETS.length - 1]) {
+      console.log('');
+      console.log('─'.repeat(60));
+    }
+  }
+
+  // Overall summary
+  console.log('');
+  console.log('📊 Overall Summary');
+  console.log('=================');
+  const totalProcessed = allResults.reduce((sum, r) => sum + r.processed, 0);
+  const totalSucceeded = allResults.reduce((sum, r) => sum + r.succeeded, 0);
+  const totalFailed = allResults.reduce((sum, r) => sum + r.failed, 0);
+  const totalOriginalSize = allResults.reduce((sum, r) => sum + r.totalOriginalSize, 0);
+  const totalNewSize = allResults.reduce((sum, r) => sum + r.totalNewSize, 0);
+
+  console.log(`  Total processed: ${totalProcessed}`);
+  console.log(`  ✅ Succeeded:    ${totalSucceeded}`);
+  console.log(`  ❌ Failed:       ${totalFailed}`);
+  console.log('');
+  console.log(`  📦 Original total size: ${formatBytes(totalOriginalSize)}`);
+  console.log(`  📦 New total size:      ${formatBytes(totalNewSize)}`);
+  if (totalOriginalSize > 0) {
+    console.log(`  💾 Total saved:         ${formatBytes(totalOriginalSize - totalNewSize)} (${((1 - totalNewSize / totalOriginalSize) * 100).toFixed(1)}%)`);
+  }
+  console.log('');
+
+  if (!EXECUTE_MODE) {
+    console.log('⚠️  This was a DRY RUN. To actually resize images, run:');
+    console.log('   node scripts/resize-s3-matchup-images.js --execute');
+    console.log('');
+  }
+}
+
+main().catch(err => {
+  console.error('❌ Fatal error:', err);
+  process.exit(1);
+});
+