@0x0501/mystack 0.0.0-stage → 0.1.0-bootstrap.0

package/template/src/__tests__/navigation-loading.test.tsx

@@ -0,0 +1,252 @@
+// @vitest-environment jsdom
+
+import { dehydrate, hydrate, QueryObserver } from "@tanstack/react-query";
+import { createMemoryHistory, RouterProvider } from "@tanstack/react-router";
+import { act, cleanup, render, screen, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { RootSession } from "@/server/auth";
+
+const { getSession, loadPage } = vi.hoisted(() => ({
+	getSession: vi.fn<() => Promise<RootSession | null>>(),
+	loadPage: vi.fn<() => Promise<string>>(),
+}));
+
+vi.mock("@/server/auth", () => ({ getSession }));
+vi.mock("#/components/root/root-document.tsx", () => ({
+	RootDocument: ({ children }: { children: ReactNode }) => children,
+}));
+
+// Keep the real root beforeLoad, router defaults and SSR Query integration.
+// Only replace the child pages and their network/database responses.
+vi.mock("@/routeTree.gen", async () => {
+	const { createRoute, Link, redirect } = await import(
+		"@tanstack/react-router"
+	);
+	const { Route: root } = await import("@/routes/__root");
+	const home = createRoute({
+		getParentRoute: () => root,
+		path: "/",
+		component: () => (
+			<div>
+				<h1>Previous page</h1>
+				<Link to="/dashboard">Next page</Link>
+			</div>
+		),
+	});
+	const dashboard = createRoute({
+		getParentRoute: () => root,
+		path: "/dashboard",
+		beforeLoad: ({ context }) => {
+			if (!context.session) throw redirect({ to: "/sign-in" });
+		},
+		loader: ({ context }) =>
+			context.queryClient.ensureQueryData({
+				queryKey: ["page"],
+				queryFn: loadPage,
+			}),
+		component: () => <h1>Next page</h1>,
+	});
+	const signIn = createRoute({
+		getParentRoute: () => root,
+		path: "/sign-in",
+		component: () => <h1>Sign in</h1>,
+	});
+	return { routeTree: root.addChildren([home, dashboard, signIn]) };
+});
+
+const { getRouter } = await import("@/router");
+const { sessionQueryOptions } = await import(
+	"@/integrations/better-auth/session-query"
+);
+
+const session: RootSession = {
+	user: {
+		id: "user-1",
+		email: "user@example.com",
+		name: "User",
+		emailVerified: true,
+		role: "user",
+		twoFactorEnabled: false,
+		locale: "en",
+	},
+};
+
+function deferred<T>() {
+	let resolve!: (value: T) => void;
+	const promise = new Promise<T>((done) => {
+		resolve = done;
+	});
+	return { promise, resolve };
+}
+
+const routers: ReturnType<typeof getRouter>[] = [];
+
+function createTestRouter() {
+	const router = getRouter();
+	router.update({
+		context: router.options.context,
+		history: createMemoryHistory({ initialEntries: ["/"] }),
+	});
+	routers.push(router);
+	return router;
+}
+
+async function start() {
+	const router = createTestRouter();
+	await router.load();
+	render(<RouterProvider router={router} />);
+	await screen.findByRole("heading", { name: "Previous page" });
+	return router;
+}
+
+beforeEach(() => {
+	vi.spyOn(window, "scrollTo").mockImplementation(() => {});
+	getSession.mockReset().mockResolvedValue(session);
+	loadPage.mockReset().mockResolvedValue("page data");
+});
+
+afterEach(() => {
+	cleanup();
+	vi.restoreAllMocks();
+	for (const router of routers.splice(0)) {
+		router.options.context.queryClient.clear();
+	}
+});
+
+describe("navigation with production network latency", () => {
+	it("isolates router caches and reuses the hydrated session in the browser", async () => {
+		const firstRequest = createTestRouter();
+		const secondRequest = createTestRouter();
+		await firstRequest.load();
+		getSession.mockResolvedValue(null);
+		await secondRequest.load();
+		expect(firstRequest.state.matches[0]?.context.session).toEqual(session);
+		expect(secondRequest.state.matches[0]?.context.session).toBeNull();
+		expect(getSession).toHaveBeenCalledTimes(2);
+
+		const browser = createTestRouter();
+		hydrate(
+			browser.options.context.queryClient,
+			dehydrate(firstRequest.options.context.queryClient),
+		);
+		await browser.load();
+		expect(browser.state.matches[0]?.context.session).toEqual(session);
+		expect(getSession).toHaveBeenCalledTimes(2);
+	});
+
+	it("does not hold a failed session check through retry backoff", async () => {
+		const router = createTestRouter();
+		getSession.mockRejectedValue(new TypeError("Failed to fetch"));
+		await expect(
+			router.options.context.queryClient.fetchQuery(sessionQueryOptions),
+		).rejects.toThrow("Failed to fetch");
+		expect(getSession).toHaveBeenCalledTimes(1);
+	});
+
+	it("reuses the session across intent preloading and client navigation", async () => {
+		const router = await start();
+		await act(() => router.preloadRoute({ to: "/dashboard" }));
+		await act(() => router.navigate({ to: "/dashboard" }));
+
+		await screen.findByRole("heading", { name: "Next page" });
+		expect(getSession).toHaveBeenCalledTimes(1);
+		expect(loadPage).toHaveBeenCalledTimes(1);
+	});
+
+	it("revalidates an expired session before entering a protected page", async () => {
+		const router = await start();
+		router.options.context.queryClient.setQueryData(
+			["auth", "session"],
+			session,
+			{
+				updatedAt: Date.now() - 31_000,
+			},
+		);
+		getSession.mockResolvedValue(null);
+		await act(() => router.navigate({ to: "/dashboard" }));
+
+		await screen.findByRole("heading", { name: "Sign in" });
+		expect(loadPage).not.toHaveBeenCalled();
+	});
+
+	it("shows loading feedback while a session check is waiting", async () => {
+		const router = await start();
+		const gate = deferred<RootSession | null>();
+		getSession.mockReturnValue(gate.promise);
+		await router.options.context.queryClient.invalidateQueries({
+			queryKey: ["auth", "session"],
+		});
+		let navigation!: Promise<void>;
+		act(() => {
+			navigation = router.navigate({ to: "/dashboard" });
+		});
+		try {
+			await screen.findByRole("status", {}, { timeout: 600 });
+			expect(loadPage).not.toHaveBeenCalled();
+		} finally {
+			await act(async () => {
+				gate.resolve(session);
+				await navigation;
+			});
+		}
+		await screen.findByRole("heading", { name: "Next page" });
+	});
+
+	it("shows loading feedback during a slow loader and renders as soon as it resolves", async () => {
+		const router = await start();
+		const gate = deferred<string>();
+		loadPage.mockReturnValue(gate.promise);
+		let navigation!: Promise<void>;
+		act(() => {
+			navigation = router.navigate({ to: "/dashboard" });
+		});
+		let resolvedAt = 0;
+		try {
+			await screen.findByRole("status", {}, { timeout: 600 });
+			expect(
+				screen.queryByRole("heading", { name: "Previous page" }),
+			).toBeNull();
+		} finally {
+			await act(async () => {
+				resolvedAt = performance.now();
+				gate.resolve("page data");
+				await navigation;
+			});
+		}
+		await screen.findByRole("heading", { name: "Next page" }, { timeout: 200 });
+		expect(performance.now() - resolvedAt).toBeLessThan(300);
+	});
+
+	it("does not fetch loader data again when the page mounts its query", async () => {
+		const router = await start();
+		await act(() => router.navigate({ to: "/dashboard" }));
+		const observer = new QueryObserver(router.options.context.queryClient, {
+			queryKey: ["page"],
+			queryFn: loadPage,
+		});
+		const unsubscribe = observer.subscribe(() => {});
+		try {
+			await waitFor(() =>
+				expect(observer.getCurrentResult().isFetching).toBe(false),
+			);
+			expect(loadPage).toHaveBeenCalledTimes(1);
+		} finally {
+			unsubscribe();
+		}
+	});
+
+	it("refreshes invalidated session data when route guards are rerun", async () => {
+		const router = await start();
+		getSession.mockResolvedValue({
+			...session,
+			user: { ...session.user, name: "Updated" },
+		});
+		await router.options.context.queryClient.invalidateQueries({
+			queryKey: ["auth", "session"],
+		});
+		await act(() => router.invalidate());
+		expect(router.state.matches[0]?.context.session?.user.name).toBe("Updated");
+		expect(getSession).toHaveBeenCalledTimes(2);
+	});
+});

package/template/src/__tests__/nowpayments.test.ts

@@ -0,0 +1,106 @@
+import { createHmac } from "node:crypto";
+import { describe, expect, it } from "vitest";
+import type { Database } from "@/db";
+import {
+	handleNowPaymentsWebhook,
+	verifyNowPaymentsSignature,
+} from "@/services/nowpayments";
+
+/** A db that fails the test if the handler touches it. */
+const unusableDb = new Proxy({} as Database, {
+	get() {
+		throw new Error("handler reached the database on an unverified callback");
+	},
+});
+
+function sign(secret: string, canonical: string): string {
+	return createHmac("sha512", secret).update(canonical).digest("hex");
+}
+
+describe("verifyNowPaymentsSignature", () => {
+	it("accepts HMAC-SHA512 over recursively sorted JSON keys", async () => {
+		const body = JSON.stringify({ payment_status: "finished", b: 1, a: 2 });
+		const canonical = JSON.stringify({
+			a: 2,
+			b: 1,
+			payment_status: "finished",
+		});
+		expect(
+			await verifyNowPaymentsSignature(
+				"ipn_sec",
+				body,
+				sign("ipn_sec", canonical),
+			),
+		).toBe(true);
+	});
+
+	it("sorts nested objects but keeps array order", async () => {
+		const body = JSON.stringify({ z: { b: 1, a: [2, 1] }, y: 0 });
+		const canonical = JSON.stringify({ y: 0, z: { a: [2, 1], b: 1 } });
+		expect(
+			await verifyNowPaymentsSignature(
+				"ipn_sec",
+				body,
+				sign("ipn_sec", canonical),
+			),
+		).toBe(true);
+	});
+
+	it("rejects a missing or wrong signature", async () => {
+		const body = '{"payment_status":"finished"}';
+		expect(await verifyNowPaymentsSignature("ipn_sec", body, null)).toBe(false);
+		expect(await verifyNowPaymentsSignature("ipn_sec", body, "deadbeef")).toBe(
+			false,
+		);
+	});
+
+	// A refusal, not a crash: a 500 here would tell NowPayments to retry, and a
+	// hostile body would be replayed forever.
+	it("refuses an unparseable body instead of throwing", async () => {
+		expect(await verifyNowPaymentsSignature("ipn_sec", "{not json", "aa")).toBe(
+			false,
+		);
+	});
+
+	it("refuses a body nested past the depth limit instead of exhausting the stack", async () => {
+		let deep = "1";
+		for (let i = 0; i < 200; i++) deep = `{"a":${deep}}`;
+		expect(await verifyNowPaymentsSignature("ipn_sec", deep, "aa")).toBe(false);
+	});
+});
+
+describe("handleNowPaymentsWebhook", () => {
+	it("refuses an unverified callback without touching the database", async () => {
+		const result = await handleNowPaymentsWebhook(unusableDb, {
+			rawBody: '{"order_id":"o1","payment_status":"finished"}',
+			signature: "deadbeef",
+			ipnKey: "ipn_sec",
+		});
+		expect(result).toBe("invalid_signature");
+	});
+
+	it("leaves a non-terminal status alone", async () => {
+		const body = JSON.stringify({ order_id: "o1", payment_status: "waiting" });
+		const result = await handleNowPaymentsWebhook(unusableDb, {
+			rawBody: body,
+			signature: sign("ipn_sec", body),
+			ipnKey: "ipn_sec",
+		});
+		expect(result).toBe("noop");
+	});
+
+	it("does not fulfill an underpaid invoice", async () => {
+		const body = JSON.stringify({
+			actually_paid: 9,
+			order_id: "o1",
+			payment_status: "finished",
+			price_amount: 10,
+		});
+		const result = await handleNowPaymentsWebhook(unusableDb, {
+			rawBody: body,
+			signature: sign("ipn_sec", body),
+			ipnKey: "ipn_sec",
+		});
+		expect(result).toBe("underpaid");
+	});
+});

package/template/src/__tests__/paraglide-url-contract.test.ts

@@ -0,0 +1,87 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { deLocalizeHref, localizeHref } from "@/paraglide/runtime";
+
+// Seam: Paraglide URL contract (ADR 0005 / 0010). Full-app i18n prefixes
+// every user-facing HTML tree; machine paths stay identity (never locale-prefixed).
+// Asserted through the *real compiled runtime* so urlPatterns regressions fail CI.
+
+beforeAll(async () => {
+	if (
+		typeof (globalThis as { URLPattern?: unknown }).URLPattern === "undefined"
+	) {
+		const mod = (await import("@inlang/paraglide-js/urlpattern-polyfill")) as {
+			URLPattern?: unknown;
+			default?: unknown;
+		};
+		(globalThis as { URLPattern?: unknown }).URLPattern =
+			mod.URLPattern ?? mod.default;
+	}
+});
+
+describe("paraglide URL contract", () => {
+	it("keeps English on bare paths", () => {
+		expect(localizeHref("/sign-in", { locale: "en" })).toBe("/sign-in");
+		expect(localizeHref("/", { locale: "en" })).toBe("/");
+		expect(localizeHref("/dashboard", { locale: "en" })).toBe("/dashboard");
+		expect(localizeHref("/admin/users", { locale: "en" })).toBe("/admin/users");
+	});
+
+	it("prefixes German for public, auth, dashboard, and admin", () => {
+		expect(localizeHref("/", { locale: "de" })).toBe("/de/");
+		expect(localizeHref("/sign-in", { locale: "de" })).toBe("/de/sign-in");
+		expect(localizeHref("/sign-up", { locale: "de" })).toBe("/de/sign-up");
+		expect(localizeHref("/oauth/consent", { locale: "de" })).toBe(
+			"/de/oauth/consent",
+		);
+		expect(localizeHref("/dashboard", { locale: "de" })).toBe("/de/dashboard");
+		expect(localizeHref("/dashboard/account", { locale: "de" })).toBe(
+			"/de/dashboard/account",
+		);
+		expect(localizeHref("/admin", { locale: "de" })).toBe("/de/admin");
+		expect(localizeHref("/admin/users", { locale: "de" })).toBe(
+			"/de/admin/users",
+		);
+		expect(localizeHref("/admin/oauth-apps", { locale: "de" })).toBe(
+			"/de/admin/oauth-apps",
+		);
+	});
+
+	it("never localizes machine paths", () => {
+		for (const p of [
+			"/api/auth/session",
+			"/api/webhooks/stripe",
+			"/.well-known/oauth-authorization-server",
+			"/.well-known/openid-configuration",
+			"/api/auth/.well-known/openid-configuration",
+		]) {
+			expect(localizeHref(p, { locale: "de" })).toBe(p);
+			expect(localizeHref(p, { locale: "en" })).toBe(p);
+		}
+	});
+
+	it("delocalizes German back to the bare path", () => {
+		expect(deLocalizeHref("/de/sign-in")).toBe("/sign-in");
+		expect(deLocalizeHref("/de/")).toBe("/");
+		expect(deLocalizeHref("/de/dashboard")).toBe("/dashboard");
+		expect(deLocalizeHref("/de/dashboard/account")).toBe("/dashboard/account");
+		expect(deLocalizeHref("/de/admin/users")).toBe("/admin/users");
+		expect(deLocalizeHref("/dashboard")).toBe("/dashboard");
+	});
+
+	it("localizes trailing-slash user-facing paths to the same-locale URL", () => {
+		expect(localizeHref("/sign-in/", { locale: "de" })).toBe("/de/sign-in/");
+		expect(localizeHref("/dashboard/", { locale: "de" })).toBe(
+			"/de/dashboard/",
+		);
+		expect(localizeHref("/admin/users/", { locale: "de" })).toBe(
+			"/de/admin/users/",
+		);
+		expect(localizeHref("/sign-in/", { locale: "en" })).toBe("/sign-in/");
+	});
+
+	it("delocalizes trailing-slash German paths back to the bare form", () => {
+		expect(deLocalizeHref("/de/sign-in/")).toBe("/sign-in/");
+		expect(deLocalizeHref("/de/dashboard/")).toBe("/dashboard/");
+		expect(deLocalizeHref("/de/admin/users/")).toBe("/admin/users/");
+	});
+});

package/template/src/__tests__/purchase-fulfillment.test.ts

@@ -0,0 +1,204 @@
+/**
+ * Purchase fulfillment seam: the purchase-paid hook runs inside the same
+ * transaction as the pending→paid flip, so a delivery is exactly-once across
+ * webhook retries — never twice, and never silently lost.
+ *
+ * Runs against the real Postgres container: the atomicity under test is the
+ * database's, and an in-memory double cannot fail the way this needs to.
+ */
+import { and, eq } from "drizzle-orm";
+import { describe, expect, it, vi } from "vitest";
+import type { Database } from "@/db";
+import { adminAction, purchase } from "@/db/schema";
+import { markPurchasePaid, type Purchase } from "@/services/purchase";
+import { createTestDatabase, hasTestDatabase } from "./test-db";
+
+const PURCHASE_DDL = `
+	CREATE TEMP TABLE "purchase" (
+		id TEXT PRIMARY KEY,
+		user_id TEXT NOT NULL,
+		provider TEXT NOT NULL,
+		external_id TEXT NOT NULL,
+		amount TEXT NOT NULL,
+		currency TEXT NOT NULL DEFAULT 'usd',
+		status TEXT NOT NULL DEFAULT 'pending',
+		metadata JSONB,
+		paid_at TIMESTAMPTZ,
+		created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+		updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+		UNIQUE (provider, external_id)
+	);
+	CREATE TEMP TABLE "admin_action" (
+		id TEXT PRIMARY KEY,
+		actor_id TEXT,
+		action TEXT NOT NULL,
+		target_type TEXT,
+		target_id TEXT,
+		detail JSONB,
+		created_at TIMESTAMPTZ DEFAULT now() NOT NULL
+	);
+`;
+
+async function seedPending(
+	db: Database,
+	overrides: Partial<{ externalId: string; amount: number }> = {},
+) {
+	const id = crypto.randomUUID();
+	await db.insert(purchase).values({
+		id,
+		userId: "user-1",
+		provider: "stripe",
+		externalId: overrides.externalId ?? "cs_test_1",
+		amount: String(overrides.amount ?? 1999),
+		currency: "usd",
+		status: "pending",
+	});
+	return id;
+}
+
+function readRow(db: Database, externalId: string) {
+	return db
+		.select()
+		.from(purchase)
+		.where(
+			and(eq(purchase.provider, "stripe"), eq(purchase.externalId, externalId)),
+		)
+		.limit(1);
+}
+
+function readAudits(db: Database) {
+	return db.select().from(adminAction);
+}
+
+describe.skipIf(!hasTestDatabase)("markPurchasePaid", () => {
+	it("fulfills a pending purchase once, with the row's own amount and user", async () => {
+		const db = await createTestDatabase(PURCHASE_DDL);
+		await seedPending(db);
+		const hook = vi.fn(async (_tx: Database, _p: Purchase) => {});
+
+		const result = await markPurchasePaid(
+			db,
+			{ provider: "stripe", externalId: "cs_test_1" },
+			hook,
+		);
+
+		expect(result.status).toBe("fulfilled");
+		expect(hook).toHaveBeenCalledTimes(1);
+		// Trusted values come from the row, never from the callback.
+		expect(hook.mock.calls[0][1]).toMatchObject({
+			userId: "user-1",
+			amount: 1999,
+			currency: "usd",
+			status: "paid",
+		});
+
+		const [row] = await readRow(db, "cs_test_1");
+		expect(row.status).toBe("paid");
+		expect(row.paidAt).not.toBeNull();
+	});
+
+	it("ignores a duplicate delivery without running the hook again", async () => {
+		const db = await createTestDatabase(PURCHASE_DDL);
+		await seedPending(db);
+		const hook = vi.fn(async (_tx: Database, _p: Purchase) => {});
+
+		await markPurchasePaid(
+			db,
+			{ provider: "stripe", externalId: "cs_test_1" },
+			hook,
+		);
+		const again = await markPurchasePaid(
+			db,
+			{ provider: "stripe", externalId: "cs_test_1" },
+			hook,
+		);
+
+		expect(again.status).toBe("already_paid");
+		expect(hook).toHaveBeenCalledTimes(1);
+
+		const audits = await readAudits(db);
+		expect(audits.map((a) => a.action)).toEqual([
+			"purchase.paid",
+			"purchase.duplicate_ignored",
+		]);
+	});
+
+	it("reports not_found for an external id it does not know", async () => {
+		const db = await createTestDatabase(PURCHASE_DDL);
+		const hook = vi.fn(async (_tx: Database, _p: Purchase) => {});
+
+		const result = await markPurchasePaid(
+			db,
+			{ provider: "stripe", externalId: "cs_missing" },
+			hook,
+		);
+
+		expect(result.status).toBe("not_found");
+		expect(hook).not.toHaveBeenCalled();
+	});
+
+	it("fails closed when the reported amount disagrees with the row", async () => {
+		const db = await createTestDatabase(PURCHASE_DDL);
+		await seedPending(db, { amount: 1999 });
+		const hook = vi.fn(async (_tx: Database, _p: Purchase) => {});
+
+		const result = await markPurchasePaid(
+			db,
+			{ provider: "stripe", externalId: "cs_test_1", reportedAmount: 100 },
+			hook,
+		);
+
+		expect(result.status).toBe("amount_mismatch");
+		expect(hook).not.toHaveBeenCalled();
+		const [row] = await readRow(db, "cs_test_1");
+		expect(row.status).toBe("pending");
+	});
+
+	// The reason the hook takes `tx`. Without the shared transaction the flip
+	// survives a failed hook, the provider's retry short-circuits on
+	// `already_paid`, and the delivery is lost while the audit log claims it
+	// happened.
+	it("rolls the flip back when the hook throws, and the retry delivers exactly once", async () => {
+		const db = await createTestDatabase(PURCHASE_DDL);
+		await seedPending(db);
+
+		let attempts = 0;
+		const delivered: string[] = [];
+		const hook = async (_tx: Database, p: Purchase) => {
+			attempts += 1;
+			if (attempts === 1) throw new Error("fulfillment backend is down");
+			delivered.push(p.id);
+		};
+
+		await expect(
+			markPurchasePaid(
+				db,
+				{ provider: "stripe", externalId: "cs_test_1" },
+				hook,
+			),
+		).rejects.toThrow("fulfillment backend is down");
+
+		// The row is back to pending, so the retry is not short-circuited.
+		const [afterFailure] = await readRow(db, "cs_test_1");
+		expect(afterFailure.status).toBe("pending");
+		expect(afterFailure.paidAt).toBeNull();
+		expect(delivered).toEqual([]);
+
+		// And nothing claimed the purchase was delivered.
+		expect(await readAudits(db)).toHaveLength(0);
+
+		const retry = await markPurchasePaid(
+			db,
+			{ provider: "stripe", externalId: "cs_test_1" },
+			hook,
+		);
+
+		expect(retry.status).toBe("fulfilled");
+		expect(delivered).toHaveLength(1);
+		const [afterRetry] = await readRow(db, "cs_test_1");
+		expect(afterRetry.status).toBe("paid");
+		expect((await readAudits(db)).map((a) => a.action)).toEqual([
+			"purchase.paid",
+		]);
+	});
+});