feat(news): add searchable paginated publication archive

src/lib/services/news-archive.test.ts

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const state = vi.hoisted(() => ({
+	total: 55,
+	fail: false,
+	queries: [] as { sql: string; params: unknown[] }[],
+}));
+vi.mock("@/lib/db", async () => {
+	const schema = await import("@/db/schema");
+	const { drizzle } = await import("drizzle-orm/mysql-proxy");
+	return {
+		...schema,
+		db: drizzle(async (sql, params) => {
+			if (state.fail) throw new Error("unavailable");
+			state.queries.push({ sql, params });
+			return { rows: sql.includes("count(*)") ? [[state.total]] : [] };
+		}),
+	};
+});
+
+import { loadNewsArchive } from "./news-archive";
+
+describe("public news archive", () => {
+	beforeEach(() => {
+		state.total = 55;
+		state.fail = false;
+		state.queries = [];
+	});
+	it("filters unpublished and future articles before counting and paginating", async () => {
+		const result = await loadNewsArchive({ search: "needle'", page: 2 });
+		expect(result).toMatchObject({ total: 55, page: 2, lastPage: 3 });
+		for (const query of state.queries) {
+			expect(query.sql).toContain("`status` = ?");
+			expect(query.sql).toContain("<= NOW()");
+			expect(query.params.slice(0, 3)).toEqual([
+				"published",
+				"%needle'%",
+				"%needle'%",
+			]);
+		}
+		expect(state.queries[1].params.slice(-2)).toEqual([24, 24]);
+		expect(state.queries[1].sql).toMatch(
+			/order by COALESCE.* desc, .*`id` desc/,
+		);
+	});
+	it("orders oldest first by publication time and bounds the last page", async () => {
+		expect(await loadNewsArchive({ page: 999, order: "oldest" })).toMatchObject(
+			{ page: 3, order: "oldest" },
+		);
+		expect(state.queries[1].sql).toMatch(/order by COALESCE.* asc, .*`id` asc/);
+		expect(state.queries[1].params.slice(-2)).toEqual([24, 48]);
+	});
+	it("handles empty results and invalid pagination", async () => {
+		state.total = 0;
+		expect(await loadNewsArchive({ page: NaN, order: "bad" })).toMatchObject({
+			page: 1,
+			lastPage: 1,
+			order: "newest",
+		});
+	});
+	it("propagates failures instead of presenting them as an empty archive", async () => {
+		state.fail = true;
+		await expect(loadNewsArchive()).rejects.toThrow();
+	});
+});

src/lib/services/news-archive.ts

@@ -0,0 +1,55 @@
+import "server-only";
+import { and, asc, count, desc, eq, like, or, sql } from "drizzle-orm";
+import { db, WebsiteArticles } from "@/lib/db";
+
+export async function loadNewsArchive(
+	options: { search?: string; page?: number; order?: string } = {},
+) {
+	const search = (options.search ?? "").trim().slice(0, 191);
+	const order = options.order === "oldest" ? "oldest" : "newest";
+	const publishedAt =
+		sql<Date | null>`COALESCE(${WebsiteArticles.publishAt}, ${WebsiteArticles.createdAt})`.mapWith(
+			WebsiteArticles.createdAt,
+		);
+	const where = and(
+		eq(WebsiteArticles.status, "published"),
+		or(
+			sql`${WebsiteArticles.publishAt} IS NULL`,
+			sql`${WebsiteArticles.publishAt} <= NOW()`,
+		),
+		search
+			? or(
+					like(WebsiteArticles.title, `%${search}%`),
+					like(WebsiteArticles.shortStory, `%${search}%`),
+				)
+			: undefined,
+	);
+	const totals = await db
+		.select({ value: count() })
+		.from(WebsiteArticles)
+		.where(where);
+	const total = Number(totals[0]?.value ?? 0);
+	const perPage = 24;
+	const lastPage = Math.max(1, Math.ceil(total / perPage));
+	const page = Math.min(
+		lastPage,
+		Number.isFinite(options.page)
+			? Math.max(1, Math.trunc(options.page ?? 1))
+			: 1,
+	);
+	const sort = order === "oldest" ? asc : desc;
+	const rows = await db
+		.select({
+			slug: WebsiteArticles.slug,
+			title: WebsiteArticles.title,
+			shortStory: WebsiteArticles.shortStory,
+			image: WebsiteArticles.image,
+			createdAt: publishedAt,
+		})
+		.from(WebsiteArticles)
+		.where(where)
+		.orderBy(sort(publishedAt), sort(WebsiteArticles.id))
+		.limit(perPage)
+		.offset((page - 1) * perPage);
+	return { rows, total, page, perPage, lastPage, search, order };
+}