@sproutboat/assets 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @sproutboat/assets
 
+## 0.3.1
+
+### Patch Changes
+
+- d4bbcd5: `_redirects` matching follows Cloudflare's rules. The whole request path must match, so a trailing slash is significant: `/compare /compare/ 308` redirects `/compare` once, and `/compare/` is then served (or matched by a rule of its own) instead of redirecting to itself forever. Before, a rule's `from` was compared segment by segment with the empty ones dropped, so `/compare` also matched `/compare/` and `/user/:id` matched `/user/42/`.
+  
+  What matches, as in Cloudflare's rules engine:
+  
+  - `:name` matches one or more characters up to the next `/`, may sit inside a segment (`/files/:name.html`), and may appear once per rule;
+  - `*` matches anything including `/` and the empty string, is `:splat` in the target, and may sit in the middle of the path (`/a/*/c`); a rule has at most one;
+  - a rule with a repeated name or two splats never matches (Cloudflare drops it);
+  - a static rule (no `:name`, no `*`) beats a dynamic one whatever the order; among rules of one kind the first in the file wins. `findRedirect(rules, pathname)` is the new entry point; `matchRedirect(rule, pathname)` still answers for one rule.
+  
+  This changes what an existing `_redirects` file does for paths that differ only by a trailing slash, with no compatibility date: the edge serves assets before any app code runs and cannot see the date, and the old matching was what looped. Run `bun run test:native-asset-redirects` to check the compiled matcher against the same cases as the portable one.
+
 ## 0.3.0
 
 ### Minor Changes

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@sproutboat/assets",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "license": "MIT",
-  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/baronunread/sproutboat-packages.git",
     "directory": "packages/assets"
   },
+  "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {

package/src/assets.test.ts

@@ -6,9 +6,11 @@ import {
   contentType,
   isSproutFirst,
   matchHeaders,
+  findRedirect,
   matchRedirect,
   parseHeaders,
   parseRedirects,
+  resolveAssetKey,
   readAssetRules,
   walkAssets,
 } from "./assets";
@@ -121,6 +123,54 @@ test("matchRedirect: a trailing * captures the rest of the path as :splat", () =
   expect(matchRedirect(rule, "/blog")).toBeNull();
 });
 
+test("matchRedirect: the whole path must match, so a trailing slash is significant", () => {
+  const add = { from: "/compare", to: "/compare/", status: 308 };
+  expect(matchRedirect(add, "/compare")).toBe("/compare/");
+  expect(matchRedirect(add, "/compare/")).toBeNull(); // the loop: this used to match again
+  const drop = { from: "/compare/", to: "/compare", status: 308 };
+  expect(matchRedirect(drop, "/compare/")).toBe("/compare");
+  expect(matchRedirect(drop, "/compare")).toBeNull();
+  const named = { from: "/user/:id", to: "/profile/:id", status: 302 };
+  expect(matchRedirect(named, "/user/42/")).toBeNull();
+  expect(matchRedirect(named, "/user/")).toBeNull();
+  const splat = { from: "/blog/*", to: "/posts/:splat", status: 301 };
+  expect(matchRedirect(splat, "/blog/a/")).toBe("/posts/a/");
+});
+
+test("matchRedirect: a name is one or more characters, backtracks around text, and the splat may sit in the middle", () => {
+  expect(matchRedirect({ from: "/files/:name.html", to: "/pages/:name", status: 302 }, "/files/about.html")).toBe(
+    "/pages/about",
+  );
+  expect(matchRedirect({ from: "/:a-:b", to: "/x/:b/:a", status: 302 }, "/one-two")).toBe("/x/two/one");
+  expect(matchRedirect({ from: "/a/*/c", to: "/x/:splat", status: 302 }, "/a/b/b2/c")).toBe("/x/b/b2");
+  expect(matchRedirect({ from: "/a/*/c", to: "/x/:splat", status: 302 }, "/a/c")).toBeNull();
+  expect(matchRedirect({ from: "/a:1", to: "/b", status: 302 }, "/a:1")).toBe("/b"); // a colon with no letter is text
+});
+
+test("matchRedirect: a rule with a repeated name or two splats never matches, as on Cloudflare", () => {
+  expect(matchRedirect({ from: "/:a/:a", to: "/x", status: 302 }, "/p/p")).toBeNull();
+  expect(matchRedirect({ from: "/*/*", to: "/x", status: 302 }, "/p/q")).toBeNull();
+});
+
+test("findRedirect: a static rule beats a dynamic one above it; within a kind the first rule wins", () => {
+  const rules = parseRedirects(
+    "/blog/* /dynamic/:splat\n/blog/old /static\n/blog/old /static-2\n/x/:a /first\n/x/:b /second",
+  );
+  expect(findRedirect(rules, "/blog/old")).toEqual({ rule: rules[1], location: "/static" });
+  expect(findRedirect(rules, "/blog/new")).toEqual({ rule: rules[0], location: "/dynamic/new" });
+  expect(findRedirect(rules, "/x/1")).toEqual({ rule: rules[3], location: "/first" });
+  expect(findRedirect(rules, "/nothing")).toBeNull();
+});
+
+test("a trailing-slash rule is one hop against the asset resolver too", () => {
+  const rules = parseRedirects("/compare /compare/ 308");
+  const files = new Set(["/compare/index.html"]);
+  const first = findRedirect(rules, "/compare");
+  expect(first?.location).toBe("/compare/");
+  expect(findRedirect(rules, first!.location)).toBeNull();
+  expect(resolveAssetKey(first!.location, (key) => files.has(key))).toBe("/compare/index.html");
+});
+
 test("readAssetRules: empty when neither file exists, parsed when both do", () => {
   const dir = mkdtempSync(join(tmpdir(), "sb-rules-"));
   expect(readAssetRules(dir)).toEqual({ headers: [], redirects: [] });

package/src/assets.ts

@@ -211,42 +211,103 @@ export function parseRedirects(text: string): RedirectRule[] {
 }
 
 /**
- * Match `pathname` against one `_redirects` rule's `from`, substituting
- * `:name` segments and a trailing `*` (as `:splat`) into `to`. `null` if the
- * rule doesn't match.
+ * Cloudflare's `_redirects` matching (workers-sdk, `asset-worker/src/utils/rules-engine.ts`), on the request pathname:
  *
- * The splat case matches on the literal string prefix up to `*`, not a
- * segment array — `pathname.split("/").filter(Boolean)` would collapse
- * `/blog` and `/blog/` to the same `["blog"]`, wrongly matching `/blog/*`
- * against a path that never reaches the `/` the wildcard starts after.
+ *   - the whole pathname must match, so a trailing slash is significant: `/compare` does not match `/compare/`, and
+ *     `/compare /compare/ 308` is one hop, not a loop;
+ *   - `:name` matches one or more characters up to the next `/` (letters, digits and `_` after a letter name it);
+ *     a name may appear once per rule;
+ *   - `*` matches anything, including `/` and nothing, and is `:splat` in `to`; a rule has at most one;
+ *   - a rule that breaks those limits never matches (Cloudflare drops it).
+ *
+ * A rule with no `:name` and no `*` is static: a static rule beats a dynamic one whatever the order (`findRedirect`);
+ * among rules of one kind the first in the file wins.
  */
-export function matchRedirect(rule: RedirectRule, pathname: string): string | null {
-  const starIndex = rule.from.indexOf("*");
-  if (starIndex !== -1) {
-    const prefix = rule.from.slice(0, starIndex);
-    if (!pathname.startsWith(prefix)) return null;
-    const splat = pathname.slice(prefix.length);
-    return rule.to.split(":splat").join(splat);
+type RedirectToken = { kind: "text"; text: string } | { kind: "name"; name: string } | { kind: "splat" };
+
+function redirectTokens(from: string): RedirectToken[] | null {
+  const tokens: RedirectToken[] = [];
+  const names = new Set<string>();
+  let text = "";
+  const flush = () => {
+    if (text !== "") tokens.push({ kind: "text", text });
+    text = "";
+  };
+  for (let i = 0; i < from.length; i++) {
+    const c = from[i]!;
+    if (c === "*") {
+      flush();
+      if (names.has("splat")) return null;
+      names.add("splat");
+      tokens.push({ kind: "splat" });
+    } else if (c === ":" && /[A-Za-z]/.test(from[i + 1] ?? "")) {
+      let end = i + 2;
+      while (end < from.length && /\w/.test(from[end]!)) end++;
+      const name = from.slice(i + 1, end);
+      if (names.has(name)) return null;
+      names.add(name);
+      flush();
+      tokens.push({ kind: "name", name });
+      i = end - 1;
+    } else text += c;
   }
+  flush();
+  return tokens;
+}
 
-  const fromSegments = rule.from.split("/").filter(Boolean);
-  const pathSegments = pathname.split("/").filter(Boolean);
-  if (fromSegments.length !== pathSegments.length) return null;
-  const params: Record<string, string> = {};
-  for (let i = 0; i < fromSegments.length; i++) {
-    const segment = fromSegments[i];
-    if (segment.startsWith(":")) {
-      params[segment.slice(1)] = pathSegments[i];
-      continue;
-    }
-    if (pathSegments[i] !== segment) return null;
+function matchTokens(tokens: RedirectToken[], t: number, path: string, p: number, groups: [string, string][]): boolean {
+  const token = tokens[t];
+  if (token === undefined) return p === path.length;
+  if (token.kind === "text")
+    return path.startsWith(token.text, p) && matchTokens(tokens, t + 1, path, p + token.text.length, groups);
+  const slash = path.indexOf("/", p);
+  const limit = token.kind === "splat" || slash === -1 ? path.length : slash;
+  const name = token.kind === "splat" ? "splat" : token.name;
+  // Longest first, as the regular expression `[^/]+` / `.*` is greedy; a name needs at least one character.
+  for (let q = limit; q >= (token.kind === "splat" ? p : p + 1); q--) {
+    groups.push([name, path.slice(p, q)]);
+    if (matchTokens(tokens, t + 1, path, q, groups)) return true;
+    groups.pop();
   }
+  return false;
+}
+
+const isStaticRedirect = (from: string): boolean => !from.includes("*") && !/:[A-Za-z]/.test(from);
 
+function redirectLocation(rule: RedirectRule, pathname: string): string | null {
+  if (isStaticRedirect(rule.from)) return rule.from === pathname ? rule.to : null;
+  const tokens = redirectTokens(rule.from);
+  if (tokens === null) return null;
+  const groups: [string, string][] = [];
+  if (!matchTokens(tokens, 0, pathname, 0, groups)) return null;
   let to = rule.to;
-  for (const [name, value] of Object.entries(params)) to = to.split(`:${name}`).join(value);
+  for (const [name, value] of groups) to = to.split(`:${name}`).join(value);
   return to;
 }
 
+/**
+ * Where one `_redirects` rule sends `pathname`, with `:name` and `:splat` substituted into `to`; `null` if the rule does
+ * not match. See the notes above for what matches.
+ */
+export function matchRedirect(rule: RedirectRule, pathname: string): string | null {
+  return redirectLocation(rule, pathname);
+}
+
+/** The rule that redirects `pathname`, and where to: the first static rule that matches, else the first dynamic one. */
+export function findRedirect(
+  rules: readonly RedirectRule[],
+  pathname: string,
+): { rule: RedirectRule; location: string } | null {
+  for (const rule of rules)
+    if (isStaticRedirect(rule.from) && rule.from === pathname) return { rule, location: rule.to };
+  for (const rule of rules) {
+    if (isStaticRedirect(rule.from)) continue;
+    const location = redirectLocation(rule, pathname);
+    if (location !== null) return { rule, location };
+  }
+  return null;
+}
+
 export type AssetRules = { headers: HeaderRule[]; redirects: RedirectRule[] };
 
 /** Read and parse `_headers`/`_redirects` from the assets root, if present. */