@remit/drizzle-service 0.0.8 → 0.0.10

package/package.json

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

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

@@ -1,10 +1,38 @@
 import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { after, before, describe, test } from "node:test";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
 import { mailboxTable } from "../schema.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
 import { MailboxRepo } from "./i4-mailbox.js";
 
+/**
+ * The `mailbox` DDL as it actually ships, read from the committed migration
+ * rather than pushed from the drizzle table objects.
+ *
+ * The two disagree: the table object declares `highest_modseq` as text, the
+ * shipped migration still declares it `integer` (reader#73). Every other
+ * SQLite test in this package runs against the pushed shape, so none of them
+ * has ever exercised the one deployments run on — and SQLite hands a column
+ * with numeric affinity back as a number regardless of what the schema says.
+ * Reading the committed file keeps this test honest as the migration changes.
+ */
+const shippedMailboxDdl = (): string => {
+	const sql = readFileSync(
+		new URL(
+			"../../../../deploy/vps/migrations-sqlite/entities/0000_happy_roland_deschain.sql",
+			import.meta.url,
+		),
+		"utf8",
+	);
+	const match = sql.match(/CREATE TABLE `mailbox` \([\s\S]*?\n\);/);
+	if (!match)
+		throw new Error("mailbox DDL not found in the committed migration");
+	return match[0];
+};
+
 function makeMailboxInput(accountId: string, fullPath = "INBOX") {
 	return {
 		accountId,
@@ -61,3 +89,51 @@ describe("MailboxRepo (sqlite)", () => {
 		assert.equal(reread.highestModseq, "9007199254740993");
 	});
 });
+
+describe("MailboxRepo (sqlite, shipped column shape)", () => {
+	let close: () => Promise<void>;
+	let repo: MailboxRepo;
+
+	before(async () => {
+		const sqlite = new Database(":memory:");
+		sqlite.exec(shippedMailboxDdl());
+		const db = drizzle(sqlite, { schema: { mailbox: mailboxTable } });
+		repo = new MailboxRepo(db as never);
+		close = async () => {
+			sqlite.close();
+		};
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("reads the sync cursor back as a string, whatever the column stores", async () => {
+		// A plain-digit cursor lands in a column with numeric affinity and comes
+		// back a number. Callers compare the value they wrote against the value
+		// they read — `"900" === 900` is false — so an unnormalised read makes a
+		// stalled cursor undetectable.
+		const accountId = randomUUID();
+		const created = await repo.create({
+			...makeMailboxInput(accountId),
+			highestModseq: "900",
+		});
+
+		assert.strictEqual(created.highestModseq, "900");
+
+		const fetched = await repo.get(accountId, created.mailboxId);
+		assert.strictEqual(fetched.highestModseq, "900");
+		assert.strictEqual(fetched.highestModseq === "900", true);
+	});
+
+	test("keeps a resumable cursor intact through the same column", async () => {
+		const accountId = randomUUID();
+		const created = await repo.create({
+			...makeMailboxInput(accountId, "Archive"),
+			highestModseq: "900:149",
+		});
+
+		const fetched = await repo.get(accountId, created.mailboxId);
+		assert.strictEqual(fetched.highestModseq, "900:149");
+	});
+});

package/src/repos/i4-mailbox.ts

@@ -33,7 +33,15 @@ export function rowToMailbox(
 		fullPath: row.fullPath,
 		uidValidity: row.uidValidity,
 		uidNext: row.uidNext,
-		highestModseq: row.highestModseq,
+		// SQLite returns a column with numeric affinity as a number whatever the
+		// schema declares, and the shipped self-host migration still declares
+		// this one `integer` (reader#73). A cursor read back as a number is not
+		// merely awkward to parse: `"900" === 900` is false, so code comparing
+		// the value it just wrote against the value it read would conclude
+		// nothing had changed — which is how a stalled cursor goes unreported.
+		// Normalising here means every consumer sees the declared type instead
+		// of each one guarding separately.
+		highestModseq: String(row.highestModseq),
 		messageCount: row.messageCount,
 		unseenCount: row.unseenCount,
 		deletedCount: row.deletedCount,

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

@@ -164,6 +164,113 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 		assert.ok(n >= 1);
 	});
 
+	test("listByThread returns inbox and sent messages interleaved in order", async () => {
+		const acct = "acct-conversation";
+		const threadId = "t-conversation";
+		const inbox = "mbx-inbox";
+		const sent = "mbx-sent";
+		const base = Date.now();
+		const turns = [
+			{ mailboxId: inbox, subject: "Databricks pricing", at: base },
+			{ mailboxId: sent, subject: "Re: Databricks pricing", at: base + 1000 },
+			{ mailboxId: inbox, subject: "Re: Databricks pricing", at: base + 2000 },
+			{ mailboxId: sent, subject: "Re: Databricks pricing", at: base + 3000 },
+		];
+		for (const [index, turn] of turns.entries()) {
+			await repo.create(
+				makeInput({
+					accountConfigId: acct,
+					threadId,
+					messageId: `m-conversation-${index}`,
+					mailboxId: turn.mailboxId,
+					subject: turn.subject,
+					referenceOrder: index,
+					internalDate: turn.at,
+					sentDate: turn.at,
+				}),
+			);
+		}
+
+		const ascending = await repo.listByThread(threadId, acct, {
+			order: "asc",
+			excludeDeleted: true,
+		});
+		assert.deepEqual(
+			ascending.items.map((item) => item.mailboxId),
+			[inbox, sent, inbox, sent],
+			"the conversation carries both received and sent messages, oldest first",
+		);
+
+		const descending = await repo.listByThread(threadId, acct, {
+			order: "desc",
+			excludeDeleted: true,
+		});
+		assert.deepEqual(
+			descending.items.map((item) => item.mailboxId),
+			[sent, inbox, sent, inbox],
+			"reversing the order reverses the conversation",
+		);
+	});
+
+	test("listByThread excludes soft-deleted messages but keeps the rest of the conversation", async () => {
+		const acct = "acct-conversation-deleted";
+		const threadId = "t-conversation-deleted";
+		const base = Date.now();
+		const kept = await repo.create(
+			makeInput({
+				accountConfigId: acct,
+				threadId,
+				messageId: "m-kept",
+				mailboxId: "mbx-sent",
+				internalDate: base,
+				sentDate: base,
+			}),
+		);
+		await repo.create(
+			makeInput({
+				accountConfigId: acct,
+				threadId,
+				messageId: "m-trashed",
+				mailboxId: "mbx-trash",
+				isDeleted: true,
+				internalDate: base + 1000,
+				sentDate: base + 1000,
+			}),
+		);
+
+		const result = await repo.listByThread(threadId, acct, {
+			excludeDeleted: true,
+		});
+		assert.deepEqual(
+			result.items.map((item) => item.threadMessageId),
+			[kept.threadMessageId],
+		);
+	});
+
+	test("listByThread scopes to the account config", async () => {
+		const threadId = "t-shared-id";
+		await repo.create(
+			makeInput({
+				accountConfigId: "acct-mine",
+				threadId,
+				messageId: "m-mine",
+			}),
+		);
+		await repo.create(
+			makeInput({
+				accountConfigId: "acct-theirs",
+				threadId,
+				messageId: "m-theirs",
+			}),
+		);
+
+		const mine = await repo.listByThread(threadId, "acct-mine");
+		assert.deepEqual(
+			mine.items.map((item) => item.messageId),
+			["m-mine"],
+		);
+	});
+
 	test("listByDate paginates with a stable keyset cursor", async () => {
 		const acct = "acct-page";
 		const base = Date.now();

package/src/repos/thread-message.ts

@@ -558,7 +558,6 @@ export class DrizzleThreadMessageRepository
 			order?: "asc" | "desc";
 			limit?: number;
 			continuationToken?: string;
-			mailboxId?: string;
 			excludeDeleted?: boolean;
 		},
 	): Promise<ResultList<ThreadMessageItem>> {
@@ -592,9 +591,6 @@ export class DrizzleThreadMessageRepository
 				and(
 					eq(threadMessageTable.threadId, threadId),
 					eq(threadMessageTable.accountConfigId, accountConfigId),
-					options?.mailboxId
-						? eq(threadMessageTable.mailboxId, options.mailboxId)
-						: undefined,
 					options?.excludeDeleted
 						? eq(threadMessageTable.isDeleted, false)
 						: undefined,