@remit/drizzle-service 0.0.74 → 0.0.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.74",
+  "version": "0.0.76",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",
@@ -9,6 +9,10 @@
     ".": {
       "types": "./src/index.ts",
       "default": "./src/index.ts"
+    },
+    "./test-sqlite": {
+      "types": "./src/test-sqlite.ts",
+      "default": "./src/test-sqlite.ts"
     }
   },
   "scripts": {

package/src/repos/i4-account.ts

@@ -19,6 +19,17 @@ import { rowToMailbox } from "./i4-mailbox.js";
 
 type DB = Db<Record<string, unknown>>;
 
+/**
+ * A stored failure is a sentence the account card shows, not a transcript.
+ * Long enough for what a mail server says when it refuses, short enough that a
+ * chatty one — or a stack-carrying `Error.message` from a sync — cannot fill the
+ * column. Clamped here so every writer is bounded, whatever it hands over.
+ */
+const LAST_ERROR_MAX_LENGTH = 500;
+
+const clampLastError = (value: string | undefined): string | undefined =>
+	value === undefined ? undefined : value.slice(0, LAST_ERROR_MAX_LENGTH);
+
 export function rowToAccount(
 	row: typeof accountTable.$inferSelect,
 ): AccountItem {
@@ -88,7 +99,7 @@ export class AccountRepo implements IAccountRepository {
 				connectionState: input.connectionState,
 				lastConnectedAt: input.lastConnectedAt,
 				lastSyncAt: input.lastSyncAt,
-				lastError: input.lastError,
+				lastError: clampLastError(input.lastError),
 				syncPhase: input.syncPhase,
 				mailboxCountTotal: input.mailboxCountTotal,
 				mailboxCountSynced: input.mailboxCountSynced,
@@ -159,7 +170,8 @@ export class AccountRepo implements IAccountRepository {
 		if (input.lastConnectedAt !== undefined)
 			updates.lastConnectedAt = input.lastConnectedAt;
 		if (input.lastSyncAt !== undefined) updates.lastSyncAt = input.lastSyncAt;
-		if (input.lastError !== undefined) updates.lastError = input.lastError;
+		if (input.lastError !== undefined)
+			updates.lastError = clampLastError(input.lastError);
 		if (input.syncPhase !== undefined) updates.syncPhase = input.syncPhase;
 		if (input.mailboxCountTotal !== undefined)
 			updates.mailboxCountTotal = input.mailboxCountTotal;

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

@@ -321,6 +321,57 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 		);
 		assert.equal(count, 5, "asc counts the whole match set too");
 	});
+
+	// ── Scenario 7 ────────────────────────────────────────────────────────────
+	// The count and the result set are two answers to one predicate, and the
+	// surfaces that render the number stopped paging to derive it (#307). This
+	// is the guard from the other direction: walk every page and assert the walk
+	// and the count agree, so the number cannot silently drift from the rows.
+	test("the count agrees with a full page-through of the same predicate", async () => {
+		const acct = uuid();
+		const mbx = uuid();
+		const now = Date.now();
+		await seed(acct, mbx, [
+			...Array.from({ length: 17 }, (_, i) => ({
+				subject: `gamma ${i}`,
+				sentDate: now - i,
+				internalDate: now - i,
+			})),
+			{ subject: "delta", sentDate: now - 100, internalDate: now - 100 },
+		]);
+
+		const walked = new Set<string>();
+		let continuationToken: string | undefined;
+		let pages = 0;
+		do {
+			const page = await repo.searchByMailboxWindow(
+				acct,
+				mbx,
+				{ subject: "gamma" },
+				{ excludeDeleted: true, limit: 5, continuationToken },
+			);
+			for (const row of page.items) walked.add(row.threadMessageId);
+			continuationToken = page.continuationToken;
+			pages += 1;
+		} while (continuationToken && pages < 10);
+		assert.ok(
+			!continuationToken,
+			"the walk never reached the end of the pages",
+		);
+
+		const count = await repo.countByMailbox(
+			acct,
+			mbx,
+			{ subject: "gamma" },
+			{ excludeDeleted: true },
+		);
+		assert.equal(
+			count,
+			walked.size,
+			"the count and the rows the predicate returns disagree",
+		);
+		assert.equal(count, 17, "the unmatched row leaked into one of the two");
+	});
 });
 
 // ─── searchByDate: the unified listing's cross-folder search mode ─────────────

package/src/test-sqlite.ts

@@ -0,0 +1,39 @@
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import type { Db } from "./db.js";
+import {
+	applyMigration,
+	migrationJournal,
+} from "./test-shipped-sqlite-schema.js";
+
+/**
+ * The store a test runs against: the committed SQLite entity migrations, in the
+ * order the migrator runs them, over the same engine a self-host deployment
+ * boots. Applying the shipped DDL rather than pushing the drizzle table objects
+ * is the point — a test then fails when the two drift (reader#73).
+ */
+export const applyShippedMigrations = (sqlite: Database.Database): void => {
+	for (const entry of [...migrationJournal()].sort(
+		(left, right) => left.idx - right.idx,
+	)) {
+		applyMigration(sqlite, entry.tag);
+	}
+};
+
+/**
+ * A migrated in-memory database and a drizzle handle over it, for a test that
+ * wants one repo and no file to clean up.
+ */
+export const createShippedSqliteDb = (): {
+	db: Db<Record<string, unknown>>;
+	sqlite: Database.Database;
+	close: () => void;
+} => {
+	const sqlite = new Database(":memory:");
+	applyShippedMigrations(sqlite);
+	return {
+		db: drizzle(sqlite) as unknown as Db<Record<string, unknown>>,
+		sqlite,
+		close: () => sqlite.close(),
+	};
+};