@caelo-cms/shared 0.10.48 → 0.10.50

package/src/redirect-emit.test.ts

@@ -0,0 +1,291 @@
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * #587 — the per-provider emitters of the redirect plan: Caddy snippet,
+ * GCP URL-map path rules, CloudFront KeyValueStore + function, Front Door
+ * rules. (The Caddy snippet also runs through a real Caddy in
+ * packages/provisioning/src/caddy-redirects.docker.test.ts.)
+ */
+
+import { describe, expect, it } from "bun:test";
+import { caddyRedirectsImport, emitCaddyRedirects } from "./redirect-emit-caddy.js";
+import {
+  CLOUDFRONT_KVS_MAX_KEY_BYTES,
+  CloudFrontKvsLimitError,
+  cloudFrontKeyValueEntries,
+  cloudFrontRedirectFunctionCode,
+} from "./redirect-emit-cloudfront.js";
+import {
+  FRONT_DOOR_MAX_RULES,
+  FrontDoorRuleLimitError,
+  frontDoorRedirectRules,
+} from "./redirect-emit-front-door.js";
+import {
+  assertGcpRedirectBudget,
+  GCP_PUBLIC_BASE_PATHS,
+  GcpUrlMapBudgetError,
+  gcpRedirectPathRules,
+  withGcpRedirects,
+} from "./redirect-emit-gcp.js";
+import { buildRedirectPlan, type RedirectPlan, type RedirectTableRow } from "./redirect-plan.js";
+
+const planOf = (rows: RedirectTableRow[]): RedirectPlan =>
+  buildRedirectPlan({ rows, pageUrlStyle: "directory", servedFiles: new Set() });
+const row = (fromPath: string, toPath: string, statusCode = 301): RedirectTableRow => ({
+  fromPath,
+  toPath,
+  statusCode,
+});
+const PLAN = planOf([
+  row("/old", "/new"),
+  row("/promo.html", "/sale", 302),
+  row("/q", "/t?a=1", 308),
+  row("/gone", "/410", 410),
+]);
+const EMPTY = planOf([]);
+
+describe("emitCaddyRedirects", () => {
+  it("maps every match path to target + status and redirects per status", () => {
+    expect(emitCaddyRedirects(PLAN)).toBe(
+      [
+        "# Auto-generated by Caelo static-generator from the redirects table. Do not edit.",
+        "map {path} {caelo_redirect_to} {caelo_redirect_status} {",
+        "\t/old /new/{?query} 301",
+        "\t/old/ /new/{?query} 301",
+        "\t/promo.html /sale/{?query} 302",
+        "\t/q /t?a=1 308",
+        "\t/q/ /t?a=1 308",
+        "\t/gone - 410",
+        "\t/gone/ - 410",
+        "}",
+        "@caelo_redirect_301 vars {caelo_redirect_status} 301",
+        "redir @caelo_redirect_301 {caelo_redirect_to} 301",
+        "@caelo_redirect_302 vars {caelo_redirect_status} 302",
+        "redir @caelo_redirect_302 {caelo_redirect_to} 302",
+        "@caelo_redirect_308 vars {caelo_redirect_status} 308",
+        "redir @caelo_redirect_308 {caelo_redirect_to} 308",
+        "@caelo_gone vars {caelo_redirect_status} 410",
+        "handle @caelo_gone {",
+        "\trespond 410",
+        "}",
+        "",
+      ].join("\n"),
+    );
+  });
+
+  it("emits only the header for an empty plan (a valid empty import)", () => {
+    expect(emitCaddyRedirects(EMPTY)).toBe(
+      "# Auto-generated by Caelo static-generator from the redirects table. Do not edit.\n",
+    );
+  });
+
+  it("refuses characters a Caddyfile token cannot carry", () => {
+    expect(() => emitCaddyRedirects(planOf([row("/a{b}", "/c")]))).toThrow(/'\{' is '%7B'/);
+    expect(() => emitCaddyRedirects(planOf([row("/a", '/c"d')]))).toThrow(/Caddyfile/);
+  });
+
+  it("imports the snippet with a wildcard so a site root without a build still starts", () => {
+    expect(caddyRedirectsImport("/srv/caelo/output/production/current/")).toBe(
+      "import /srv/caelo/output/production/current/_redirects.caddy*",
+    );
+  });
+});
+
+describe("GCP URL-map rules", () => {
+  it("emits one urlRedirect path rule per redirect, keeping the query", () => {
+    const plan = planOf([
+      row("/old", "/new"),
+      row("/promo.html", "/sale", 302),
+      row("/x", "/y", 307),
+    ]);
+    expect(gcpRedirectPathRules(plan)).toEqual([
+      {
+        paths: ["/old", "/old/"],
+        urlRedirect: {
+          pathRedirect: "/new/",
+          redirectResponseCode: "MOVED_PERMANENTLY_DEFAULT",
+          stripQuery: false,
+        },
+      },
+      {
+        paths: ["/promo.html"],
+        urlRedirect: { pathRedirect: "/sale/", redirectResponseCode: "FOUND", stripQuery: false },
+      },
+      {
+        paths: ["/x", "/x/"],
+        urlRedirect: {
+          pathRedirect: "/y/",
+          redirectResponseCode: "TEMPORARY_REDIRECT",
+          stripQuery: false,
+        },
+      },
+    ]);
+  });
+
+  it("refuses what a URL map cannot express", () => {
+    expect(() => gcpRedirectPathRules(planOf([row("/a*", "/b")]))).toThrow(/wildcard/);
+    expect(() => gcpRedirectPathRules(planOf([row("/a", "/b?x=1")]))).toThrow(/query string/);
+  });
+
+  it("replaces earlier redirect rules and keeps the stack's routing first", () => {
+    const api = { paths: ["/api/*"], service: "gateway" };
+    const stale = { paths: ["/stale"], urlRedirect: { pathRedirect: "/x/" } };
+    const out = withGcpRedirects(
+      { name: "public", defaultService: "bucket", pathRules: [api, stale] },
+      planOf([row("/old", "/new")]),
+    );
+    expect(out.defaultService).toBe("bucket");
+    expect(out.pathRules?.map((r) => r.paths)).toEqual([["/api/*"], ["/old", "/old/"]]);
+  });
+
+  it("an empty plan removes every redirect rule", () => {
+    const out = withGcpRedirects(
+      {
+        name: "public",
+        pathRules: [
+          { paths: ["/api/*"], service: "g" },
+          { paths: ["/a"], urlRedirect: {} },
+        ],
+      },
+      EMPTY,
+    );
+    expect(out.pathRules).toEqual([{ paths: ["/api/*"], service: "g" }]);
+  });
+
+  it("refuses a plan over the 1,000-predicate quota with the counts, before any change", () => {
+    const base = [{ paths: [...GCP_PUBLIC_BASE_PATHS] }];
+    const rows = (n: number) => Array.from({ length: n }, (_, i) => row(`/p${i}`, "/x"));
+    expect(() => assertGcpRedirectBudget(planOf(rows(499)), base)).not.toThrow();
+    try {
+      assertGcpRedirectBudget(planOf(rows(500)), base);
+      throw new Error("expected GcpUrlMapBudgetError");
+    } catch (e) {
+      expect(e).toBeInstanceOf(GcpUrlMapBudgetError);
+      expect((e as GcpUrlMapBudgetError).predicatesNeeded).toBe(1001);
+      expect((e as Error).message).toContain("500 redirect(s) need 1001 paths");
+      expect((e as Error).message).toContain("bulk_delete_redirects");
+    }
+    // File-like paths cost one predicate each.
+    const files = Array.from({ length: 999 }, (_, i) => row(`/p${i}.html`, "/x"));
+    expect(() => assertGcpRedirectBudget(planOf(files), base)).not.toThrow();
+  });
+
+  it("refuses a path matcher using routeRules (changed outside the stack)", () => {
+    expect(() => withGcpRedirects({ name: "public", routeRules: [{}] }, EMPTY)).toThrow(
+      /routeRules/,
+    );
+  });
+});
+
+describe("CloudFront KeyValueStore + function", () => {
+  it("stores one entry per match path, sorted", () => {
+    expect(cloudFrontKeyValueEntries(PLAN)).toEqual([
+      { key: "/gone", value: '{"s":410}' },
+      { key: "/gone/", value: '{"s":410}' },
+      { key: "/old", value: '{"s":301,"l":"/new/","q":1}' },
+      { key: "/old/", value: '{"s":301,"l":"/new/","q":1}' },
+      { key: "/promo.html", value: '{"s":302,"l":"/sale/","q":1}' },
+      { key: "/q", value: '{"s":308,"l":"/t?a=1"}' },
+      { key: "/q/", value: '{"s":308,"l":"/t?a=1"}' },
+    ]);
+  });
+
+  it("refuses a plan over the store limits", () => {
+    const long = `/${"a".repeat(CLOUDFRONT_KVS_MAX_KEY_BYTES)}`;
+    expect(() => cloudFrontKeyValueEntries(planOf([row(long, "/x")]))).toThrow(
+      CloudFrontKvsLimitError,
+    );
+    const many = Array.from({ length: 30_000 }, (_, i) =>
+      row(`/${String(i).padStart(60, "0")}`, `/${"t".repeat(60)}`),
+    );
+    expect(() => cloudFrontKeyValueEntries(planOf(many))).toThrow(/a store holds 5242880/);
+  });
+
+  it("the function answers stored paths and passes the rest through", async () => {
+    const entries = new Map(cloudFrontKeyValueEntries(PLAN).map((e) => [e.key, e.value]));
+    const kvsIds: string[] = [];
+    const cf = {
+      kvs(id: string) {
+        kvsIds.push(id);
+        return {
+          async get(key: string, opts: { format: string }) {
+            expect(opts.format).toBe("json");
+            const v = entries.get(key);
+            if (v === undefined) throw new Error(`The key ${key} does not exist`);
+            return JSON.parse(v);
+          },
+        };
+      },
+    };
+    const code = cloudFrontRedirectFunctionCode("abc-123");
+    expect(code.startsWith("import cf from 'cloudfront';")).toBe(true);
+    const handler = new Function(
+      "cf",
+      `${code.replace("import cf from 'cloudfront';", "")}\nreturn handler;`,
+    )(cf) as (e: unknown) => Promise<Record<string, unknown>>;
+    expect(kvsIds).toEqual(["abc-123"]);
+    const req = (uri: string, query = "") => ({
+      request: { uri, rawQueryString: () => query },
+    });
+
+    expect(await handler(req("/old/", "utm=x&y=1"))).toEqual({
+      statusCode: 301,
+      statusDescription: "Moved Permanently",
+      headers: { location: { value: "/new/?utm=x&y=1" } },
+    });
+    expect(await handler(req("/q", "dropped=1"))).toEqual({
+      statusCode: 308,
+      statusDescription: "Permanent Redirect",
+      headers: { location: { value: "/t?a=1" } },
+    });
+    expect(await handler(req("/promo.html"))).toMatchObject({
+      statusCode: 302,
+      headers: { location: { value: "/sale/" } },
+    });
+    expect(await handler(req("/gone"))).toEqual({ statusCode: 410, statusDescription: "Gone" });
+    const passthrough = req("/live/");
+    expect(await handler(passthrough)).toBe(passthrough.request);
+  });
+
+  it("refuses something that is not a store id in the generated code", () => {
+    expect(() => cloudFrontRedirectFunctionCode("x'); evil('")).toThrow(/not a KeyValueStore id/);
+  });
+});
+
+describe("Front Door rules", () => {
+  it("emits one UrlPath + UrlRedirect rule per redirect", () => {
+    const rules = frontDoorRedirectRules(PLAN);
+    expect(rules.map((r) => [r.ruleName, r.order])).toEqual([
+      ["caeloRedirect1", 1],
+      ["caeloRedirect2", 2],
+      ["caeloRedirect3", 3],
+    ]);
+    expect(rules[0]?.conditions[0].parameters.matchValues).toEqual(["old", "old/"]);
+    expect(rules[0]?.actions[0].parameters).toEqual({
+      typeName: "DeliveryRuleUrlRedirectActionParameters",
+      redirectType: "Moved",
+      destinationProtocol: "MatchRequest",
+      customPath: "/new/",
+    });
+    expect(rules[1]?.actions[0].parameters.redirectType).toBe("Found");
+    expect(rules[2]?.actions[0].parameters).toMatchObject({
+      redirectType: "PermanentRedirect",
+      customPath: "/t",
+      customQueryString: "a=1",
+    });
+  });
+
+  it("replaces the visitor's query for a fragment-only target", () => {
+    const [rule] = frontDoorRedirectRules(planOf([row("/a", "/b#top")]));
+    expect(rule?.actions[0].parameters).toMatchObject({
+      customPath: "/b",
+      customQueryString: "",
+      customFragment: "top",
+    });
+  });
+
+  it("refuses more redirects than a route holds", () => {
+    const rows = Array.from({ length: FRONT_DOOR_MAX_RULES + 1 }, (_, i) => row(`/p${i}`, "/x"));
+    expect(() => frontDoorRedirectRules(planOf(rows))).toThrow(FrontDoorRuleLimitError);
+  });
+});

package/src/redirect-plan.test.ts

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * #587 — the redirect plan every provider serves: exact paths, the build
+ * wins, chains collapse, loops and unservable rows fail loudly.
+ */
+
+import { describe, expect, it } from "bun:test";
+import {
+  buildRedirectPlan,
+  formatRedirectsFile,
+  parseRedirectsFile,
+  type RedirectTableRow,
+} from "./redirect-plan.js";
+
+const NO_FILES: ReadonlySet<string> = new Set();
+const plan = (rows: RedirectTableRow[], servedFiles = NO_FILES, style = "directory" as const) =>
+  buildRedirectPlan({ rows, pageUrlStyle: style, servedFiles });
+const row = (fromPath: string, toPath: string, statusCode = 301): RedirectTableRow => ({
+  fromPath,
+  toPath,
+  statusCode,
+});
+
+describe("parseRedirectsFile / formatRedirectsFile", () => {
+  it("round-trips the generator's file", () => {
+    const rows = [row("/a", "/b"), row("/gone", "/410", 410)];
+    expect(parseRedirectsFile(formatRedirectsFile(rows))).toEqual(rows);
+  });
+
+  it("skips comments and blank lines, fails loudly on a malformed line", () => {
+    expect(parseRedirectsFile("# x\n\n/a /b 302\n")).toEqual([row("/a", "/b", 302)]);
+    expect(() => parseRedirectsFile("/a /b\n")).toThrow(/line 1 is not/);
+    expect(() => parseRedirectsFile("/a /b x\n")).toThrow(/line 1 is not/);
+  });
+});
+
+describe("buildRedirectPlan", () => {
+  it("matches a page path with and without the slash, a file-like path and the root as written", () => {
+    const p = plan([row("/old", "/new"), row("/old.html", "/new.pdf"), row("/", "/de", 302)]);
+    expect(p.redirects.map((r) => r.matchPaths)).toEqual([["/old", "/old/"], ["/old.html"], ["/"]]);
+  });
+
+  it("points page targets at the directory URL in the directory style only", () => {
+    const rows = [row("/a", "/b"), row("/c", "/d.pdf"), row("/e", "/f?x=1"), row("/g", "/h/")];
+    expect(plan(rows).redirects.map((r) => r.location)).toEqual(["/b/", "/d.pdf", "/f?x=1", "/h/"]);
+    expect(
+      buildRedirectPlan({
+        rows,
+        pageUrlStyle: "no-extension",
+        servedFiles: NO_FILES,
+      }).redirects.map((r) => r.location),
+    ).toEqual(["/b", "/d.pdf", "/f?x=1", "/h/"]);
+  });
+
+  it("keeps the visitor's query only when the target has no query or fragment", () => {
+    const p = plan([row("/a", "/b"), row("/c", "/d?x"), row("/e", "/f#top")]);
+    expect(p.redirects.map((r) => r.preserveQuery)).toEqual([true, false, false]);
+  });
+
+  it("normalises a stored trailing slash", () => {
+    expect(plan([row("/old/", "/new")]).redirects[0]?.fromPath).toBe("/old");
+  });
+
+  it("leaves out rows whose from path a build file serves (#575)", () => {
+    const p = plan(
+      [row("/preise", "/de/preise"), row("/de/preise", "/preise"), row("/", "/de", 302)],
+      new Set(["index.html", "preise/index.html"]),
+    );
+    expect(p.shadowedByBuild).toEqual(["/preise", "/"]);
+    expect(p.redirects.map((r) => [r.fromPath, r.location])).toEqual([["/de/preise", "/preise/"]]);
+    const noExt = buildRedirectPlan({
+      rows: [row("/preise", "/x")],
+      pageUrlStyle: "no-extension",
+      servedFiles: new Set(["preise"]),
+    });
+    expect(noExt.redirects).toEqual([]);
+  });
+
+  it("collapses chains and combines the statuses", () => {
+    const p = plan([
+      row("/a", "/b", 301),
+      row("/b", "/c", 308),
+      row("/c", "/d", 308),
+      row("/x", "/y", 302),
+      row("/y", "/z", 301),
+      row("/m", "/n", 307),
+      row("/n", "/o", 308),
+    ]);
+    const byFrom = Object.fromEntries(p.redirects.map((r) => [r.fromPath, r]));
+    expect([byFrom["/a"]?.location, byFrom["/a"]?.statusCode]).toEqual(["/d/", 301]);
+    expect([byFrom["/b"]?.location, byFrom["/b"]?.statusCode]).toEqual(["/d/", 308]);
+    expect([byFrom["/x"]?.location, byFrom["/x"]?.statusCode]).toEqual(["/z/", 302]);
+    expect([byFrom["/m"]?.location, byFrom["/m"]?.statusCode]).toEqual(["/o/", 307]);
+  });
+
+  it("follows a chain through a target written with a trailing slash", () => {
+    expect(plan([row("/a", "/b/"), row("/b", "/c")]).redirects[0]?.location).toBe("/c/");
+  });
+
+  it("stops a chain at a row the build shadows, at a gone row and at a target with a query", () => {
+    const p = plan(
+      [row("/a", "/b"), row("/b", "/c"), row("/g", "/gone"), row("/gone", "/410", 410)],
+      new Set(["b/index.html"]),
+    );
+    expect(p.redirects.map((r) => [r.fromPath, r.location])).toEqual([
+      ["/a", "/b/"],
+      ["/g", "/gone/"],
+    ]);
+    expect(plan([row("/a", "/b?x=1"), row("/b", "/c")]).redirects[0]?.location).toBe("/b?x=1");
+  });
+
+  it("turns 410 rows into gone entries", () => {
+    const p = plan([row("/gone", "/410", 410)]);
+    expect(p.redirects).toEqual([]);
+    expect(p.gone).toEqual([{ fromPath: "/gone", matchPaths: ["/gone", "/gone/"] }]);
+  });
+
+  it("fails loudly on a loop and names it", () => {
+    expect(() => plan([row("/a", "/b"), row("/b", "/c"), row("/c", "/a")])).toThrow(
+      /\/a → \/b → \/c → \/a form a loop/,
+    );
+    expect(() => plan([row("/a", "/a/")])).toThrow(/loop/);
+  });
+
+  it("fails loudly on rows no host can serve", () => {
+    expect(() => plan([row("/a?x=1", "/b")])).toThrow(/'\?' or '#'.*'\/a'/);
+    expect(() => plan([row("/a b", "/b")])).toThrow(/whitespace/);
+    expect(() => plan([row("/a", "/b", 200)])).toThrow(/301, 302, 307, 308 or 410/);
+    expect(() => plan([row("/a", "//evil.example")])).toThrow(/another host/);
+  });
+
+  it("dedupes identical spellings and refuses conflicting ones", () => {
+    expect(plan([row("/a", "/b"), row("/a/", "/b")]).redirects).toHaveLength(1);
+    expect(() => plan([row("/a", "/b"), row("/a/", "/c")])).toThrow(/two redirects answer "\/a"/);
+  });
+
+  it("keeps the rows' order (deterministic output)", () => {
+    const rows = [row("/z", "/1"), row("/a", "/2")];
+    expect(plan(rows).redirects.map((r) => r.fromPath)).toEqual(["/z", "/a"]);
+    expect(plan(rows)).toEqual(plan([...rows]));
+  });
+});