@remit/drizzle-service 0.0.36 → 0.0.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",

package/src/repos/i4-message-flag-push.test.ts

@@ -122,6 +122,26 @@ describe("MessageFlagPushRepo (relational counterpart to MessageFlagPushService)
 		assert.equal(found?.state, "pending");
 	});
 
+	test("put resets createdAt too — a stale createdAt would misread as a stuck deferred marker later", async () => {
+		const input = seedInput();
+		const first = await repo.put(input);
+
+		await new Promise((resolve) => setTimeout(resolve, 5));
+
+		const second = await repo.put(
+			seedInput({
+				messageId: input.messageId,
+				flagName: input.flagName,
+				operation: "remove",
+			}),
+		);
+
+		assert.ok(
+			second.createdAt > first.createdAt,
+			"a replacing put must start a fresh lifecycle, not inherit the row it replaces",
+		);
+	});
+
 	test("put is idempotent — a later flip of the SAME field replaces the marker", async () => {
 		const messageId = randomId();
 		const flagName = "\\Seen";

package/src/repos/i4-message-flag-push.ts

@@ -64,9 +64,14 @@ export class MessageFlagPushRepo {
 		input: PutMessageFlagPushInput,
 	): Promise<MessageFlagPushItem> => {
 		const now = Date.now();
-		// A fresh put ALWAYS resets state to `pending` (the field's default) —
-		// a new flip decision starts a new lifecycle regardless of whatever
-		// state the row it replaces was in.
+		// A fresh put ALWAYS resets state to `pending` AND createdAt to now — a
+		// new flip decision starts a genuinely new lifecycle regardless of
+		// whatever state (or age) the row it replaces was in. The conflict path
+		// must reset createdAt explicitly: onConflictDoUpdate only touches the
+		// columns named in `set`, so an omission here would let a replacing put
+		// silently inherit the original row's createdAt (its age then misreads
+		// as a stuck deferred marker elsewhere — see flag-push.ts's defer-max
+		// check, which measures a marker's age off exactly this field).
 		const [row] = await this.db
 			.insert(messageFlagPushTable)
 			.values({
@@ -83,6 +88,7 @@ export class MessageFlagPushRepo {
 					mailboxId: input.mailboxId,
 					operation: input.operation,
 					state: DEFAULT_STATE,
+					createdAt: now,
 					updatedAt: now,
 				},
 			})

package/src/repos/message.ts

@@ -94,6 +94,9 @@ function toMessageItem(row: typeof messageTable.$inferSelect): MessageItem {
 		...(row.placementDecidedAt !== null
 			? { placementDecidedAt: row.placementDecidedAt }
 			: {}),
+		...(row.spamReport !== null
+			? { spamReport: row.spamReport as MessageItem["spamReport"] }
+			: {}),
 	};
 }
 
@@ -193,6 +196,7 @@ export class DrizzleMessageRepository implements IMessageRepository {
 			placementVerdict: input.placementVerdict ?? null,
 			filterMove: input.filterMove ?? null,
 			placementDecidedAt: input.placementDecidedAt ?? null,
+			spamReport: input.spamReport ?? null,
 			createdAt: now,
 			updatedAt: now,
 		};
@@ -388,6 +392,9 @@ export class DrizzleMessageRepository implements IMessageRepository {
 			...(input.messageIdHeader !== undefined
 				? { messageIdHeader: input.messageIdHeader }
 				: {}),
+			...(input.spamReport !== undefined
+				? { spamReport: input.spamReport }
+				: {}),
 			updatedAt: now,
 		};
 
@@ -432,6 +439,28 @@ export class DrizzleMessageRepository implements IMessageRepository {
 		return this.get(messageId);
 	}
 
+	async clearSpamReport(
+		messageId: string,
+	): ReturnType<IMessageRepository["clearSpamReport"]> {
+		const now = Date.now();
+		await this.db
+			.update(messageTable)
+			.set({ spamReport: null, updatedAt: now })
+			.where(eq(messageTable.messageId, messageId));
+		return this.get(messageId);
+	}
+
+	async clearOriginalMailboxId(
+		messageId: string,
+	): ReturnType<IMessageRepository["clearOriginalMailboxId"]> {
+		const now = Date.now();
+		await this.db
+			.update(messageTable)
+			.set({ originalMailboxId: null, originalUid: null, updatedAt: now })
+			.where(eq(messageTable.messageId, messageId));
+		return this.get(messageId);
+	}
+
 	async delete(messageId: string): Promise<void> {
 		await this.deleteMany([messageId]);
 	}

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

@@ -10,7 +10,10 @@ import {
 	LIVE_TOTALS,
 	totalRows,
 } from "./category-fixture.js";
-import { DrizzleThreadMessageRepository } from "./thread-message.js";
+import {
+	DrizzleThreadMessageRepository,
+	THREAD_SEARCH_MAX_LIMIT,
+} from "./thread-message.js";
 
 // The thread-message repo on sqlite (RFC 036 D1): CRUD, keyset pagination, and
 // text search — the FTS5 trigram index for terms of three characters or more
@@ -163,12 +166,9 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 	});
 
 	test("countByMailbox counts matches under the same predicate", async () => {
-		const n = await repo.countByMailbox(
-			ACCOUNT,
-			MAILBOX,
-			{ subject: "invoice" },
-			{ limit: 100 },
-		);
+		const n = await repo.countByMailbox(ACCOUNT, MAILBOX, {
+			subject: "invoice",
+		});
 		assert.ok(n >= 1);
 	});
 
@@ -754,9 +754,6 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 			assert.equal(seen.length, LIVE_TOTALS.social + LIVE_TOTALS.transactional);
 		});
 
-		// No `limit`: countByMailbox still clamps its answer to the clamped limit,
-		// which is what #305 changes. What this asserts is the predicate — the
-		// count is over the mailbox rather than over a page of it.
 		test("countByMailbox counts the matches in the mailbox, not the page", async () => {
 			assert.equal(
 				await repo.countByMailbox(
@@ -769,6 +766,34 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 			);
 		});
 
+		// Regression for #509. The count was computed in full and then discarded
+		// down to THREAD_SEARCH_MAX_LIMIT, so this mailbox's 4,753 personal
+		// messages reported as 500 — a number that reads to the user as the whole
+		// match. A page size bounds the rows a response carries; it cannot bound
+		// how many messages match.
+		test("a match far larger than a page reports its real size", async () => {
+			assert.ok(
+				LIVE_TOTALS.personal > THREAD_SEARCH_MAX_LIMIT,
+				"the fixture has to outgrow the page cap for this to mean anything",
+			);
+			const page = await repo.searchByMailboxWindow(
+				CAT_ACCOUNT,
+				CAT_MAILBOX,
+				{ category: ["personal"] },
+				{ order: "desc", excludeDeleted: true },
+			);
+			assert.equal(page.items.length, THREAD_SEARCH_MAX_LIMIT);
+			assert.equal(
+				await repo.countByMailbox(
+					CAT_ACCOUNT,
+					CAT_MAILBOX,
+					{ category: ["personal"] },
+					{ excludeDeleted: true },
+				),
+				LIVE_TOTALS.personal,
+			);
+		});
+
 		test("the category predicate composes with the other filters", async () => {
 			const page = await repo.searchByMailboxWindow(
 				CAT_ACCOUNT,

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

@@ -241,15 +241,15 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 			acct,
 			mbx,
 			{ subject: "match" },
-			{ excludeDeleted: true, limit: 2 },
+			{ excludeDeleted: true },
 		);
-		assert.equal(count, 2, "count is capped at the page limit when more match");
+		assert.equal(count, 4, "count names every match, not one page of them");
 	});
 
 	// ── Scenario 5 ────────────────────────────────────────────────────────────
-	// desc default: the first page holds the newest matches; count equals the
-	// page length when more rows match than the limit.
-	test("desc page holds the newest matches and count equals items.length", async () => {
+	// desc default: the first page holds the newest matches; the count names the
+	// whole match set behind that page.
+	test("desc page holds the newest matches and the count names the whole match", async () => {
 		const acct = uuid();
 		const mbx = uuid();
 		const now = Date.now();
@@ -277,14 +277,13 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 			acct,
 			mbx,
 			{ subject: "alpha" },
-			{ excludeDeleted: true, limit: 2 },
+			{ excludeDeleted: true },
 		);
-		assert.equal(count, window.items.length, "count == items.length");
-		assert.equal(count, 2);
+		assert.equal(count, 5, "every alpha row is counted, not the page of two");
 	});
 
 	// ── Scenario 6 ────────────────────────────────────────────────────────────
-	// order:asc returns the OLDEST matches first; count agrees with the page.
+	// order:asc returns the OLDEST matches first; the count is order-independent.
 	test("order:asc returns the oldest matches first", async () => {
 		const acct = uuid();
 		const mbx = uuid();
@@ -317,10 +316,9 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 			acct,
 			mbx,
 			{ subject: "beta" },
-			{ excludeDeleted: true, limit: 2, order: "asc" },
+			{ excludeDeleted: true, order: "asc" },
 		);
-		assert.equal(count, window.items.length, "count == items.length for asc");
-		assert.equal(count, 2);
+		assert.equal(count, 5, "asc counts the whole match set too");
 	});
 });
 

package/src/repos/thread-message.ts

@@ -876,21 +876,19 @@ export class DrizzleThreadMessageRepository
 	}
 
 	/**
-	 * COUNT of matches over the SAME predicate as `searchByMailboxWindow`, capped
-	 * at the same clamped limit so `count` never exceeds one page — count equals
-	 * `items.length` whenever both are issued with the same limit.
+	 * COUNT of matches over the SAME predicate as `searchByMailboxWindow`, over
+	 * the whole mailbox. `THREAD_SEARCH_MAX_LIMIT` bounds a page of rows; a count
+	 * returns no rows, so it is answered in full however many messages match.
 	 */
 	async countByMailbox(
 		accountConfigId: string,
 		mailboxId: string,
 		search: SearchOptions,
 		options?: {
-			limit?: number;
 			excludeDeleted?: boolean;
 			order?: "asc" | "desc";
 		},
 	): Promise<number> {
-		const cap = clampThreadSearchLimit(options?.limit);
 		const [{ count }] = await this.db
 			.select({ count: sql<number>`cast(count(*) as int)` })
 			.from(threadMessageTable)
@@ -904,7 +902,7 @@ export class DrizzleThreadMessageRepository
 					...buildSearchConditions(search),
 				),
 			);
-		return Math.min(count, cap);
+		return count;
 	}
 
 	async listAllByAccount(