Legacy Confluence Redirect

/**
 * Cloudflare Worker — legacy Confluence URL → Atlassian Cloud search
 *
 * What it does
 * ------------
 * - Handles ALL of these legacy shapes:
 *    1) /pages/viewpage.action?pageId=12345678        -> extract pageId
 *    2) /x/abCD (Confluence tiny link)                -> decode to pageId
 *    3) /display/SPACEKEY/Title+With%2C+Encoding      -> parse space/title
 *    4) Anything else                                 -> use last path segment
 *
 * - If it can resolve a numeric pageId, it looks up {"s":"SPACEKEY","t":"Title"}
 *   from KV (binding name: PAGES) where keys are "pid:<pageId>".
 *   On hit → redirects with ?text=<Title>&spaces=<SPACEKEY>
 *
 * - Redirects to:
 *     https://<new-wiki>.atlassian.net/wiki/search?text=<Title>&spaces=<SPACEKEY>
 *
 * Setup (once)
 * ------------
 * 1) In Cloudflare Dashboard:
 *    Workers & Pages → Storage → KV → Create namespace (e.g. "confluence-pages")
 *    Then bind it to this Worker as KV binding **PAGES**
 *
 * 2) Your KV should contain:
 *    key:   pid:<CONTENTID>
 *    value: {"s":"<SPACEKEY>","t":"<Title>"}   (JSON string)
 *
 * 3) Route example (wrangler.toml or UI Triggers → Routes):
 *   <old-wiki.yourdomain.com>/display/*
 *   <old-wiki.yourdomain.com>/x/*
 *   <old-wiki.yourdomain.com>/pages/viewpage.action*
 *
 * Testing
 * -------
 * curl -I "https://<oldwiki.yourdomain.com>/pages/viewpage.action?pageId=123456789"
 * curl -I "https://<oldwiki.yourdomain.com>/x/abCD"
 *
 * Tuning
 * ------
 * - Set PERMANENT = false while testing (302), then true for final (301).
 * - Set env.DEBUG = "1" (Worker variable) to enable basic logging.
 */

const PERMANENT = true; // true=301 permanent, false=302 temporary while testing

// ---------- Helpers ----------

// Decode Confluence "tiny link" (/x/<code>) to numeric pageId.
// Tiny link is URL-safe base64 of a 4-byte LITTLE-ENDIAN pageId, no padding.
function tinyToId(tiny) {
  // Revert URL-safe alphabet to standard Base64
  let s = tiny.replace(/-/g, "+").replace(/_/g, "/");

  // Confluence may drop padding; if length%4==1, they sometimes pad with 'A'
  if (s.length % 4 === 1) s += "A";
  while (s.length % 4) s += "=";

  const bin = Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
  if (bin.length < 4) return null;

  // 4-byte little-endian to unsigned 32-bit integer
  const id =
    (bin[0] | (bin[1] << 8) | (bin[2] << 16) | ((bin[3] << 24) >>> 0)) >>> 0;
  return id;
}

// Extract pageId from known URL forms: ?pageId=... or /x/<tiny>
function extractPageId(u) {
  const url = new URL(u);

  // 1) /pages/viewpage.action?pageId=123
  const pid = url.searchParams.get("pageId");
  if (pid && /^\d+$/.test(pid)) return Number(pid);

  // 2) /x/kxRAD (allow trailing slash)
  const tinyMatch = url.pathname.match(/^\/x\/([A-Za-z0-9_-]+)\/?$/);
  if (tinyMatch) {
    const id = tinyToId(tinyMatch[1]);
    if (typeof id === "number" && isFinite(id)) return id;
  }

  return null;
}

// Extract /display/<SPACE>/<TITLE...> if available
function extractDisplaySpaceAndTitle(u) {
  const url = new URL(u);
  const m = url.pathname.match(/^\/display\/([^/]+)\/(.+)$/);
  if (!m) return null;

  const spacekey = safeDecodePlusThenUri(m[1]); // typically already plain
  const rawTitle = m[2];

  // Titles in old URLs often have '+' for spaces and % encodings
  const title = safeDecodePlusThenUri(rawTitle);
  return { spacekey, title };
}

// Decode helper: replace '+' with space, then decodeURIComponent safely
function safeDecodePlusThenUri(s) {
  try {
    // '+' represented spaces in many legacy Confluence links
    const withSpaces = s.replace(/\+/g, " ");
    // decode %XX sequences (if any); if invalid, keep as-is
    return decodeURIComponent(withSpaces);
  } catch {
    return s.replace(/\+/g, " ");
  }
}

// Build the Atlassian Cloud search URL:
//   - text: page title
//   - spaces: optional space key (e.g., "~username" or "SPACEKEY")
function buildSearchUrl(text, spaces) {
  const url = new URL("https://<new-wiki>.atlassian.net/wiki/search");
  url.searchParams.set("text", text);
  if (spaces) url.searchParams.set("spaces", spaces);
  return url.toString();
}

// Basic logger controlled by env.DEBUG == "1"
function log(env, ...args) {
  if (env && env.DEBUG === "1") {
    // eslint-disable-next-line no-console
    console.log(...args);
  }
}

// ---------- Worker ----------

export default {
  /**
   * @param {Request} request
   * @param {{ PAGES: KVNamespace, DEBUG?: string }} env  // bind KV as PAGES
   * @param {ExecutionContext} ctx
   */
  async fetch(request, env, ctx) {
    try {
      const url = new URL(request.url);
      // this block of code limits CF worker to respond to request coming from just certain AS (IP ranges)
      const asn = request.cf?.asn;
      const allowedASN = new Set([12345, 67890,]); // your ASNs
      if (!allowedASN.has(asn)) {
        return new Response("Forbidden", { status: 403 });
      }
      //

      // 1) Best path: resolve a numeric pageId (from ?pageId= or /x/<tiny>) and hit KV
      const pageId = extractPageId(request.url);
      if (pageId != null) {
        const kvKey = `pid:${pageId}`;
        // Add null check for env.PAGES to prevent runtime error
        if (env && env.PAGES) {
          const rec = await env.PAGES.get(kvKey, { type: "json" }); // { s: SPACEKEY, t: Title }
          log(env, "KV lookup", kvKey, "→", rec ? "HIT" : "MISS");

          if (rec && rec.s && rec.t) {
            // Use title in ?text= and space key in ?spaces=
            const target = buildSearchUrl(rec.t, rec.s);
            return Response.redirect(target, PERMANENT ? 301 : 302);
          }
        }
      }

      // 2) Next best: if we have /display/<SPACE>/<TITLE>, use both directly
      const display = extractDisplaySpaceAndTitle(request.url);
      if (display) {
        const target = buildSearchUrl(display.title, display.spacekey);
        return Response.redirect(target, PERMANENT ? 301 : 302);
      }

      // 3) Fallback: last non-empty path segment decoded
      const parts = url.pathname.split("/").filter(Boolean);
      const last = parts.length ? parts[parts.length - 1] : "";
      const query = safeDecodePlusThenUri(last);
      const target = buildSearchUrl(query || ""); // text-only fallback
      return Response.redirect(target, PERMANENT ? 301 : 302);
    } catch (err) {
      // Ultimate safety net: send them to search home with a TEMP redirect
      // (Don't 301 unexpected errors, to avoid caching a mistake.)
      return Response.redirect(
        "https://<new-wiki>.atlassian.net/wiki/search",
        302
      );
    }
  },
};