dubs-server 1.0.0

package/services/s3Service.js

@@ -0,0 +1,396 @@
+/**
+ * 📸 S3 Service for Avatar and Matchup Image Uploads
+ */
+
+const { S3Client, PutObjectCommand, HeadObjectCommand } = require('@aws-sdk/client-s3');
+const { getSignedUrl } = require('@aws-sdk/s3-request-presigner');
+const sharp = require('sharp');
+
+class S3Service {
+  constructor() {
+    // Check for AWS credentials
+    this.credentialsAvailable = !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY);
+    
+    if (!this.credentialsAvailable) {
+      console.warn('⚠️  AWS credentials not set - uploads will fail');
+      console.warn('   Add AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY to .env');
+      this.client = null;
+      return;
+    }
+
+    // Region must match bucket location: dev in us-east-1, prod in us-east-2
+    this.region = process.env.NODE_ENV === 'production' 
+      ? 'us-east-2'
+      : 'us-east-1';
+
+    // Bucket configuration based on environment
+    // Avatars bucket (existing)
+    this.bucketName = process.env.NODE_ENV === 'production' 
+      ? 'dubs-avatars-prod'
+      : 'dubs-avatars-dev';
+
+    // What's New bucket (dedicated for feature announcements)
+    this.whatsNewBucketName = process.env.NODE_ENV === 'production' 
+      ? 'dubs-whats-new-prod'
+      : 'dubs-whats-new-dev';
+
+    // S3 Client must use the same region as the bucket
+    this.client = new S3Client({
+      region: this.region,
+      credentials: {
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+      },
+    });
+
+    console.log(`📸 S3 Service initialized:`);
+    console.log(`   - Avatars: ${this.bucketName} (${this.region})`);
+    console.log(`   - What's New: ${this.whatsNewBucketName} (${this.region})`);
+  }
+
+  /**
+   * Generate presigned URL for direct browser upload
+   */
+  async getUploadUrl(walletAddress, fileExtension) {
+    if (!this.credentialsAvailable || !this.client) {
+      throw new Error('AWS credentials not configured. Please set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in .env file');
+    }
+
+    const fileName = `${walletAddress}-${Date.now()}.${fileExtension}`;
+    const key = `avatars/${fileName}`;
+
+    const command = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      ContentType: this.getContentType(fileExtension),
+      // Public read access handled by bucket policy
+    });
+
+    // Generate presigned URL valid for 5 minutes
+    const uploadUrl = await getSignedUrl(this.client, command, { expiresIn: 300 });
+
+    // Public URL for accessing the file
+    const publicUrl = `https://${this.bucketName}.s3.${this.region}.amazonaws.com/${key}`;
+
+    return {
+      uploadUrl,
+      publicUrl,
+      key,
+    };
+  }
+
+  /**
+   * Get content type based on file extension
+   */
+  getContentType(extension) {
+    const types = {
+      'jpg': 'image/jpeg',
+      'jpeg': 'image/jpeg',
+      'png': 'image/png',
+      'gif': 'image/gif',
+      'webp': 'image/webp',
+    };
+    return types[extension.toLowerCase()] || 'application/octet-stream';
+  }
+
+  /**
+   * Validate file extension
+   */
+  isValidFileType(extension) {
+    const allowed = ['jpg', 'jpeg', 'png', 'gif', 'webp'];
+    return allowed.includes(extension.toLowerCase());
+  }
+
+  /**
+   * Normalize team name for use in file keys
+   * Converts to lowercase, replaces spaces with underscores, removes special chars
+   */
+  normalizeTeamName(teamName) {
+    return teamName
+      .toLowerCase()
+      .trim()
+      .replace(/[^a-z0-9\s]/g, '') // Remove special characters
+      .replace(/\s+/g, '_') // Replace spaces with underscores
+      .replace(/_+/g, '_') // Collapse multiple underscores
+      .replace(/^_|_$/g, ''); // Remove leading/trailing underscores
+  }
+
+  /**
+   * Generate a team-based key for matchup images
+   * Format: matchups/{league}/{away_team}_{home_team}.jpg
+   * This allows reusing the same image for all games with the same teams
+   */
+  getMatchupImageKey(awayTeam, homeTeam, league) {
+    const normalizedAway = this.normalizeTeamName(awayTeam);
+    const normalizedHome = this.normalizeTeamName(homeTeam);
+    const normalizedLeague = league.toUpperCase();
+    return `matchups/${normalizedLeague}/${normalizedAway}_${normalizedHome}.jpg`;
+  }
+
+  /**
+   * Check if a matchup image already exists in S3
+   */
+  async matchupImageExists(key) {
+    if (!this.credentialsAvailable || !this.client) {
+      return false;
+    }
+
+    try {
+      const command = new HeadObjectCommand({
+        Bucket: this.bucketName,
+        Key: key,
+      });
+      await this.client.send(command);
+      return true;
+    } catch (err) {
+      if (err.name === 'NotFound' || err.$metadata?.httpStatusCode === 404) {
+        return false;
+      }
+      // For other errors, log but assume it doesn't exist
+      console.warn(`[S3] Error checking if image exists: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Upload a matchup image directly from buffer
+   * Used for server-side generated matchup images
+   * Optimizes image size by resizing to half dimensions and converting to JPEG for better compression
+   * Uses team-based keys to allow image reuse across games with the same teams
+   * 
+   * @param {string} awayTeam - Away team name
+   * @param {string} homeTeam - Home team name
+   * @param {string} league - League abbreviation (NHL, NBA, NFL, MLB)
+   * @param {Buffer} imageBuffer - PNG image buffer (from canvas)
+   * @returns {Promise<{publicUrl: string, key: string, wasReused: boolean}>}
+   */
+  async uploadMatchupImage(awayTeam, homeTeam, league, imageBuffer, forceOverwrite = false) {
+    if (!this.credentialsAvailable || !this.client) {
+      throw new Error('AWS credentials not configured');
+    }
+
+    // Generate team-based key (reusable across all games with same teams)
+    const key = this.getMatchupImageKey(awayTeam, homeTeam, league);
+
+    // Check if image already exists (skip check if forceOverwrite is true)
+    if (!forceOverwrite) {
+      const exists = await this.matchupImageExists(key);
+      if (exists) {
+        const publicUrl = `https://${this.bucketName}.s3.${this.region}.amazonaws.com/${key}`;
+        console.log(`[S3] ♻️  Reusing existing matchup image: ${key}`);
+        return {
+          publicUrl,
+          key,
+          wasReused: true,
+        };
+      }
+    } else {
+      console.log(`[S3] 🔄 Force overwriting matchup image: ${key}`);
+    }
+
+    console.log(`[S3] Optimizing matchup image: ${key} (original: ${imageBuffer.length} bytes)`);
+
+    // Optimize image: convert PNG to JPEG without resizing (maintain full quality)
+    let optimizedBuffer;
+    try {
+      // Get original dimensions
+      const metadata = await sharp(imageBuffer).metadata();
+      const originalWidth = metadata.width;
+      const originalHeight = metadata.height;
+
+      // Convert to JPEG without resizing (maintain full 600x315 quality)
+      optimizedBuffer = await sharp(imageBuffer)
+        .jpeg({
+          quality: 90, // High quality for crisp images
+          mozjpeg: true, // Use mozjpeg encoder for better compression
+        })
+        .toBuffer();
+
+      const sizeSaved = imageBuffer.length - optimizedBuffer.length;
+      const percentSaved = ((sizeSaved / imageBuffer.length) * 100).toFixed(1);
+      
+      console.log(`[S3] Optimized: ${originalWidth}x${originalHeight} (PNG → JPEG, no resize)`);
+      console.log(`[S3] Size: ${imageBuffer.length} bytes → ${optimizedBuffer.length} bytes (saved ${percentSaved}%)`);
+    } catch (optimizeError) {
+      console.warn(`[S3] ⚠️ Image optimization failed, using original: ${optimizeError.message}`);
+      optimizedBuffer = imageBuffer; // Fallback to original if optimization fails
+    }
+
+    const command = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: optimizedBuffer,
+      ContentType: 'image/jpeg',
+      CacheControl: 'public, max-age=31536000', // Cache for 1 year (images don't change)
+      // NOTE: ACL won't work because bucket has "Object Ownership: Bucket owner enforced"
+      // Public access must be granted via bucket policy. Add this policy in AWS Console:
+      // {
+      //   "Version": "2012-10-17",
+      //   "Statement": [{
+      //     "Sid": "PublicReadMatchups",
+      //     "Effect": "Allow",
+      //     "Principal": "*",
+      //     "Action": "s3:GetObject",
+      //     "Resource": "arn:aws:s3:::dubs-avatars-prod/matchups/*"
+      //   }]
+      // }
+    });
+
+    await this.client.send(command);
+
+    // Add cache-busting timestamp to URL to ensure browsers fetch the new image
+    // This is important when overwriting existing images (e.g., EPL regeneration)
+    const cacheBuster = Date.now();
+    const publicUrl = `https://${this.bucketName}.s3.${this.region}.amazonaws.com/${key}?v=${cacheBuster}`;
+
+    console.log(`[S3] ✅ Matchup image uploaded: ${publicUrl} (${optimizedBuffer.length} bytes)`);
+
+    return {
+      publicUrl,
+      key,
+      wasReused: false,
+    };
+  }
+
+  /**
+   * Check if S3 credentials are available
+   */
+  isConfigured() {
+    return this.credentialsAvailable && this.client !== null;
+  }
+
+  /**
+   * Get the S3 key for a profile OG image
+   * @param {string} username - Username
+   * @param {string} variant - 'default' or 'twitter'
+   */
+  getProfileOGImageKey(username, variant = 'default') {
+    // Normalize username for safe file naming
+    const normalizedUsername = username
+      .toLowerCase()
+      .trim()
+      .replace(/[^a-z0-9_-]/g, '_');
+    const suffix = variant === 'twitter' ? '-twitter' : '';
+    return `og-profiles/${normalizedUsername}${suffix}.png`;
+  }
+
+  /**
+   * Get the public URL for a profile OG image
+   * @param {string} username - Username
+   * @param {string} variant - 'default' or 'twitter'
+   */
+  getProfileOGImageUrl(username, variant = 'default') {
+    const key = this.getProfileOGImageKey(username, variant);
+    return `https://${this.bucketName}.s3.${this.region}.amazonaws.com/${key}`;
+  }
+
+  /**
+   * Check if a profile OG image exists in S3
+   * @param {string} username - Username
+   * @param {string} variant - 'default' or 'twitter'
+   */
+  async profileOGImageExists(username, variant = 'default') {
+    if (!this.credentialsAvailable || !this.client) {
+      return false;
+    }
+
+    try {
+      const key = this.getProfileOGImageKey(username, variant);
+      const command = new HeadObjectCommand({
+        Bucket: this.bucketName,
+        Key: key,
+      });
+      await this.client.send(command);
+      return true;
+    } catch (err) {
+      if (err.name === 'NotFound' || err.$metadata?.httpStatusCode === 404) {
+        return false;
+      }
+      console.warn(`[S3] Error checking if profile OG image exists: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Upload a profile OG image to S3
+   * Used for the beautiful ShareablePNLCard captured via html2canvas
+   *
+   * @param {string} username - Username for the profile
+   * @param {Buffer} imageBuffer - PNG image buffer
+   * @param {string} variant - 'default' or 'twitter' (1200x628 for Twitter cards)
+   * @returns {Promise<{publicUrl: string, key: string}>}
+   */
+  async uploadProfileOGImage(username, imageBuffer, variant = 'default') {
+    if (!this.credentialsAvailable || !this.client) {
+      throw new Error('AWS credentials not configured');
+    }
+
+    const key = this.getProfileOGImageKey(username, variant);
+
+    console.log(`[S3] Uploading profile OG image (${variant}): ${key} (${imageBuffer.length} bytes)`);
+
+    const command = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: imageBuffer,
+      ContentType: 'image/png',
+      CacheControl: 'public, max-age=3600', // Cache for 1 hour (profiles change more often than matchups)
+    });
+
+    await this.client.send(command);
+
+    const publicUrl = `https://${this.bucketName}.s3.${this.region}.amazonaws.com/${key}`;
+
+    console.log(`[S3] ✅ Profile OG image (${variant}) uploaded: ${publicUrl}`);
+
+    return {
+      publicUrl,
+      key,
+    };
+  }
+
+  /**
+   * Upload a What's New GIF to S3
+   * Uses dedicated whats-new bucket
+   * 
+   * @param {Buffer} imageBuffer - GIF/image buffer
+   * @param {string} originalFilename - Original filename for extension detection
+   * @param {string} contentType - MIME type of the file
+   * @returns {Promise<{publicUrl: string, key: string}>}
+   */
+  async uploadWhatsNewGif(imageBuffer, originalFilename, contentType) {
+    if (!this.credentialsAvailable || !this.client) {
+      throw new Error('AWS credentials not configured');
+    }
+
+    // Generate unique filename
+    const extension = originalFilename.split('.').pop().toLowerCase() || 'gif';
+    const timestamp = Date.now();
+    const randomId = Math.random().toString(36).substring(2, 8);
+    const key = `${timestamp}-${randomId}.${extension}`;
+
+    console.log(`[S3] Uploading What's New GIF to ${this.whatsNewBucketName}: ${key} (${imageBuffer.length} bytes)`);
+
+    const command = new PutObjectCommand({
+      Bucket: this.whatsNewBucketName,
+      Key: key,
+      Body: imageBuffer,
+      ContentType: contentType || this.getContentType(extension),
+      CacheControl: 'public, max-age=31536000', // Cache for 1 year
+    });
+
+    await this.client.send(command);
+
+    const publicUrl = `https://${this.whatsNewBucketName}.s3.${this.region}.amazonaws.com/${key}`;
+
+    console.log(`[S3] ✅ What's New GIF uploaded: ${publicUrl}`);
+
+    return {
+      publicUrl,
+      key,
+    };
+  }
+}
+
+module.exports = S3Service;
+