@remit/drizzle-service 0.0.77 → 0.0.79

package/package.json

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

package/src/outbox-created-cleanup.sqlite.test.ts

@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import Database from "better-sqlite3";
+import {
+	applyMigration,
+	migrationJournal,
+} from "./test-shipped-sqlite-schema.js";
+
+/**
+ * The data migration that clears the `message.created` backlog (reader#1063),
+ * against a database that already holds those rows.
+ *
+ * Every other outbox test starts from an empty table, so the case that matters
+ * — an instance upgrading with 30,906 undrained rows the drain filters out and
+ * the column's type no longer admits — is only reachable by running the shipped
+ * migrations over a table populated at the point the upgrade finds it.
+ */
+
+const CLEANUP_TAG = "0022_drop_message_created_outbox";
+
+const seed = (sqlite: Database.Database, event: string, id: string): void => {
+	sqlite
+		.prepare(
+			`INSERT INTO outbox (id, message_id, event, payload, created_at)
+			 VALUES (?, ?, ?, ?, ?)`,
+		)
+		.run(id, `message-${id}`, event, JSON.stringify({ messageId: id }), 1);
+};
+
+const unprocessed = (sqlite: Database.Database): string[] =>
+	(
+		sqlite
+			.prepare(
+				"SELECT event FROM outbox WHERE processed_at IS NULL ORDER BY event",
+			)
+			.all() as Array<{ event: string }>
+	).map((row) => row.event);
+
+const upgradedDatabase = (): Database.Database => {
+	const entries = [...migrationJournal()].sort(
+		(left, right) => left.idx - right.idx,
+	);
+	const cleanup = entries.findIndex((entry) => entry.tag === CLEANUP_TAG);
+	assert.notEqual(cleanup, -1, `${CLEANUP_TAG} is not in the journal`);
+
+	const sqlite = new Database(":memory:");
+	for (const entry of entries.slice(0, cleanup)) {
+		applyMigration(sqlite, entry.tag);
+	}
+
+	seed(sqlite, "message.created", "created-1");
+	seed(sqlite, "message.created", "created-2");
+	seed(sqlite, "message.body_synced", "synced-1");
+	seed(sqlite, "message.moved", "moved-1");
+
+	for (const entry of entries.slice(cleanup)) {
+		applyMigration(sqlite, entry.tag);
+	}
+	return sqlite;
+};
+
+describe("the message.created outbox cleanup", () => {
+	test("clears the rows an upgrading instance already has", () => {
+		const sqlite = upgradedDatabase();
+
+		const left = sqlite
+			.prepare("SELECT COUNT(*) AS n FROM outbox WHERE event = ?")
+			.get("message.created") as { n: number };
+
+		assert.equal(left.n, 0);
+		sqlite.close();
+	});
+
+	test("leaves the drained kinds alone", () => {
+		const sqlite = upgradedDatabase();
+
+		assert.deepEqual(unprocessed(sqlite), [
+			"message.body_synced",
+			"message.moved",
+		]);
+		sqlite.close();
+	});
+});

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

@@ -52,7 +52,7 @@ describe("DrizzleMessageRepository (sqlite)", () => {
 		await close();
 	});
 
-	test("create returns a MessageItem and writes one outbox row atomically", async () => {
+	test("create returns a MessageItem and writes no outbox row", async () => {
 		const item = await repo.create(BASE_INPUT);
 		assert.equal(item.messageId, MESSAGE_ID);
 		assert.equal(item.status, "active");
@@ -62,9 +62,11 @@ describe("DrizzleMessageRepository (sqlite)", () => {
 			.select()
 			.from(outboxTable)
 			.where(eq(outboxTable.messageId, MESSAGE_ID));
-		assert.equal(rows.length, 1);
-		assert.equal(rows[0].event, "message.created");
-		assert.deepEqual(rows[0].payload, { messageId: MESSAGE_ID });
+		assert.equal(
+			rows.length,
+			0,
+			"a message with no body yet has nothing to index",
+		);
 	});
 
 	test("boolean and json columns round-trip", async () => {
@@ -120,7 +122,7 @@ describe("DrizzleMessageRepository (sqlite)", () => {
 		assert.equal(afterUpdate.placementVerdict?.action, "MoveToInbox");
 	});
 
-	test("duplicate messageId throws CreateFailedConflictError and rolls back the outbox row", async () => {
+	test("duplicate messageId throws CreateFailedConflictError and appends no outbox row", async () => {
 		const before = await db
 			.select()
 			.from(outboxTable)

package/src/repos/message.test.ts

@@ -44,7 +44,7 @@ describe("DrizzleMessageRepository", () => {
 		await stop();
 	});
 
-	describe("create — writes message + outbox row in one transaction", () => {
+	describe("create — writes the message row only", () => {
 		test("creates a message and returns MessageItem", async () => {
 			const item = await messageRepo.create(BASE_MESSAGE_INPUT);
 			assert.equal(item.messageId, MESSAGE_ID);
@@ -56,16 +56,14 @@ describe("DrizzleMessageRepository", () => {
 			assert.ok(typeof item.updatedAt === "number");
 		});
 
-		test("writes an outbox row in the same transaction", async () => {
+		test("writes no outbox row — there is nothing to index before the body", async () => {
 			const { outboxTable } = await import("../schema/message-data.js");
 			const { eq } = await import("drizzle-orm");
 			const rows = await db
 				.select()
 				.from(outboxTable)
 				.where(eq(outboxTable.messageId, MESSAGE_ID));
-			assert.ok(rows.length >= 1, "should have at least 1 outbox row");
-			assert.equal(rows[0].event, "message.created");
-			assert.deepStrictEqual(rows[0].payload, { messageId: MESSAGE_ID });
+			assert.equal(rows.length, 0);
 		});
 
 		test("duplicate messageId throws CreateFailedConflictError and writes no extra outbox row", async () => {

package/src/repos/message.ts

@@ -107,7 +107,7 @@ function toMessageItem(row: typeof messageTable.$inferSelect): MessageItem {
  * the search-index worker relays a search-index REMOVE and the vectors are
  * dropped.
  */
-export const MESSAGE_REMOVED_EVENT = "message.removed";
+export const MESSAGE_REMOVED_EVENT = "message.removed" as const;
 
 export type SubtreeDb = Pick<Db<Record<string, unknown>>, "delete" | "insert">;
 
@@ -207,22 +207,15 @@ export class DrizzleMessageRepository implements IMessageRepository {
 			updatedAt: now,
 		};
 
-		// Faithful to ElectroDB message.create: a duplicate messageId throws
-		// CreateFailedConflictError. The plain insert raises a unique-constraint
-		// violation, which rolls back the transaction so NO outbox row is
-		// written; we surface it as the domain conflict error.
+		// Faithful to ElectroDB message.create: a duplicate messageId raises a
+		// unique-constraint violation, surfaced as the domain conflict error.
+		//
+		// No outbox event. A freshly created message has neither a body nor a
+		// threadMessage yet, so there is nothing to index — the search-index
+		// relay never drained a creation event, and the rows accumulated forever
+		// (reader#1063). Body-sync appends the event once there is content.
 		try {
-			await runInTransaction(this.db, async (tx) => {
-				await tx.insert(messageTable).values(row);
-
-				await tx.insert(outboxTable).values({
-					id: randomUUID(),
-					messageId: input.messageId,
-					event: "message.created",
-					payload: { messageId: input.messageId },
-					createdAt: new Date(),
-				});
-			});
+			await this.db.insert(messageTable).values(row);
 		} catch (error) {
 			if (isUniqueViolation(error)) {
 				throw new CreateFailedConflictError("Message", input);

package/src/repos/serialized-writes.sqlite.test.ts

@@ -21,7 +21,7 @@ import { runInTransaction, serializeSqliteWrites } from "../tx.js";
 const row = (id: string) => ({
 	id,
 	messageId: `msg-${id}`,
-	event: "message.body_synced",
+	event: "message.body_synced" as const,
 	payload: { messageId: `msg-${id}` },
 	createdAt: new Date(),
 });

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

@@ -0,0 +1,277 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import type { CreateThreadMessageInput } from "@remit/data-ports";
+import { threadMessageTable } from "../schema/thread-message.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
+import {
+	DrizzleThreadMessageRepository,
+	THREAD_SEARCH_MAX_LIMIT,
+} from "./thread-message.js";
+
+// `listByFieldTerms` on sqlite (#459): the terms decide inside the query, so a
+// rule for a sender that has been quiet for months reaches its mail however
+// much newer mail sits above it. Filtering a date-ordered page instead answers
+// "matches among the newest N", which is the defect this pins.
+
+const ACCOUNT = "acct-terms";
+const OTHER_ACCOUNT = "acct-terms-other";
+const MAILBOX = "mbx-terms";
+const ARCHIVE = "mbx-terms-archive";
+
+// One more than the ceiling a back-apply reads with, so the single old match
+// sits strictly below any window the newest page could cover.
+const NEWER_NOISE = THREAD_SEARCH_MAX_LIMIT + 1;
+
+const OLD_DATE = 1_600_000_000_000;
+
+function makeInput(
+	overrides: Partial<CreateThreadMessageInput> = {},
+): CreateThreadMessageInput {
+	return {
+		accountConfigId: ACCOUNT,
+		threadId: `t-${Math.random().toString(36).slice(2)}`,
+		messageId: `m-${Math.random().toString(36).slice(2)}`,
+		mailboxId: MAILBOX,
+		uid: 1,
+		referenceOrder: 0,
+		internalDate: OLD_DATE,
+		sentDate: OLD_DATE,
+		isRead: false,
+		isDeleted: false,
+		hasAttachment: false,
+		hasStars: false,
+		...overrides,
+	};
+}
+
+describe("DrizzleThreadMessageRepository.listByFieldTerms (sqlite, #459)", () => {
+	let close: () => Promise<void>;
+	let repo: DrizzleThreadMessageRepository;
+
+	before(async () => {
+		const created = await createSqliteTestDb(
+			{ threadMessage: threadMessageTable },
+			{ searchIndex: true },
+		);
+		close = created.close;
+		repo = new DrizzleThreadMessageRepository(created.db);
+
+		await repo.create(
+			makeInput({
+				messageId: "quiet-sender",
+				subject: "Your March statement",
+				fromName: "Statements",
+				fromEmail: "noreply@bank.example",
+				listId: "statements.bank.example",
+			}),
+		);
+		await repo.create(
+			makeInput({
+				messageId: "accented",
+				subject: "CAFÉ closing early",
+				fromName: "Café",
+				fromEmail: "hello@paris.example",
+				sentDate: OLD_DATE + 9_000_000,
+				internalDate: OLD_DATE + 9_000_000,
+			}),
+		);
+		for (let index = 0; index < NEWER_NOISE; index++) {
+			await repo.create(
+				makeInput({
+					messageId: `noise-${index}`,
+					subject: `Daily digest ${index}`,
+					fromName: "Digest",
+					fromEmail: "digest@other.example",
+					sentDate: OLD_DATE + 1 + index,
+					internalDate: OLD_DATE + 1 + index,
+				}),
+			);
+		}
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("finds a match older than a whole page of newer non-matching mail", async () => {
+		const result = await repo.listByFieldTerms(
+			ACCOUNT,
+			[{ field: "sender", contains: "bank.example" }],
+			{ limit: THREAD_SEARCH_MAX_LIMIT },
+		);
+
+		assert.deepEqual(
+			result.items.map((item) => item.messageId),
+			["quiet-sender"],
+		);
+		assert.equal(result.continuationToken, undefined);
+	});
+
+	test("a page is a page of matches, not a page of rows", async () => {
+		const result = await repo.listByFieldTerms(
+			ACCOUNT,
+			[{ field: "sender", contains: "bank.example" }],
+			{ limit: 5 },
+		);
+
+		assert.equal(result.items.length, 1);
+	});
+
+	test("matches the subject and the List-Id columns", async () => {
+		const bySubject = await repo.listByFieldTerms(ACCOUNT, [
+			{ field: "subject", contains: "march statement" },
+		]);
+		const byListId = await repo.listByFieldTerms(ACCOUNT, [
+			{ field: "listId", contains: "statements.bank.example" },
+		]);
+
+		assert.deepEqual(
+			bySubject.items.map((item) => item.messageId),
+			["quiet-sender"],
+		);
+		assert.deepEqual(
+			byListId.items.map((item) => item.messageId),
+			["quiet-sender"],
+		);
+	});
+
+	test("`and` requires every term, `or` any of them", async () => {
+		const terms = [
+			{ field: "sender", contains: "bank.example" },
+			{ field: "subject", contains: "daily digest 0" },
+		] as const;
+
+		const conjunction = await repo.listByFieldTerms(ACCOUNT, terms, {
+			operator: "and",
+		});
+		const disjunction = await repo.listByFieldTerms(ACCOUNT, terms, {
+			operator: "or",
+		});
+
+		assert.deepEqual(conjunction.items, []);
+		assert.deepEqual(disjunction.items.map((item) => item.messageId).sort(), [
+			"noise-0",
+			"quiet-sender",
+		]);
+	});
+
+	// Below the trigram floor the predicate is the folded LIKE, and sqlite's
+	// lower() folds ASCII only — `é` never matches a stored `CAFÉ`. Applying it
+	// anyway would drop a row the caller's own matcher accepts, which is #459
+	// again for that clause shape, so a short non-ASCII term narrows nothing.
+	test("drops a short accented term rather than missing the row it should match", async () => {
+		const result = await repo.listByFieldTerms(
+			ACCOUNT,
+			[{ field: "subject", contains: "é" }],
+			{ limit: THREAD_SEARCH_MAX_LIMIT },
+		);
+
+		assert.ok(
+			result.items.some((item) => item.messageId === "accented"),
+			"the accented row survives",
+		);
+		assert.ok(result.items.length > 1, "the term narrowed nothing at all");
+	});
+
+	test("keeps narrowing on the other terms of an `and` around a dropped one", async () => {
+		const result = await repo.listByFieldTerms(
+			ACCOUNT,
+			[
+				{ field: "subject", contains: "é" },
+				{ field: "sender", contains: "bank.example" },
+			],
+			{ operator: "and" },
+		);
+
+		assert.deepEqual(
+			result.items.map((item) => item.messageId),
+			["quiet-sender"],
+		);
+	});
+
+	test("drops the whole narrowing when an `or` branch cannot be evaluated", async () => {
+		const result = await repo.listByFieldTerms(
+			ACCOUNT,
+			[
+				{ field: "subject", contains: "é" },
+				{ field: "sender", contains: "bank.example" },
+			],
+			{ operator: "or", limit: 5 },
+		);
+
+		const found = result.items.map((item) => item.messageId);
+		assert.ok(found.includes("accented"), "the dropped branch keeps its rows");
+		assert.ok(
+			found.some((messageId) => messageId.startsWith("noise-")),
+			"a narrowed `or` would have excluded these",
+		);
+	});
+
+	test("still narrows on a short ASCII term, which lower() folds correctly", async () => {
+		const result = await repo.listByFieldTerms(ACCOUNT, [
+			{ field: "sender", contains: "k." },
+		]);
+
+		assert.deepEqual(
+			result.items.map((item) => item.messageId),
+			["quiet-sender"],
+		);
+	});
+
+	test("no terms narrows nothing", async () => {
+		const result = await repo.listByFieldTerms(ACCOUNT, [], { limit: 3 });
+
+		assert.equal(result.items.length, 3);
+		assert.ok(result.continuationToken, "more rows remain");
+	});
+
+	test("stays inside the account and skips deleted rows on request", async () => {
+		await repo.create(
+			makeInput({
+				accountConfigId: OTHER_ACCOUNT,
+				messageId: "other-account",
+				fromEmail: "noreply@bank.example",
+			}),
+		);
+		await repo.create(
+			makeInput({
+				messageId: "deleted-match",
+				mailboxId: ARCHIVE,
+				fromEmail: "noreply@bank.example",
+				isDeleted: true,
+			}),
+		);
+
+		const result = await repo.listByFieldTerms(
+			ACCOUNT,
+			[{ field: "sender", contains: "bank.example" }],
+			{ excludeDeleted: true },
+		);
+
+		assert.deepEqual(
+			result.items.map((item) => item.messageId),
+			["quiet-sender"],
+		);
+	});
+
+	test("pages the matches with a keyset cursor", async () => {
+		const first = await repo.listByFieldTerms(
+			ACCOUNT,
+			[{ field: "sender", contains: "other.example" }],
+			{ limit: 2 },
+		);
+		assert.equal(first.items.length, 2);
+		assert.ok(first.continuationToken);
+
+		const second = await repo.listByFieldTerms(
+			ACCOUNT,
+			[{ field: "sender", contains: "other.example" }],
+			{ limit: 2, continuationToken: first.continuationToken },
+		);
+
+		const overlap = second.items.filter((item) =>
+			first.items.some((seen) => seen.messageId === item.messageId),
+		);
+		assert.deepEqual(overlap, [], "pages do not repeat a row");
+	});
+});

package/src/repos/thread-message.ts

@@ -3,6 +3,7 @@ import type {
 	IThreadMessageRepository,
 	ResultList,
 	SearchOptions,
+	ThreadMessageFieldTerm,
 	ThreadMessageItem,
 	UpdateThreadMessageInput,
 } from "@remit/data-ports";
@@ -24,7 +25,12 @@ import { NotFoundError } from "../error.js";
 import { deterministicBase36Id } from "../id.js";
 import { decodeToken } from "../pagination.js";
 import { threadMessageTable } from "../schema/thread-message.js";
-import { fromMatch, subjectMatch } from "./thread-search-predicates.js";
+import {
+	fromMatch,
+	isNarrowableTerm,
+	listIdMatch,
+	subjectMatch,
+} from "./thread-search-predicates.js";
 
 export const deriveThreadMessageId = (
 	threadId: string,
@@ -158,6 +164,30 @@ function buildSearchConditions(search: SearchOptions): SQL[] {
 	return conditions;
 }
 
+const fieldTermCondition = (term: ThreadMessageFieldTerm): SQL => {
+	if (term.field === "subject") return subjectMatch(term.contains);
+	if (term.field === "listId") return listIdMatch(term.contains);
+	return fromMatch(term.contains);
+};
+
+// Combine the caller's terms into one condition, or `undefined` when there are
+// none — an empty set narrows nothing, which is what both operators mean here.
+//
+// A term this engine cannot evaluate faithfully ({@link isNarrowableTerm}) is
+// left out rather than emitted: under `and` a missing conjunct only widens the
+// candidate set, which the caller refines anyway, but under `or` a missing
+// branch loses matches outright, so the whole narrowing goes.
+function buildFieldTermCondition(
+	terms: readonly ThreadMessageFieldTerm[],
+	operator: "and" | "or",
+): SQL | undefined {
+	const narrowable = terms.filter((term) => isNarrowableTerm(term.contains));
+	if (operator === "or" && narrowable.length !== terms.length) return undefined;
+	const conditions = narrowable.map(fieldTermCondition);
+	if (conditions.length === 0) return undefined;
+	return operator === "or" ? or(...conditions) : and(...conditions);
+}
+
 // Keyset cursor over (sent_date, thread_message_id). `desc` walks newest→oldest,
 // `asc` oldest→newest; the id tiebreak keeps paging stable across equal dates.
 function sentDateCursorCond(
@@ -530,6 +560,62 @@ export class DrizzleThreadMessageRepository
 		};
 	}
 
+	/**
+	 * Cross-mailbox narrowing for a rule back-apply. Same keyset cursor and
+	 * ordering as `searchByDate`, with the terms combined under the caller's
+	 * operator instead of the AND-only `SearchOptions` shape a search box needs.
+	 * The terms run in SQL over the whole config, so a page is a page of
+	 * narrowed rows and a rule for a sender that has been quiet for a month
+	 * reaches its mail (#459).
+	 */
+	async listByFieldTerms(
+		accountConfigId: string,
+		terms: readonly ThreadMessageFieldTerm[],
+		options?: {
+			operator?: "and" | "or";
+			order?: "asc" | "desc";
+			limit?: number;
+			continuationToken?: string;
+			excludeDeleted?: boolean;
+		},
+	): Promise<ResultList<ThreadMessageItem>> {
+		const order = options?.order ?? "desc";
+		const limit = clampThreadSearchLimit(options?.limit);
+		const cursor = options?.continuationToken
+			? decodeDateCursor(options.continuationToken)
+			: null;
+
+		const rows = await this.db
+			.select()
+			.from(threadMessageTable)
+			.where(
+				and(
+					eq(threadMessageTable.accountConfigId, accountConfigId),
+					options?.excludeDeleted
+						? eq(threadMessageTable.isDeleted, false)
+						: undefined,
+					buildFieldTermCondition(terms, options?.operator ?? "and"),
+					sentDateCursorCond(order, cursor),
+				),
+			)
+			.orderBy(
+				order === "desc"
+					? desc(threadMessageTable.sentDate)
+					: asc(threadMessageTable.sentDate),
+				asc(threadMessageTable.threadMessageId),
+			)
+			.limit(limit);
+
+		const lastRow = rows[rows.length - 1];
+		return {
+			items: rows.map(toItem),
+			continuationToken:
+				rows.length === limit && lastRow
+					? encodeDateCursor(lastRow.sentDate, lastRow.threadMessageId)
+					: undefined,
+		};
+	}
+
 	/**
 	 * COUNT of matching CONVERSATIONS over the SAME predicate as the
 	 * cross-account listings, across the caller's mailbox scope.

package/src/repos/thread-search-predicates.ts

@@ -31,11 +31,29 @@ const ftsPhrase = (term: string): string => `"${term.replace(/"/g, '""')}"`;
 // index floor.
 const isTrigramIndexable = (term: string): boolean => [...term].length >= 3;
 
+const isAscii = (term: string): boolean =>
+	[...term].every((char) => (char.codePointAt(0) ?? 0) < 128);
+
+/**
+ * Whether a term can be pushed into the query without dropping a row the
+ * caller's own matcher would accept.
+ *
+ * Below the trigram floor the predicate is the folded LIKE, and SQLite's
+ * `lower()` folds ASCII only: `é` never matches a stored `CAFÉ`. For a search
+ * box that is the accepted C10 difference between a short term and an indexed
+ * one. For a NARROWING it is not — a narrowing that misses is the #459 defect
+ * again, one clause shape at a time — so such a term is not narrowable at all
+ * and the caller widens instead.
+ */
+export const isNarrowableTerm = (term: string): boolean =>
+	isTrigramIndexable(term) || isAscii(term);
+
 const ftsRowidMatch = (matchExpr: string): SQL =>
 	sql`"thread_message"."rowid" in (select "rowid" from "thread_message_fts" where "thread_message_fts" match ${matchExpr})`;
 
 const SUBJECT_FOLDED = sql`lower(coalesce(subject, ''))`;
 const FROM_FOLDED = sql`lower(coalesce(from_name, '') || ' ' || coalesce(from_email, ''))`;
+const LIST_ID_FOLDED = sql`lower(coalesce(list_id, ''))`;
 
 const likePattern = (term: string): SQL =>
 	sql`'%' || lower(${escapeLike(term)}) || '%'`;
@@ -49,3 +67,9 @@ export const fromMatch = (term: string): SQL =>
 	isTrigramIndexable(term)
 		? ftsRowidMatch(`sender : ${ftsPhrase(term)}`)
 		: sql`${FROM_FOLDED} like ${likePattern(term)} escape '\\'`;
+
+// The FTS index carries subject and sender only, so a List-Id term is always
+// the folded LIKE scan. It is the narrowing half of a rule back-apply, where a
+// scan of one config's rows beats reading them all into the service (#459).
+export const listIdMatch = (term: string): SQL =>
+	sql`${LIST_ID_FOLDED} like ${likePattern(term)} escape '\\'`;

package/src/repos/unit-of-work.test.ts

@@ -22,7 +22,7 @@ describe("DrizzleUnitOfWork", () => {
 	const MAILBOX_ID = "00000000-0000-0000-2222-000000000002";
 	const NOW = 1700000000000;
 
-	const writeEnvelopeAndMessage = async (
+	const writeEnvelopeMessageAndBody = async (
 		repos: Parameters<Parameters<DrizzleUnitOfWork["transaction"]>[0]>[0],
 	) => {
 		await repos.envelope.upsertEnvelope({
@@ -43,6 +43,10 @@ describe("DrizzleUnitOfWork", () => {
 			envelopeId: deriveEnvelopeId(MESSAGE_ID),
 			rootBodyPartId: deriveRootBodyPartId(MESSAGE_ID),
 		});
+		// Body-sync appends the transactional-outbox row; the create emits none.
+		await repos.message.update(MESSAGE_ID, {
+			bodyStorageKey: "body/hello.json",
+		});
 	};
 
 	const rows = async () => {
@@ -74,7 +78,7 @@ describe("DrizzleUnitOfWork", () => {
 		await assert.rejects(
 			() =>
 				unitOfWork.transaction(async (repos) => {
-					await writeEnvelopeAndMessage(repos);
+					await writeEnvelopeMessageAndBody(repos);
 					// A later write in the set fails after the envelope, message and its
 					// transactional-outbox row have already been written.
 					throw new Error("thread write failed");
@@ -93,13 +97,13 @@ describe("DrizzleUnitOfWork", () => {
 	});
 
 	test("a successful transaction commits the data rows and the outbox row", async () => {
-		await unitOfWork.transaction(writeEnvelopeAndMessage);
+		await unitOfWork.transaction(writeEnvelopeMessageAndBody);
 
 		const { envelopes, messages, outbox } = await rows();
 		assert.equal(envelopes.length, 1);
 		assert.equal(messages.length, 1);
 		assert.equal(outbox.length, 1);
-		assert.equal(outbox[0].event, "message.created");
+		assert.equal(outbox[0].event, "message.body_synced");
 		assert.deepStrictEqual(outbox[0].payload, { messageId: MESSAGE_ID });
 	});
 });

package/src/schema/message-data.ts

@@ -1,7 +1,7 @@
 import * as entities from "@remit/drizzle-sqlite-schema";
-import { outboxTable } from "./outbox.js";
+import { OUTBOX_EVENTS, type OutboxEvent, outboxTable } from "./outbox.js";
 
-export { outboxTable };
+export { OUTBOX_EVENTS, type OutboxEvent, outboxTable };
 
 const bodyPartContentTable = entities.bodyPartContents;
 const bodyPartParameterTable = entities.bodyPartParameters;

package/src/schema/outbox.ts

@@ -10,12 +10,27 @@ import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
  * Exported raw for committed-migration generation (schema-full-sqlite) as well
  * as for the repos and the drain logic.
  */
+/**
+ * The event vocabulary a producer may append. Every kind here is drained by the
+ * search-index relay (`DRAIN_EVENTS`); a kind nothing drains accumulates
+ * undrained rows forever, which is what `message.created` did (reader#1063).
+ * The column carries the union so a new producer cannot invent a kind without
+ * adding it here, where the drain-coverage test picks it up.
+ */
+export const OUTBOX_EVENTS = [
+	"message.body_synced",
+	"message.moved",
+	"message.removed",
+] as const;
+
+export type OutboxEvent = (typeof OUTBOX_EVENTS)[number];
+
 export const outboxTable = sqliteTable(
 	"outbox",
 	{
 		id: text("id").primaryKey(),
 		messageId: text("message_id").notNull(),
-		event: text("event").notNull(),
+		event: text("event", { enum: OUTBOX_EVENTS }).notNull(),
 		payload: text("payload", { mode: "json" }).notNull(),
 		createdAt: integer("created_at", { mode: "timestamp_ms" })
 			.$defaultFn(() => new Date())