cdnController.js

import { Storage } from '@google-cloud/storage';

// Initialize GCS client (uses Application Default Credentials)
const storage = new Storage();

// MIME type mapping for common file extensions
const MIME_TYPES = {
    '.json': 'application/json',
    '.js': 'application/javascript',
    '.png': 'image/png',
    '.svg': 'image/svg+xml',
    '.csv': 'text/csv',
    '.pdf': 'application/pdf'
};

/**
 * Get MIME type from file path
 */
function getMimeType(filePath) {
    const ext = filePath.substring(filePath.lastIndexOf('.')).toLowerCase();
    return MIME_TYPES[ext] || 'application/octet-stream';
}

/**
 * Proxy endpoint to serve files from private GCS bucket
 * GET /v1/static/*
 *
 * This serves as a proxy for files stored in gs://httparchive/
 * The request path after /v1/static/ maps directly to the GCS object path
 */
export const proxyReportsFile = async (req, res, filePath) => {
    try {
        const BUCKET_NAME = process.env.GCS_BUCKET_NAME || 'httparchive';

        // Block access to crawls and results paths
        if (filePath.startsWith('crawls/') || filePath.startsWith('results/')) {
            res.statusCode = 400;
            res.end(JSON.stringify({ error: 'Not supported. Response size too large.' }));
            return;
        }

        // Validate file path to prevent directory traversal
        if (filePath.includes('..') || filePath.includes('//')) {
            res.statusCode = 400;
            res.end(JSON.stringify({ error: 'Invalid file path' }));
            return;
        }

        // Remove leading slash if present - use path directly without base path prefix
        const objectPath = filePath.startsWith('/') ? filePath.slice(1) : filePath;

        // Get the file from GCS
        const bucket = storage.bucket(BUCKET_NAME);
        const file = bucket.file(objectPath);

        // Get file metadata for content type and caching
        // This implicitly checks if the file exists, saving a network request
        let metadata;
        try {
            [metadata] = await file.getMetadata();
        } catch (error) {
            if (error.code === 404) {
                res.statusCode = 404;
                res.end(JSON.stringify({ error: 'File not found' }));
                return;
            }
            throw error;
        }

        // Determine content type
        const contentType = metadata.contentType || getMimeType(objectPath);

        // Set response headers
        res.setHeader('Content-Type', contentType);
        res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
        res.setHeader('Cache-Tag', 'bucket-proxy');
        // Browser cache: 1 hour, CDN cache: 1 days
        res.setHeader('Cache-Control', 'public, max-age=3600, s-maxage=86400');

        if (metadata.etag) {
            res.setHeader('ETag', metadata.etag);
        }

        // Check for conditional request (If-None-Match)
        const ifNoneMatch = req.headers['if-none-match'];
        if (ifNoneMatch && metadata.etag && ifNoneMatch === metadata.etag) {
            res.statusCode = 304;
            res.end();
            return;
        }

        // Stream the file content to the response
        res.statusCode = 200;

        // If the file is gzip-encoded in GCS, pass the compressed stream through
        // directly so that Content-Length (compressed size) stays accurate.
        // Without this, createReadStream() decompresses transparently while
        // metadata.size still reflects the compressed size, truncating the response.
        const isGzipEncoded = metadata.contentEncoding === 'gzip';
        if (isGzipEncoded) {
            res.setHeader('Content-Encoding', 'gzip');
        }
        if (metadata.size) {
            res.setHeader('Content-Length', metadata.size);
        }

        const readStream = file.createReadStream({ decompress: !isGzipEncoded });

        readStream.on('error', (err) => {
            console.error('Error streaming file from GCS:', err);
            if (!res.headersSent) {
                res.statusCode = 500;
                res.end(JSON.stringify({ error: 'Failed to read file' }));
            }
        });

        readStream.pipe(res);

    } catch (error) {
        console.error('Error proxying GCS file:', error);
        if (!res.headersSent) {
            res.statusCode = 500;
            res.end(JSON.stringify({
                error: 'Server failed to respond',
                details: error.message
            }));
        }
    }
};