Deploy AXP Edge with Cloudflare

// Publive Publisher Router Worker

const LOOP_GUARD_HEADER = "x-pl-request";
const PREVIEW_HEADER = "x-pl-preview";
const SKIP_UA_HEADER = "x-pl-skip";
const HOST_HEADER = "x-pl-host";
const URL_HEADER = "x-pl-url";
const API_KEY_HEADER = "x-pl-api-key";
const CLIENT_IP_HEADER = "x-pl-client-ip";
const CLIENT_AGENT_HEADER = "x-pl-client-agent";
const PROTOCOL_HEADER = "x-pl-protocol";
const REFERER_HEADER = "x-pl-referer";
const ACCEPT_LANGUAGE_HEADER = "x-pl-accept-language";
const FAILOVER_HEADER = "x-pl-fo";

const AGENT_BOTS = [
  "GPTBot",
  "OAI-SearchBot",
  "ChatGPT-User",
  "ClaudeBot",
  "Claude-User",
  "Claude-SearchBot",
  "Google-Extended",
  "anthropic-ai",
  "PerplexityBot",
  "Perplexity-User"
];

const INBOUND_HEADERS_TO_STRIP = [
  "host",
  API_KEY_HEADER,
  URL_HEADER,
  HOST_HEADER,
  CLIENT_IP_HEADER,
  LOOP_GUARD_HEADER,
  PREVIEW_HEADER
];

const STATIC_FILE_EXTENSIONS = /\.(js|css|map|json|xml|txt|ico|png|jpe?g|gif|svg|webp|avif|woff2?|ttf|eot|otf|mp4|webm|mov|mp3|wav|pdf|zip|rar|7z|gz)$/i;

const FAILOVER_ON_4XX = true;
const FAILOVER_ON_5XX = true;

function debugLog(env, step, data) {
  if (env.PL_EDGE_DEBUG !== "1") return;
  console.log(`[pl-edge:${step}]`, data ? JSON.stringify(data) : "");
}

function isAgenticUA(ua) {
  const lower = ua.toLowerCase();
  return AGENT_BOTS.some((bot) => lower.includes(bot.toLowerCase()));
}

function isHtmlPageRequest(request, pathname) {
  const isGetOrHead = request.method === "GET" || request.method === "HEAD";
  return isGetOrHead && !STATIC_FILE_EXTENSIONS.test(pathname);
}

function isBotUA(request) {
  const skipUA = request.headers.get(SKIP_UA_HEADER) === "1";
  return !skipUA && isAgenticUA(request.headers.get("user-agent") ?? "");
}

// Single decision point: should this request be routed to the backend?
function isEligibleForOptimization(request, url, env) {
  if (url.hostname != env.PL_EDGE_CLIENT_HOST) {
    debugLog(env, "skip:hostname-mismatch", { hostname: url.hostname, expected: env.PL_EDGE_CLIENT_HOST });
    return false;
  }

  const isLoopedRequest = !!request.headers.get(LOOP_GUARD_HEADER);
  if (isLoopedRequest) {
    debugLog(env, "skip:loop-guard");
    return false;
  }

  const preview = request.headers.get(PREVIEW_HEADER) === "1";
  const botMatch = isBotUA(request);
  debugLog(env, "eligibility-check", { preview, botMatch, ua: request.headers.get("user-agent") });

  if (!preview && !botMatch) {
    debugLog(env, "skip:not-preview-not-bot");
    return false;
  }

  if (!isHtmlPageRequest(request, url.pathname)) {
    debugLog(env, "skip:not-html-page", { pathname: url.pathname });
    return false;
  }

  return true;
}

function buildCDSHeaders(request, url, env) {
  const preview = request.headers.get(PREVIEW_HEADER) === "1";
  const headers = new Headers(request.headers);
  INBOUND_HEADERS_TO_STRIP.forEach((k) => headers.delete(k));

  headers.set(HOST_HEADER, env.PL_EDGE_CLIENT_HOST);
  headers.set(URL_HEADER, `${url.pathname}${url.search}`);
  headers.set(API_KEY_HEADER, env.PL_EDGE_API_KEY);
  headers.set(LOOP_GUARD_HEADER, preview ? "preview" : "edge");
  headers.set(CLIENT_IP_HEADER, request.headers.get("cf-connecting-ip") ?? "");
  headers.set(CLIENT_AGENT_HEADER, request.headers.get("user-agent") ?? "");
  headers.set(PROTOCOL_HEADER, url.protocol.replace(/:$/, ""));
  headers.set(ACCEPT_LANGUAGE_HEADER, request.headers.get("accept-language") ?? "");
  const referer = request.headers.get("referer");
  if (referer) headers.set(REFERER_HEADER, referer);
  return headers;
}

function isErrorStatus(status) {
  const is4xx = FAILOVER_ON_4XX && status >= 400 && status < 500;
  const is5xx = FAILOVER_ON_5XX && status >= 500 && status < 600;
  return is4xx || is5xx;
}

async function routeToPublive(request, url, env) {
  if (!env.PL_EDGE_API_KEY || !env.PL_EDGE_BACKEND_URL) {
    console.error("[error] PL_EDGE_API_KEY or PL_EDGE_BACKEND_URL not configured", { path: url.pathname });
    debugLog(env, "skip:missing-config", {
      hasApiKey: !!env.PL_EDGE_API_KEY,
      hasBackendUrl: !!env.PL_EDGE_BACKEND_URL,
    });
    return null;
  }

  const headers = buildCDSHeaders(request, url, env);
  const backendURL = `${env.PL_EDGE_BACKEND_URL}`;
  debugLog(env, "fetching-cds", { backendURL, path: url.pathname });

  try {
    const response = await fetch(
      new Request(backendURL, { method: request.method, headers, redirect: "manual" }),
      { cf: { cacheEverything: false } }
    );

    debugLog(env, "cds-response", { status: response.status });

    if (isErrorStatus(response.status)) {
      console.error("[error] backend responded with error status", { status: response.status, path: url.pathname });
      debugLog(env, "skip:cds-error-status", { status: response.status });
      return null;
    }

    debugLog(env, "success:returning-cds-response");
    return response;
  } catch (err) {
    console.error("[error] backend fetch failed", String(err), { path: url.pathname });
    debugLog(env, "skip:fetch-threw", { error: String(err) });
    return null;
  }
}

async function fetchOrigin(request, env, url, { failover = false } = {}) {
  if (!failover) {
    debugLog(env, "serving-origin-directly");
    return fetch(request);
  }

  const originHost = env.PL_EDGE_CLIENT_HOST ?? url.host;
  const originURL = `https://${originHost}${url.pathname}${url.search}`;
  debugLog(env, "failover-to-origin", { originURL });

  const headers = new Headers(request.headers);
  headers.set("Host", originHost);
  headers.set(LOOP_GUARD_HEADER, "fo");
  try {
    const response = await fetch(new Request(originURL, {
      method: request.method,
      headers,
      body: request.body,
      redirect: "manual",
    }));

    const failoverResponse = new Response(response.body, response);
    failoverResponse.headers.set(FAILOVER_HEADER, "1");
    return failoverResponse;
  } catch (err) {
    console.error("failed in fetching failover", err);
    debugLog(env, "failover-fetch-threw", { error: String(err) });
    return fetch(request);
  }
}

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    debugLog(env, "entry", { path: url.pathname, method: request.method });

    if (!isEligibleForOptimization(request, url, env)) {
      return fetchOrigin(request, env, url);
    }

    const response = await routeToPublive(request, url, env);
    return response ?? fetchOrigin(request, env, url, { failover: true });
  },
};

export { isEligibleForOptimization, routeToPublive, fetchOrigin };