@remit/drizzle-service 0.0.102 → 0.0.104

package/src/repos/thread-message.ts

@@ -23,8 +23,8 @@ import {
 	type SQLWrapper,
 	sql,
 } from "drizzle-orm";
-import { runBatch } from "../batch.js";
-import type { Db } from "../db.js";
+import type { WriteBatch } from "../batch.js";
+import type { RepositoryDb, SqliteStore } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { deterministicBase36Id } from "../id.js";
 import { decodeToken } from "../pagination.js";
@@ -37,13 +37,17 @@ import type {
 import { inList } from "./in-list.js";
 import {
 	bodyMatch,
+	fromContains,
 	fromMatch,
 	isNarrowableTerm,
 	listIdMatch,
 	senderMatchRank,
+	subjectContains,
 	subjectMatch,
 } from "./thread-search-predicates.js";
 
+type DB = RepositoryDb<Record<string, unknown>>;
+
 export const deriveThreadMessageId = (
 	threadId: string,
 	messageId: string,
@@ -163,9 +167,10 @@ function toItem(row: Row): ThreadMessageItem {
 
 // ─── Search predicates ────────────────────────────────────────────────────────
 
-// The accent-/case-insensitive substring predicates are the one engine-specific
-// text-search seam; they live in ./thread-search-predicates.ts (the FTS5 trigram
-// index, with a folded LIKE fallback below three characters, RFC 036 D4).
+// The accent-/case-insensitive word-prefix predicates are the one
+// engine-specific text-search seam; they live in ./thread-search-predicates.ts
+// (the FTS5 unicode61 index, with a folded LIKE scan for substring field terms,
+// RFC 036 D4).
 
 /**
  * Whether the row's From address is muted, as a correlated subquery over the
@@ -182,8 +187,9 @@ function toItem(row: Row): ThreadMessageItem {
 const mutedSender = (): SQL =>
 	sql`exists (select 1 from ${addressTable} where ${addressTable.accountConfigId} = ${threadMessageTable.accountConfigId} and ${addressTable.normalizedEmail} = lower(coalesce(${threadMessageTable.fromEmail}, '')) and json_extract(coalesce(nullif(${addressTable.flags}, ''), '{}'), '$.muted.value') = 1)`;
 
-// The columns the search index is built from; an update that sets none of them
-// leaves the index as it is.
+// The columns the search index is built from, and the snippet, which body sync
+// writes after the body's search text; an update that sets none of them leaves
+// the index as it is.
 const touchesSearchIndex = (input: UpdateThreadMessageInput): boolean =>
 	input.mailboxId !== undefined ||
 	input.sentDate !== undefined ||
@@ -243,9 +249,9 @@ function buildSearchConditions(search: SearchOptions): SearchConditions {
 }
 
 const fieldTermCondition = (term: ThreadMessageFieldTerm): SQL => {
-	if (term.field === "subject") return subjectMatch(term.contains);
+	if (term.field === "subject") return subjectContains(term.contains);
 	if (term.field === "listId") return listIdMatch(term.contains);
-	return fromMatch(term.contains);
+	return fromContains(term.contains);
 };
 
 // Combine the caller's terms into one condition, or `undefined` when there are
@@ -326,10 +332,16 @@ function sentDateCursorCond(
 export class DrizzleThreadMessageRepository
 	implements IThreadMessageRepository
 {
+	private readonly db: DB;
+	private readonly batch: WriteBatch;
+
 	constructor(
-		private readonly db: Db<Record<string, unknown>>,
+		store: SqliteStore<Record<string, unknown>>,
 		private readonly search: SearchIndex,
-	) {}
+	) {
+		this.db = store.db;
+		this.batch = store.batch;
+	}
 
 	/**
 	 * One page of rows in date order (ranked first when asked). Without a text
@@ -1082,7 +1094,7 @@ export class DrizzleThreadMessageRepository
 					.returning({ threadMessageId: threadMessageTable.threadMessageId }),
 			];
 		});
-		const results = await runBatch(this.db, items);
+		const results = await this.batch(items);
 		await this.search.sync(
 			rows.flatMap((row) => [
 				row.threadMessageId,
@@ -1253,8 +1265,8 @@ export class DrizzleThreadMessageRepository
 
 	/**
 	 * Mailbox search for `searchThreads`. Matching (subject / from / query and
-	 * the boolean filters) runs in SQL over the whole mailbox via the trigram
-	 * indexes, ordered by sent_date with an id tiebreak. `limit` is a page size
+	 * the boolean filters) runs in SQL over the whole mailbox via the full-text
+	 * index, ordered by sent_date with an id tiebreak. `limit` is a page size
 	 * over MATCHES (clamped to THREAD_SEARCH_MAX_LIMIT); the DynamoDB name is
 	 * kept for interface parity, but there is no recent-window read bound — the
 	 * text is indexed, so a match anywhere in the mailbox is reachable.

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

@@ -1,55 +1,39 @@
 import { type SQL, type SQLWrapper, sql } from "drizzle-orm";
 import { threadMessageSearchTable as fts } from "../search/thread-message-search.js";
 
-// Accent- and case-insensitive substring match over the whole mailbox, isolated
-// here as the one text-search seam whose behaviour is engine-specific. The
-// subject and sender predicates match the `contains()` substring contract:
-// LIKE metacharacters (`\`, `%`, `_`) are escaped in JS so the needle arrives as
-// bind-parameter text, and the escaped form is treated literally.
+// Every predicate here is a condition over `thread_message_fts`, the FTS5 index
+// in the tenant search database (#1420), tokenized `unicode61
+// remove_diacritics 2`: it indexes words, folding case and diacritics. A
+// search term matches words that start with it, so "matt" finds "Matthijs",
+// and a term the tokenizer splits ("ada@example") matches those words in a
+// row. The predicate is a `rowid IN (subquery)` over the same table, so terms
+// combine with AND and OR like any other condition.
+//
+// A term with no letter or digit has no word to match and falls back to a
+// folded LIKE scan of the index's own copy of the text, as do the field-term
+// narrowings, whose contract is substring: lower() both sides,
+// substring-match, `escape '\'` making the JS-escaped metacharacters literal.
+// The scan folds ASCII case only (contract C10).
 
 const escapeLike = (term: string): string => term.replace(/[\\%_]/g, "\\$&");
 
-// Every predicate here is a condition over `thread_message_fts`, the FTS5
-// trigram index in the tenant search database (#1420). It indexes the folded
-// subject, the sender and the body preview the row carries, and MATCH is an
-// accent- and case-insensitive substring search (the tokenizer folds both
-// sides, so the needle is passed through untransformed). The predicate is a
-// `rowid IN (subquery)` over the same table, so terms combine with AND and OR
-// like any other condition.
-//
-// Trigram indexing needs three characters, so a one- or two-character term
-// falls back to a folded LIKE scan of the index's own copy of the text —
-// lower() both sides, substring-match, `escape '\'` making the JS-escaped
-// metacharacters literal. It is case-insensitive for ASCII and does not fold
-// diacritics; the accepted difference between a short term and an indexed one
-// (contract C10).
-
-// FTS5 treats bare query text as its match grammar (AND/OR/NEAR/`*`/`-`/`:`), so
-// wrap the term as a double-quoted string literal — doubling embedded quotes —
-// to match it verbatim as a trigram substring.
-const ftsPhrase = (term: string): string => `"${term.replace(/"/g, '""')}"`;
-
-// Trigram tokenization is by character, so measure the term in code points, not
-// UTF-16 units — a two-astral-character term is still under the three-char
-// index floor.
-const isTrigramIndexable = (term: string): boolean => [...term].length >= 3;
+// Quoted, so the term is tokenized as a phrase rather than read as FTS5 query
+// grammar; the trailing `*` makes its last word a prefix.
+const ftsPrefixPhrase = (term: string): string =>
+	`"${term.replace(/"/g, '""')}" *`;
+
+const hasWord = (term: string): boolean => /[\p{L}\p{N}]/u.test(term);
 
 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.
+ * Whether a field term can be pushed into the query without dropping a row the
+ * caller's own matcher would accept. The narrowing is a substring LIKE, and
+ * SQLite's `lower()` folds ASCII only: `é` never matches a stored `CAFÉ`, so a
+ * non-ASCII term is not narrowable and the caller widens instead (#459).
  */
-export const isNarrowableTerm = (term: string): boolean =>
-	isTrigramIndexable(term) || isAscii(term);
+export const isNarrowableTerm = (term: string): boolean => isAscii(term);
 
 const ftsRowidMatch = (matchExpr: string): SQL =>
 	sql`${fts}.rowid in (select rowid from ${fts} where ${fts} match ${matchExpr})`;
@@ -60,31 +44,20 @@ const likePattern = (term: string): SQL =>
 const folded = (column: SQLWrapper, term: string): SQL =>
 	sql`lower(${column}) like ${likePattern(term)} escape '\\'`;
 
-export const subjectMatch = (term: string): SQL =>
-	isTrigramIndexable(term)
-		? ftsRowidMatch(`subject : ${ftsPhrase(term)}`)
-		: folded(fts.subject, term);
+const wordMatch = (column: "subject" | "sender" | "body", term: string): SQL =>
+	hasWord(term)
+		? ftsRowidMatch(`${column} : ${ftsPrefixPhrase(term)}`)
+		: folded(fts[column], term);
 
-export const fromMatch = (term: string): SQL =>
-	isTrigramIndexable(term)
-		? ftsRowidMatch(`sender : ${ftsPhrase(term)}`)
-		: folded(fts.sender, term);
+export const subjectMatch = (term: string): SQL => wordMatch("subject", term);
 
-/**
- * Match the body text the row carries: the stored preview, quoted replies
- * already removed, which is the same text the list renders under the subject.
- *
- * The brief used to reach this text with a pass over the rows a page had
- * loaded, so what a search found depended on how far the reader had scrolled
- * (#1135). It is a column like the other two, so it belongs in the index and in
- * the predicate. A term further into a long message is still out of reach —
- * the preview is what is stored — but a term the reader can see on the row is
- * now found wherever that row sits in the collection.
- */
-export const bodyMatch = (term: string): SQL =>
-	isTrigramIndexable(term)
-		? ftsRowidMatch(`body : ${ftsPhrase(term)}`)
-		: folded(fts.body, term);
+export const fromMatch = (term: string): SQL => wordMatch("sender", term);
+
+export const bodyMatch = (term: string): SQL => wordMatch("body", term);
+
+export const subjectContains = (term: string): SQL => folded(fts.subject, term);
+
+export const fromContains = (term: string): SQL => folded(fts.sender, term);
 
 // The List-Id is carried unindexed, so a List-Id term is always the folded LIKE
 // scan. It is the narrowing half of a rule back-apply (#459).

package/src/schema/message-data.ts

@@ -8,6 +8,7 @@ const envelopeAddressTable = entities.envelopeAddresses;
 const envelopeTable = entities.envelopes;
 const messageFlagTable = entities.messageFlags;
 const messageReferenceTable = entities.messageReferences;
+const messageSearchTextTable = entities.messageSearchTexts;
 const messageTable = entities.messageRecords;
 const rawMessageStorageTable = entities.rawMessageStorages;
 
@@ -20,6 +21,7 @@ export {
 	envelopeTable,
 	messageFlagTable,
 	messageReferenceTable,
+	messageSearchTextTable,
 	messageTable,
 	rawMessageStorageTable,
 };
@@ -35,6 +37,7 @@ export const messageDataSchema = {
 	bodyStructureRefetch: bodyStructureRefetchTable,
 	message: messageTable,
 	messageFlag: messageFlagTable,
+	messageSearchText: messageSearchTextTable,
 };
 
 export type MessageDataSchema = typeof messageDataSchema;

package/src/schema-sets/mail.ts

@@ -21,6 +21,7 @@ export {
 	messagePlacementMoves,
 	messageRecords,
 	messageReferences,
+	messageSearchTexts,
 	organizeJobRequests,
 	outboxAttachments,
 	outboxMessages,

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

@@ -3,8 +3,10 @@ import { after, before, describe, test } from "node:test";
 import type { CreateThreadMessageInput } from "@remit/data-ports";
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
+import { syncStore } from "../databases.js";
 import type { Db } from "../db.js";
-import { DrizzleThreadMessageRepository } from "../repos/thread-message.js";
+import { messageSearchTextTable } from "../schema/message-data.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { applyMigrationSet } from "../test-shipped-sqlite-schema.js";
 import {
 	SearchIndex,
@@ -48,8 +50,12 @@ const open = (set: "mail" | "search") => {
 describe("the thread-message search index in its own database", () => {
 	const mail = open("mail");
 	const search = open("search");
-	const index = new SearchIndex(mail.db, search.db);
-	const repo = new DrizzleThreadMessageRepository(mail.db, index);
+	const index = new SearchIndex(mail.db, syncStore(search.db));
+	const repo = createSqliteRepositories({
+		app: mail.db,
+		mail: mail.db,
+		search: search.db,
+	}).threadMessage;
 
 	const found = async (query: string): Promise<string[]> =>
 		(await repo.searchByMailboxWindow(ACCOUNT, MAILBOX, { query })).items.map(
@@ -83,14 +89,18 @@ describe("the thread-message search index in its own database", () => {
 	});
 
 	test("finds a message by subject, sender and body once it is written", async () => {
-		const created = await repo.create(
-			input({
-				subject: "Quarterly invoice",
-				fromName: "Ada Lovelace",
-				fromEmail: "ada@example.test",
-				snippet: "the analytical engine",
-			}),
-		);
+		const message = input({
+			subject: "Quarterly invoice",
+			fromName: "Ada Lovelace",
+			fromEmail: "ada@example.test",
+		});
+		await mail.db.insert(messageSearchTextTable).values({
+			messageId: message.messageId,
+			text: "the analytical engine",
+			createdAt: 0,
+			updatedAt: 0,
+		});
+		const created = await repo.create(message);
 
 		assert.deepEqual(await found("invoice"), [created.threadMessageId]);
 		assert.deepEqual(await found("lovelace"), [created.threadMessageId]);
@@ -98,6 +108,19 @@ describe("the thread-message search index in its own database", () => {
 		assert.deepEqual(await found("nowhere"), []);
 	});
 
+	test("matches words by prefix, folding case and diacritics", async () => {
+		const created = await repo.create(
+			input({
+				subject: "Crème brûlée recipe",
+				fromName: "Matthijs van Henten",
+			}),
+		);
+
+		assert.deepEqual(await found("matt"), [created.threadMessageId]);
+		assert.deepEqual(await found("CREME brul"), [created.threadMessageId]);
+		assert.deepEqual(await found("thijs"), []);
+	});
+
 	test("follows a rewritten subject and drops the old one", async () => {
 		const created = await repo.create(input({ subject: "Draft agenda" }));
 		await repo.update(ACCOUNT, created.threadMessageId, {
@@ -128,4 +151,27 @@ describe("the thread-message search index in its own database", () => {
 		assert.equal(await index.needsRebuild(), false);
 		assert.deepEqual(await found("receipt"), [created.threadMessageId]);
 	});
+
+	test("matches the body text past the snippet, through a rewrite and a rebuild", async () => {
+		const created = await repo.create(
+			input({ subject: "Long letter", snippet: "Dear reader, a preview" }),
+		);
+		const text = `Dear reader, a preview ${"filler words ".repeat(200)}zygomorphic`;
+		await mail.db.insert(messageSearchTextTable).values({
+			messageId: created.messageId,
+			text,
+			createdAt: 0,
+			updatedAt: 0,
+		});
+		await index.sync([created.threadMessageId]);
+		assert.deepEqual(await found("zygomorphic"), [created.threadMessageId]);
+
+		await repo.update(ACCOUNT, created.threadMessageId, {
+			subject: "Longer letter",
+		});
+		assert.deepEqual(await found("zygomorphic"), [created.threadMessageId]);
+
+		await index.rebuild();
+		assert.deepEqual(await found("zygomorphic"), [created.threadMessageId]);
+	});
 });

package/src/search/thread-message-search.ts

@@ -12,11 +12,12 @@ import {
 	sql,
 } from "drizzle-orm";
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
-import { runBatch, type SqliteBatchItem } from "../batch.js";
-import type { Db } from "../db.js";
+import type { SqliteBatchItem, WriteBatch } from "../batch.js";
+import type { RepositoryDb, SqliteStore } from "../db.js";
+import { messageSearchTextTable } from "../schema/message-data.js";
 import { threadMessageTable } from "../schema/thread-message.js";
 
-// The FTS5 trigram table the search migration set creates
+// The FTS5 table the search migration set creates
 // (deploy/vps/migrations-sqlite/search). drizzle-kit cannot express a virtual
 // table, so its DDL is that committed migration and this declaration only lets
 // drizzle build statements against it; no drizzle-kit config reads it.
@@ -32,7 +33,7 @@ export const threadMessageSearchTable = sqliteTable("thread_message_fts", {
 	body: text("body").notNull(),
 });
 
-type AnyDb = Db<Record<string, unknown>>;
+type AnyDb = RepositoryDb<Record<string, unknown>>;
 
 type SearchDocument = typeof threadMessageSearchTable.$inferInsert;
 
@@ -68,7 +69,7 @@ const indexedColumns = {
 	subject: threadMessageTable.subject,
 	fromName: threadMessageTable.fromName,
 	fromEmail: threadMessageTable.fromEmail,
-	snippet: threadMessageTable.snippet,
+	searchText: messageSearchTextTable.text,
 };
 
 interface IndexedRow {
@@ -80,7 +81,7 @@ interface IndexedRow {
 	subject: string | null;
 	fromName: string | null;
 	fromEmail: string | null;
-	snippet: string | null;
+	searchText: string | null;
 }
 
 const toDocument = (row: IndexedRow): SearchDocument => ({
@@ -92,7 +93,7 @@ const toDocument = (row: IndexedRow): SearchDocument => ({
 	listId: row.listId ?? "",
 	subject: row.subject ?? "",
 	sender: `${row.fromName ?? ""} ${row.fromEmail ?? ""}`,
-	body: row.snippet ?? "",
+	body: row.searchText ?? "",
 });
 
 const chunk = <T>(items: readonly T[], size: number): T[][] => {
@@ -138,10 +139,16 @@ export interface CandidateQuery {
  * only, so no statement carries more ids than a page holds.
  */
 export class SearchIndex {
+	private readonly search: AnyDb;
+	private readonly batch: WriteBatch;
+
 	constructor(
 		private readonly mail: AnyDb,
-		private readonly search: AnyDb,
-	) {}
+		store: SqliteStore<Record<string, unknown>>,
+	) {
+		this.search = store.db;
+		this.batch = store.batch;
+	}
 
 	/** Make the index match the mail database for these thread messages. */
 	async sync(threadMessageIds: readonly string[]): Promise<void> {
@@ -150,6 +157,10 @@ export class SearchIndex {
 			const rows = await this.mail
 				.select(indexedColumns)
 				.from(threadMessageTable)
+				.leftJoin(
+					messageSearchTextTable,
+					eq(messageSearchTextTable.messageId, threadMessageTable.messageId),
+				)
 				.where(inArray(threadMessageTable.threadMessageId, slice));
 			const items: SqliteBatchItem[] = [
 				this.search
@@ -165,7 +176,7 @@ export class SearchIndex {
 						.values(rows.map(toDocument)),
 				);
 			}
-			await runBatch(this.search, items);
+			await this.batch(items);
 		}
 	}
 
@@ -251,13 +262,16 @@ export class SearchIndex {
 			const rows = await this.mail
 				.select(indexedColumns)
 				.from(threadMessageTable)
+				.leftJoin(
+					messageSearchTextTable,
+					eq(messageSearchTextTable.messageId, threadMessageTable.messageId),
+				)
 				.where(gt(threadMessageTable.threadMessageId, after))
 				.orderBy(asc(threadMessageTable.threadMessageId))
 				.limit(DOCUMENTS_PER_REBUILD_PAGE);
 			const last = rows.at(-1);
 			if (!last) return indexed;
-			await runBatch(
-				this.search,
+			await this.batch(
 				chunk(rows, DOCUMENTS_PER_STATEMENT).map((slice) =>
 					this.search
 						.insert(threadMessageSearchTable)

package/src/sqlite-repositories.ts

@@ -1,4 +1,8 @@
-import type { SqliteDatabases } from "./databases.js";
+import {
+	type SqliteDatabases,
+	type SqliteStores,
+	syncStores,
+} from "./databases.js";
 import { CalendarCollectionRepo } from "./repos/calendar-collection.js";
 import { CalendarEventIndexRepo } from "./repos/calendar-event-index.js";
 import { CalendarFeedTokenRepo } from "./repos/calendar-feed-token.js";
@@ -31,45 +35,57 @@ import { SyncWarningRepo } from "./repos/sync-warning.js";
 import { DrizzleThreadMessageRepository } from "./repos/thread-message.js";
 import { SearchIndex } from "./search/thread-message-search.js";
 
-// Every repo over the database that holds its tables (#1420).
-export const createSqliteRepositories = ({
+export const composeSqliteRepositories = ({
 	app,
 	mail,
 	search,
-}: SqliteDatabases) => {
-	const searchIndex = new SearchIndex(mail, search);
+}: SqliteStores) => {
+	const searchIndex = new SearchIndex(mail.db, search);
+	const accountSetting = new AccountSettingRepo(app.db);
+	const address = new AddressRepo(mail.db);
+	const mailbox = new MailboxRepo(mail, searchIndex);
+	const account = new AccountRepo(app.db, mailbox);
+	const calendarSuggestion = new CalendarSuggestionRepo(mail.db);
 	return {
-		accountConfig: new AccountConfigRepo(app, mail),
-		account: new AccountRepo(app, mail),
-		accountSetting: new AccountSettingRepo(app),
-		address: new AddressRepo(mail),
-		mailbox: new MailboxRepo(mail, searchIndex),
-		mailboxSpecialUse: new MailboxSpecialUseRepo(app, mail),
-		mailboxLock: new MailboxLockRepo(mail),
+		accountConfig: new AccountConfigRepo(app.db, address),
+		account,
+		accountSetting,
+		address,
+		mailbox,
+		mailboxSpecialUse: new MailboxSpecialUseRepo(
+			mail.db,
+			account,
+			accountSetting,
+		),
+		mailboxLock: new MailboxLockRepo(mail.db),
 		message: new DrizzleMessageRepository(mail, searchIndex),
-		messageFlag: new DrizzleMessageFlagRepository(mail),
-		outboxMessage: new OutboxMessageRepo(mail),
+		messageFlag: new DrizzleMessageFlagRepository(mail.db),
+		outboxMessage: new OutboxMessageRepo(mail.db),
 		outboxAttachment: new OutboxAttachmentRepo(mail),
 		threadMessage: new DrizzleThreadMessageRepository(mail, searchIndex),
 		envelope: new DrizzleEnvelopeRepository(mail),
-		accountExportRequest: new AccountExportRequestRepo(app),
-		configImport: new ConfigImportRepo(app),
-		quarantine: new QuarantineRepo(mail),
-		syncWarning: new SyncWarningRepo(mail),
-		organizeJobRequest: new OrganizeJobRequestRepo(mail),
-		placementMove: new MessagePlacementMoveRepo(mail),
-		flagPush: new MessageFlagPushRepo(mail),
-		filter: new FilterRepo(app),
-		label: new LabelRepo(app),
-		messageLabel: new MessageLabelRepo(mail),
-		senderSignerStanding: new SenderSignerStandingRepo(mail),
-		calendarCollection: new CalendarCollectionRepo(app),
-		calendarObject: new CalendarObjectRepo(app),
-		calendarEventIndex: new CalendarEventIndexRepo(app),
-		calendarFeedToken: new CalendarFeedTokenRepo(app),
-		calendarSuggestion: new CalendarSuggestionRepo(mail),
-		calendarStore: new DrizzleCalendarStore(app, mail),
+		accountExportRequest: new AccountExportRequestRepo(app.db),
+		configImport: new ConfigImportRepo(app.db),
+		quarantine: new QuarantineRepo(mail.db),
+		syncWarning: new SyncWarningRepo(mail.db),
+		organizeJobRequest: new OrganizeJobRequestRepo(mail.db),
+		placementMove: new MessagePlacementMoveRepo(mail.db),
+		flagPush: new MessageFlagPushRepo(mail.db),
+		filter: new FilterRepo(app.db),
+		label: new LabelRepo(app.db),
+		messageLabel: new MessageLabelRepo(mail.db),
+		senderSignerStanding: new SenderSignerStandingRepo(mail.db),
+		calendarCollection: new CalendarCollectionRepo(app.db),
+		calendarObject: new CalendarObjectRepo(app.db),
+		calendarEventIndex: new CalendarEventIndexRepo(app.db),
+		calendarFeedToken: new CalendarFeedTokenRepo(app.db),
+		calendarSuggestion,
+		calendarStore: new DrizzleCalendarStore(app, calendarSuggestion),
 	};
 };
 
-export type SqliteRepositories = ReturnType<typeof createSqliteRepositories>;
+export type SqliteRepositories = ReturnType<typeof composeSqliteRepositories>;
+
+export const createSqliteRepositories = (
+	databases: SqliteDatabases,
+): SqliteRepositories => composeSqliteRepositories(syncStores(databases));

package/src/test-d1.ts

@@ -0,0 +1,40 @@
+import { drizzle } from "drizzle-orm/d1";
+import { Miniflare } from "miniflare";
+import { asyncBatch } from "./batch.js";
+import { syncStore } from "./databases.js";
+import { migrationStatements } from "./test-shipped-sqlite-schema.js";
+import { createShippedSqliteDb } from "./test-sqlite.js";
+import type { OpenTestStores } from "./test-stores.js";
+
+/**
+ * The stores a Cloudflare deployment runs the app repositories on: the app
+ * database on an in-process D1, migrated with the committed app set, written
+ * through `db.batch()`. The mail and search sets stay on a synchronous handle,
+ * as they do in the tenant mail Durable Object.
+ */
+export const openD1TestStores: OpenTestStores = async () => {
+	const miniflare = new Miniflare({
+		modules: true,
+		script: "export default {};",
+		d1Databases: { APP: "app" },
+	});
+	const d1 = await miniflare.getD1Database("APP");
+	const statements = migrationStatements("app").filter(
+		(statement) => statement.trim() !== "",
+	);
+	await d1.batch(statements.map((statement) => d1.prepare(statement)));
+	const app = drizzle(d1);
+	const shipped = createShippedSqliteDb();
+	const local = syncStore(shipped.db);
+	return {
+		stores: {
+			app: { db: app, batch: asyncBatch(app) },
+			mail: local,
+			search: local,
+		},
+		close: async () => {
+			shipped.close();
+			await miniflare.dispose();
+		},
+	};
+};

package/src/test-db-sqlite.ts

@@ -46,7 +46,7 @@ export async function createSqliteTestDb<
 	}
 
 	// Install the committed search set beside the pushed schema so the
-	// thread-message search predicates run their real trigram path. The one
+	// thread-message search predicates run their real FTS5 path. The one
 	// handle then plays both the mail and the search database.
 	if (options?.searchIndex) {
 		applyMigrationSet(sqlite, "search");

package/src/test-shipped-sqlite-schema.ts

@@ -61,16 +61,18 @@ export const shippedIndexDdl = (index: string): string => {
 	return statement;
 };
 
+/** Every statement of a set's committed migrations, in the order the migrator runs them. */
+export const migrationStatements = (set: MigrationSet): string[] =>
+	migrationJournal(set).flatMap((entry) =>
+		migrationSql(set, entry.tag).split("--> statement-breakpoint"),
+	);
+
 /** Run every committed migration of a set against an open database. */
 export const applyMigrationSet = (
 	sqlite: Database.Database,
 	set: MigrationSet,
 ): void => {
-	for (const entry of migrationJournal(set)) {
-		for (const statement of migrationSql(set, entry.tag).split(
-			"--> statement-breakpoint",
-		)) {
-			sqlite.exec(statement);
-		}
+	for (const statement of migrationStatements(set)) {
+		sqlite.exec(statement);
 	}
 };