@sigil-dev/grimoire 0.7.4 → 0.7.6

package/test/routing.test.ts

@@ -1,45 +1,83 @@
-import { describe, expect, test } from "bun:test";
-import { matchRoute } from "../src/routing/router";
-import type { RouteFile, RouteTree } from "../src/routing/scanner";
-
-const makeRoute = (path: string, type: RouteFile["type"]): RouteFile => ({
-	path,
-	filePath: `/app/routes${path}`,
-	type,
-	paramNames: path
-		.split("/")
-		.filter((p) => p.startsWith(":"))
-		.map((p) => p.slice(1)),
-});
-
-const tree: RouteTree = {
-	routes: [
-		makeRoute("/", "page"),
-		makeRoute("/about", "simple"),
-		makeRoute("/blog", "page"),
-		makeRoute("/blog/:slug", "page"),
-		makeRoute("/blog/:slug", "pageServer"),
-	],
-	layouts: [makeRoute("/", "layout"), makeRoute("/blog", "layout")],
-	servers: [makeRoute("/api/todos", "server")],
-	errors: [],
-};
-
-describe("matchRoute", () => {
-	test("matches static route", () => {
-		const match = matchRoute(tree, new URL("http://localhost/about"));
-		expect(match?.route.path).toBe("/about");
-		expect(match?.params).toEqual({});
-	});
-
-	test("matches dynamic route and extracts params", () => {
-		const match = matchRoute(tree, new URL("http://localhost/blog/hello"));
-		expect(match?.route.path).toBe("/blog/:slug");
-		expect(match?.params).toEqual({ slug: "hello" });
-	});
-
-	test("returns null for unknown route", () => {
-		const match = matchRoute(tree, new URL("http://localhost/unknown"));
-		expect(match).toBeNull();
-	});
-});
+import { describe, expect, test } from "bun:test";
+import { matchRoute } from "../src/routing/router";
+import type { RouteFile, RouteTree } from "../src/routing/scanner";
+
+const makeRoute = (path: string, type: RouteFile["type"]): RouteFile => ({
+	path,
+	filePath: `/app/routes${path}`,
+	type,
+	paramNames: path
+		.split("/")
+		.filter((p) => p.startsWith(":"))
+		.map((p) => p.slice(1)),
+	restParamNames: path
+		.split("/")
+		.filter((p) => p.startsWith("*"))
+		.map((p) => p.slice(1)),
+});
+
+const tree: RouteTree = {
+	routes: [
+		makeRoute("/", "page"),
+		makeRoute("/about", "simple"),
+		makeRoute("/blog", "page"),
+		makeRoute("/blog/:slug", "page"),
+		makeRoute("/blog/:slug", "pageServer"),
+	],
+	layouts: [makeRoute("/", "layout"), makeRoute("/blog", "layout")],
+	servers: [makeRoute("/api/todos", "server")],
+	errors: [],
+};
+
+describe("matchRoute", () => {
+	test("matches static route", () => {
+		const match = matchRoute(tree, new URL("http://localhost/about"));
+		expect(match?.route.path).toBe("/about");
+		expect(match?.params).toEqual({});
+	});
+
+	test("matches dynamic route and extracts params", () => {
+		const match = matchRoute(tree, new URL("http://localhost/blog/hello"));
+		expect(match?.route.path).toBe("/blog/:slug");
+		expect(match?.params).toEqual({ slug: "hello" });
+	});
+
+	test("returns null for unknown route", () => {
+		const match = matchRoute(tree, new URL("http://localhost/unknown"));
+		expect(match).toBeNull();
+	});
+});
+
+describe("matchRoute — rest params (catch-all)", () => {
+	const restTree: RouteTree = {
+		routes: [],
+		layouts: [],
+		servers: [
+			makeRoute("/docs/*path", "server"),
+		],
+		errors: [],
+	};
+
+	test("matches single remaining segment", () => {
+		const match = matchRoute(restTree, new URL("http://localhost/docs/abc"));
+		expect(match?.route.path).toBe("/docs/*path");
+		expect(match?.params).toEqual({ path: "abc" });
+	});
+
+	test("matches multiple remaining segments joined by /", () => {
+		const match = matchRoute(restTree, new URL("http://localhost/docs/a/b/c"));
+		expect(match?.route.path).toBe("/docs/*path");
+		expect(match?.params).toEqual({ path: "a/b/c" });
+	});
+
+	test("matches zero remaining segments as empty string", () => {
+		const match = matchRoute(restTree, new URL("http://localhost/docs/"));
+		expect(match?.route.path).toBe("/docs/*path");
+		expect(match?.params).toEqual({ path: "" });
+	});
+
+	test("does not match when prefix segments don't line up", () => {
+		const match = matchRoute(restTree, new URL("http://localhost/other/a"));
+		expect(match).toBeNull();
+	});
+});

package/test/scanning.test.ts

@@ -1,169 +1,181 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdir, rm, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-import { filePathToRoutePath, scanRoutes } from "../src/routing/scanner";
-
-describe("File scanning", () => {
-	test("index.tsx → /", () => {
-		expect(filePathToRoutePath("/app/routes/index.tsx", "/app/routes")).toEqual(
-			{ pattern: "/", params: [] },
-		);
-	});
-
-	test("about.tsx → /about", () => {
-		expect(filePathToRoutePath("/app/routes/about.tsx", "/app/routes")).toEqual(
-			{ pattern: "/about", params: [] },
-		);
-	});
-
-	test("[slug].tsx → /:slug", () => {
-		expect(
-			filePathToRoutePath("/app/routes/[slug].tsx", "/app/routes"),
-		).toEqual({ pattern: "/:slug", params: ["slug"] });
-	});
-
-	test("blog/+page.tsx → /blog", () => {
-		expect(
-			filePathToRoutePath("/app/routes/blog/+page.tsx", "/app/routes"),
-		).toEqual({ pattern: "/blog", params: [] });
-	});
-
-	test("blog/[slug]/+page.tsx → /blog/:slug", () => {
-		expect(
-			filePathToRoutePath("/app/routes/blog/[slug]/+page.tsx", "/app/routes"),
-		).toEqual({ pattern: "/blog/:slug", params: ["slug"] });
-	});
-
-	test("blog/[slug]/+page.server.ts → /blog/:slug", () => {
-		expect(
-			filePathToRoutePath(
-				"/app/routes/blog/[slug]/+page.server.ts",
-				"/app/routes",
-			),
-		).toEqual({ pattern: "/blog/:slug", params: ["slug"] });
-	});
-
-	test("+layout.tsx → /", () => {
-		expect(
-			filePathToRoutePath("/app/routes/+layout.tsx", "/app/routes"),
-		).toEqual({ pattern: "/", params: [] });
-	});
-
-	test("nested +layout.tsx → /blog", () => {
-		expect(
-			filePathToRoutePath("/app/routes/blog/+layout.tsx", "/app/routes"),
-		).toEqual({ pattern: "/blog", params: [] });
-	});
-
-	test("about/index.tsx, about/+page.tsx, and about.tsx all resolve to /about", () => {
-		const index = filePathToRoutePath(
-			"/app/routes/about/index.tsx",
-			"/app/routes",
-		);
-		const page = filePathToRoutePath(
-			"/app/routes/about/+page.tsx",
-			"/app/routes",
-		);
-		const bare = filePathToRoutePath("/app/routes/about.tsx", "/app/routes");
-		expect(index.pattern).toBe("/about");
-		expect(page.pattern).toBe("/about");
-		expect(bare.pattern).toBe("/about");
-	});
-
-	test("+server.ts resolves to the same path as +page.tsx", () => {
-		const server = filePathToRoutePath(
-			"/app/routes/api/items/+server.ts",
-			"/app/routes",
-		);
-		expect(server.pattern).toBe("/api/items");
-	});
-
-	test("+error.tsx resolves to its directory path", () => {
-		const root = filePathToRoutePath("/app/routes/+error.tsx", "/app/routes");
-		const nested = filePathToRoutePath(
-			"/app/routes/blog/+error.tsx",
-			"/app/routes",
-		);
-		expect(root.pattern).toBe("/");
-		expect(nested.pattern).toBe("/blog");
-	});
-});
-
-describe("Duplicate route detection", () => {
-	let tmpDir: string;
-
-	beforeAll(async () => {
-		tmpDir = join(tmpdir(), `grimoire-scan-${Date.now()}`);
-		await mkdir(tmpDir, { recursive: true });
-	});
-
-	afterAll(async () => {
-		await rm(tmpDir, { recursive: true });
-	});
-
-	test("throws when two page files resolve to the same path", async () => {
-		const dir = join(tmpDir, "dup-pages");
-		await mkdir(join(dir, "about"), { recursive: true });
-		await writeFile(join(dir, "about.tsx"), "export default () => null");
-		await writeFile(
-			join(dir, "about", "index.tsx"),
-			"export default () => null",
-		);
-		await expect(scanRoutes(dir)).rejects.toThrow('Duplicate page at "/about"');
-	});
-
-	test("+page.tsx and +page.server.ts at the same path do NOT conflict", async () => {
-		const dir = join(tmpDir, "no-conflict");
-		await mkdir(join(dir, "blog"), { recursive: true });
-		await writeFile(
-			join(dir, "blog", "+page.tsx"),
-			"export default () => null",
-		);
-		await writeFile(
-			join(dir, "blog", "+page.server.ts"),
-			"export async function load() {}",
-		);
-		await expect(scanRoutes(dir)).resolves.toBeDefined();
-	});
-
-	test("throws when two API routes resolve to the same path", async () => {
-		const dir = join(tmpDir, "dup-server");
-		await mkdir(join(dir, "api", "items"), { recursive: true });
-		// Bun glob finds all files; we simulate two +server files at same path via subdirs
-		// Use two different nesting depths that produce the same URL
-		await mkdir(join(dir, "api2"), { recursive: true });
-		await writeFile(
-			join(dir, "api2", "+server.ts"),
-			"export async function GET() {}",
-		);
-		await mkdir(join(dir, "api2", "index"), { recursive: true });
-		// Can't easily duplicate +server.ts via nesting — test the named-file vs +server collision instead
-		// Two +server.ts under different folder structures that map to same URL isn't possible without
-		// [param] collisions, so verify a simple valid tree is fine
-		await expect(scanRoutes(dir)).resolves.toBeDefined();
-	});
-
-	test("throws when two error pages resolve to the same path", async () => {
-		const dir = join(tmpDir, "dup-error");
-		await mkdir(join(dir, "blog"), { recursive: true });
-		// Two +error.tsx at root level isn't possible via filesystem (same filename).
-		// The real collision scenario is two dynamic segments mapping to the same pattern.
-		// Test that a single error page is accepted without error.
-		await writeFile(join(dir, "+error.tsx"), "export default () => null");
-		await expect(scanRoutes(dir)).resolves.toBeDefined();
-	});
-
-	test("throws when a simple file and +page.tsx both resolve to the same path", async () => {
-		const dir = join(tmpDir, "dup-mixed");
-		await mkdir(join(dir, "contact"), { recursive: true });
-		await writeFile(join(dir, "contact.tsx"), "export default () => null");
-		await writeFile(
-			join(dir, "contact", "+page.tsx"),
-			"export default () => null",
-		);
-		await expect(scanRoutes(dir)).rejects.toThrow(
-			'Duplicate page at "/contact"',
-		);
-	});
-});
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdir, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { filePathToRoutePath, scanRoutes } from "../src/routing/scanner";
+
+describe("File scanning", () => {
+	test("index.tsx → /", () => {
+		expect(filePathToRoutePath("/app/routes/index.tsx", "/app/routes")).toEqual(
+			{ pattern: "/", params: [], restParams: [] },
+		);
+	});
+
+	test("about.tsx → /about", () => {
+		expect(filePathToRoutePath("/app/routes/about.tsx", "/app/routes")).toEqual(
+			{ pattern: "/about", params: [], restParams: [] },
+		);
+	});
+
+	test("[slug].tsx → /:slug", () => {
+		expect(
+			filePathToRoutePath("/app/routes/[slug].tsx", "/app/routes"),
+		).toEqual({ pattern: "/:slug", params: ["slug"], restParams: [] });
+	});
+
+	test("blog/+page.tsx → /blog", () => {
+		expect(
+			filePathToRoutePath("/app/routes/blog/+page.tsx", "/app/routes"),
+		).toEqual({ pattern: "/blog", params: [], restParams: [] });
+	});
+
+	test("blog/[slug]/+page.tsx → /blog/:slug", () => {
+		expect(
+			filePathToRoutePath("/app/routes/blog/[slug]/+page.tsx", "/app/routes"),
+		).toEqual({ pattern: "/blog/:slug", params: ["slug"], restParams: [] });
+	});
+
+	test("blog/[slug]/+page.server.ts → /blog/:slug", () => {
+		expect(
+			filePathToRoutePath(
+				"/app/routes/blog/[slug]/+page.server.ts",
+				"/app/routes",
+			),
+		).toEqual({ pattern: "/blog/:slug", params: ["slug"], restParams: [] });
+	});
+
+	test("+layout.tsx → /", () => {
+		expect(
+			filePathToRoutePath("/app/routes/+layout.tsx", "/app/routes"),
+		).toEqual({ pattern: "/", params: [], restParams: [] });
+	});
+
+	test("nested +layout.tsx → /blog", () => {
+		expect(
+			filePathToRoutePath("/app/routes/blog/+layout.tsx", "/app/routes"),
+		).toEqual({ pattern: "/blog", params: [], restParams: [] });
+	});
+
+	test("[...rest].tsx → /*rest (catch-all)", () => {
+		expect(
+			filePathToRoutePath("/app/routes/[...rest].tsx", "/app/routes"),
+		).toEqual({ pattern: "/*rest", params: [], restParams: ["rest"] });
+	});
+
+	test("docs/[...path]/+server.ts → /docs/*path (nested catch-all)", () => {
+		expect(
+			filePathToRoutePath("/app/routes/docs/[...path]/+server.ts", "/app/routes"),
+		).toEqual({ pattern: "/docs/*path", params: [], restParams: ["path"] });
+	});
+
+	test("about/index.tsx, about/+page.tsx, and about.tsx all resolve to /about", () => {
+		const index = filePathToRoutePath(
+			"/app/routes/about/index.tsx",
+			"/app/routes",
+		);
+		const page = filePathToRoutePath(
+			"/app/routes/about/+page.tsx",
+			"/app/routes",
+		);
+		const bare = filePathToRoutePath("/app/routes/about.tsx", "/app/routes");
+		expect(index.pattern).toBe("/about");
+		expect(page.pattern).toBe("/about");
+		expect(bare.pattern).toBe("/about");
+	});
+
+	test("+server.ts resolves to the same path as +page.tsx", () => {
+		const server = filePathToRoutePath(
+			"/app/routes/api/items/+server.ts",
+			"/app/routes",
+		);
+		expect(server.pattern).toBe("/api/items");
+	});
+
+	test("+error.tsx resolves to its directory path", () => {
+		const root = filePathToRoutePath("/app/routes/+error.tsx", "/app/routes");
+		const nested = filePathToRoutePath(
+			"/app/routes/blog/+error.tsx",
+			"/app/routes",
+		);
+		expect(root.pattern).toBe("/");
+		expect(nested.pattern).toBe("/blog");
+	});
+});
+
+describe("Duplicate route detection", () => {
+	let tmpDir: string;
+
+	beforeAll(async () => {
+		tmpDir = join(tmpdir(), `grimoire-scan-${Date.now()}`);
+		await mkdir(tmpDir, { recursive: true });
+	});
+
+	afterAll(async () => {
+		await rm(tmpDir, { recursive: true });
+	});
+
+	test("throws when two page files resolve to the same path", async () => {
+		const dir = join(tmpDir, "dup-pages");
+		await mkdir(join(dir, "about"), { recursive: true });
+		await writeFile(join(dir, "about.tsx"), "export default () => null");
+		await writeFile(
+			join(dir, "about", "index.tsx"),
+			"export default () => null",
+		);
+		await expect(scanRoutes(dir)).rejects.toThrow('Duplicate page at "/about"');
+	});
+
+	test("+page.tsx and +page.server.ts at the same path do NOT conflict", async () => {
+		const dir = join(tmpDir, "no-conflict");
+		await mkdir(join(dir, "blog"), { recursive: true });
+		await writeFile(
+			join(dir, "blog", "+page.tsx"),
+			"export default () => null",
+		);
+		await writeFile(
+			join(dir, "blog", "+page.server.ts"),
+			"export async function load() {}",
+		);
+		await expect(scanRoutes(dir)).resolves.toBeDefined();
+	});
+
+	test("throws when two API routes resolve to the same path", async () => {
+		const dir = join(tmpDir, "dup-server");
+		await mkdir(join(dir, "api", "items"), { recursive: true });
+		// Bun glob finds all files; we simulate two +server files at same path via subdirs
+		// Use two different nesting depths that produce the same URL
+		await mkdir(join(dir, "api2"), { recursive: true });
+		await writeFile(
+			join(dir, "api2", "+server.ts"),
+			"export async function GET() {}",
+		);
+		await mkdir(join(dir, "api2", "index"), { recursive: true });
+		// Can't easily duplicate +server.ts via nesting — test the named-file vs +server collision instead
+		// Two +server.ts under different folder structures that map to same URL isn't possible without
+		// [param] collisions, so verify a simple valid tree is fine
+		await expect(scanRoutes(dir)).resolves.toBeDefined();
+	});
+
+	test("throws when two error pages resolve to the same path", async () => {
+		const dir = join(tmpDir, "dup-error");
+		await mkdir(join(dir, "blog"), { recursive: true });
+		// Two +error.tsx at root level isn't possible via filesystem (same filename).
+		// The real collision scenario is two dynamic segments mapping to the same pattern.
+		// Test that a single error page is accepted without error.
+		await writeFile(join(dir, "+error.tsx"), "export default () => null");
+		await expect(scanRoutes(dir)).resolves.toBeDefined();
+	});
+
+	test("throws when a simple file and +page.tsx both resolve to the same path", async () => {
+		const dir = join(tmpDir, "dup-mixed");
+		await mkdir(join(dir, "contact"), { recursive: true });
+		await writeFile(join(dir, "contact.tsx"), "export default () => null");
+		await writeFile(
+			join(dir, "contact", "+page.tsx"),
+			"export default () => null",
+		);
+		await expect(scanRoutes(dir)).rejects.toThrow(
+			'Duplicate page at "/contact"',
+		);
+	});
+});