server.js

'use strict';

const express = require('express');
const fetch = require('node-fetch');
const { LRUCache } = require('lru-cache');
const crypto = require('crypto');
const path = require('path');

const app = express();
const PORT = process.env.PORT || 3000;
const START_TIME = Date.now();
const VERSION = '1.0.0';

app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));

// In-memory LRU cache: max 500 entries, no global TTL (TTL is per-entry)
const cache = new LRUCache({ max: 500 });

// In-memory usage counters keyed by API key
const usageMap = new Map();

function getCacheKey(url) {
  return crypto.createHash('sha256').update(url).digest('hex');
}

function isValidUrl(str) {
  try {
    const u = new URL(str);
    return u.protocol === 'http:' || u.protocol === 'https:';
  } catch {
    return false;
  }
}

function getUsage(apiKey) {
  if (!usageMap.has(apiKey)) {
    usageMap.set(apiKey, { fresh_scrapes: 0, cache_hits: 0 });
  }
  return usageMap.get(apiKey);
}

function requireApiKey(req, res, next) {
  const key = req.headers['x-api-key'];
  if (!key || key.trim() === '') {
    return res.status(401).json({ error: 'Missing X-API-Key header' });
  }
  req.apiKey = key.trim();
  next();
}

// ── GET /health ────────────────────────────────────────────────────────────
app.get('/health', (req, res) => {
  res.json({
    status: 'ok',
    version: VERSION,
    uptime_seconds: Math.floor((Date.now() - START_TIME) / 1000)
  });
});

// ── POST /scrape ───────────────────────────────────────────────────────────
app.post('/scrape', requireApiKey, async (req, res) => {
  const { url, ttl_seconds = 3600 } = req.body || {};

  if (!url) {
    return res.status(400).json({ error: 'url is required' });
  }
  if (!isValidUrl(url)) {
    return res.status(400).json({ error: 'Invalid URL' });
  }

  const cacheKey = getCacheKey(url);
  const now = new Date();
  const entry = cache.get(cacheKey);

  if (entry) {
    const ttlRemaining = Math.max(0, Math.floor((entry.expiresAt - Date.now()) / 1000));
    if (ttlRemaining > 0) {
      getUsage(req.apiKey).cache_hits += 1;
      return res.json({
        url,
        html: entry.html,
        cached: true,
        fetched_at: entry.fetched_at,
        ttl_remaining_sec: ttlRemaining,
        credits_used: 0,
        cache_key: cacheKey
      });
    }
  }

  // Cache miss or TTL expired — perform fresh fetch
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), 10000);

  try {
    const response = await fetch(url, {
      signal: controller.signal,
      follow: 10,
      headers: { 'User-Agent': 'CacheSnap/1.0 (+https://cachesnap.io)' }
    });
    clearTimeout(timeout);

    const html = await response.text();
    const fetchedAt = now.toISOString();
    const expiresAt = Date.now() + ttl_seconds * 1000;

    cache.set(cacheKey, { html, fetched_at: fetchedAt, expiresAt }, { ttl: ttl_seconds * 1000 });
    getUsage(req.apiKey).fresh_scrapes += 1;

    return res.json({
      url,
      html,
      cached: false,
      fetched_at: fetchedAt,
      ttl_remaining_sec: ttl_seconds,
      credits_used: 1,
      cache_key: cacheKey
    });
  } catch (err) {
    clearTimeout(timeout);
    if (err.name === 'AbortError') {
      return res.status(500).json({ error: 'Fetch timed out', url });
    }
    return res.status(500).json({ error: 'Fetch failed', url, detail: err.message });
  }
});

// ── GET /cache/status ──────────────────────────────────────────────────────
app.get('/cache/status', requireApiKey, (req, res) => {
  const { url } = req.query;
  if (!url) return res.status(400).json({ error: 'url query parameter is required' });

  const cacheKey = getCacheKey(url);
  const entry = cache.get(cacheKey);

  if (!entry) {
    return res.json({ url, cached: false, ttl_remaining_sec: 0, fetched_at: null });
  }

  const ttlRemaining = Math.max(0, Math.floor((entry.expiresAt - Date.now()) / 1000));
  return res.json({
    url,
    cached: ttlRemaining > 0,
    ttl_remaining_sec: ttlRemaining,
    fetched_at: entry.fetched_at
  });
});

// ── DELETE /cache ──────────────────────────────────────────────────────────
app.delete('/cache', requireApiKey, (req, res) => {
  const { url } = req.query;
  if (!url) return res.status(400).json({ error: 'url query parameter is required' });

  const cacheKey = getCacheKey(url);
  cache.delete(cacheKey);
  return res.json({ message: 'Cache invalidated', url });
});

// ── GET /usage ─────────────────────────────────────────────────────────────
app.get('/usage', requireApiKey, (req, res) => {
  const usage = getUsage(req.apiKey);
  const now = new Date();
  const period = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
  const planLimit = 1000;

  return res.json({
    period,
    fresh_scrapes: usage.fresh_scrapes,
    cache_hits: usage.cache_hits,
    credits_used: usage.fresh_scrapes,
    credits_remaining: Math.max(0, planLimit - usage.fresh_scrapes),
    plan: 'Free',
    plan_limit: planLimit
  });
});

// ── GET /docs ──────────────────────────────────────────────────────────────
app.get('/docs', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'docs.html'));
});

// ── Serve openapi.json ─────────────────────────────────────────────────────
app.get('/openapi.json', (req, res) => {
  res.sendFile(path.join(__dirname, 'openapi.json'));
});

app.listen(PORT, '0.0.0.0', () => {
  console.log(`CacheSnap API v${VERSION} running on port ${PORT}`);
});