Cloudflare Workers Subpath Setup

// Cloudflare Worker - Multi-Route Proxy
// Proxies requests from custom domain to documentation platform

addEventListener("fetch", (event) => {
  event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
  try {
    const url = new URL(request.url);
    const originalDomain = url.hostname;

    // ============ CONFIGURATION ============
    // Target domain where docs are hosted
    const TARGET_DOMAIN = "YOUR_SUBDOMAIN.documentationai.com";
    // Base path where docs are mounted on your site (e.g. "/docs", "/help", "/knowledge-base")
    const DOCS_PATH = "/docs";
    // =======================================

    // Escape DOCS_PATH for safe use in RegExp
    const escapedDocsPath = DOCS_PATH.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

    // Handle domain verification paths (Let's Encrypt, Vercel, etc.)
    if (url.pathname.startsWith("/.well-known/")) {
      return await fetch(request);
    }

    // Define routing rules
    const routes = [
      // Special file rewrites - MUST come first (most specific)
      {
        pattern: new RegExp(`^${escapedDocsPath}/llms\\.txt$`),
        targetPath: "/llms.txt",
      },
      {
        pattern: new RegExp(`^${escapedDocsPath}/llms-full\\.txt$`),
        targetPath: "/llms-full.txt",
      },
      {
        pattern: new RegExp(`^${escapedDocsPath}/sitemap\\.xml$`),
        targetPath: "/sitemap.xml",
      },
      {
        pattern: new RegExp(`^${escapedDocsPath}/robots\\.txt$`),
        targetPath: "/robots.txt",
      },
      // API routes - keep full path
      {
        pattern: /^\/_dai\/api\/.*/,
        targetPath: null, // null = use original path
      },
      // Static asset routes - keep full path
      {
        pattern: /^\/dai-assets\/.*/,
        targetPath: null,
      },
      // Docs routes - keep full path including docs prefix
      {
        pattern: new RegExp(`^${escapedDocsPath}(\\/.*)?$`),
        targetPath: null,
      },
    ];

    // Check if the current path matches any proxy route
    const matchedRoute = routes.find((route) => route.pattern.test(url.pathname));

    if (matchedRoute) {
      // Use rewritten path or original path
      const targetPath =
        matchedRoute.targetPath !== null
          ? matchedRoute.targetPath
          : url.pathname;

      // Build the target URL
      const targetUrl = `https://${TARGET_DOMAIN}${targetPath}${url.search}`;

      // Create new request with proper headers
      const proxyRequest = new Request(targetUrl, {
        method: request.method,
        headers: new Headers(request.headers),
        body: request.body,
        redirect: "follow",
      });

      // Set essential proxy headers
      proxyRequest.headers.set("Host", TARGET_DOMAIN);
      proxyRequest.headers.set("X-Forwarded-Host", originalDomain);
      proxyRequest.headers.set("X-Forwarded-Proto", "https");

      // Forward real client IP for analytics and logging
      const clientIP = request.headers.get("CF-Connecting-IP");
      if (clientIP) {
        proxyRequest.headers.set("CF-Connecting-IP", clientIP);
        proxyRequest.headers.set("X-Forwarded-For", clientIP);
        proxyRequest.headers.set("X-Real-IP", clientIP);
      }

      // Optimize caching for static assets (dai-assets prefix)
      if (url.pathname.startsWith("/dai-assets/")) {
        proxyRequest.headers.set(
          "Cache-Control",
          "public, max-age=31536000, immutable"
        );
      }

      // Make the proxy request
      const response = await fetch(proxyRequest);

      // Clone the response to modify headers
      const modifiedResponse = new Response(response.body, {
        status: response.status,
        statusText: response.statusText,
        headers: new Headers(response.headers),
      });

      // Add security and CORS headers
      modifiedResponse.headers.set("X-Frame-Options", "SAMEORIGIN");
      modifiedResponse.headers.set("X-Content-Type-Options", "nosniff");
      modifiedResponse.headers.set("Access-Control-Allow-Origin", "*");
      modifiedResponse.headers.set(
        "Access-Control-Allow-Methods",
        "GET, POST, PUT, DELETE, OPTIONS"
      );
      modifiedResponse.headers.set(
        "Access-Control-Allow-Headers",
        "Content-Type, Authorization"
      );

      return modifiedResponse;
    }

    // All other routes pass through normally
    return await fetch(request);
  } catch (error) {
    console.error("Worker error:", error);

    // Return user-friendly error response
    return new Response(
      "Proxy Error: Unable to fetch content. Please try again later.",
      {
        status: 502,
        statusText: "Bad Gateway",
        headers: {
          "Content-Type": "text/plain",
          "Cache-Control": "no-cache",
        },
      }
    );
  }
}