dsas-cca-backend-bun/services/s3-service.ts

// services/s3-service.ts
import { S3Client } from "bun";
import { v4 as uuidv4 } from 'uuid';
import { config } from 'dotenv';
import sharp from 'sharp';
import { logger } from '../utils/logger';
import { decodeBase64Image } from '../utils/image-processor';

config();

// S3 configuration
const S3_ENDPOINT = process.env.S3_ENDPOINT;
const S3_REGION = process.env.S3_REGION;
const S3_ACCESS_KEY_ID = process.env.S3_ACCESS_KEY_ID;
const S3_SECRET_ACCESS_KEY = process.env.S3_SECRET_ACCESS_KEY;
const BUCKET_NAME = process.env.S3_BUCKET_NAME;
const PUBLIC_URL_FILE_PREFIX = (process.env.S3_PUBLIC_URL_PREFIX || 'files').replace(/\/$/, '');

// Initialize S3 client
let s3Client: S3Client | null = null;

if (S3_ACCESS_KEY_ID && S3_SECRET_ACCESS_KEY && BUCKET_NAME) {
    try {
        s3Client = new S3Client({
            accessKeyId: S3_ACCESS_KEY_ID,
            secretAccessKey: S3_SECRET_ACCESS_KEY,
            bucket: BUCKET_NAME,
            endpoint: S3_ENDPOINT,
            region: S3_REGION
        });
        logger.info('S3 client initialized successfully.');
    } catch (error) {
        logger.error('Failed to initialize S3 client:', error);
    }
} else {
    logger.warn('S3 client configuration is incomplete. S3 operations will be disabled.');
}

/**
 * Uploads an image from a base64 string to S3, converting it to AVIF format.
 * @param base64Data - The base64 content (without the data URI prefix)
 * @param originalFormat - The image format (e.g., 'png', 'jpeg')
 * @param activityId - The activity ID, used for naming
 * @returns The public URL of the uploaded image or null on error
 */
export async function uploadImageFromBase64(
    base64Data: string, 
    originalFormat: string, 
    activityId: string
): Promise<string | null> {
    if (!s3Client) {
        logger.warn('S3 client not configured. Cannot upload image.');
        return null;
    }
    if (!base64Data || !originalFormat || !activityId) {
        logger.error('S3 Upload: Missing base64Data, originalFormat, or activityId');
        return null;
    }

    try {
        // First decode the base64 image
        const imageBuffer = decodeBase64Image(base64Data);
        
        // Convert to AVIF format with quality 80 using Sharp
        const avifBuffer = await sharp(imageBuffer)
            .avif({ 
                quality: 80,
                // You can add more AVIF options here if needed
                // lossless: false,
                // effort: 4,
            })
            .toBuffer();
        
        // Use .avif extension for the object key
        const objectKey = `${PUBLIC_URL_FILE_PREFIX}/activity-${activityId}-${uuidv4()}.avif`;
        
        // Using Bun's S3Client file API
        const s3File = s3Client.file(objectKey);
        
        await s3File.write(avifBuffer, {
            type: 'image/avif',
            acl: 'public-read'
        });
        
        const publicUrl = constructS3Url(objectKey);
        logger.info(`Image uploaded to S3 as AVIF: ${publicUrl}`);
        return publicUrl;
    } catch (error) {
        logger.error(`S3 Upload Error for activity ${activityId}:`, error);
        return null;
    }
}

/**
 * Lists all objects in the S3 bucket under a specific prefix.
 * @param prefix - The prefix to filter objects by
 * @returns A list of object keys
 */
export async function listS3Objects(prefix: string): Promise<string[]> {
    if (!s3Client) {
        logger.warn('S3 client not configured. Cannot list objects.');
        return [];
    }
    
    logger.debug(`Listing objects from S3 with prefix: "${prefix}"`);
    
    try {
        const objectKeys: string[] = [];
        let isTruncated = true;
        let startAfter: string | undefined;
        
        while (isTruncated) {
            // Use Bun's list method with pagination
            const result = await s3Client.list({
                prefix,
                startAfter,
                maxKeys: 1000
            });
            
            if (result.contents) {
                // Add keys to our array, filtering out "directories"
                result.contents.forEach(item => {
                    if (item.key && !item.key.endsWith('/')) {
                        objectKeys.push(item.key);
                    }
                });
                
                // Get the last key for pagination
                if (result.contents?.length > 0) {
                    startAfter = result.contents[result.contents.length - 1]?.key;
                }
            }
            
            isTruncated = result.isTruncated || false;
            
            // Safety check to prevent infinite loops
            if (result.contents?.length === 0) {
                break;
            }
        }
        
        logger.info(`Listed ${objectKeys.length} object keys from S3 with prefix "${prefix}"`);
        return objectKeys;
    } catch (error) {
        logger.error(`S3 ListObjects Error with prefix "${prefix}":`, error);
        return [];
    }
}

/**
 * Deletes multiple objects from S3.
 * @param objectKeysArray - Array of object keys to delete
 * @returns True if successful or partially successful, false on major error
 */
export async function deleteS3Objects(objectKeysArray: string[]): Promise<boolean> {
    if (!s3Client) {
        logger.warn('S3 client not configured. Cannot delete objects.');
        return false;
    }
    if (!objectKeysArray || objectKeysArray.length === 0) {
        logger.info('No objects to delete from S3.');
        return true;
    }

    try {
        // With Bun's S3Client, we need to delete objects one by one
        // Process in batches of 100 for better performance
        const BATCH_SIZE = 100;
        let successCount = 0;
        let errorCount = 0;
        
        for (let i = 0; i < objectKeysArray.length; i += BATCH_SIZE) {
            const batch = objectKeysArray.slice(i, i + BATCH_SIZE);
            
            // Process batch in parallel
            const results = await Promise.allSettled(
                batch.map(key => s3Client!.delete(key))
            );
            
            // Count successes and failures
            for (const result of results) {
                if (result.status === 'fulfilled') {
                    successCount++;
                } else {
                    errorCount++;
                    logger.error(`Failed to delete object: ${result.reason}`);
                }
            }
        }
        
        logger.info(`Deleted ${successCount} objects from S3. Failed: ${errorCount}`);
        return errorCount === 0; // True if all succeeded
    } catch (error) {
        logger.error('S3 DeleteObjects Error:', error);
        return false;
    }
}

/**
 * Constructs the public S3 URL for an object key.
 * @param objectKey - The key of the object in S3
 * @returns The full public URL
 */
export function constructS3Url(objectKey: string): string {
    if (!S3_ENDPOINT || !BUCKET_NAME) {
        return '';
    }
    
    // Ensure S3_ENDPOINT does not end with a slash
    const s3Base = S3_ENDPOINT.replace(/\/$/, '');
    // Ensure BUCKET_NAME does not start or end with a slash
    const bucket = BUCKET_NAME.replace(/^\//, '').replace(/\/$/, '');
    // Ensure objectKey does not start with a slash
    const key = objectKey.replace(/^\//, '');
    
    return `${s3Base}/${bucket}/${key}`;
}