@sigil-dev/grimoire 0.3.0

package/test/typegen.test.ts

@@ -0,0 +1,652 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, sep } from "node:path";
+import type { RouteFile } from "../src/scanner";
+import { scanRoutes } from "../src/scanner";
+import {
+	buildParams,
+	generateTypes,
+	groupByDirectory,
+	toImportPath,
+} from "../src/typegen";
+
+// ---------------------------------------------------------------------------
+// toImportPath
+// ---------------------------------------------------------------------------
+
+describe("toImportPath", () => {
+	test(".ts extension becomes .js", () => {
+		const result = toImportPath("/a/b", "/a/b/c/file.ts");
+		expect(result).toBe("c/file.js");
+	});
+
+	test(".tsx extension becomes .js", () => {
+		const result = toImportPath("/a/b", "/a/b/c/file.tsx");
+		expect(result).toBe("c/file.js");
+	});
+
+	test("produces ../ prefixes for parent directories", () => {
+		const result = toImportPath(
+			"/project/.grimoire/types/src/routes/blog/[slug]",
+			"/project/src/routes/blog/[slug]/+page.server.ts",
+		);
+		// From .grimoire/types/src/routes/blog/[slug] up 6 levels to /project/, then down
+		expect(result).toBe(
+			"../../../../../../src/routes/blog/[slug]/+page.server.js",
+		);
+	});
+
+	test("never contains backslashes regardless of platform separator", () => {
+		// Construct paths using the OS separator to exercise the replace logic
+		// from: C:\project\.grimoire\types\src\routes  (4 levels below C:\project)
+		// to:   C:\project\src\routes\+page.server.ts
+		// → 4 "../" to escape back to C:\project, then down to src/routes/file
+		const from = ["C:", "project", ".grimoire", "types", "src", "routes"].join(
+			sep,
+		);
+		const to = ["C:", "project", "src", "routes", "+page.server.ts"].join(sep);
+		const result = toImportPath(from, to);
+		expect(result).not.toContain("\\");
+		expect(result).toBe("../../../../src/routes/+page.server.js");
+	});
+
+	test("sibling file produces just the filename", () => {
+		const result = toImportPath("/a/b/c", "/a/b/c/file.ts");
+		expect(result).toBe("file.js");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// buildParams
+// ---------------------------------------------------------------------------
+
+describe("buildParams", () => {
+	test("empty array returns {}", () => {
+		expect(buildParams([])).toBe("{}");
+	});
+
+	test("single param", () => {
+		expect(buildParams(["id"])).toBe("{\n  id: string;\n}");
+	});
+
+	test("multiple params", () => {
+		expect(buildParams(["org", "repo"])).toBe(
+			"{\n  org: string;\n  repo: string;\n}",
+		);
+	});
+
+	test("produces valid TypeScript type syntax", () => {
+		const result = buildParams(["slug"]);
+		expect(result).toContain("slug: string;");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// groupByDirectory
+// ---------------------------------------------------------------------------
+
+function makeRouteFile(
+	overrides: Partial<RouteFile> & { filePath: string; type: RouteFile["type"] },
+): RouteFile {
+	return {
+		path: "/",
+		clientPath: "/src/routes/+page.tsx",
+		paramNames: [],
+		...overrides,
+	};
+}
+
+describe("groupByDirectory", () => {
+	test("simple files are excluded", () => {
+		const tree = {
+			routes: [
+				makeRouteFile({ filePath: "/app/routes/index.tsx", type: "simple" }),
+				makeRouteFile({ filePath: "/app/routes/about.tsx", type: "simple" }),
+			],
+			layouts: [],
+			servers: [],
+			errors: [],
+		};
+		const groups = groupByDirectory(tree);
+		expect(groups.size).toBe(0);
+	});
+
+	test("+page.tsx and +page.server.ts in the same directory form one group", () => {
+		const tree = {
+			routes: [
+				makeRouteFile({
+					filePath: "/app/routes/blog/[slug]/+page.tsx",
+					type: "page",
+					paramNames: ["slug"],
+				}),
+				makeRouteFile({
+					filePath: "/app/routes/blog/[slug]/+page.server.ts",
+					type: "pageServer",
+					paramNames: ["slug"],
+				}),
+			],
+			layouts: [],
+			servers: [],
+			errors: [],
+		};
+		const groups = groupByDirectory(tree);
+		expect(groups.size).toBe(1);
+		const group = groups.get("/app/routes/blog/[slug]")!;
+		expect(group).toBeDefined();
+		expect(group.page?.filePath).toBe("/app/routes/blog/[slug]/+page.tsx");
+		expect(group.pageServer?.filePath).toBe(
+			"/app/routes/blog/[slug]/+page.server.ts",
+		);
+	});
+
+	test("+layout files go into their own group separate from +page files", () => {
+		const tree = {
+			routes: [
+				makeRouteFile({ filePath: "/app/routes/+page.tsx", type: "page" }),
+			],
+			layouts: [
+				makeRouteFile({ filePath: "/app/routes/+layout.tsx", type: "layout" }),
+			],
+			servers: [],
+			errors: [],
+		};
+		const groups = groupByDirectory(tree);
+		expect(groups.size).toBe(1);
+		const group = groups.get("/app/routes")!;
+		expect(group.page).toBeDefined();
+		expect(group.layout).toBeDefined();
+	});
+
+	test("+server.ts creates a group with server field set", () => {
+		const tree = {
+			routes: [],
+			layouts: [],
+			servers: [
+				makeRouteFile({
+					filePath: "/app/routes/api/hello/+server.ts",
+					type: "server",
+				}),
+			],
+			errors: [],
+		};
+		const groups = groupByDirectory(tree);
+		expect(groups.size).toBe(1);
+		expect(groups.get("/app/routes/api/hello")!.server).toBeDefined();
+	});
+
+	test("+error.tsx creates a group with error field set", () => {
+		const tree = {
+			routes: [],
+			layouts: [],
+			servers: [],
+			errors: [
+				makeRouteFile({
+					filePath: "/app/routes/+error.tsx",
+					type: "error",
+				}),
+			],
+		};
+		const groups = groupByDirectory(tree);
+		expect(groups.size).toBe(1);
+		expect(groups.get("/app/routes")!.error).toBeDefined();
+	});
+
+	test("paramNames taken from the file with most params", () => {
+		const tree = {
+			routes: [
+				makeRouteFile({
+					filePath: "/app/routes/[org]/[repo]/+page.tsx",
+					type: "page",
+					paramNames: ["org", "repo"],
+				}),
+				makeRouteFile({
+					filePath: "/app/routes/[org]/[repo]/+page.server.ts",
+					type: "pageServer",
+					paramNames: ["org", "repo"],
+				}),
+			],
+			layouts: [],
+			servers: [],
+			errors: [],
+		};
+		const groups = groupByDirectory(tree);
+		const group = groups.values().next().value!;
+		expect(group.paramNames).toEqual(["org", "repo"]);
+	});
+
+	test("simple files mixed with +page files: only +page files contribute to groups", () => {
+		const tree = {
+			routes: [
+				makeRouteFile({ filePath: "/app/routes/about.tsx", type: "simple" }),
+				makeRouteFile({
+					filePath: "/app/routes/blog/+page.tsx",
+					type: "page",
+				}),
+			],
+			layouts: [],
+			servers: [],
+			errors: [],
+		};
+		const groups = groupByDirectory(tree);
+		expect(groups.size).toBe(1);
+		expect(groups.has("/app/routes/blog")).toBe(true);
+		expect(groups.has("/app/routes")).toBe(false);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// generateTypes — integration (file system)
+// ---------------------------------------------------------------------------
+
+let tmpDir: string;
+
+beforeAll(async () => {
+	tmpDir = join(tmpdir(), `grimoire-typegen-${Date.now()}`);
+	await mkdir(join(tmpDir, "src", "routes", "blog", "[slug]"), {
+		recursive: true,
+	});
+	await mkdir(join(tmpDir, "src", "routes", "api", "posts"), {
+		recursive: true,
+	});
+
+	// Layout at root
+	await writeFile(
+		join(tmpDir, "src", "routes", "+layout.tsx"),
+		"export default () => null;",
+	);
+
+	// Page-only route (no server)
+	await writeFile(
+		join(tmpDir, "src", "routes", "blog", "+page.tsx"),
+		"export default () => null;",
+	);
+
+	// Route with +page.server.ts that has a load function
+	await writeFile(
+		join(tmpDir, "src", "routes", "blog", "[slug]", "+page.tsx"),
+		"export default () => null;",
+	);
+	await writeFile(
+		join(tmpDir, "src", "routes", "blog", "[slug]", "+page.server.ts"),
+		`export async function load({ params }: { params: { slug: string } }) {
+  return { post: { title: "Hello", views: 42 } };
+}
+export async function DELETE({ request }: { request: Request }) {
+  return {};
+}`,
+	);
+
+	// Route with +layout.server.ts
+	await writeFile(
+		join(tmpDir, "src", "routes", "blog", "+layout.server.ts"),
+		`export async function load() { return { nav: ["Home", "Blog"] }; }`,
+	);
+
+	// API route (+server.ts)
+	await writeFile(
+		join(tmpDir, "src", "routes", "api", "posts", "+server.ts"),
+		`export async function GET() { return Response.json([]); }
+export async function POST() { return Response.json({}); }`,
+	);
+
+	// Error page
+	await writeFile(
+		join(tmpDir, "src", "routes", "+error.tsx"),
+		"export default () => null;",
+	);
+
+	// Simple file (should be ignored)
+	await writeFile(
+		join(tmpDir, "src", "routes", "about.tsx"),
+		"export default () => null;",
+	);
+});
+
+afterAll(async () => {
+	await rm(tmpDir, { recursive: true, force: true });
+});
+
+async function runGenerate() {
+	const routesDir = join(tmpDir, "src", "routes");
+	const tree = await scanRoutes(routesDir, tmpDir);
+	await generateTypes(tree, {
+		projectRoot: tmpDir,
+		routesDir,
+		outDir: join(tmpDir, ".grimoire", "types"),
+	});
+}
+
+async function readGenerated(routeRelPath: string) {
+	const p = join(tmpDir, ".grimoire", "types", routeRelPath, "$types.d.ts");
+	return readFile(p, "utf-8");
+}
+
+describe("generateTypes — output structure", () => {
+	test("creates ambient.d.ts with App.Locals namespace", async () => {
+		await runGenerate();
+		const ambient = await readFile(
+			join(tmpDir, ".grimoire", "types", "ambient.d.ts"),
+			"utf-8",
+		);
+		expect(ambient).toContain("declare namespace App");
+		expect(ambient).toContain("interface Locals");
+	});
+
+	test("creates tsconfig.generated.json with rootDirs", async () => {
+		const config = JSON.parse(
+			await readFile(
+				join(tmpDir, ".grimoire", "tsconfig.generated.json"),
+				"utf-8",
+			),
+		);
+		expect(config.compilerOptions.rootDirs).toContain("..");
+		expect(config.compilerOptions.rootDirs).toContain("./types");
+	});
+
+	test("generates $types.d.ts for each route directory with + files", async () => {
+		expect(
+			existsSync(
+				join(tmpDir, ".grimoire", "types", "src", "routes", "$types.d.ts"),
+			),
+		).toBe(true);
+		expect(
+			existsSync(
+				join(
+					tmpDir,
+					".grimoire",
+					"types",
+					"src",
+					"routes",
+					"blog",
+					"$types.d.ts",
+				),
+			),
+		).toBe(true);
+		expect(
+			existsSync(
+				join(
+					tmpDir,
+					".grimoire",
+					"types",
+					"src",
+					"routes",
+					"blog",
+					"[slug]",
+					"$types.d.ts",
+				),
+			),
+		).toBe(true);
+	});
+
+	test("does NOT generate $types.d.ts for simple (non-+ convention) files", async () => {
+		// about.tsx is a simple file in src/routes/ — there's no $types for it
+		// (src/routes/ does get $types from +layout.tsx, but it's not created for about.tsx alone)
+		// Confirm that about/ directory itself has no $types
+		expect(
+			existsSync(
+				join(
+					tmpDir,
+					".grimoire",
+					"types",
+					"src",
+					"routes",
+					"about",
+					"$types.d.ts",
+				),
+			),
+		).toBe(false);
+	});
+});
+
+describe("generateTypes — route without +page.server.ts", () => {
+	test("PageData = Record<string, never>", async () => {
+		const content = await readGenerated("src/routes/blog");
+		expect(content).toContain("export type PageData = Record<string, never>;");
+	});
+
+	test("PageServerLoad = never", async () => {
+		const content = await readGenerated("src/routes/blog");
+		expect(content).toContain("export type PageServerLoad = never;");
+	});
+
+	test("Actions = Record<string, never>", async () => {
+		const content = await readGenerated("src/routes/blog");
+		expect(content).toContain("export type Actions = Record<string, never>;");
+	});
+
+	test("PageProps contains params", async () => {
+		const content = await readGenerated("src/routes/blog");
+		expect(content).toContain("export type PageProps = { params: Params };");
+	});
+});
+
+describe("generateTypes — route with +page.server.ts", () => {
+	test("uses typeof import() for the server module", async () => {
+		const content = await readGenerated("src/routes/blog/[slug]");
+		expect(content).toMatch(/type _PS = typeof import\("/);
+	});
+
+	test("import path ends with .js", async () => {
+		const content = await readGenerated("src/routes/blog/[slug]");
+		const match = content.match(/typeof import\("([^"]+)"\)/);
+		expect(match?.[1]).toMatch(/\.js$/);
+	});
+
+	test("import path contains only forward slashes", async () => {
+		const content = await readGenerated("src/routes/blog/[slug]");
+		const match = content.match(/typeof import\("([^"]+)"\)/);
+		expect(match?.[1]).not.toContain("\\");
+	});
+
+	test("PageData inferred from load() via ReturnType", async () => {
+		const content = await readGenerated("src/routes/blog/[slug]");
+		expect(content).toContain(
+			'export type PageData = "load" extends keyof _PS',
+		);
+		expect(content).toContain('Awaited<ReturnType<_PS["load"]>>');
+	});
+
+	test("PageProps = PageData & { params: Params }", async () => {
+		const content = await readGenerated("src/routes/blog/[slug]");
+		expect(content).toContain(
+			"export type PageProps = PageData & { params: Params };",
+		);
+	});
+
+	test("Actions excludes load and default from keys", async () => {
+		const content = await readGenerated("src/routes/blog/[slug]");
+		expect(content).toContain(
+			'type _ActionKeys = Exclude<keyof _PS, "load" | "default">;',
+		);
+	});
+
+	test("Params has slug typed as string", async () => {
+		const content = await readGenerated("src/routes/blog/[slug]");
+		expect(content).toContain("slug: string;");
+	});
+});
+
+describe("generateTypes — +layout.server.ts", () => {
+	test("LayoutData inferred from load() via ReturnType", async () => {
+		const content = await readGenerated("src/routes/blog");
+		expect(content).toMatch(/type _LS = typeof import\("/);
+		expect(content).toContain(
+			'export type LayoutData = "load" extends keyof _LS',
+		);
+		expect(content).toContain('Awaited<ReturnType<_LS["load"]>>');
+	});
+
+	test("LayoutProps includes children", async () => {
+		const content = await readGenerated("src/routes/blog");
+		expect(content).toContain("children?: unknown");
+	});
+});
+
+describe("generateTypes — +server.ts (API route)", () => {
+	test("generates ServerHandlers type", async () => {
+		const content = await readGenerated("src/routes/api/posts");
+		expect(content).toContain("export type ServerHandlers");
+	});
+
+	test("uses typeof import() for server module", async () => {
+		const content = await readGenerated("src/routes/api/posts");
+		expect(content).toMatch(/type _SRV = typeof import\("/);
+	});
+
+	test("extracts HTTP method keys", async () => {
+		const content = await readGenerated("src/routes/api/posts");
+		expect(content).toContain("_HttpMethods");
+		expect(content).toContain("_ServerKeys");
+	});
+});
+
+describe("generateTypes — +error.tsx", () => {
+	test("generates ErrorProps type", async () => {
+		const content = await readGenerated("src/routes");
+		expect(content).toContain(
+			"export type ErrorProps = { status: number; message: string };",
+		);
+	});
+});
+
+describe("generateTypes — clears stale output", () => {
+	test("removes files from a deleted route on re-run", async () => {
+		// First run already happened in beforeAll via runGenerate()
+		// Write a stale file manually
+		const staleDir = join(
+			tmpDir,
+			".grimoire",
+			"types",
+			"src",
+			"routes",
+			"old-route",
+		);
+		await mkdir(staleDir, { recursive: true });
+		await writeFile(join(staleDir, "$types.d.ts"), "// stale");
+
+		// Re-run
+		await runGenerate();
+
+		// Stale file should be gone
+		expect(existsSync(join(staleDir, "$types.d.ts"))).toBe(false);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// tsc integration — proves the generated types actually type-check
+// ---------------------------------------------------------------------------
+
+describe("tsc integration", () => {
+	let tscDir: string;
+
+	beforeAll(async () => {
+		tscDir = join(tmpdir(), `grimoire-tsc-${Date.now()}`);
+		const routeDir = join(tscDir, "src", "routes", "blog", "[slug]");
+		await mkdir(routeDir, { recursive: true });
+
+		// Minimal +page.server.ts whose return type flows through to PageProps
+		await writeFile(
+			join(routeDir, "+page.server.ts"),
+			`export async function load({ params }: { params: { slug: string } }) {
+  return { post: { title: "Hello", views: 42 } };
+}`,
+		);
+
+		// File that uses the generated types — must live in the route dir for ./$types to resolve
+		await writeFile(
+			join(routeDir, "check.ts"),
+			`import type { PageProps } from "./$types";
+declare const props: PageProps;
+const _title: string = props.post.title;
+const _views: number = props.post.views;
+const _slug: string = props.params.slug;
+export {};`,
+		);
+
+		// tsconfig for this mini-project
+		await writeFile(
+			join(tscDir, "tsconfig.json"),
+			JSON.stringify(
+				{
+					extends: "./.grimoire/tsconfig.generated.json",
+					compilerOptions: {
+						target: "ESNext",
+						module: "ESNext",
+						moduleResolution: "bundler",
+						strict: true,
+						skipLibCheck: true,
+						noEmit: true,
+					},
+					include: ["src", ".grimoire/types"],
+				},
+				null,
+				2,
+			),
+		);
+
+		// Generate types
+		const routesDir = join(tscDir, "src", "routes");
+		const tree = await scanRoutes(routesDir, tscDir);
+		await generateTypes(tree, {
+			projectRoot: tscDir,
+			routesDir,
+			outDir: join(tscDir, ".grimoire", "types"),
+		});
+	});
+
+	afterAll(async () => {
+		await rm(tscDir, { recursive: true, force: true });
+	});
+
+	function runTsc(cwd: string) {
+		return Bun.spawnSync(
+			[process.execPath, "x", "tsc", "--noEmit", "--project", "tsconfig.json"],
+			{ cwd },
+		);
+	}
+
+	test("check.ts with correct types passes tsc", () => {
+		const result = runTsc(tscDir);
+		// Ignore bun package-download messages; only care about exit code
+		expect(result.exitCode).toBe(0);
+	});
+
+	test("accessing a non-existent property fails tsc", async () => {
+		// Add a file with a wrong property access
+		const routeDir = join(tscDir, "src", "routes", "blog", "[slug]");
+		await writeFile(
+			join(routeDir, "bad.ts"),
+			`import type { PageProps } from "./$types";
+declare const props: PageProps;
+const _bad = props.post.bogus;
+export {};`,
+		);
+
+		const result = runTsc(tscDir);
+		expect(result.exitCode).not.toBe(0);
+
+		// Clean up so subsequent test runs are clean
+		const { unlink } = await import("node:fs/promises");
+		await unlink(join(routeDir, "bad.ts"));
+	});
+
+	test("params properties are typed as string", async () => {
+		// Assigning params.slug to a number should fail
+		const routeDir = join(tscDir, "src", "routes", "blog", "[slug]");
+		await writeFile(
+			join(routeDir, "wrong-param-type.ts"),
+			`import type { PageProps } from "./$types";
+declare const props: PageProps;
+const _n: number = props.params.slug;
+export {};`,
+		);
+
+		const result = runTsc(tscDir);
+		expect(result.exitCode).not.toBe(0);
+
+		const { unlink } = await import("node:fs/promises");
+		await unlink(join(routeDir, "wrong-param-type.ts"));
+	});
+});

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"compilerOptions": {
+		"module": "Preserve",
+		"moduleResolution": "bundler",
+		"lib": ["ESNext", "DOM"]
+	}
+}