caching-proxy.js

import express from 'express';
import NodeCache from 'node-cache';
import axios from 'axios';
import yargs from 'yargs';
import { hideBin } from 'yargs/helpers';

// Parse command line arguments
const { 
  port, 
  origin: originUrl, 
  ttl = 3600, 
  clearCache 
} = yargs(hideBin(process.argv))
  .option('port', {
    alias: 'p',
    description: 'Port to run the proxy server on',
    type: 'number',
  })
  .option('origin', {
    alias: 'o',
    description: 'Origin server URL',
    type: 'string',
  })
  .option('ttl', {
    alias: 't',
    description: 'Cache TTL in seconds',
    type: 'number',
    default: 3600,
  })
  .option('clear-cache', {
    description: 'Clear the cache and exit',
    type: 'boolean',
  })
  .help()
  .argv;

// Initialize cache with configured TTL
const cache = new NodeCache({ stdTTL: ttl });
const app = express();

// If --clear-cache is used, clear and exit
if (clearCache) {
  cache.flushAll();
  console.log('Cache cleared successfully');
  process.exit(0);
}

// Ensure required arguments are provided
if (!port || !originUrl) {
  console.error('Error: Both --port and --origin are required when not using --clear-cache');
  process.exit(1);
}

// Remove trailing slash from origin if present
const origin = originUrl.replace(/\/$/, '');

// Attach body-parsing middleware
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(express.raw({ type: '*/*' }));

// Handle incoming requests
app.use(async (req, res) => {
  const targetUrl = `${origin}${req.url}`;
  const cacheKey = `${req.method}:${targetUrl}`;

  try {
    // Check cache
    const cachedResponse = cache.get(cacheKey);
    if (cachedResponse) {
      console.log(`Cache HIT: ${req.method} ${targetUrl}`);
      res.set('X-Cache', 'HIT');
      Object.entries(cachedResponse.headers).forEach(([key, value]) => {
        if (!['transfer-encoding', 'connection'].includes(key.toLowerCase())) {
          res.set(key, value);
        }
      });
      return res.status(cachedResponse.status).send(cachedResponse.data);
    }

    // If no cache, forward request to origin
    const response = await axios({
      method: req.method,
      url: targetUrl,
      headers: {
        ...req.headers,
        host: new URL(origin).host, // Override Host header
      },
      data: req.body,
      responseType: 'arraybuffer',  // Support binary data
      validateStatus: false,        // Prevent Axios from throwing on non-2xx
    });

    console.log(`Cache MISS: ${req.method} ${targetUrl}`);

    // Cache the response
    cache.set(cacheKey, {
      data: response.data,
      status: response.status,
      headers: response.headers,
    });

    // Send response to client
    res.set('X-Cache', 'MISS');
    Object.entries(response.headers).forEach(([key, value]) => {
      if (!['transfer-encoding', 'connection'].includes(key.toLowerCase())) {
        res.set(key, value);
      }
    });
    res.status(response.status).send(response.data);
  } catch (error) {
    console.error(`Proxy error for ${req.method} ${targetUrl}:`, error.message);
    res.status(502).json({
      error: 'Bad Gateway',
      message: error.message || 'Error forwarding request to origin server',
    });
  }
});

// Start the server
const server = app.listen(port, () => {
  console.log(`Proxy server running on port ${port}`);
  console.log(`Forwarding requests to ${origin}`);
});

// Handle graceful shutdown
process.on('SIGINT', () => {
  console.log('\nShutting down server...');
  server.close(() => {
    console.log('Server stopped');
    process.exit(0);
  });
});