@remit/drizzle-service 0.0.103 → 0.0.104

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

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
 import type { CreateThreadMessageInput } from "@remit/data-ports";
+import { messageSearchTextTable } from "../schema/message-data.js";
 import { threadMessageTable } from "../schema/thread-message.js";
 import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
@@ -51,7 +52,10 @@ describe("DrizzleThreadMessageRepository.listByFieldTerms (sqlite, #459)", () =>
 
 	before(async () => {
 		const created = await createSqliteTestDb(
-			{ threadMessage: threadMessageTable },
+			{
+				threadMessage: threadMessageTable,
+				messageSearchText: messageSearchTextTable,
+			},
 			{ searchIndex: true },
 		);
 		close = created.close;
@@ -160,10 +164,10 @@ describe("DrizzleThreadMessageRepository.listByFieldTerms (sqlite, #459)", () =>
 		]);
 	});
 
-	// 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.
+	// A field term 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 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,

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

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
 import type { CreateThreadMessageInput } from "@remit/data-ports";
+import { messageSearchTextTable } from "../schema/message-data.js";
 import { threadMessageTable } from "../schema/thread-message.js";
 import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
@@ -17,9 +18,9 @@ import {
 } 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
-// (D4), the folded-LIKE scan for shorter terms. The search contract is accent-
-// and case-insensitive substring match over subject and sender.
+// text search — the FTS5 unicode61 index (D4), matching words by prefix, and
+// the folded-LIKE scan for terms with no word. The search contract is accent-
+// and case-insensitive word-prefix match over subject and sender.
 
 const ACCOUNT = "acct-thread";
 const MAILBOX = "mbx-thread";
@@ -55,6 +56,7 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 		({ db, sqlite, close } = await createSqliteTestDb(
 			{
 				threadMessage: threadMessageTable,
+				messageSearchText: messageSearchTextTable,
 			},
 			{ searchIndex: true },
 		));
@@ -115,7 +117,7 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 		assert.ok(byName.items.some((i) => i.fromName === "Alice Kramer"));
 	});
 
-	test("FTS trigram search folds diacritics both ways", async () => {
+	test("FTS search folds diacritics both ways", async () => {
 		await repo.create(makeInput({ subject: "Réunion budget" }));
 		const folded = await repo.searchByMailbox(
 			ACCOUNT,

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

@@ -1,7 +1,11 @@
 import assert from "node:assert";
 import { after, before, describe, test } from "node:test";
-import type { CreateThreadMessageInput } from "@remit/data-ports";
+import type {
+	CreateThreadMessageInput,
+	IMessageRepository,
+} from "@remit/data-ports";
 import shortUuid from "short-uuid";
+import { messageSearchTextTable } from "../schema/message-data.js";
 import { threadMessageTable } from "../schema/thread-message.js";
 import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
@@ -40,11 +44,14 @@ function makeInput(
 	};
 }
 
-// A real better-sqlite3 database with the FTS5 trigram objects the migrator
+// A real better-sqlite3 database with the FTS5 objects the migrator
 // installs, so the search predicates run their shipped path.
 const setupDb = () =>
 	createSqliteTestDb(
-		{ threadMessage: threadMessageTable },
+		{
+			threadMessage: threadMessageTable,
+			messageSearchText: messageSearchTextTable,
+		},
 		{ searchIndex: true },
 	);
 
@@ -194,7 +201,7 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 	});
 
 	// ── Scenario 4 ────────────────────────────────────────────────────────────
-	// Matching runs over the WHOLE mailbox via the trigram index, so an old
+	// Matching runs over the WHOLE mailbox via the full-text index, so an old
 	// match well behind the recent rows is still found and paged (the DynamoDB
 	// recent-window bound does not apply here — the improvement over #443 on the
 	// DDB path).
@@ -386,17 +393,20 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 
 describe("DrizzleThreadMessageRepository.searchByDate", () => {
 	let repo: DrizzleThreadMessageRepository;
+	let messages: IMessageRepository;
 	let close: () => Promise<void>;
 	const cleanup: Array<() => Promise<void>> = [];
 
 	before(async () => {
 		const harness = await setupDb();
 		close = harness.close;
-		repo = createSqliteRepositories({
+		const repositories = createSqliteRepositories({
 			app: harness.db,
 			mail: harness.db,
 			search: harness.db,
-		}).threadMessage;
+		});
+		repo = repositories.threadMessage;
+		messages = repositories.message;
 	});
 
 	after(async () => {
@@ -412,9 +422,11 @@ describe("DrizzleThreadMessageRepository.searchByDate", () => {
 		rows: Array<Partial<CreateThreadMessageInput>>,
 	): Promise<void> {
 		for (const overrides of rows) {
-			const created = await repo.create(
-				makeInput(accountConfigId, mailboxId, overrides),
-			);
+			const input = makeInput(accountConfigId, mailboxId, overrides);
+			if (overrides.snippet) {
+				await messages.setSearchText(input.messageId, overrides.snippet);
+			}
+			const created = await repo.create(input);
 			cleanup.push(() => repo.delete(accountConfigId, created.threadMessageId));
 		}
 	}
@@ -1053,7 +1065,7 @@ describe("DrizzleThreadMessageRepository — native text search", () => {
 		assert.deepEqual(subjectsOf(res), ["shared token here"]);
 	});
 
-	test("LIKE metacharacters in the query match literally", async () => {
+	test("LIKE metacharacters in a query with no word match literally", async () => {
 		const acct = uuid();
 		const mbx = uuid();
 		await seed(acct, mbx, [
@@ -1061,7 +1073,7 @@ describe("DrizzleThreadMessageRepository — native text search", () => {
 			{ subject: "50 percent off" },
 		]);
 
-		const res = await repo.searchByMailboxWindow(acct, mbx, { query: "50%" });
+		const res = await repo.searchByMailboxWindow(acct, mbx, { query: "%" });
 		assert.deepEqual(subjectsOf(res), ["50% off today"]);
 	});
 

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

@@ -5,6 +5,7 @@ import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 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 {
@@ -88,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]);
@@ -103,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, {
@@ -133,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

@@ -14,9 +14,10 @@ import {
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
 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.
@@ -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[][] => {
@@ -156,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
@@ -257,6 +262,10 @@ 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);

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

package/src/test-stores.ts

@@ -0,0 +1,30 @@
+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 }), 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 }), close };
+};