@remit/drizzle-service 0.0.103 → 0.0.105

package/src/repos/thread-message.ts

@@ -37,10 +37,12 @@ import type {
 import { inList } from "./in-list.js";
 import {
 	bodyMatch,
+	fromContains,
 	fromMatch,
 	isNarrowableTerm,
 	listIdMatch,
 	senderMatchRank,
+	subjectContains,
 	subjectMatch,
 } from "./thread-search-predicates.js";
 
@@ -165,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
@@ -184,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 ||
@@ -245,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
@@ -1261,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 { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import { syncStore } from "../databases.js";
 import type { Db } from "../db.js";
+import { messageSearchTextTable } from "../schema/message-data.js";
 import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { applyMigrationSet } from "../test-shipped-sqlite-schema.js";
 import {
@@ -49,12 +51,18 @@ 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, syncStore(search.db));
-	const repo = createSqliteRepositories({
-		app: mail.db,
-		mail: mail.db,
-		search: search.db,
-	}).threadMessage;
+	const index = new SearchIndex(
+		mail.db,
+		syncStore(search.db, BETTER_SQLITE3_LIMITS),
+	);
+	const repo = createSqliteRepositories(
+		{
+			app: mail.db,
+			mail: mail.db,
+			search: search.db,
+		},
+		BETTER_SQLITE3_LIMITS,
+	).threadMessage;
 
 	const found = async (query: string): Promise<string[]> =>
 		(await repo.searchByMailboxWindow(ACCOUNT, MAILBOX, { query })).items.map(
@@ -88,14 +96,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]);
@@ -103,6 +115,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, {
@@ -133,4 +158,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

@@ -13,10 +13,12 @@ import {
 } from "drizzle-orm";
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
 import type { SqliteBatchItem, WriteBatch } from "../batch.js";
+import { chunkRows } from "../bound-parameters.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.
@@ -36,10 +38,7 @@ type AnyDb = RepositoryDb<Record<string, unknown>>;
 
 type SearchDocument = typeof threadMessageSearchTable.$inferInsert;
 
-// D1 refuses a statement with more than 100 bound parameters. A document is
-// nine parameters, so ten documents per insert stay under it.
-const DOCUMENTS_PER_STATEMENT = 10;
-const DOCUMENTS_PER_REBUILD_PAGE = DOCUMENTS_PER_STATEMENT * 30;
+const DOCUMENTS_PER_REBUILD_PAGE = 300;
 
 // The document's rowid, derived from its thread message id so a write or a
 // removal finds the document without a lookup. 53 bits, the integers a number
@@ -68,7 +67,7 @@ const indexedColumns = {
 	subject: threadMessageTable.subject,
 	fromName: threadMessageTable.fromName,
 	fromEmail: threadMessageTable.fromEmail,
-	snippet: threadMessageTable.snippet,
+	searchText: messageSearchTextTable.text,
 };
 
 interface IndexedRow {
@@ -80,7 +79,7 @@ interface IndexedRow {
 	subject: string | null;
 	fromName: string | null;
 	fromEmail: string | null;
-	snippet: string | null;
+	searchText: string | null;
 }
 
 const toDocument = (row: IndexedRow): SearchDocument => ({
@@ -92,17 +91,9 @@ 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[][] => {
-	const chunks: T[][] = [];
-	for (let start = 0; start < items.length; start += size) {
-		chunks.push(items.slice(start, start + size));
-	}
-	return chunks;
-};
-
 /** Where a page of candidates resumes: the last one the previous page held. */
 export interface SearchPosition {
 	rank: number;
@@ -140,6 +131,7 @@ export interface CandidateQuery {
 export class SearchIndex {
 	private readonly search: AnyDb;
 	private readonly batch: WriteBatch;
+	private readonly maxBoundParameters: number;
 
 	constructor(
 		private readonly mail: AnyDb,
@@ -147,15 +139,24 @@ export class SearchIndex {
 	) {
 		this.search = store.db;
 		this.batch = store.batch;
+		this.maxBoundParameters = store.maxBoundParameters;
 	}
 
 	/** Make the index match the mail database for these thread messages. */
 	async sync(threadMessageIds: readonly string[]): Promise<void> {
 		const ids = [...new Set(threadMessageIds)];
-		for (const slice of chunk(ids, DOCUMENTS_PER_STATEMENT)) {
+		for (const slice of chunkRows(
+			threadMessageSearchTable,
+			ids,
+			this.maxBoundParameters,
+		)) {
 			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
@@ -257,16 +258,21 @@ 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 this.batch(
-				chunk(rows, DOCUMENTS_PER_STATEMENT).map((slice) =>
-					this.search
-						.insert(threadMessageSearchTable)
-						.values(slice.map(toDocument)),
+				chunkRows(threadMessageSearchTable, rows, this.maxBoundParameters).map(
+					(slice) =>
+						this.search
+							.insert(threadMessageSearchTable)
+							.values(slice.map(toDocument)),
 				),
 			);
 			indexed += rows.length;

package/src/sqlite-repositories.ts

@@ -1,3 +1,4 @@
+import type { SqliteLimits } from "./bound-parameters.js";
 import {
 	type SqliteDatabases,
 	type SqliteStores,
@@ -67,7 +68,7 @@ export const composeSqliteRepositories = ({
 		accountExportRequest: new AccountExportRequestRepo(app.db),
 		configImport: new ConfigImportRepo(app.db),
 		quarantine: new QuarantineRepo(mail.db),
-		syncWarning: new SyncWarningRepo(mail.db),
+		syncWarning: new SyncWarningRepo(mail),
 		organizeJobRequest: new OrganizeJobRequestRepo(mail.db),
 		placementMove: new MessagePlacementMoveRepo(mail.db),
 		flagPush: new MessageFlagPushRepo(mail.db),
@@ -77,7 +78,7 @@ export const composeSqliteRepositories = ({
 		senderSignerStanding: new SenderSignerStandingRepo(mail.db),
 		calendarCollection: new CalendarCollectionRepo(app.db),
 		calendarObject: new CalendarObjectRepo(app.db),
-		calendarEventIndex: new CalendarEventIndexRepo(app.db),
+		calendarEventIndex: new CalendarEventIndexRepo(app),
 		calendarFeedToken: new CalendarFeedTokenRepo(app.db),
 		calendarSuggestion,
 		calendarStore: new DrizzleCalendarStore(app, calendarSuggestion),
@@ -88,4 +89,6 @@ export type SqliteRepositories = ReturnType<typeof composeSqliteRepositories>;
 
 export const createSqliteRepositories = (
 	databases: SqliteDatabases,
-): SqliteRepositories => composeSqliteRepositories(syncStores(databases));
+	limits: SqliteLimits,
+): SqliteRepositories =>
+	composeSqliteRepositories(syncStores(databases, limits));

package/src/test-d1.ts

@@ -0,0 +1,57 @@
+import { drizzle } from "drizzle-orm/d1";
+import { Miniflare } from "miniflare";
+import { asyncBatch } from "./batch.js";
+import type { SqliteLimits } from "./bound-parameters.js";
+import { syncStore } from "./databases.js";
+import type { SqliteStore } from "./db.js";
+import {
+	type MigrationSet,
+	migrationStatements,
+} from "./test-shipped-sqlite-schema.js";
+import { createShippedSqliteDb } from "./test-sqlite.js";
+import type { OpenTestStores } from "./test-stores.js";
+
+const CLOUDFLARE_LIMITS: SqliteLimits = { maxBoundParameters: 100 };
+
+/** One in-process D1 database migrated with a committed set, written through `db.batch()`. */
+export const openD1TestStore = async (
+	set: MigrationSet,
+): Promise<{
+	store: SqliteStore<Record<string, unknown>>;
+	close: () => Promise<void>;
+}> => {
+	const miniflare = new Miniflare({
+		modules: true,
+		script: "export default {};",
+		d1Databases: { DB: set },
+	});
+	const d1 = await miniflare.getD1Database("DB");
+	const statements = migrationStatements(set).filter(
+		(statement) => statement.trim() !== "",
+	);
+	await d1.batch(statements.map((statement) => d1.prepare(statement)));
+	const db = drizzle(d1);
+	return {
+		store: { db, batch: asyncBatch(db), ...CLOUDFLARE_LIMITS },
+		close: () => miniflare.dispose(),
+	};
+};
+
+/**
+ * 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 app = await openD1TestStore("app");
+	const shipped = createShippedSqliteDb();
+	const local = syncStore(shipped.db, CLOUDFLARE_LIMITS);
+	return {
+		stores: { app: app.store, mail: local, search: local },
+		close: async () => {
+			shipped.close();
+			await app.close();
+		},
+	};
+};

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);
 	}
 };

package/src/test-stores.ts

@@ -0,0 +1,43 @@
+import { BETTER_SQLITE3_LIMITS } from "./bound-parameters.js";
+import { type SqliteStores, syncStores } from "./databases.js";
+import {
+	calendarEventIndexTable,
+	calendarObjectTable,
+	calendarTable,
+} from "./schema.js";
+import { createTestDb } from "./test-db.js";
+import { createSqliteTestDb } from "./test-db-sqlite.js";
+
+/** The stores a repository suite runs against, opened once per test file. */
+export type OpenTestStores = () => Promise<{
+	stores: SqliteStores;
+	close: () => Promise<void>;
+}>;
+
+/** The whole schema on one in-memory better-sqlite3 handle that plays all three databases. */
+export const openSqliteTestStores: OpenTestStores = async () => {
+	const { db, close } = await createTestDb();
+	return {
+		stores: syncStores(
+			{ app: db, mail: db, search: db },
+			BETTER_SQLITE3_LIMITS,
+		),
+		close,
+	};
+};
+
+/** The three calendar tables alone on one in-memory better-sqlite3 handle. */
+export const openCalendarSqliteTestStores: OpenTestStores = async () => {
+	const { db, close } = await createSqliteTestDb({
+		calendars: calendarTable,
+		calendarObjects: calendarObjectTable,
+		calendarEventIndexes: calendarEventIndexTable,
+	});
+	return {
+		stores: syncStores(
+			{ app: db, mail: db, search: db },
+			BETTER_SQLITE3_LIMITS,
+		),
+		close,
+	};
+};