@remit/drizzle-service 0.0.16 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "Drizzle ORM service parameterized by dialect (Postgres / SQLite)",
   "type": "module",
   "main": "src/index.ts",

package/src/pagination.test.ts

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { decodeToken, encodeToken, resultList } from "./pagination.js";
+
+describe("continuation token decoding", () => {
+	test("round-trips a minted token", () => {
+		const token = encodeToken({ createdAt: 42, accountId: "a-1" });
+		assert.deepEqual(decodeToken(token), { createdAt: 42, accountId: "a-1" });
+	});
+
+	test("decodes a standard base64 token when asked", () => {
+		const token = Buffer.from(JSON.stringify({ id: "x" })).toString("base64");
+		assert.deepEqual(decodeToken(token, "base64"), { id: "x" });
+	});
+
+	for (const [label, token] of [
+		["unparseable", "not-a-cursor"],
+		["a bare number", Buffer.from("123").toString("base64url")],
+		["a JSON array", Buffer.from("[1,2]").toString("base64url")],
+		["JSON null", Buffer.from("null").toString("base64url")],
+	] as const) {
+		test(`rejects ${label}`, () => {
+			assert.throws(
+				() => decodeToken(token),
+				(error: unknown) => {
+					assert.equal((error as { statusCode?: number }).statusCode, 400);
+					assert.equal((error as Error).name, "BadRequestError");
+					return true;
+				},
+			);
+		});
+	}
+
+	test("a full page yields a token and a short page does not", () => {
+		assert.ok(resultList([1, 2], 2, { createdAt: 1 }).continuationToken);
+		assert.equal(
+			resultList([1], 2, { createdAt: 1 }).continuationToken,
+			undefined,
+		);
+	});
+});

package/src/pagination.ts

@@ -1,19 +1,31 @@
 import type { ResultList } from "@remit/data-ports";
+import { BadRequestError } from "@remit/data-ports/errors";
 
 export function encodeToken(data: Record<string, unknown>): string {
 	return Buffer.from(JSON.stringify(data)).toString("base64url");
 }
 
+// A continuation token is opaque and server-minted: absent means "first page",
+// present means "resume here". A token that does not decode is neither, so it
+// is a malformed parameter. Reading it as "first page" answered the request
+// with page one under a fresh token, so a client that kept paging kept
+// appending the same rows with nothing signalling the failure (#136).
 export function decodeToken(
 	token: string,
-): Record<string, unknown> | undefined {
+	encoding: "base64" | "base64url" = "base64url",
+): Record<string, unknown> {
+	let parsed: unknown;
 	try {
-		return JSON.parse(
-			Buffer.from(token, "base64url").toString("utf8"),
-		) as Record<string, unknown>;
+		parsed = JSON.parse(Buffer.from(token, encoding).toString("utf8"));
 	} catch {
-		return undefined;
+		throw new BadRequestError("Invalid continuationToken");
 	}
+
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+		throw new BadRequestError("Invalid continuationToken");
+	}
+
+	return parsed as Record<string, unknown>;
 }
 
 export function resultList<T>(

package/src/repos/filter.test.ts

@@ -276,4 +276,26 @@ describe("FilterRepo", () => {
 			"every filter is paged exactly once",
 		);
 	});
+
+	describe("continuation token rejection (#172)", () => {
+		for (const [label, token] of [
+			["an unparseable", "not-a-cursor"],
+			["a bare number", Buffer.from("123").toString("base64url")],
+			["a JSON array", Buffer.from("[1,2]").toString("base64url")],
+		] as const) {
+			test(`${label} token is rejected as a 400`, async () => {
+				await assert.rejects(
+					() =>
+						repo.listPageByAccountConfig(randomId(), {
+							continuationToken: token,
+						}),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+		}
+	});
 });

package/src/repos/i4-account-config.test.ts

@@ -102,4 +102,23 @@ describe("AccountConfigRepo", () => {
 
 		await repo.deleteMany([c1.accountConfigId, c2.accountConfigId]);
 	});
+
+	describe("continuation token rejection (#172)", () => {
+		for (const [label, token] of [
+			["an unparseable", "not-a-cursor"],
+			["a bare number", Buffer.from("123").toString("base64url")],
+			["a JSON array", Buffer.from("[1,2]").toString("base64url")],
+		] as const) {
+			test(`${label} token is rejected as a 400`, async () => {
+				await assert.rejects(
+					() => repo.listByUser(randomId(), { continuationToken: token }),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+		}
+	});
 });

package/src/repos/i4-account-export-request.test.ts

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { createTestDb, randomId, type TestDb } from "../test-db.js";
+import { AccountExportRequestRepo } from "./i4-account-export-request.js";
+
+describe("AccountExportRequestRepo", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let repo: AccountExportRequestRepo;
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		repo = new AccountExportRequestRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	describe("continuation token rejection (#172)", () => {
+		for (const [label, token] of [
+			["an unparseable", "not-a-cursor"],
+			["a bare number", Buffer.from("123").toString("base64url")],
+			["a JSON array", Buffer.from("[1,2]").toString("base64url")],
+		] as const) {
+			test(`${label} token is rejected as a 400`, async () => {
+				await assert.rejects(
+					() =>
+						repo.listByAccountConfig(randomId(), {
+							continuationToken: token,
+						}),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+		}
+	});
+});

package/src/repos/i4-account.test.ts

@@ -220,4 +220,34 @@ describe("AccountRepo", () => {
 
 		await repo.deleteMany(created);
 	});
+
+	describe("continuation token rejection (#172)", () => {
+		for (const [label, token] of [
+			["an unparseable", "not-a-cursor"],
+			["a bare number", Buffer.from("123").toString("base64url")],
+			["a JSON array", Buffer.from("[1,2]").toString("base64url")],
+		] as const) {
+			test(`list() rejects ${label} token as a 400`, async () => {
+				await assert.rejects(
+					() => repo.list(randomId(), { continuationToken: token }),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+
+			test(`listAllAccountsPage() rejects ${label} cursor as a 400`, async () => {
+				await assert.rejects(
+					() => repo.listAllAccountsPage({ cursor: token }),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+		}
+	});
 });

package/src/repos/i4-address.test.ts

@@ -406,4 +406,27 @@ describe("AddressRepo", () => {
 
 		await repo.deleteAddress(configB, b.addressId);
 	});
+
+	describe("continuation token rejection (#172)", () => {
+		for (const [label, token] of [
+			["an unparseable", "not-a-cursor"],
+			["a bare number", Buffer.from("123").toString("base64url")],
+			["a JSON array", Buffer.from("[1,2]").toString("base64url")],
+		] as const) {
+			test(`${label} cursor is rejected as a 400`, async () => {
+				await assert.rejects(
+					() =>
+						repo.listByAccountConfig({
+							accountConfigId: randomId(),
+							cursor: token,
+						}),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+		}
+	});
 });

package/src/repos/i4-mailbox.test.ts

@@ -208,4 +208,23 @@ describe("MailboxRepo", () => {
 
 		await repo.delete(accountB, b.mailboxId);
 	});
+
+	describe("continuation token rejection (#172)", () => {
+		for (const [label, token] of [
+			["an unparseable", "not-a-cursor"],
+			["a bare number", Buffer.from("123").toString("base64url")],
+			["a JSON array", Buffer.from("[1,2]").toString("base64url")],
+		] as const) {
+			test(`${label} token is rejected as a 400`, async () => {
+				await assert.rejects(
+					() => repo.listByAccount(randomId(), { continuationToken: token }),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+		}
+	});
 });

package/src/repos/i4-organize-job-request.test.ts

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { createTestDb, randomId, type TestDb } from "../test-db.js";
+import { OrganizeJobRequestRepo } from "./i4-organize-job-request.js";
+
+describe("OrganizeJobRequestRepo", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let repo: OrganizeJobRequestRepo;
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		repo = new OrganizeJobRequestRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	describe("continuation token rejection (#172)", () => {
+		for (const [label, token] of [
+			["an unparseable", "not-a-cursor"],
+			["a bare number", Buffer.from("123").toString("base64url")],
+			["a JSON array", Buffer.from("[1,2]").toString("base64url")],
+		] as const) {
+			test(`${label} token is rejected as a 400`, async () => {
+				await assert.rejects(
+					() =>
+						repo.listByAccountConfig(randomId(), {
+							continuationToken: token,
+						}),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+		}
+	});
+});

package/src/repos/i4-outbox-message.test.ts

@@ -295,4 +295,23 @@ describe("OutboxMessageRepo", () => {
 
 		await repo.delete(accountConfigId, msg.outboxMessageId);
 	});
+
+	describe("continuation token rejection (#172)", () => {
+		for (const [label, token] of [
+			["an unparseable", "not-a-cursor"],
+			["a bare number", Buffer.from("123").toString("base64url")],
+			["a JSON array", Buffer.from("[1,2]").toString("base64url")],
+		] as const) {
+			test(`${label} token is rejected as a 400`, async () => {
+				await assert.rejects(
+					() => repo.listByAccount(randomId(), { continuationToken: token }),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+		}
+	});
 });

package/src/repos/message.test.ts

@@ -485,4 +485,26 @@ describe("DrizzleMessageRepository", () => {
 			await messageRepo.deleteMany([]);
 		});
 	});
+
+	describe("continuation token rejection (#172)", () => {
+		for (const [label, token] of [
+			["an unparseable", "not-a-cursor"],
+			["a bare number", Buffer.from("123").toString("base64url")],
+			["a JSON array", Buffer.from("[1,2]").toString("base64url")],
+		] as const) {
+			test(`${label} token is rejected as a 400`, async () => {
+				await assert.rejects(
+					() =>
+						messageRepo.listByMailbox("mailbox-172", {
+							continuationToken: token,
+						}),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+		}
+	});
 });

package/src/repos/thread-message.sqlite.test.ts

@@ -520,4 +520,92 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 			"pages do not overlap",
 		);
 	});
+
+	describe("search continuation token", () => {
+		const acct = "acct-search-cursor";
+
+		before(async () => {
+			const base = Date.now();
+			for (let i = 0; i < 4; i++) {
+				await repo.create(
+					makeInput({
+						accountConfigId: acct,
+						subject: `cursor probe ${i}`,
+						sentDate: base - i,
+						internalDate: base - i,
+					}),
+				);
+			}
+		});
+
+		test("an absent token returns the first page", async () => {
+			const page = await repo.searchByMailboxWindow(
+				acct,
+				MAILBOX,
+				{ subject: "cursor probe" },
+				{ limit: 2, order: "desc" },
+			);
+			assert.equal(page.items.length, 2);
+			assert.equal(page.items[0]?.subject, "cursor probe 0");
+			assert.ok(page.continuationToken);
+		});
+
+		test("a server-minted token returns the next page", async () => {
+			const first = await repo.searchByMailboxWindow(
+				acct,
+				MAILBOX,
+				{ subject: "cursor probe" },
+				{ limit: 2, order: "desc" },
+			);
+			const second = await repo.searchByMailboxWindow(
+				acct,
+				MAILBOX,
+				{ subject: "cursor probe" },
+				{
+					limit: 2,
+					order: "desc",
+					continuationToken: first.continuationToken,
+				},
+			);
+			assert.equal(second.items.length, 2);
+			const firstIds = new Set(first.items.map((i) => i.threadMessageId));
+			assert.ok(
+				second.items.every((i) => !firstIds.has(i.threadMessageId)),
+				"pages do not overlap",
+			);
+		});
+
+		for (const [label, token] of [
+			["an unparseable", "not-a-cursor"],
+			["a non-object", Buffer.from("123").toString("base64")],
+			["an incomplete", Buffer.from('{"s":1}').toString("base64")],
+		] as const) {
+			test(`${label} token is a validation failure`, async () => {
+				await assert.rejects(
+					() =>
+						repo.searchByMailboxWindow(
+							acct,
+							MAILBOX,
+							{ subject: "cursor probe" },
+							{ limit: 2, continuationToken: token },
+						),
+					(error: unknown) => {
+						assert.equal((error as { statusCode?: number }).statusCode, 400);
+						assert.equal((error as Error).name, "BadRequestError");
+						return true;
+					},
+				);
+			});
+		}
+
+		test("an undecodable account cursor is a validation failure", async () => {
+			await assert.rejects(
+				() => repo.listByAccount(acct, { continuationToken: "not-a-cursor" }),
+				(error: unknown) => {
+					assert.equal((error as { statusCode?: number }).statusCode, 400);
+					return true;
+				},
+			);
+		});
+	});
 });

package/src/repos/thread-message.ts

@@ -6,6 +6,7 @@ import type {
 	ThreadMessageItem,
 	UpdateThreadMessageInput,
 } from "@remit/data-ports";
+import { BadRequestError } from "@remit/data-ports/errors";
 import {
 	and,
 	asc,
@@ -23,6 +24,7 @@ import shortUuid from "short-uuid";
 import { v5 as uuidv5 } from "uuid";
 import type { Db } from "../db.js";
 import { NotFoundError } from "../error.js";
+import { decodeToken } from "../pagination.js";
 import { threadMessageTable } from "../schema/thread-message.js";
 import { fromMatch, subjectMatch } from "./thread-search-predicates.js";
 
@@ -64,12 +66,12 @@ function encodeDateCursor(sentDate: number, threadMessageId: string): string {
 	).toString("base64");
 }
 
-function decodeDateCursor(token: string): DateCursor | null {
-	try {
-		return JSON.parse(Buffer.from(token, "base64").toString()) as DateCursor;
-	} catch {
-		return null;
+function decodeDateCursor(token: string): DateCursor {
+	const decoded = decodeToken(token, "base64");
+	if (typeof decoded.s !== "number" || typeof decoded.id !== "string") {
+		throw new BadRequestError("Invalid continuationToken");
 	}
+	return { s: decoded.s, id: decoded.id };
 }
 
 function encodeAccountCursor(threadMessageId: string): string {
@@ -78,12 +80,12 @@ function encodeAccountCursor(threadMessageId: string): string {
 	);
 }
 
-function decodeAccountCursor(token: string): AccountCursor | null {
-	try {
-		return JSON.parse(Buffer.from(token, "base64").toString()) as AccountCursor;
-	} catch {
-		return null;
+function decodeAccountCursor(token: string): AccountCursor {
+	const decoded = decodeToken(token, "base64");
+	if (typeof decoded.id !== "string") {
+		throw new BadRequestError("Invalid continuationToken");
 	}
+	return { id: decoded.id };
 }
 
 // ─── Schema ──────────────────────────────────────────────────────────────────