@sigil-dev/grimoire 0.3.0 → 0.5.0

package/test/middleware.test.ts

@@ -1,217 +1,217 @@
-import { describe, expect, test } from "bun:test";
-import { sequence, createHooks } from "../src/hooks";
-import { createCookies } from "../src/cookie-utils";
-import type { Handle, RequestEvent } from "../src/hooks";
-
-function fakeEvent(overrides?: Partial<RequestEvent>): RequestEvent {
-	return {
-		request: new Request("http://localhost/"),
-		url: new URL("http://localhost/"),
-		params: {},
-		locals: {},
-		cookies: {
-			get: () => undefined,
-			set: () => {},
-			delete: () => {},
-		},
-		setHeaders: () => {},
-		...overrides,
-	};
-}
-
-describe("sequence()", () => {
-	test("chains two handlers in order", async () => {
-		const order: string[] = [];
-
-		const a: Handle = async ({ event, resolve }) => {
-			order.push("a-before");
-			const res = await resolve(event);
-			order.push("a-after");
-			return res;
-		};
-
-		const b: Handle = async ({ event, resolve }) => {
-			order.push("b-before");
-			const res = await resolve(event);
-			order.push("b-after");
-			return res;
-		};
-
-		const handler = sequence(a, b);
-		const res = await handler({
-			event: fakeEvent(),
-			resolve: async (evt) => new Response("OK"),
-		});
-
-		expect(order).toEqual(["a-before", "b-before", "b-after", "a-after"]);
-		expect(await res.text()).toBe("OK");
-	});
-
-	test("can short-circuit", async () => {
-		let reached = false;
-
-		const a: Handle = async () => {
-			return new Response("Blocked", { status: 403 });
-		};
-
-		const b: Handle = async ({ resolve, event }) => {
-			reached = true;
-			return resolve(event);
-		};
-
-		const handler = sequence(a, b);
-		const res = await handler({
-			event: fakeEvent(),
-			resolve: async () => new Response("OK"),
-		});
-
-		expect(reached).toBe(false);
-		expect(res.status).toBe(403);
-	});
-
-	test("can modify event.locals", async () => {
-		const a: Handle = async ({ event, resolve }) => {
-			event.locals.user = "alice";
-			return resolve(event);
-		};
-
-		const b: Handle = async ({ event, resolve }) => {
-			event.locals.greet = `hello ${event.locals.user}`;
-			return resolve(event);
-		};
-
-		const handler = sequence(a, b);
-		const event = fakeEvent();
-		await handler({
-			event,
-			resolve: async (evt) => {
-				return new Response(JSON.stringify(evt.locals));
-			},
-		});
-
-		expect(event.locals.user).toBe("alice");
-		expect(event.locals.greet).toBe("hello alice");
-	});
-
-	test("can modify response", async () => {
-		const a: Handle = async ({ event, resolve }) => {
-			const res = await resolve(event);
-			const headers = new Headers(res.headers);
-			headers.set("X-First", "1");
-			return new Response(res.body, { status: res.status, headers });
-		};
-
-		const b: Handle = async ({ event, resolve }) => {
-			const res = await resolve(event);
-			const headers = new Headers(res.headers);
-			headers.set("X-Second", "2");
-			return new Response(res.body, { status: res.status, headers });
-		};
-
-		const handler = sequence(a, b);
-		const res = await handler({
-			event: fakeEvent(),
-			resolve: async () => new Response("OK"),
-		});
-
-		expect(res.headers.get("X-First")).toBe("1");
-		expect(res.headers.get("X-Second")).toBe("2");
-	});
-
-	test("single handler works", async () => {
-		const handler: Handle = async ({ event, resolve }) => {
-			return resolve(event);
-		};
-
-		const res = await sequence(handler)({
-			event: fakeEvent(),
-			resolve: async () => new Response("Single"),
-		});
-
-		expect(await res.text()).toBe("Single");
-	});
-
-	test("three handlers chain correctly", async () => {
-		const order: string[] = [];
-
-		const a: Handle = async ({ event, resolve }) => {
-			order.push("a");
-			return resolve(event);
-		};
-		const b: Handle = async ({ event, resolve }) => {
-			order.push("b");
-			return resolve(event);
-		};
-		const c: Handle = async ({ event, resolve }) => {
-			order.push("c");
-			return resolve(event);
-		};
-
-		await sequence(a, b, c)({
-			event: fakeEvent(),
-			resolve: async () => new Response("OK"),
-		});
-
-		expect(order).toEqual(["a", "b", "c"]);
-	});
-});
-
-describe("Cookies", () => {
-	function makeEvent(cookieHeader = ""): RequestEvent {
-		return fakeEvent({
-			cookies: createCookies(cookieHeader),
-		});
-	}
-
-	test("cookies.get reads from header", async () => {
-		let value: string | undefined;
-		const handler: Handle = async ({ event, resolve }) => {
-			value = event.cookies.get("session");
-			return resolve(event);
-		};
-
-		await handler({
-			event: makeEvent("session=abc123; theme=dark"),
-			resolve: async () => new Response("OK"),
-		});
-
-		expect(value).toBe("abc123");
-	});
-
-	test("cookies.set adds Set-Cookie header", async () => {
-		const event = makeEvent();
-		const handler: Handle = async ({ event: evt, resolve }) => {
-			evt.cookies.set("token", "xyz", { httpOnly: true, path: "/" });
-			return resolve(evt);
-		};
-
-		await handler({
-			event,
-			resolve: async () => new Response("OK"),
-		});
-
-		expect(event.cookies.get("token")).toBe("xyz");
-		const cookieUtils = event.cookies as ReturnType<typeof createCookies>;
-		expect(cookieUtils.toHeaders().length).toBe(1);
-		expect(cookieUtils.toHeaders()[0]).toContain("token=xyz");
-		expect(cookieUtils.toHeaders()[0]).toContain("HttpOnly");
-		expect(cookieUtils.toHeaders()[0]).toContain("Path=/");
-	});
-});
-
-describe("createHooks()", () => {
-	test("returns handle and init", async () => {
-		const handle: Handle = async ({ resolve, event }) => resolve(event);
-		const init = () => {};
-		const hooks = createHooks(handle, init);
-		expect(hooks.handle).toBe(handle);
-		expect(hooks.init).toBe(init);
-	});
-
-	test("returns handle without init", () => {
-		const handle: Handle = async ({ resolve, event }) => resolve(event);
-		const hooks = createHooks(handle);
-		expect(hooks.handle).toBe(handle);
-		expect(hooks.init).toBeUndefined();
-	});
-});
+import { describe, expect, test } from "bun:test";
+import { sequence, createHooks } from "../src/hooks";
+import { createCookies } from "../src/cookie-utils";
+import type { Handle, RequestEvent } from "../src/hooks";
+
+function fakeEvent(overrides?: Partial<RequestEvent>): RequestEvent {
+	return {
+		request: new Request("http://localhost/"),
+		url: new URL("http://localhost/"),
+		params: {},
+		locals: {},
+		cookies: {
+			get: () => undefined,
+			set: () => {},
+			delete: () => {},
+		},
+		setHeaders: () => {},
+		...overrides,
+	};
+}
+
+describe("sequence()", () => {
+	test("chains two handlers in order", async () => {
+		const order: string[] = [];
+
+		const a: Handle = async ({ event, resolve }) => {
+			order.push("a-before");
+			const res = await resolve(event);
+			order.push("a-after");
+			return res;
+		};
+
+		const b: Handle = async ({ event, resolve }) => {
+			order.push("b-before");
+			const res = await resolve(event);
+			order.push("b-after");
+			return res;
+		};
+
+		const handler = sequence(a, b);
+		const res = await handler({
+			event: fakeEvent(),
+			resolve: async (evt) => new Response("OK"),
+		});
+
+		expect(order).toEqual(["a-before", "b-before", "b-after", "a-after"]);
+		expect(await res.text()).toBe("OK");
+	});
+
+	test("can short-circuit", async () => {
+		let reached = false;
+
+		const a: Handle = async () => {
+			return new Response("Blocked", { status: 403 });
+		};
+
+		const b: Handle = async ({ resolve, event }) => {
+			reached = true;
+			return resolve(event);
+		};
+
+		const handler = sequence(a, b);
+		const res = await handler({
+			event: fakeEvent(),
+			resolve: async () => new Response("OK"),
+		});
+
+		expect(reached).toBe(false);
+		expect(res.status).toBe(403);
+	});
+
+	test("can modify event.locals", async () => {
+		const a: Handle = async ({ event, resolve }) => {
+			event.locals.user = "alice";
+			return resolve(event);
+		};
+
+		const b: Handle = async ({ event, resolve }) => {
+			event.locals.greet = `hello ${event.locals.user}`;
+			return resolve(event);
+		};
+
+		const handler = sequence(a, b);
+		const event = fakeEvent();
+		await handler({
+			event,
+			resolve: async (evt) => {
+				return new Response(JSON.stringify(evt.locals));
+			},
+		});
+
+		expect(event.locals.user).toBe("alice");
+		expect(event.locals.greet).toBe("hello alice");
+	});
+
+	test("can modify response", async () => {
+		const a: Handle = async ({ event, resolve }) => {
+			const res = await resolve(event);
+			const headers = new Headers(res.headers);
+			headers.set("X-First", "1");
+			return new Response(res.body, { status: res.status, headers });
+		};
+
+		const b: Handle = async ({ event, resolve }) => {
+			const res = await resolve(event);
+			const headers = new Headers(res.headers);
+			headers.set("X-Second", "2");
+			return new Response(res.body, { status: res.status, headers });
+		};
+
+		const handler = sequence(a, b);
+		const res = await handler({
+			event: fakeEvent(),
+			resolve: async () => new Response("OK"),
+		});
+
+		expect(res.headers.get("X-First")).toBe("1");
+		expect(res.headers.get("X-Second")).toBe("2");
+	});
+
+	test("single handler works", async () => {
+		const handler: Handle = async ({ event, resolve }) => {
+			return resolve(event);
+		};
+
+		const res = await sequence(handler)({
+			event: fakeEvent(),
+			resolve: async () => new Response("Single"),
+		});
+
+		expect(await res.text()).toBe("Single");
+	});
+
+	test("three handlers chain correctly", async () => {
+		const order: string[] = [];
+
+		const a: Handle = async ({ event, resolve }) => {
+			order.push("a");
+			return resolve(event);
+		};
+		const b: Handle = async ({ event, resolve }) => {
+			order.push("b");
+			return resolve(event);
+		};
+		const c: Handle = async ({ event, resolve }) => {
+			order.push("c");
+			return resolve(event);
+		};
+
+		await sequence(a, b, c)({
+			event: fakeEvent(),
+			resolve: async () => new Response("OK"),
+		});
+
+		expect(order).toEqual(["a", "b", "c"]);
+	});
+});
+
+describe("Cookies", () => {
+	function makeEvent(cookieHeader = ""): RequestEvent {
+		return fakeEvent({
+			cookies: createCookies(cookieHeader),
+		});
+	}
+
+	test("cookies.get reads from header", async () => {
+		let value: string | undefined;
+		const handler: Handle = async ({ event, resolve }) => {
+			value = event.cookies.get("session");
+			return resolve(event);
+		};
+
+		await handler({
+			event: makeEvent("session=abc123; theme=dark"),
+			resolve: async () => new Response("OK"),
+		});
+
+		expect(value).toBe("abc123");
+	});
+
+	test("cookies.set adds Set-Cookie header", async () => {
+		const event = makeEvent();
+		const handler: Handle = async ({ event: evt, resolve }) => {
+			evt.cookies.set("token", "xyz", { httpOnly: true, path: "/" });
+			return resolve(evt);
+		};
+
+		await handler({
+			event,
+			resolve: async () => new Response("OK"),
+		});
+
+		expect(event.cookies.get("token")).toBe("xyz");
+		const cookieUtils = event.cookies as ReturnType<typeof createCookies>;
+		expect(cookieUtils.toHeaders().length).toBe(1);
+		expect(cookieUtils.toHeaders()[0]).toContain("token=xyz");
+		expect(cookieUtils.toHeaders()[0]).toContain("HttpOnly");
+		expect(cookieUtils.toHeaders()[0]).toContain("Path=/");
+	});
+});
+
+describe("createHooks()", () => {
+	test("returns handle and init", async () => {
+		const handle: Handle = async ({ resolve, event }) => resolve(event);
+		const init = () => {};
+		const hooks = createHooks(handle, init);
+		expect(hooks.handle).toBe(handle);
+		expect(hooks.init).toBe(init);
+	});
+
+	test("returns handle without init", () => {
+		const handle: Handle = async ({ resolve, event }) => resolve(event);
+		const hooks = createHooks(handle);
+		expect(hooks.handle).toBe(handle);
+		expect(hooks.init).toBeUndefined();
+	});
+});

package/test/redirect-error.test.ts

@@ -1,112 +1,112 @@
-import { describe, expect, test } from "bun:test";
-import { redirect, isRedirectResult } from "../src/redirect";
-import { error, isErrorResult } from "../src/error";
-
-describe("redirect()", () => {
-	test("throws a RedirectResult", () => {
-		try {
-			redirect(302, "/login");
-			expect(true).toBe(false); // should not reach
-		} catch (e) {
-			expect(isRedirectResult(e)).toBe(true);
-			expect(e.status).toBe(302);
-			expect(e.location).toBe("/login");
-		}
-	});
-
-	test("isRedirectResult returns false for plain objects", () => {
-		expect(isRedirectResult({ status: 302, location: "/login" })).toBe(false);
-		expect(isRedirectResult(null)).toBe(false);
-		expect(isRedirectResult(undefined)).toBe(false);
-	});
-
-	test("works with different status codes", () => {
-		try {
-			redirect(301, "/old");
-		} catch (e) {
-			expect(e.status).toBe(301);
-			expect(e.location).toBe("/old");
-		}
-		try {
-			redirect(303, "/other");
-		} catch (e) {
-			expect(e.status).toBe(303);
-			expect(e.location).toBe("/other");
-		}
-		try {
-			redirect(307, "/temp");
-		} catch (e) {
-			expect(e.status).toBe(307);
-			expect(e.location).toBe("/temp");
-		}
-	});
-});
-
-describe("error()", () => {
-	test("throws an ErrorResult with status and message", () => {
-		try {
-			error(404, "Not found");
-			expect(true).toBe(false);
-		} catch (e) {
-			expect(isErrorResult(e)).toBe(true);
-			expect(e.status).toBe(404);
-			expect(e.message).toBe("Not found");
-		}
-	});
-
-	test("isErrorResult returns false for plain objects", () => {
-		expect(isErrorResult({ status: 404, message: "Not found" })).toBe(false);
-		expect(isErrorResult(null)).toBe(false);
-	});
-
-	test("works with different status codes", () => {
-		try {
-			error(401, "Unauthorized");
-		} catch (e) {
-			expect(e.status).toBe(401);
-			expect(e.message).toBe("Unauthorized");
-		}
-		try {
-			error(500, "Internal Server Error");
-		} catch (e) {
-			expect(e.status).toBe(500);
-			expect(e.message).toBe("Internal Server Error");
-		}
-	});
-});
-
-describe("redirect and error together", () => {
-	test("can be caught in sequence", async () => {
-		let caught = 0;
-
-		try {
-			redirect(302, "/login");
-		} catch (e) {
-			if (isRedirectResult(e)) caught++;
-		}
-
-		try {
-			error(404, "Not found");
-		} catch (e) {
-			if (isErrorResult(e)) caught++;
-		}
-
-		expect(caught).toBe(2);
-	});
-
-	test("redirect and error are distinguishable", () => {
-		try {
-			redirect(302, "/login");
-		} catch (e) {
-			expect(isRedirectResult(e)).toBe(true);
-			expect(isErrorResult(e)).toBe(false);
-		}
-
-		try {
-			error(404, "Not found");
-		} catch (e) {
-			expect(isErrorResult(e)).toBe(true);
-			expect(isRedirectResult(e)).toBe(false);
-		}
-	});
-});
+import { describe, expect, test } from "bun:test";
+import { redirect, isRedirectResult } from "../src/redirect";
+import { error, isErrorResult } from "../src/error";
+
+describe("redirect()", () => {
+	test("throws a RedirectResult", () => {
+		try {
+			redirect(302, "/login");
+			expect(true).toBe(false); // should not reach
+		} catch (e) {
+			expect(isRedirectResult(e)).toBe(true);
+			expect(e.status).toBe(302);
+			expect(e.location).toBe("/login");
+		}
+	});
+
+	test("isRedirectResult returns false for plain objects", () => {
+		expect(isRedirectResult({ status: 302, location: "/login" })).toBe(false);
+		expect(isRedirectResult(null)).toBe(false);
+		expect(isRedirectResult(undefined)).toBe(false);
+	});
+
+	test("works with different status codes", () => {
+		try {
+			redirect(301, "/old");
+		} catch (e) {
+			expect(e.status).toBe(301);
+			expect(e.location).toBe("/old");
+		}
+		try {
+			redirect(303, "/other");
+		} catch (e) {
+			expect(e.status).toBe(303);
+			expect(e.location).toBe("/other");
+		}
+		try {
+			redirect(307, "/temp");
+		} catch (e) {
+			expect(e.status).toBe(307);
+			expect(e.location).toBe("/temp");
+		}
+	});
+});
+
+describe("error()", () => {
+	test("throws an ErrorResult with status and message", () => {
+		try {
+			error(404, "Not found");
+			expect(true).toBe(false);
+		} catch (e) {
+			expect(isErrorResult(e)).toBe(true);
+			expect(e.status).toBe(404);
+			expect(e.message).toBe("Not found");
+		}
+	});
+
+	test("isErrorResult returns false for plain objects", () => {
+		expect(isErrorResult({ status: 404, message: "Not found" })).toBe(false);
+		expect(isErrorResult(null)).toBe(false);
+	});
+
+	test("works with different status codes", () => {
+		try {
+			error(401, "Unauthorized");
+		} catch (e) {
+			expect(e.status).toBe(401);
+			expect(e.message).toBe("Unauthorized");
+		}
+		try {
+			error(500, "Internal Server Error");
+		} catch (e) {
+			expect(e.status).toBe(500);
+			expect(e.message).toBe("Internal Server Error");
+		}
+	});
+});
+
+describe("redirect and error together", () => {
+	test("can be caught in sequence", async () => {
+		let caught = 0;
+
+		try {
+			redirect(302, "/login");
+		} catch (e) {
+			if (isRedirectResult(e)) caught++;
+		}
+
+		try {
+			error(404, "Not found");
+		} catch (e) {
+			if (isErrorResult(e)) caught++;
+		}
+
+		expect(caught).toBe(2);
+	});
+
+	test("redirect and error are distinguishable", () => {
+		try {
+			redirect(302, "/login");
+		} catch (e) {
+			expect(isRedirectResult(e)).toBe(true);
+			expect(isErrorResult(e)).toBe(false);
+		}
+
+		try {
+			error(404, "Not found");
+		} catch (e) {
+			expect(isErrorResult(e)).toBe(true);
+			expect(isRedirectResult(e)).toBe(false);
+		}
+	});
+});