@remit/drizzle-service 0.0.101 → 0.0.103

package/src/repos/cascade-delete.ts

@@ -1,9 +1,9 @@
-import { and, eq, inArray, or, type SQL } from "drizzle-orm";
-import { runBatch, type SqliteBatchItem } from "../batch.js";
+import type { SqliteBatchItem } from "../batch.js";
 import {
 	openSqliteDatabases,
 	type SqliteDatabasePaths,
-	type SqliteDatabases,
+	type SqliteStores,
+	syncStores,
 } from "../databases.js";
 import { accountTable } from "../schema/i4-account-config.js";
 import { accountSettingTable } from "../schema/i4-account-setting.js";
@@ -17,6 +17,7 @@ import { quarantineTable } from "../schema/quarantine.js";
 import { syncWarningTable } from "../schema/sync-warning.js";
 import { threadMessageTable } from "../schema/thread-message.js";
 import { SearchIndex } from "../search/thread-message-search.js";
+import { inList, pairInList } from "./in-list.js";
 import { deleteMessageSubtree } from "./message.js";
 
 export interface CascadeEntity {
@@ -82,10 +83,12 @@ const groupByType = (
  * cascade-in-progress marker.
  */
 export const runDrizzleCascadeDelete = async (
-	{ app, mail, search }: SqliteDatabases,
+	stores: SqliteStores,
 	entities: CascadeEntity[],
 	log: CascadeDeleteLogger,
 ): Promise<void> => {
+	const app = stores.app.db;
+	const mail = stores.mail.db;
 	const grouped = groupByType(entities);
 
 	for (const entityType of grouped.keys()) {
@@ -107,7 +110,7 @@ export const runDrizzleCascadeDelete = async (
 		items.push(
 			mail
 				.delete(threadMessageTable)
-				.where(inArray(threadMessageTable.threadMessageId, threadMessageIds)),
+				.where(inList(threadMessageTable.threadMessageId, threadMessageIds)),
 		);
 	}
 
@@ -116,12 +119,12 @@ export const runDrizzleCascadeDelete = async (
 		items.push(
 			mail
 				.delete(syncWarningTable)
-				.where(inArray(syncWarningTable.mailboxId, mailboxIds)),
+				.where(inList(syncWarningTable.mailboxId, mailboxIds)),
 		);
 		items.push(
 			mail
 				.delete(mailboxTable)
-				.where(inArray(mailboxTable.mailboxId, mailboxIds)),
+				.where(inList(mailboxTable.mailboxId, mailboxIds)),
 		);
 	}
 
@@ -132,19 +135,21 @@ export const runDrizzleCascadeDelete = async (
 		items.push(
 			mail
 				.delete(outboxMessageTable)
-				.where(inArray(outboxMessageTable.outboxMessageId, outboxMessageIds)),
+				.where(inList(outboxMessageTable.outboxMessageId, outboxMessageIds)),
 		);
 	}
 
 	const lockKeys = grouped.get("MailboxLock") ?? [];
 	if (lockKeys.length > 0) {
-		const conditions: SQL[] = lockKeys.map((k) =>
-			and(
-				eq(mailboxLockTable.mailboxId, k.mailboxId),
-				eq(mailboxLockTable.eventName, k.eventName),
+		items.push(
+			mail.delete(mailboxLockTable).where(
+				pairInList(
+					mailboxLockTable.mailboxId,
+					mailboxLockTable.eventName,
+					lockKeys.map((k) => [k.mailboxId, k.eventName]),
+				),
 			),
-		) as SQL[];
-		items.push(mail.delete(mailboxLockTable).where(or(...conditions)));
+		);
 	}
 
 	const accountSettingIds = (grouped.get("AccountSetting") ?? []).map(
@@ -154,9 +159,7 @@ export const runDrizzleCascadeDelete = async (
 		appItems.push(
 			app
 				.delete(accountSettingTable)
-				.where(
-					inArray(accountSettingTable.accountSettingId, accountSettingIds),
-				),
+				.where(inList(accountSettingTable.accountSettingId, accountSettingIds)),
 		);
 	}
 
@@ -165,7 +168,7 @@ export const runDrizzleCascadeDelete = async (
 		items.push(
 			mail
 				.delete(addressTable)
-				.where(inArray(addressTable.addressId, addressIds)),
+				.where(inList(addressTable.addressId, addressIds)),
 		);
 	}
 
@@ -178,17 +181,17 @@ export const runDrizzleCascadeDelete = async (
 		items.push(
 			mail
 				.delete(quarantineTable)
-				.where(inArray(quarantineTable.accountId, accountIds)),
+				.where(inList(quarantineTable.accountId, accountIds)),
 		);
 		items.push(
 			mail
 				.delete(syncWarningTable)
-				.where(inArray(syncWarningTable.accountId, accountIds)),
+				.where(inList(syncWarningTable.accountId, accountIds)),
 		);
 		appItems.push(
 			app
 				.delete(accountTable)
-				.where(inArray(accountTable.accountId, accountIds)),
+				.where(inList(accountTable.accountId, accountIds)),
 		);
 	}
 
@@ -200,27 +203,26 @@ export const runDrizzleCascadeDelete = async (
 			mail
 				.delete(messagePlacementMoveTable)
 				.where(
-					inArray(messagePlacementMoveTable.messageId, placementMoveMessageIds),
+					inList(messagePlacementMoveTable.messageId, placementMoveMessageIds),
 				),
 		);
 	}
 
-	// Composite key (messageId, flagName) — a message can carry an
-	// independent pending read-state marker and pending star marker at once
-	// (issue #1273), so a single-column inArray cannot target one row.
 	const flagPushKeys = grouped.get("MessageFlagPush") ?? [];
 	if (flagPushKeys.length > 0) {
-		const conditions: SQL[] = flagPushKeys.map((k) =>
-			and(
-				eq(messageFlagPushTable.messageId, k.messageId),
-				eq(messageFlagPushTable.flagName, k.flagName),
+		items.push(
+			mail.delete(messageFlagPushTable).where(
+				pairInList(
+					messageFlagPushTable.messageId,
+					messageFlagPushTable.flagName,
+					flagPushKeys.map((k) => [k.messageId, k.flagName]),
+				),
 			),
-		) as SQL[];
-		items.push(mail.delete(messageFlagPushTable).where(or(...conditions)));
+		);
 	}
-	await runBatch(mail, items);
-	await runBatch(app, appItems);
-	await new SearchIndex(mail, search).sync(threadMessageIds);
+	await stores.mail.batch(items);
+	await stores.app.batch(appItems);
+	await new SearchIndex(mail, stores.search).sync(threadMessageIds);
 
 	log.info({ entityCount: entities.length }, "Drizzle cascade delete complete");
 };
@@ -239,5 +241,6 @@ export const createSqliteCascadeDeleter = async (
 	paths: SqliteDatabasePaths,
 ): Promise<CascadeDeleter> => {
 	const databases = await openSqliteDatabases(paths);
-	return (entities, log) => runDrizzleCascadeDelete(databases, entities, log);
+	const stores = syncStores(databases);
+	return (entities, log) => runDrizzleCascadeDelete(stores, entities, log);
 };

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

@@ -4,8 +4,9 @@ import {
 	type MessageDataSchema,
 	messageDataSchema,
 } from "../schema/message-data.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb, type SqliteTestDb } from "../test-db-sqlite.js";
-import { DrizzleEnvelopeRepository } from "./envelope.js";
+import type { DrizzleEnvelopeRepository } from "./envelope.js";
 
 // Envelope repo on sqlite (RFC 036 D1): the onConflictDoUpdate upsert path and
 // the transactional body-part upsert both run on better-sqlite3 unchanged.
@@ -19,7 +20,7 @@ describe("DrizzleEnvelopeRepository (sqlite)", () => {
 
 	before(async () => {
 		({ db, close } = await createSqliteTestDb(messageDataSchema));
-		repo = new DrizzleEnvelopeRepository(db);
+		repo = createSqliteRepositories({ app: db, mail: db, search: db }).envelope;
 	});
 
 	after(async () => {

package/src/repos/envelope.test.ts

@@ -2,7 +2,8 @@ import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
 import type { BodyPartUpsertInput } from "@remit/data-ports";
 import { envelopeId as deriveEnvelopeId } from "../id.js";
-import { DrizzleEnvelopeRepository } from "./envelope.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
+import type { DrizzleEnvelopeRepository } from "./envelope.js";
 import { createTestDb, type TestDb } from "./test-helpers.js";
 
 describe("DrizzleEnvelopeRepository", () => {
@@ -18,7 +19,7 @@ describe("DrizzleEnvelopeRepository", () => {
 
 	before(async () => {
 		({ db, stop } = await createTestDb());
-		repo = new DrizzleEnvelopeRepository(db);
+		repo = createSqliteRepositories({ app: db, mail: db, search: db }).envelope;
 
 		await repo.upsertEnvelope({
 			envelopeId: ENVELOPE_ID,

package/src/repos/envelope.ts

@@ -8,9 +8,9 @@ import type {
 	MessageReferenceInput,
 	UpdateEnvelopeInput,
 } from "@remit/data-ports";
-import { eq, inArray } from "drizzle-orm";
-import { runBatch } from "../batch.js";
-import type { Db } from "../db.js";
+import { eq } from "drizzle-orm";
+import type { WriteBatch } from "../batch.js";
+import type { RepositoryDb, SqliteStore } from "../db.js";
 import {
 	CreateFailedConflictError,
 	isUniqueViolation,
@@ -29,11 +29,11 @@ import {
 	bodyStructureRefetchTable,
 	envelopeAddressTable,
 	envelopeTable,
-	type MessageDataSchema,
 	messageReferenceTable,
 	messageTable,
 	rawMessageStorageTable,
 } from "../schema/message-data.js";
+import { inList } from "./in-list.js";
 import {
 	toBodyPartItem,
 	toBodyPartParameterItem,
@@ -44,7 +44,7 @@ import {
 	toRawMessageStorageItem,
 } from "./mappers.js";
 
-type DB = Db<MessageDataSchema>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function dedupeById<T>(rows: T[], getId: (row: T) => string): T[] {
 	const byId = new Map<string, T>();
@@ -55,7 +55,13 @@ function dedupeById<T>(rows: T[], getId: (row: T) => string): T[] {
 }
 
 export class DrizzleEnvelopeRepository implements IEnvelopeRepository {
-	constructor(private db: DB) {}
+	private readonly db: DB;
+	private readonly batch: WriteBatch;
+
+	constructor(store: SqliteStore<Record<string, unknown>>) {
+		this.db = store.db;
+		this.batch = store.batch;
+	}
 
 	async getMessageData(messageId: string): Promise<MessageData> {
 		const [
@@ -182,10 +188,10 @@ export class DrizzleEnvelopeRepository implements IEnvelopeRepository {
 				set: { updatedAt: now },
 			});
 		if (dedupedParameterRows.length === 0) {
-			await runBatch(this.db, [insertParts]);
+			await this.batch([insertParts]);
 			return;
 		}
-		await runBatch(this.db, [
+		await this.batch([
 			insertParts,
 			this.db
 				.insert(bodyPartParameterTable)
@@ -210,10 +216,10 @@ export class DrizzleEnvelopeRepository implements IEnvelopeRepository {
 			.delete(messageReferenceTable)
 			.where(eq(messageReferenceTable.messageId, messageId));
 		if (references.length === 0) {
-			await runBatch(this.db, [clear]);
+			await this.batch([clear]);
 			return;
 		}
-		await runBatch(this.db, [
+		await this.batch([
 			clear,
 			this.db.insert(messageReferenceTable).values(
 				references.map((reference) => ({
@@ -235,7 +241,7 @@ export class DrizzleEnvelopeRepository implements IEnvelopeRepository {
 
 		await this.db
 			.delete(envelopeTable)
-			.where(inArray(envelopeTable.envelopeId, envelopeIds));
+			.where(inList(envelopeTable.envelopeId, envelopeIds));
 	}
 
 	async createEnvelope(input: CreateEnvelopeInput): Promise<EnvelopeItem> {
@@ -293,7 +299,7 @@ export class DrizzleEnvelopeRepository implements IEnvelopeRepository {
 			const rows = await this.db
 				.select()
 				.from(envelopeTable)
-				.where(inArray(envelopeTable.envelopeId, envelopeId));
+				.where(inList(envelopeTable.envelopeId, envelopeId));
 			return rows.map(toEnvelopeItem);
 		}
 
@@ -353,6 +359,6 @@ export class DrizzleEnvelopeRepository implements IEnvelopeRepository {
 		if (messageIds.length === 0) return;
 		await this.db
 			.delete(bodyStructureRefetchTable)
-			.where(inArray(bodyStructureRefetchTable.messageId, messageIds));
+			.where(inList(bodyStructureRefetchTable.messageId, messageIds));
 	}
 }

package/src/repos/filter.ts

@@ -12,13 +12,13 @@ import {
 	FilterState,
 } from "@remit/domain-enums";
 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 { filterTable } from "../schema.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 const RULE_ASSERTION_FIELDS = [
 	"matchOperator",

package/src/repos/i4-account-config.test.ts

@@ -1,9 +1,8 @@
 import assert from "node:assert";
 import { after, before, describe, test } from "node:test";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createTestDb, randomId, type TestDb } from "../test-db.js";
-import { AccountRepo } from "./i4-account.js";
-import { AccountConfigRepo } from "./i4-account-config.js";
-import { AddressRepo } from "./i4-address.js";
+import type { AccountConfigRepo } from "./i4-account-config.js";
 
 describe("AccountConfigRepo", () => {
 	let db: TestDb;
@@ -12,7 +11,11 @@ describe("AccountConfigRepo", () => {
 
 	before(async () => {
 		({ db, close } = await createTestDb());
-		repo = new AccountConfigRepo(db as never, db as never);
+		repo = createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).accountConfig;
 	});
 
 	after(async () => {
@@ -58,8 +61,9 @@ describe("AccountConfigRepo", () => {
 		const userId = randomId();
 		const cfg = await repo.create({ userId });
 
-		const accountRepo = new AccountRepo(db as never, db as never);
-		const addrRepo = new AddressRepo(db as never);
+		const repos = createSqliteRepositories({ app: db, mail: db, search: db });
+		const accountRepo = repos.account;
+		const addrRepo = repos.address;
 
 		await accountRepo.create({
 			accountConfigId: cfg.accountConfigId,

package/src/repos/i4-account-config.ts

@@ -3,11 +3,12 @@ import type {
 	AccountConfigItem,
 	CreateAccountConfigInput,
 	IAccountConfigRepository,
+	IAddressRepository,
 	ResultList,
 	UpdateAccountConfigInput,
 } from "@remit/data-ports";
-import { and, asc, eq, gt, inArray, or } from "drizzle-orm";
-import type { Db } from "../db.js";
+import { and, asc, eq, gt, or } from "drizzle-orm";
+import type { RepositoryDb } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { randomId } from "../id.js";
 import { decodeToken, resultList } from "../pagination.js";
@@ -15,11 +16,12 @@ import {
 	accountConfigTable,
 	accountTable,
 } from "../schema/i4-account-config.js";
-import { addressTable } from "../schema/i4-address.js";
 import { rowToAccount } from "./i4-account.js";
-import { rowToAddress } from "./i4-address.js";
+import { inList } from "./in-list.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
+
+type AddressReader = Pick<IAddressRepository, "listAllByAccountConfig">;
 
 function rowToAccountConfig(
 	row: typeof accountConfigTable.$inferSelect,
@@ -39,7 +41,7 @@ function rowToAccountConfig(
 export class AccountConfigRepo implements IAccountConfigRepository {
 	constructor(
 		private db: DB,
-		private mail: DB,
+		private addresses: AddressReader,
 	) {}
 
 	async create(input: CreateAccountConfigInput): Promise<AccountConfigItem> {
@@ -71,7 +73,7 @@ export class AccountConfigRepo implements IAccountConfigRepository {
 			const rows = await this.db
 				.select()
 				.from(accountConfigTable)
-				.where(inArray(accountConfigTable.accountConfigId, accountConfigId));
+				.where(inList(accountConfigTable.accountConfigId, accountConfigId));
 			return rows.map(rowToAccountConfig);
 		}
 		const [row] = await this.db
@@ -116,7 +118,7 @@ export class AccountConfigRepo implements IAccountConfigRepository {
 		if (accountConfigIds.length === 0) return;
 		await this.db
 			.delete(accountConfigTable)
-			.where(inArray(accountConfigTable.accountConfigId, accountConfigIds));
+			.where(inList(accountConfigTable.accountConfigId, accountConfigIds));
 	}
 
 	async listByUser(
@@ -182,10 +184,7 @@ export class AccountConfigRepo implements IAccountConfigRepository {
 				.select()
 				.from(accountTable)
 				.where(eq(accountTable.accountConfigId, accountConfigId)),
-			this.mail
-				.select()
-				.from(addressTable)
-				.where(eq(addressTable.accountConfigId, accountConfigId)),
+			this.addresses.listAllByAccountConfig(accountConfigId),
 		]);
 		if (configs.length === 0) {
 			throw new NotFoundError(`AccountConfig not found: ${accountConfigId}`);
@@ -193,7 +192,7 @@ export class AccountConfigRepo implements IAccountConfigRepository {
 		return {
 			accountConfig: configs.map(rowToAccountConfig),
 			account: accounts.map(rowToAccount),
-			address: addresses.map(rowToAddress),
+			address: addresses,
 		};
 	}
 

package/src/repos/i4-account-export-request.ts

@@ -6,13 +6,13 @@ import type {
 	UpdateAccountExportRequestInput,
 } from "@remit/data-ports";
 import { eq } 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 { accountExportRequestTable } from "../schema/i4-account-export-request.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToItem(
 	row: typeof accountExportRequestTable.$inferSelect,

package/src/repos/i4-account-setting.ts

@@ -5,11 +5,12 @@ import type {
 	IAccountSettingRepository,
 	UpsertAccountSettingInput,
 } 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 { accountSettingTable } from "../schema/i4-account-setting.js";
+import { inList } from "./in-list.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 // The PG store derives its own deterministic id from the composite key. It is
 // stable within this backend but not byte-identical to the DDB base36 UUIDv5
@@ -63,8 +64,8 @@ export class AccountSettingRepo implements IAccountSettingRepository {
 			.from(accountSettingTable)
 			.where(
 				and(
-					inArray(accountSettingTable.accountConfigId, [...accountConfigIds]),
-					inArray(accountSettingTable.name, [...names]),
+					inList(accountSettingTable.accountConfigId, accountConfigIds),
+					inList(accountSettingTable.name, names),
 				),
 			);
 		return rows.map(rowToAccountSetting);

package/src/repos/i4-account.test.ts

@@ -1,9 +1,8 @@
 import assert from "node:assert";
 import { after, before, describe, test } from "node:test";
-import { SearchIndex } from "../search/thread-message-search.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createTestDb, randomId, type TestDb } from "../test-db.js";
-import { AccountRepo } from "./i4-account.js";
-import { MailboxRepo } from "./i4-mailbox.js";
+import type { AccountRepo } from "./i4-account.js";
 import { mailboxCreated } from "./test-helpers.js";
 
 function makeAccountInput(accountConfigId: string) {
@@ -27,7 +26,11 @@ describe("AccountRepo", () => {
 
 	before(async () => {
 		({ db, close } = await createTestDb());
-		repo = new AccountRepo(db as never, db as never);
+		repo = createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).account;
 	});
 
 	after(async () => {
@@ -161,10 +164,11 @@ describe("AccountRepo", () => {
 		const accountConfigId = randomId();
 		const account = await repo.create(makeAccountInput(accountConfigId));
 
-		const mailboxRepo = new MailboxRepo(
-			db as never,
-			new SearchIndex(db as never, db as never),
-		);
+		const mailboxRepo = createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).mailbox;
 		mailboxCreated(
 			await mailboxRepo.create({
 				accountId: account.accountId,

package/src/repos/i4-account.ts

@@ -4,21 +4,21 @@ import type {
 	AccountSchedulerPage,
 	CreateAccountInput,
 	IAccountRepository,
+	IMailboxRepository,
 	RemovableAccountField,
 	ResultList,
 	UpdateAccountInput,
 } from "@remit/data-ports";
 import { AccountService, SyncPhase } from "@remit/domain-enums";
-import { and, asc, eq, gt, inArray, like, or, sql } from "drizzle-orm";
-import type { Db } from "../db.js";
+import { and, asc, eq, gt, like, or, sql } from "drizzle-orm";
+import type { RepositoryDb } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { randomId } from "../id.js";
 import { decodeToken, encodeToken, resultList } from "../pagination.js";
 import { accountTable } from "../schema/i4-account-config.js";
-import { mailboxTable } from "../schema/i4-mailbox.js";
-import { rowToMailbox } from "./i4-mailbox.js";
+import { inList } from "./in-list.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 /**
  * A stored failure is a sentence the account card shows, not a transcript.
@@ -73,7 +73,7 @@ export function rowToAccount(
 export class AccountRepo implements IAccountRepository {
 	constructor(
 		private db: DB,
-		private mail: DB,
+		private mailboxes: Pick<IMailboxRepository, "listAllByAccount">,
 	) {}
 
 	async create(input: CreateAccountInput): Promise<AccountItem> {
@@ -129,7 +129,7 @@ export class AccountRepo implements IAccountRepository {
 			const rows = await this.db
 				.select()
 				.from(accountTable)
-				.where(inArray(accountTable.accountId, accountId));
+				.where(inList(accountTable.accountId, accountId));
 			return rows.map(rowToAccount);
 		}
 		const [row] = await this.db
@@ -187,7 +187,7 @@ export class AccountRepo implements IAccountRepository {
 		if (accountIds.length === 0) return;
 		await this.db
 			.delete(accountTable)
-			.where(inArray(accountTable.accountId, accountIds));
+			.where(inList(accountTable.accountId, accountIds));
 	}
 
 	async list(
@@ -268,17 +268,14 @@ export class AccountRepo implements IAccountRepository {
 				.select()
 				.from(accountTable)
 				.where(eq(accountTable.accountId, accountId)),
-			this.mail
-				.select()
-				.from(mailboxTable)
-				.where(eq(mailboxTable.accountId, accountId)),
+			this.mailboxes.listAllByAccount(accountId),
 		]);
 		if (accounts.length === 0) {
 			throw new NotFoundError(`Account not found: ${accountId}`);
 		}
 		return {
 			account: accounts.map(rowToAccount),
-			mailbox: mailboxes.map(rowToMailbox),
+			mailbox: mailboxes,
 		};
 	}
 

package/src/repos/i4-address-junk-move.sqlite.test.ts

@@ -1,9 +1,10 @@
 import assert from "node:assert/strict";
 import { after, before, beforeEach, describe, test } from "node:test";
 import type Database from "better-sqlite3";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createTestDb, type TestDb } from "../test-db.js";
 import { AddressRepo } from "./i4-address.js";
-import { MailboxSpecialUseRepo } from "./i4-mailbox-special-use.js";
+import type { MailboxSpecialUseRepo } from "./i4-mailbox-special-use.js";
 
 const CONFIG = "cfg-1";
 
@@ -124,7 +125,11 @@ describe("reconciling one message's addresses at the moment it moves", () => {
 	before(async () => {
 		({ db, sqlite, close } = await createTestDb());
 		repo = new AddressRepo(db as never);
-		specialUse = new MailboxSpecialUseRepo(db as never, db as never);
+		specialUse = createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).mailboxSpecialUse;
 	});
 
 	/**