@sigil-dev/grimoire 0.4.0 → 0.6.0

package/test/scanning.test.ts

@@ -2,7 +2,7 @@ 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/scanner";
+import { filePathToRoutePath, scanRoutes } from "../src/routing/scanner";
 
 describe("File scanning", () => {
 	test("index.tsx → /", () => {
@@ -57,8 +57,14 @@ describe("File scanning", () => {
 	});
 
 	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 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");
@@ -66,13 +72,19 @@ describe("File scanning", () => {
 	});
 
 	test("+server.ts resolves to the same path as +page.tsx", () => {
-		const server = filePathToRoutePath("/app/routes/api/items/+server.ts", "/app/routes");
+		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");
+		const nested = filePathToRoutePath(
+			"/app/routes/blog/+error.tsx",
+			"/app/routes",
+		);
 		expect(root.pattern).toBe("/");
 		expect(nested.pattern).toBe("/blog");
 	});
@@ -94,15 +106,24 @@ describe("Duplicate route detection", () => {
 		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 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 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();
 	});
 
@@ -112,7 +133,10 @@ describe("Duplicate route detection", () => {
 		// 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 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
@@ -134,7 +158,12 @@ describe("Duplicate route detection", () => {
 		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"');
+		await writeFile(
+			join(dir, "contact", "+page.tsx"),
+			"export default () => null",
+		);
+		await expect(scanRoutes(dir)).rejects.toThrow(
+			'Duplicate page at "/contact"',
+		);
 	});
 });

package/test/scope.test.ts

@@ -8,8 +8,12 @@
  *      a fresh empty pool instead of recycling stale DOM nodes.
  */
 import { describe, expect, test } from "bun:test";
-import { createEffect, createSignal, withEffectScope as runtimeScope } from "@sigil-dev/runtime";
-import { withEffectScope } from "../src/scope.ts";
+import {
+	createEffect,
+	createSignal,
+	withEffectScope as runtimeScope,
+} from "@sigil-dev/runtime";
+import { withEffectScope } from "../src/client/scope.ts";
 
 describe("grimoire withEffectScope", () => {
 	test("effects inside scope stop after dispose", () => {
@@ -38,7 +42,10 @@ describe("grimoire withEffectScope", () => {
 
 		// Mount page A
 		let disposeCurrentPage = withEffectScope(() => {
-			createEffect(() => { count(); pageARuns++; });
+			createEffect(() => {
+				count();
+				pageARuns++;
+			});
 		});
 		count.set(1);
 		expect(pageARuns).toBe(2);
@@ -47,7 +54,10 @@ describe("grimoire withEffectScope", () => {
 		// Navigate to page B — dispose A first
 		disposeCurrentPage();
 		disposeCurrentPage = withEffectScope(() => {
-			createEffect(() => { count(); pageBRuns++; });
+			createEffect(() => {
+				count();
+				pageBRuns++;
+			});
 		});
 
 		count.set(2);
@@ -96,7 +106,10 @@ describe("grimoire withEffectScope", () => {
 
 		// grimoire's local withEffectScope wraps a createEffect from @sigil-dev/runtime
 		const dispose = withEffectScope(() => {
-			createEffect(() => { count(); runs++; });
+			createEffect(() => {
+				count();
+				runs++;
+			});
 		});
 
 		count.set(1);
@@ -114,7 +127,10 @@ describe("grimoire withEffectScope", () => {
 		let runs = 0;
 
 		const dispose = runtimeScope(() => {
-			createEffect(() => { count(); runs++; });
+			createEffect(() => {
+				count();
+				runs++;
+			});
 		});
 
 		count.set(1);
@@ -127,7 +143,7 @@ describe("grimoire withEffectScope", () => {
 
 describe("__nodes pool reset on SPA navigation", () => {
 	test("navigate sets __nodes to [] before calling Page()", () => {
-		// Simulate exactly what client-router.ts's navigate() does:
+		// Simulate exactly what router.ts's navigate() does:
 		//   dispose old effects → set __nodes = [] → call Page() → replaceChildren(node)
 		// We only care that Page() sees an empty pool.
 		let nodesAtCallTime: unknown = "not set";
@@ -136,9 +152,8 @@ describe("__nodes pool reset on SPA navigation", () => {
 			nodesAtCallTime = (globalThis as any).__nodes;
 			return document.createElement("div"); // satisfy replaceChildren
 		};
-
 		// Mimic the three lines in navigate() that matter
-		;(globalThis as any).__nodes = ["stale", "dom", "nodes"]; // leftover from previous page
+		(globalThis as any).__nodes = ["stale", "dom", "nodes"]; // leftover from previous page
 		(globalThis as any).__nodes = []; // the reset
 		mockPage();
 
@@ -154,7 +169,7 @@ describe("__nodes pool reset on SPA navigation", () => {
 			nodesAtCallTime = (globalThis as any).__nodes;
 		};
 
-		;(globalThis as any).__nodes = [fakeSlotChild]; // hydrate.ts sets real nodes
+		(globalThis as any).__nodes = [fakeSlotChild]; // hydrate.ts sets real nodes
 		mockPage();
 
 		expect(Array.isArray(nodesAtCallTime)).toBe(true);

package/test/server.test.ts

@@ -73,8 +73,157 @@ describe("Server — API routes (+server.ts)", () => {
 
 	test("unsupported method returns 405", async () => {
 		const server = await createServer({ port: 3004, routes: tmpDir });
-		const res = await fetch("http://localhost:3004/api/items", { method: "DELETE" });
+		const res = await fetch("http://localhost:3004/api/items", {
+			method: "DELETE",
+		});
 		expect(res.status).toBe(405);
 		server.stop();
 	});
 });
+
+describe("Server — WebSocket routes", () => {
+	let wsDir: string;
+	let server: Awaited<ReturnType<typeof createServer>>;
+
+	beforeAll(async () => {
+		wsDir = join(tmpdir(), `grimoire-ws-${Date.now()}`);
+		await mkdir(join(wsDir, "echo"), { recursive: true });
+		await mkdir(join(wsDir, "params", "[docId]"), { recursive: true });
+		await mkdir(join(wsDir, "reject"), { recursive: true });
+		await mkdir(join(wsDir, "mixed"), { recursive: true });
+
+		// echo: upgrade() merges extra data, message handler echoes back
+		await writeFile(
+			join(wsDir, "echo", "+server.ts"),
+			`export function upgrade({ params }) {
+  return { sessionId: "abc123" };
+}
+export const websocket = {
+  message(ws, data) { ws.send("echo:" + data); },
+};`,
+		);
+
+		// params: no upgrade(), ws.data.params still available
+		await writeFile(
+			join(wsDir, "params", "[docId]", "+server.ts"),
+			`export const websocket = {
+  open(ws) { ws.send("docId:" + ws.data.params.docId); },
+};`,
+		);
+
+		// reject: upgrade() throws → 426
+		await writeFile(
+			join(wsDir, "reject", "+server.ts"),
+			`export function upgrade() {
+  throw new Error("Unauthorized");
+}
+export const websocket = {
+  message(ws, data) { ws.send(data); },
+};`,
+		);
+
+		// mixed: HTTP GET and WebSocket both exported
+		await writeFile(
+			join(wsDir, "mixed", "+server.ts"),
+			`export function GET() {
+  return Response.json({ kind: "http" });
+}
+export function upgrade({ params }) { return {}; }
+export const websocket = {
+  message(ws, data) { ws.send(data); },
+};`,
+		);
+
+		server = await createServer({ port: 3005, routes: wsDir });
+	});
+
+	afterAll(() => {
+		server.stop();
+	});
+
+	function wsConnect(path: string): Promise<WebSocket> {
+		return new Promise((resolve, reject) => {
+			const ws = new WebSocket(`ws://localhost:3005${path}`);
+			ws.onopen = () => resolve(ws);
+			ws.onerror = () =>
+				reject(new Error(`WebSocket connection failed: ${path}`));
+		});
+	}
+
+	function nextMessage(ws: WebSocket): Promise<string> {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(
+				() => reject(new Error("timeout waiting for message")),
+				2000,
+			);
+			ws.onmessage = (ev) => {
+				clearTimeout(timer);
+				resolve(String(ev.data));
+			};
+			ws.onerror = () => {
+				clearTimeout(timer);
+				reject(new Error("ws error"));
+			};
+		});
+	}
+
+	test("message is echoed back", async () => {
+		const ws = await wsConnect("/echo");
+		const pending = nextMessage(ws);
+		ws.send("hello");
+		expect(await pending).toBe("echo:hello");
+		ws.close();
+	});
+
+	test("upgrade() return value merges into ws.data", async () => {
+		// sessionId set in upgrade() — echo route sends it back via a second message
+		const ws = new WebSocket("ws://localhost:3005/echo");
+		// just verify connection opens cleanly (sessionId is in ws.data server-side)
+		await new Promise<void>((resolve, reject) => {
+			const t = setTimeout(() => reject(new Error("timeout")), 2000);
+			ws.onopen = () => {
+				clearTimeout(t);
+				resolve();
+			};
+			ws.onerror = () => {
+				clearTimeout(t);
+				reject(new Error("connect failed"));
+			};
+		});
+		ws.close();
+	});
+
+	test("ws.data.params available when no upgrade() export", async () => {
+		const ws = await wsConnect("/params/42");
+		expect(await nextMessage(ws)).toBe("docId:42");
+		ws.close();
+	});
+
+	test("upgrade() throwing rejects the connection", async () => {
+		await new Promise<void>((resolve, reject) => {
+			const ws = new WebSocket("ws://localhost:3005/reject");
+			const t = setTimeout(() => reject(new Error("timeout")), 2000);
+			ws.onopen = () => {
+				clearTimeout(t);
+				ws.close();
+				reject(new Error("should not have opened"));
+			};
+			ws.onerror = () => {
+				clearTimeout(t);
+				resolve();
+			};
+			ws.onclose = (ev) => {
+				clearTimeout(t);
+				if (ev.code !== 1006) resolve();
+				else resolve();
+			};
+		});
+	});
+
+	test("plain HTTP GET on mixed route still works (no Upgrade header)", async () => {
+		const res = await fetch("http://localhost:3005/mixed");
+		expect(res.status).toBe(200);
+		const body = await res.json();
+		expect(body.kind).toBe("http");
+	});
+});

package/test/streaming.test.ts

@@ -1,132 +1,145 @@
-import { describe, expect, test } from "bun:test";
-import { renderRoute } from "../src/renderer";
-
-describe("Streaming SSR", () => {
-	test("returns a ReadableStream response", async () => {
-		const matched = {
-			route: {
-				path: "/",
-				params: {},
-				filePath: "data:text/javascript,export default (p) => '<div>hello</div>'",
-			},
-			params: {},
-		} as any;
-
-		const res = await renderRoute(matched, new Request("http://localhost/"));
-		expect(res.body).toBeInstanceOf(ReadableStream);
-	});
-
-	test("stream contains full HTML document", async () => {
-		const matched = {
-			route: {
-				path: "/test",
-				params: {},
-				filePath:
-					"data:text/javascript,export default (p) => '<p>streaming works</p>'",
-			},
-			params: {},
-		} as any;
-
-		const res = await renderRoute(matched, new Request("http://localhost/test"));
-		const html = await res.text();
-
-		expect(html).toContain("<!DOCTYPE html>");
-		expect(html).toContain('<meta charset="UTF-8" />');
-		expect(html).toContain("streaming works");
-		expect(html).toContain("</html>");
-		expect(html).toContain("__grimoire_state__");
-	});
-
-	test("stream includes state JSON with route pattern", async () => {
-		const matched = {
-			route: {
-				path: "/spells/:id",
-				params: {},
-				filePath:
-					"data:text/javascript,export default (p) => '<div>spell</div>'",
-			},
-			params: { id: "fireball" },
-		} as any;
-
-		const res = await renderRoute(
-			matched,
-			new Request("http://localhost/spells/fireball"),
-		);
-		const html = await res.text();
-
-		expect(html).toContain('"pattern":"/spells/:id"');
-		expect(html).toContain('"id":"fireball"');
-	});
-
-	test("head script tag comes before head content", async () => {
-		const matched = {
-			route: {
-				path: "/head-test",
-				params: {},
-				filePath:
-					"data:text/javascript,export default (p) => '<div>head</div>'",
-			},
-			params: {},
-		} as any;
-
-		const res = await renderRoute(matched, new Request("http://localhost/head-test"));
-		const html = await res.text();
-
-		const hydrateScript = html.indexOf("hydrate.js");
-		const headClosing = html.indexOf("</head>");
-		// hydrate.js should be in <head>
-		expect(hydrateScript).toBeGreaterThan(-1);
-		expect(hydrateScript).toBeLessThan(headClosing);
-	});
-
-	test("stream chunks arrive incrementally", async () => {
-		const matched = {
-			route: {
-				path: "/chunked",
-				params: {},
-				filePath:
-					"data:text/javascript,export default (p) => '<div>chunked</div>'",
-			},
-			params: {},
-		} as any;
-
-		const res = await renderRoute(matched, new Request("http://localhost/chunked"));
-		const reader = res.body!.getReader();
-		const chunks: string[] = [];
-
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			// Bun ReadableStream returns Uint8Array
-			chunks.push(typeof value === "string" ? value : new TextDecoder().decode(value.buffer));
-		}
-
-		// Should have multiple chunks (at least DOCTYPE + body)
-		expect(chunks.length).toBeGreaterThan(1);
-		// First chunk should start with DOCTYPE
-		expect(chunks[0]).toContain("<!DOCTYPE html>");
-		// Last chunk should close the document
-		expect(chunks[chunks.length - 1]).toContain("</html>");
-	});
-
-	test("navigation request returns JSON not stream", async () => {
-		const matched = {
-			route: {
-				path: "/nav",
-				params: {},
-				filePath:
-					"data:text/javascript,export default (p) => '<div>nav</div>'",
-			},
-			params: {},
-		} as any;
-
-		const req = new Request("http://localhost/nav", {
-			headers: { "x-grimoire-navigate": "1" },
-		});
-		const res = await renderRoute(matched, req);
-		const json = await res.json();
-
-		expect(json.pattern).toBe("/nav");
-		expect(json.data).toBeDefined();
-	});
-});
+import { describe, expect, test } from "bun:test";
+import { renderRoute } from "../src/rendering";
+
+describe("Streaming SSR", () => {
+	test("returns a ReadableStream response", async () => {
+		const matched = {
+			route: {
+				path: "/",
+				params: {},
+				filePath:
+					"data:text/javascript,export default (p) => '<div>hello</div>'",
+			},
+			params: {},
+		} as any;
+
+		const res = await renderRoute(matched, new Request("http://localhost/"));
+		expect(res.body).toBeInstanceOf(ReadableStream);
+	});
+
+	test("stream contains full HTML document", async () => {
+		const matched = {
+			route: {
+				path: "/test",
+				params: {},
+				filePath:
+					"data:text/javascript,export default (p) => '<p>streaming works</p>'",
+			},
+			params: {},
+		} as any;
+
+		const res = await renderRoute(
+			matched,
+			new Request("http://localhost/test"),
+		);
+		const html = await res.text();
+
+		expect(html).toContain("<!DOCTYPE html>");
+		expect(html).toContain('<meta charset="UTF-8" />');
+		expect(html).toContain("streaming works");
+		expect(html).toContain("</html>");
+		expect(html).toContain("__grimoire_state__");
+	});
+
+	test("stream includes state JSON with route pattern", async () => {
+		const matched = {
+			route: {
+				path: "/spells/:id",
+				params: {},
+				filePath:
+					"data:text/javascript,export default (p) => '<div>spell</div>'",
+			},
+			params: { id: "fireball" },
+		} as any;
+
+		const res = await renderRoute(
+			matched,
+			new Request("http://localhost/spells/fireball"),
+		);
+		const html = await res.text();
+
+		expect(html).toContain('"pattern":"/spells/:id"');
+		expect(html).toContain('"id":"fireball"');
+	});
+
+	test("head script tag comes before head content", async () => {
+		const matched = {
+			route: {
+				path: "/head-test",
+				params: {},
+				filePath:
+					"data:text/javascript,export default (p) => '<div>head</div>'",
+			},
+			params: {},
+		} as any;
+
+		const res = await renderRoute(
+			matched,
+			new Request("http://localhost/head-test"),
+		);
+		const html = await res.text();
+
+		const hydrateScript = html.indexOf("hydrate.js");
+		const headClosing = html.indexOf("</head>");
+		// hydrate.js should be in <head>
+		expect(hydrateScript).toBeGreaterThan(-1);
+		expect(hydrateScript).toBeLessThan(headClosing);
+	});
+
+	test("stream chunks arrive incrementally", async () => {
+		const matched = {
+			route: {
+				path: "/chunked",
+				params: {},
+				filePath:
+					"data:text/javascript,export default (p) => '<div>chunked</div>'",
+			},
+			params: {},
+		} as any;
+
+		const res = await renderRoute(
+			matched,
+			new Request("http://localhost/chunked"),
+		);
+		const reader = res.body!.getReader();
+		const chunks: string[] = [];
+
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			// Bun ReadableStream returns Uint8Array
+			chunks.push(
+				typeof value === "string"
+					? value
+					: new TextDecoder().decode(value.buffer),
+			);
+		}
+
+		// Should have multiple chunks (at least DOCTYPE + body)
+		expect(chunks.length).toBeGreaterThan(1);
+		// First chunk should start with DOCTYPE
+		expect(chunks[0]).toContain("<!DOCTYPE html>");
+		// Last chunk should close the document
+		expect(chunks[chunks.length - 1]).toContain("</html>");
+	});
+
+	test("navigation request returns JSON not stream", async () => {
+		const matched = {
+			route: {
+				path: "/nav",
+				params: {},
+				filePath: "data:text/javascript,export default (p) => '<div>nav</div>'",
+			},
+			params: {},
+		} as any;
+
+		const req = new Request("http://localhost/nav", {
+			headers: { "x-grimoire-navigate": "1" },
+		});
+		const res = await renderRoute(matched, req);
+		const json = await res.json();
+
+		expect(json.pattern).toBe("/nav");
+		expect(json.data).toBeDefined();
+	});
+});

package/test/transform-routes.test.ts

@@ -2,8 +2,8 @@ import { describe, expect, test } from "bun:test";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
-import type { RouteFile } from "../src/scanner";
-import { transformRoutes } from "../src/transform-routes";
+import type { RouteFile } from "../src/routing/scanner";
+import { transformRoutes } from "../src/routing/transform-routes";
 
 describe("transformRoutes", () => {
 	test("pre-transforms TypeScript TSX routes to unique JavaScript files", async () => {