@remit/drizzle-service 0.0.101 → 0.0.103

package/src/repos/i4-outbox-message.ts

@@ -5,13 +5,14 @@ import type {
 	ResultList,
 	UpdateOutboxMessageInput,
 } from "@remit/data-ports";
-import { and, desc, eq, inArray, lt, or } from "drizzle-orm";
-import type { Db } from "../db.js";
+import { and, desc, eq, lt, or } from "drizzle-orm";
+import type { RepositoryDb } from "../db.js";
 import { ForbiddenError, NotFoundError } from "../error.js";
 import { decodeToken, resultList } from "../pagination.js";
 import { outboxMessageTable } from "../schema/i4-outbox-message.js";
+import { inList } from "./in-list.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToOutboxMessage(
 	row: typeof outboxMessageTable.$inferSelect,
@@ -99,7 +100,7 @@ export class OutboxMessageRepo implements IOutboxMessageRepository {
 				.where(
 					and(
 						eq(outboxMessageTable.accountConfigId, accountConfigId),
-						inArray(outboxMessageTable.outboxMessageId, outboxMessageId),
+						inList(outboxMessageTable.outboxMessageId, outboxMessageId),
 					),
 				);
 			return rows.map(rowToOutboxMessage);
@@ -264,7 +265,7 @@ export class OutboxMessageRepo implements IOutboxMessageRepository {
 			.where(
 				and(
 					eq(outboxMessageTable.accountConfigId, accountConfigId),
-					inArray(outboxMessageTable.outboxMessageId, outboxMessageIds),
+					inList(outboxMessageTable.outboxMessageId, outboxMessageIds),
 				),
 			);
 	}
@@ -298,7 +299,7 @@ export class OutboxMessageRepo implements IOutboxMessageRepository {
 			.from(outboxMessageTable)
 			.where(
 				and(
-					inArray(outboxMessageTable.accountId, accountIds),
+					inList(outboxMessageTable.accountId, accountIds),
 					after
 						? or(
 								lt(outboxMessageTable.createdAt, after.createdAt),

package/src/repos/i4-sender-signer-standing.ts

@@ -4,11 +4,11 @@ import type {
 	SenderSignerStandingItem,
 } from "@remit/data-ports";
 import { and, eq, sql } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { senderSignerStandingTable } from "../schema.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToStanding(
 	row: typeof senderSignerStandingTable.$inferSelect,

package/src/repos/in-list.sqlite.test.ts

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { calendarTable } from "../schema.js";
+import { createSqliteTestDb, type SqliteTestDb } from "../test-db-sqlite.js";
+import { inList } from "./in-list.js";
+
+const SCHEMA = { calendars: calendarTable };
+
+const calendar = (calendarId: string): typeof calendarTable.$inferInsert => ({
+	calendarId,
+	accountConfigId: "account-config-in-list",
+	urlSegment: calendarId,
+	displayName: calendarId,
+	color: "Cal1",
+	componentSet: "VeventOnly",
+	source: "UserCreated",
+	timezone: "",
+	subscriptionUrl: "",
+	subscriptionEnabled: false,
+	syncSequence: 0,
+	createdAt: 0,
+	updatedAt: 0,
+});
+
+describe("inList on better-sqlite3", () => {
+	let db: SqliteTestDb<typeof SCHEMA>;
+	let close: () => Promise<void>;
+	const allIds = Array.from({ length: 150 }, (_, index) => `calendar-${index}`);
+
+	before(async () => {
+		({ db, close } = await createSqliteTestDb(SCHEMA));
+		await db.insert(calendarTable).values(allIds.map(calendar));
+	});
+
+	after(() => close());
+
+	test("binds a single parameter for 150 ids", () => {
+		const query = db
+			.select({ calendarId: calendarTable.calendarId })
+			.from(calendarTable)
+			.where(inList(calendarTable.calendarId, allIds))
+			.toSQL();
+		assert.equal(query.params.length, 1);
+	});
+
+	test("matches only the listed ids", async () => {
+		const rows = await db
+			.select({ calendarId: calendarTable.calendarId })
+			.from(calendarTable)
+			.where(inList(calendarTable.calendarId, ["calendar-3", "missing"]));
+		assert.deepEqual(rows, [{ calendarId: "calendar-3" }]);
+	});
+
+	test("matches nothing for an empty list", async () => {
+		const rows = await db
+			.select({ calendarId: calendarTable.calendarId })
+			.from(calendarTable)
+			.where(inList(calendarTable.calendarId, []));
+		assert.deepEqual(rows, []);
+	});
+});

package/src/repos/in-list.ts

@@ -0,0 +1,14 @@
+import { type Column, type SQL, sql } from "drizzle-orm";
+
+export const inList = <T extends Column>(
+	column: T,
+	values: readonly T["_"]["data"][],
+): SQL =>
+	sql`${column} in (select value from json_each(${JSON.stringify(values)}))`;
+
+export const pairInList = <A extends Column, B extends Column>(
+	first: A,
+	second: B,
+	pairs: readonly (readonly [A["_"]["data"], B["_"]["data"]])[],
+): SQL =>
+	sql`(${first}, ${second}) in (select value->>0, value->>1 from json_each(${JSON.stringify(pairs)}))`;

package/src/repos/label.ts

@@ -6,13 +6,13 @@ import type {
 	UpdateLabelInput,
 } from "@remit/data-ports";
 import { and, asc, eq, gt, or } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { randomId } from "../id.js";
 import { decodeToken, resultList } from "../pagination.js";
 import { labelTable } from "../schema.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 const normalize = (name: string): string => name.trim().toLowerCase();
 

package/src/repos/message-flag.ts

@@ -4,15 +4,13 @@ import type {
 	IMessageFlagRepository,
 	MessageFlagItem,
 } from "@remit/data-ports";
-import { and, eq, inArray } from "drizzle-orm";
-import type { Db } from "../db.js";
+import { and, eq } from "drizzle-orm";
+import type { RepositoryDb } from "../db.js";
 import { NotFoundError } from "../error.js";
-import {
-	type MessageDataSchema,
-	messageFlagTable,
-} from "../schema/message-data.js";
+import { messageFlagTable } from "../schema/message-data.js";
+import { inList } from "./in-list.js";
 
-type DB = Db<MessageDataSchema>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToMessageFlag(
 	row: typeof messageFlagTable.$inferSelect,
@@ -58,7 +56,7 @@ export class DrizzleMessageFlagRepository implements IMessageFlagRepository {
 			const rows = await this.db
 				.select()
 				.from(messageFlagTable)
-				.where(inArray(messageFlagTable.messageFlagId, idOrIds));
+				.where(inList(messageFlagTable.messageFlagId, idOrIds));
 			return rows.map(rowToMessageFlag);
 		}
 		const [row] = await this.db
@@ -79,7 +77,7 @@ export class DrizzleMessageFlagRepository implements IMessageFlagRepository {
 		if (messageFlagIds.length === 0) return;
 		await this.db
 			.delete(messageFlagTable)
-			.where(inArray(messageFlagTable.messageFlagId, messageFlagIds));
+			.where(inList(messageFlagTable.messageFlagId, messageFlagIds));
 	}
 
 	async getFlags(messageId: string): Promise<MessageFlagItem[]> {
@@ -155,7 +153,7 @@ export class DrizzleMessageFlagRepository implements IMessageFlagRepository {
 			.where(
 				and(
 					eq(messageFlagTable.messageId, messageId),
-					inArray(messageFlagTable.flagName, flagNames),
+					inList(messageFlagTable.flagName, flagNames),
 				),
 			);
 	}

package/src/repos/message-label.ts

@@ -3,12 +3,13 @@ import type {
 	IMessageLabelRepository,
 	MessageLabelItem,
 } from "@remit/data-ports";
-import { and, desc, eq, inArray } from "drizzle-orm";
-import type { Db } from "../db.js";
+import { and, desc, eq } from "drizzle-orm";
+import type { RepositoryDb } from "../db.js";
 import { deterministicBase36Id } from "../id.js";
 import { messageLabelTable } from "../schema.js";
+import { inList } from "./in-list.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToMessageLabel(
 	row: typeof messageLabelTable.$inferSelect,
@@ -82,7 +83,7 @@ export class MessageLabelRepo implements IMessageLabelRepository {
 		const rows = await this.db
 			.select()
 			.from(messageLabelTable)
-			.where(inArray(messageLabelTable.messageId, messageIds));
+			.where(inList(messageLabelTable.messageId, messageIds));
 		return rows.map(rowToMessageLabel);
 	}
 

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

@@ -6,9 +6,9 @@ import {
 } from "../id.js";
 import { messageDataSchema } from "../schema/message-data.js";
 import { threadMessageTable } from "../schema/thread-message.js";
-import { SearchIndex } from "../search/thread-message-search.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb, type SqliteTestDb } from "../test-db-sqlite.js";
-import { DrizzleMessageRepository } from "./message.js";
+import type { DrizzleMessageRepository } from "./message.js";
 
 const SCHEMA = { ...messageDataSchema, threadMessages: threadMessageTable };
 
@@ -43,7 +43,7 @@ describe("DrizzleMessageRepository (sqlite)", () => {
 
 	before(async () => {
 		({ db, close } = await createSqliteTestDb(SCHEMA));
-		repo = new DrizzleMessageRepository(db, new SearchIndex(db, db));
+		repo = createSqliteRepositories({ app: db, mail: db, search: db }).message;
 	});
 
 	after(async () => {

package/src/repos/message.test.ts

@@ -4,9 +4,9 @@ import {
 	envelopeId as deriveEnvelopeId,
 	rootBodyPartId as deriveRootBodyPartId,
 } from "../id.js";
-import { SearchIndex } from "../search/thread-message-search.js";
-import { DrizzleEnvelopeRepository } from "./envelope.js";
-import { DrizzleMessageRepository } from "./message.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
+import type { DrizzleEnvelopeRepository } from "./envelope.js";
+import type { DrizzleMessageRepository } from "./message.js";
 import { createTestDb, type TestDb } from "./test-helpers.js";
 
 describe("DrizzleMessageRepository", () => {
@@ -37,8 +37,9 @@ describe("DrizzleMessageRepository", () => {
 
 	before(async () => {
 		({ db, stop } = await createTestDb());
-		messageRepo = new DrizzleMessageRepository(db, new SearchIndex(db, db));
-		envelopeRepo = new DrizzleEnvelopeRepository(db);
+		const repos = createSqliteRepositories({ app: db, mail: db, search: db });
+		messageRepo = repos.message;
+		envelopeRepo = repos.envelope;
 	});
 
 	after(async () => {

package/src/repos/message.ts

@@ -18,8 +18,8 @@ import {
 	or,
 	type SQL,
 } from "drizzle-orm";
-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 {
 	CreateFailedConflictError,
 	isUniqueViolation,
@@ -37,7 +37,6 @@ import {
 	bodyStructureRefetchTable,
 	envelopeAddressTable,
 	envelopeTable,
-	type MessageDataSchema,
 	messageFlagTable,
 	messageReferenceTable,
 	messageTable,
@@ -45,6 +44,7 @@ import {
 } from "../schema/message-data.js";
 import { threadMessageTable } from "../schema/thread-message.js";
 import type { SearchIndex } from "../search/thread-message-search.js";
+import { inList } from "./in-list.js";
 import {
 	toBodyPartItem,
 	toBodyPartParameterItem,
@@ -55,7 +55,7 @@ import {
 	toRawMessageStorageItem,
 } from "./mappers.js";
 
-type DB = Db<MessageDataSchema>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function toMessageItem(row: typeof messageTable.$inferSelect): MessageItem {
 	return {
@@ -111,7 +111,7 @@ function toMessageItem(row: typeof messageTable.$inferSelect): MessageItem {
 	};
 }
 
-export type SubtreeDb = Pick<Db<Record<string, unknown>>, "delete">;
+export type SubtreeDb = Pick<RepositoryDb<Record<string, unknown>>, "delete">;
 
 /**
  * The statements that delete a message and its whole per-message subtree by
@@ -129,36 +129,36 @@ export function deleteMessageSubtree(
 	return [
 		db
 			.delete(messageFlagTable)
-			.where(and(inArray(messageFlagTable.messageId, messageIds), guard)),
+			.where(and(inList(messageFlagTable.messageId, messageIds), guard)),
 		db
 			.delete(messageReferenceTable)
-			.where(and(inArray(messageReferenceTable.messageId, messageIds), guard)),
+			.where(and(inList(messageReferenceTable.messageId, messageIds), guard)),
 		db
 			.delete(envelopeAddressTable)
-			.where(and(inArray(envelopeAddressTable.messageId, messageIds), guard)),
+			.where(and(inList(envelopeAddressTable.messageId, messageIds), guard)),
 		db
 			.delete(bodyPartParameterTable)
-			.where(and(inArray(bodyPartParameterTable.messageId, messageIds), guard)),
+			.where(and(inList(bodyPartParameterTable.messageId, messageIds), guard)),
 		db
 			.delete(bodyPartStorageTable)
-			.where(and(inArray(bodyPartStorageTable.messageId, messageIds), guard)),
+			.where(and(inList(bodyPartStorageTable.messageId, messageIds), guard)),
 		db
 			.delete(rawMessageStorageTable)
-			.where(and(inArray(rawMessageStorageTable.messageId, messageIds), guard)),
+			.where(and(inList(rawMessageStorageTable.messageId, messageIds), guard)),
 		db
 			.delete(bodyPartTable)
-			.where(and(inArray(bodyPartTable.messageId, messageIds), guard)),
+			.where(and(inList(bodyPartTable.messageId, messageIds), guard)),
 		db
 			.delete(bodyStructureRefetchTable)
 			.where(
-				and(inArray(bodyStructureRefetchTable.messageId, messageIds), guard),
+				and(inList(bodyStructureRefetchTable.messageId, messageIds), guard),
 			),
 		db
 			.delete(envelopeTable)
-			.where(and(inArray(envelopeTable.messageId, messageIds), guard)),
+			.where(and(inList(envelopeTable.messageId, messageIds), guard)),
 		db
 			.delete(messageTable)
-			.where(and(inArray(messageTable.messageId, messageIds), guard))
+			.where(and(inList(messageTable.messageId, messageIds), guard))
 			.returning({ messageId: messageTable.messageId }),
 	];
 }
@@ -192,10 +192,16 @@ const placementTerms = (expected: PlacementPredicate): SQL[] => {
 };
 
 export class DrizzleMessageRepository implements IMessageRepository {
+	private readonly db: DB;
+	private readonly batch: WriteBatch;
+
 	constructor(
-		private db: DB,
+		store: SqliteStore<Record<string, unknown>>,
 		private search: SearchIndex,
-	) {}
+	) {
+		this.db = store.db;
+		this.batch = store.batch;
+	}
 
 	private rowOf(input: CreateMessageInput) {
 		const now = Date.now();
@@ -275,7 +281,7 @@ export class DrizzleMessageRepository implements IMessageRepository {
 			const rows = await this.db
 				.select()
 				.from(messageTable)
-				.where(inArray(messageTable.messageId, messageId));
+				.where(inList(messageTable.messageId, messageId));
 			return rows.map(toMessageItem);
 		}
 
@@ -461,7 +467,7 @@ export class DrizzleMessageRepository implements IMessageRepository {
 			.select({ threadMessageId: threadMessageTable.threadMessageId })
 			.from(threadMessageTable)
 			.where(eq(threadMessageTable.messageId, messageId));
-		const results = await runBatch(this.db, [
+		const results = await this.batch([
 			this.db
 				.delete(threadMessageTable)
 				.where(and(eq(threadMessageTable.messageId, messageId), placed)),
@@ -474,7 +480,7 @@ export class DrizzleMessageRepository implements IMessageRepository {
 
 	async deleteMany(messageIds: string[]): Promise<void> {
 		if (messageIds.length === 0) return;
-		await runBatch(this.db, deleteMessageSubtree(this.db, messageIds));
+		await this.batch(deleteMessageSubtree(this.db, messageIds));
 	}
 
 	async listByMailbox(
@@ -547,18 +553,18 @@ export class DrizzleMessageRepository implements IMessageRepository {
 					or(
 						and(
 							eq(messageTable.status, "moving"),
-							inArray(messageTable.originalMailboxId, ids),
+							inList(messageTable.originalMailboxId, ids),
 							isNotNull(messageTable.originalUid),
 						),
 						and(
 							eq(messageTable.status, "deleting"),
-							inArray(messageTable.mailboxId, ids),
+							inList(messageTable.mailboxId, ids),
 						),
 						and(
 							eq(messageTable.status, "moving"),
 							eq(messageTable.uid, 0),
 							isNull(messageTable.originalUid),
-							inArray(messageTable.mailboxId, ids),
+							inList(messageTable.mailboxId, ids),
 						),
 					),
 				),
@@ -622,7 +628,7 @@ export class DrizzleMessageRepository implements IMessageRepository {
 			.select({ threadMessageId: threadMessageTable.threadMessageId })
 			.from(threadMessageTable)
 			.where(eq(threadMessageTable.messageId, messageId));
-		const [moved] = await runBatch(this.db, [
+		const [moved] = await this.batch([
 			this.db
 				.update(messageTable)
 				.set({

package/src/repos/quarantine.ts

@@ -6,10 +6,10 @@ import type {
 } from "@remit/data-ports";
 import { deriveQuarantineId } from "@remit/data-ports/id";
 import { desc, eq } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { quarantineTable } from "../schema/quarantine.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToItem(row: typeof quarantineTable.$inferSelect): QuarantineItem {
 	return {

package/src/repos/sync-warning.ts

@@ -5,11 +5,12 @@ import type {
 	SyncWarningKey,
 } from "@remit/data-ports";
 import { deriveSyncWarningId } from "@remit/data-ports/id";
-import { and, count, desc, eq, gte, inArray, sql } from "drizzle-orm";
-import type { Db } from "../db.js";
+import { and, count, desc, eq, gte, sql } from "drizzle-orm";
+import type { RepositoryDb } from "../db.js";
 import { syncWarningTable } from "../schema/sync-warning.js";
+import { inList } from "./in-list.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 export class SyncWarningRepo implements ISyncWarningRepository {
 	constructor(private db: DB) {}
@@ -71,6 +72,6 @@ export class SyncWarningRepo implements ISyncWarningRepository {
 		if (syncWarningIds.length === 0) return;
 		await this.db
 			.delete(syncWarningTable)
-			.where(inArray(syncWarningTable.syncWarningId, syncWarningIds));
+			.where(inList(syncWarningTable.syncWarningId, syncWarningIds));
 	};
 }

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

@@ -12,10 +12,10 @@ import { after, before, describe, test } from "node:test";
 import type { CreateThreadMessageInput } from "@remit/data-ports";
 import { addressTable } from "../schema/i4-address.js";
 import { threadMessageTable } from "../schema/thread-message.js";
-import { SearchIndex } from "../search/thread-message-search.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
 import { shippedIndexDdl } from "../test-shipped-sqlite-schema.js";
-import { DrizzleThreadMessageRepository } from "./thread-message.js";
+import type { DrizzleThreadMessageRepository } from "./thread-message.js";
 
 // The index the mail baseline creates for this predicate, read from the one
 // committed source so the plan assertion below is about the real object.
@@ -61,7 +61,11 @@ describe("thread-message body and muted-sender predicates (sqlite)", () => {
 			{ searchIndex: true },
 		));
 		sqlite.exec(mutedIndexDdl);
-		repo = new DrizzleThreadMessageRepository(db, new SearchIndex(db, db));
+		repo = createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).threadMessage;
 	});
 
 	after(async () => {

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

@@ -2,10 +2,10 @@ 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 { SearchIndex } from "../search/thread-message-search.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
 import {
-	DrizzleThreadMessageRepository,
+	type DrizzleThreadMessageRepository,
 	THREAD_SEARCH_MAX_LIMIT,
 } from "./thread-message.js";
 
@@ -55,10 +55,11 @@ describe("DrizzleThreadMessageRepository.listByFieldTerms (sqlite, #459)", () =>
 			{ searchIndex: true },
 		);
 		close = created.close;
-		repo = new DrizzleThreadMessageRepository(
-			created.db,
-			new SearchIndex(created.db, created.db),
-		);
+		repo = createSqliteRepositories({
+			app: created.db,
+			mail: created.db,
+			search: created.db,
+		}).threadMessage;
 
 		await repo.create(
 			makeInput({

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

@@ -2,7 +2,7 @@ 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 { SearchIndex } from "../search/thread-message-search.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
 import {
 	BASE_DATE,
@@ -12,7 +12,7 @@ import {
 	totalRows,
 } from "./category-fixture.js";
 import {
-	DrizzleThreadMessageRepository,
+	type DrizzleThreadMessageRepository,
 	THREAD_SEARCH_MAX_LIMIT,
 } from "./thread-message.js";
 
@@ -58,7 +58,11 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 			},
 			{ searchIndex: true },
 		));
-		repo = new DrizzleThreadMessageRepository(db, new SearchIndex(db, db));
+		repo = createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).threadMessage;
 	});
 
 	after(async () => {

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

@@ -3,11 +3,11 @@ import { after, before, describe, test } from "node:test";
 import type { CreateThreadMessageInput } from "@remit/data-ports";
 import shortUuid from "short-uuid";
 import { threadMessageTable } from "../schema/thread-message.js";
-import { SearchIndex } from "../search/thread-message-search.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
 import {
 	clampThreadSearchLimit,
-	DrizzleThreadMessageRepository,
+	type DrizzleThreadMessageRepository,
 	deriveThreadMessageId,
 	THREAD_SEARCH_MAX_LIMIT,
 } from "./thread-message.js";
@@ -87,10 +87,11 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 	before(async () => {
 		const harness = await setupDb();
 		close = harness.close;
-		repo = new DrizzleThreadMessageRepository(
-			harness.db,
-			new SearchIndex(harness.db, harness.db),
-		);
+		repo = createSqliteRepositories({
+			app: harness.db,
+			mail: harness.db,
+			search: harness.db,
+		}).threadMessage;
 	});
 
 	after(async () => {
@@ -391,10 +392,11 @@ describe("DrizzleThreadMessageRepository.searchByDate", () => {
 	before(async () => {
 		const harness = await setupDb();
 		close = harness.close;
-		repo = new DrizzleThreadMessageRepository(
-			harness.db,
-			new SearchIndex(harness.db, harness.db),
-		);
+		repo = createSqliteRepositories({
+			app: harness.db,
+			mail: harness.db,
+			search: harness.db,
+		}).threadMessage;
 	});
 
 	after(async () => {
@@ -921,10 +923,11 @@ describe("DrizzleThreadMessageRepository — native text search", () => {
 	before(async () => {
 		const harness = await setupDb();
 		close = harness.close;
-		repo = new DrizzleThreadMessageRepository(
-			harness.db,
-			new SearchIndex(harness.db, harness.db),
-		);
+		repo = createSqliteRepositories({
+			app: harness.db,
+			mail: harness.db,
+			search: harness.db,
+		}).threadMessage;
 	});
 
 	after(async () => {
@@ -1096,10 +1099,11 @@ describe("DrizzleThreadMessageRepository — core CRUD", () => {
 	before(async () => {
 		const harness = await setupDb();
 		close = harness.close;
-		repo = new DrizzleThreadMessageRepository(
-			harness.db,
-			new SearchIndex(harness.db, harness.db),
-		);
+		repo = createSqliteRepositories({
+			app: harness.db,
+			mail: harness.db,
+			search: harness.db,
+		}).threadMessage;
 	});
 
 	after(async () => {