@remit/drizzle-service 0.0.102 → 0.0.103

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.102",
+  "version": "0.0.103",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",

package/src/batch.sqlite.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
 import { eq } from "drizzle-orm";
-import { runBatch } from "./batch.js";
+import { syncBatch } from "./batch.js";
 import { calendarTable } from "./schema.js";
 import { createSqliteTestDb, type SqliteTestDb } from "./test-db-sqlite.js";
 
@@ -36,7 +36,7 @@ describe("a batch on better-sqlite3", () => {
 	const stored = () => db.select().from(calendarTable);
 
 	test("answers each statement in order, reads seeing the writes before them", async () => {
-		const [inserted, read] = await runBatch(db, [
+		const [inserted, read] = await syncBatch(db)([
 			db.insert(calendarTable).values(collection("first")).returning(),
 			db
 				.select()
@@ -58,7 +58,7 @@ describe("a batch on better-sqlite3", () => {
 		const before = await stored();
 
 		await assert.rejects(
-			runBatch(db, [
+			syncBatch(db)([
 				db.insert(calendarTable).values(collection("second")),
 				db
 					.update(calendarTable)
@@ -73,6 +73,6 @@ describe("a batch on better-sqlite3", () => {
 	});
 
 	test("an empty batch writes nothing and answers nothing", async () => {
-		assert.deepEqual(await runBatch(db, []), []);
+		assert.deepEqual(await syncBatch(db)([]), []);
 	});
 });

package/src/batch.ts

@@ -3,6 +3,26 @@ import type { Db } from "./db.js";
 
 export type SqliteBatchItem = BatchItem<"sqlite">;
 
+/**
+ * The one write port a repository is handed for a write set, bound to one
+ * database. It has the shape of D1's `batch()`: every statement commits
+ * together or not at all, and none of them reads another's result mid-flight.
+ * A write that needs a value reads it before the batch and is written so a
+ * stale read loses safely (a conditional `WHERE`, an upsert, a deterministic
+ * id).
+ */
+export type WriteBatch = <T extends readonly SqliteBatchItem[]>(
+	items: T,
+) => Promise<BatchResponse<T>>;
+
+type NonEmptyBatch = readonly [SqliteBatchItem, ...SqliteBatchItem[]];
+
+export interface BatchingDatabase {
+	batch<U extends SqliteBatchItem, T extends Readonly<[U, ...U[]]>>(
+		batch: T,
+	): Promise<BatchResponse<T>>;
+}
+
 interface SyncPreparable {
 	_prepare(): { execute(): { sync(): unknown } };
 }
@@ -12,6 +32,10 @@ const isSyncPreparable = (value: unknown): value is SyncPreparable =>
 	value !== null &&
 	typeof Reflect.get(value, "_prepare") === "function";
 
+const isNonEmpty = <T extends readonly SqliteBatchItem[]>(
+	items: T,
+): items is T & NonEmptyBatch => items.length > 0;
+
 const runSync = (item: SqliteBatchItem): unknown => {
 	if (!isSyncPreparable(item)) {
 		throw new TypeError("batch item is not a drizzle sqlite query");
@@ -19,28 +43,30 @@ const runSync = (item: SqliteBatchItem): unknown => {
 	return item._prepare().execute().sync();
 };
 
+const emptyResponse = <
+	T extends readonly SqliteBatchItem[],
+>(): BatchResponse<T> => [] as unknown as BatchResponse<T>;
+
 /**
- * The shape of D1's `batch()`: every statement commits together or not at all,
- * and none of them reads another's result mid-flight. A write that needs a
- * value reads it before the batch and is written so a stale read loses safely
- * (a conditional `WHERE`, an upsert, a deterministic id).
- *
- * On better-sqlite3 the batch is one synchronous IMMEDIATE transaction: it
- * never yields the event loop, so no other write on the shared connection lands
- * inside it, and IMMEDIATE takes the file's write lock before the first
+ * A batch as one synchronous transaction. On better-sqlite3 it is IMMEDIATE:
+ * it never yields the event loop, so no other write on the shared connection
+ * lands inside it, and it takes the file's write lock before the first
  * statement so a writer in another process waits out the busy timeout. On a
  * Durable Object's `durable-sqlite` handle it is one `transactionSync`.
  */
-export const runBatch = async <
-	TSchema extends Record<string, unknown>,
-	T extends readonly SqliteBatchItem[],
->(
-	db: Db<TSchema>,
-	items: T,
-): Promise<BatchResponse<T>> => {
-	if (items.length === 0) return [] as unknown as BatchResponse<T>;
-	const results = db.transaction(() => items.map(runSync), {
-		behavior: "immediate",
-	});
-	return results as unknown as BatchResponse<T>;
-};
+export const syncBatch =
+	<TSchema extends Record<string, unknown>>(db: Db<TSchema>): WriteBatch =>
+	async (items) => {
+		if (items.length === 0) return emptyResponse();
+		const results = db.transaction(() => items.map(runSync), {
+			behavior: "immediate",
+		});
+		return results as unknown as BatchResponse<typeof items>;
+	};
+
+export const asyncBatch =
+	(db: BatchingDatabase): WriteBatch =>
+	async (items) => {
+		if (!isNonEmpty(items)) return emptyResponse();
+		return db.batch(items);
+	};

package/src/databases.ts

@@ -1,8 +1,6 @@
-import type { Db } from "./db.js";
-import {
-	type MessageDataSchema,
-	messageDataSchema,
-} from "./schema/message-data.js";
+import { syncBatch } from "./batch.js";
+import type { Db, SqliteStore } from "./db.js";
+import { messageDataSchema } from "./schema/message-data.js";
 import { createSqliteDatabase } from "./sqlite-client.js";
 
 // The three databases a self-host instance runs on (#1420). The app database
@@ -12,10 +10,30 @@ import { createSqliteDatabase } from "./sqlite-client.js";
 // rebuilt from the mail database, so it never commits together with it.
 export interface SqliteDatabases {
 	app: Db<Record<string, unknown>>;
-	mail: Db<MessageDataSchema>;
+	mail: Db<Record<string, unknown>>;
 	search: Db<Record<string, unknown>>;
 }
 
+export interface SqliteStores {
+	app: SqliteStore<Record<string, unknown>>;
+	mail: SqliteStore<Record<string, unknown>>;
+	search: SqliteStore<Record<string, unknown>>;
+}
+
+export const syncStore = <TSchema extends Record<string, unknown>>(
+	db: Db<TSchema>,
+): SqliteStore<TSchema> => ({ db, batch: syncBatch(db) });
+
+export const syncStores = ({
+	app,
+	mail,
+	search,
+}: SqliteDatabases): SqliteStores => ({
+	app: syncStore(app),
+	mail: syncStore(mail),
+	search: syncStore(search),
+});
+
 export interface SqliteDatabasePaths {
 	app: string;
 	mail: string;

package/src/db.ts

@@ -1,14 +1,29 @@
 import type { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+import type { WriteBatch } from "./batch.js";
 
 /**
- * The drizzle handle a repository runs on: any synchronous SQLite driver.
- *
- * better-sqlite3 is the one this package opens; a Cloudflare Durable Object's
- * `durable-sqlite` handle satisfies it too, so its adapter constructs the same
- * repositories over its own storage.
+ * A synchronous SQLite handle: better-sqlite3, or a Cloudflare Durable
+ * Object's `durable-sqlite`. Only `syncBatch` and the better-sqlite3
+ * composition name it; a repository never does.
  */
 export type Db<TSchema extends Record<string, unknown>> = BaseSQLiteDatabase<
 	"sync",
 	unknown,
 	TSchema
 >;
+
+/**
+ * The handle a repository runs on: any SQLite driver, synchronous or not
+ * (better-sqlite3, Durable Object storage, D1, libsql). It has no
+ * `transaction` and no `batch`, so a repository writes a set through the
+ * injected `WriteBatch` and cannot open an interactive transaction (C5).
+ */
+export type RepositoryDb<TSchema extends Record<string, unknown>> = Omit<
+	BaseSQLiteDatabase<"sync" | "async", unknown, TSchema>,
+	"transaction" | "batch"
+>;
+
+export interface SqliteStore<TSchema extends Record<string, unknown>> {
+	db: RepositoryDb<TSchema>;
+	batch: WriteBatch;
+}

package/src/index.ts

@@ -1,11 +1,22 @@
+export {
+	asyncBatch,
+	type BatchingDatabase,
+	type SqliteBatchItem,
+	syncBatch,
+	type WriteBatch,
+} from "./batch.js";
 export {
 	hasSqliteDatabaseEnv,
 	openSqliteDatabases,
 	SQLITE_DATABASE_ENV,
 	type SqliteDatabasePaths,
 	type SqliteDatabases,
+	type SqliteStores,
 	sqliteDatabasePathsFromEnv,
+	syncStore,
+	syncStores,
 } from "./databases.js";
+export type { RepositoryDb, SqliteStore } from "./db.js";
 export { CreateFailedConflictError, NotFoundError } from "./error.js";
 export { CalendarCollectionRepo } from "./repos/calendar-collection.js";
 export { CalendarEventIndexRepo } from "./repos/calendar-event-index.js";
@@ -79,6 +90,7 @@ export {
 	type SqliteClientOptions,
 } from "./sqlite-client.js";
 export {
+	composeSqliteRepositories,
 	createSqliteRepositories,
 	type SqliteRepositories,
 } from "./sqlite-repositories.js";

package/src/repair/junk-only-address.sqlite.test.ts

@@ -5,7 +5,8 @@ import { CanonicalMailboxRole } from "@remit/domain-enums";
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { AccountSettingRepo } from "../repos/i4-account-setting.js";
-import { MailboxSpecialUseRepo } from "../repos/i4-mailbox-special-use.js";
+import type { MailboxSpecialUseRepo } from "../repos/i4-mailbox-special-use.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { applyMigrationSet } from "../test-shipped-sqlite-schema.js";
 import {
 	type JunkOnlyRepairClient,
@@ -181,7 +182,11 @@ describe("addresses standing only on mail in Junk", () => {
 	before(() => {
 		sqlite = new Database(":memory:");
 		const db = drizzle(sqlite);
-		specialUse = new MailboxSpecialUseRepo(db as never, db as never);
+		specialUse = createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).mailboxSpecialUse;
 		accountSetting = new AccountSettingRepo(db as never);
 		applyMigrationSet(sqlite, "app");
 		applyMigrationSet(sqlite, "mail");

package/src/repos/account.conformance.sqlite.test.ts

@@ -2,8 +2,8 @@ import { accountRepositoryConformance } from "@remit/data-ports/conformance";
 import { NotFoundError } from "../error.js";
 import { randomId } from "../id.js";
 import { accountTable } from "../schema.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
-import { AccountRepo } from "./i4-account.js";
 
 let close: (() => Promise<void>) | undefined;
 
@@ -13,7 +13,11 @@ accountRepositoryConformance({
 			accounts: accountTable,
 		});
 		close = closeDb;
-		return new AccountRepo(db as never, db as never);
+		return createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).account;
 	},
 	teardown: async () => {
 		await close?.();

package/src/repos/calendar-collection.ts

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

package/src/repos/calendar-default.sqlite.test.ts

@@ -8,9 +8,9 @@ import {
 	calendarObjectTable,
 	calendarTable,
 } from "../schema.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
 import { CalendarCollectionRepo } from "./calendar-collection.js";
-import { DrizzleCalendarStore } from "./calendar-store.js";
 
 const ACCOUNT_CONFIG_ID = "account-config-default";
 
@@ -27,7 +27,11 @@ describe("provisioning the default calendar", () => {
 		});
 		db = created.db as unknown as Db<Record<string, unknown>>;
 		close = created.close;
-		store = new DrizzleCalendarStore(db, db);
+		store = createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).calendarStore;
 	});
 
 	after(() => close());

package/src/repos/calendar-event-index.ts

@@ -4,10 +4,10 @@ import type {
 	ICalendarEventIndexRepository,
 } from "@remit/data-ports";
 import { and, asc, eq, gte, lt } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { calendarEventIndexTable } from "../schema.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToOccurrence(
 	row: typeof calendarEventIndexTable.$inferSelect,

package/src/repos/calendar-feed-token.ts

@@ -5,10 +5,10 @@ import type {
 } from "@remit/data-ports";
 import { deriveCalendarFeedTokenId } from "@remit/data-ports/id";
 import { and, eq } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { calendarFeedTokenTable } from "../schema.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToFeedToken(
 	row: typeof calendarFeedTokenTable.$inferSelect,

package/src/repos/calendar-object.ts

@@ -5,11 +5,11 @@ import type {
 } from "@remit/data-ports";
 import { deriveCalendarObjectId } from "@remit/data-ports/id";
 import { and, asc, eq, gt, gte, lt, ne } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { calendarObjectTable } from "../schema.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToCalendarObject(
 	row: typeof calendarObjectTable.$inferSelect,

package/src/repos/calendar-put.sqlite.test.ts

@@ -16,8 +16,8 @@ import {
 	calendarObjectTable,
 	calendarTable,
 } from "../schema.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
-import { DrizzleCalendarStore } from "./calendar-store.js";
 
 const ACCOUNT_CONFIG_ID = "account-config-1";
 
@@ -77,7 +77,11 @@ describe("the calendar write path against sqlite", () => {
 		});
 		db = created.db as unknown as Db<Record<string, unknown>>;
 		close = created.close;
-		store = new DrizzleCalendarStore(db, db);
+		store = createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).calendarStore;
 		const collection = await provisionDefaultCalendar(store, ACCOUNT_CONFIG_ID);
 		calendarId = collection.calendarId;
 	});

package/src/repos/calendar-store.ts

@@ -2,56 +2,67 @@ import type {
 	CalendarRepositories,
 	CalendarWrite,
 	ICalendarStore,
+	ICalendarSuggestionRepository,
+	SettleCalendarSuggestionWrite,
 } from "@remit/data-ports";
 import { deriveCalendarObjectId } from "@remit/data-ports/id";
 import { and, eq, exists, 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 {
 	calendarEventIndexTable,
 	calendarFeedTokenTable,
 	calendarObjectTable,
-	calendarSuggestionTable,
 	calendarTable,
 } from "../schema.js";
 import { CalendarCollectionRepo } from "./calendar-collection.js";
 import { CalendarEventIndexRepo } from "./calendar-event-index.js";
 import { CalendarFeedTokenRepo } from "./calendar-feed-token.js";
 import { CalendarObjectRepo } from "./calendar-object.js";
-import { CalendarSuggestionRepo } from "./calendar-suggestion.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
+
+type CalendarBatchWrite = Exclude<CalendarWrite, SettleCalendarSuggestionWrite>;
+
+const isSettlement = (
+	write: CalendarWrite,
+): write is SettleCalendarSuggestionWrite => write.kind === "SettleSuggestion";
+
+const isBatchWrite = (write: CalendarWrite): write is CalendarBatchWrite =>
+	!isSettlement(write);
 
 export class DrizzleCalendarStore implements ICalendarStore {
 	readonly repos: CalendarRepositories;
 
+	private readonly db: DB;
+	private readonly batch: WriteBatch;
+
 	constructor(
-		private db: DB,
-		private mail: DB,
+		store: SqliteStore<Record<string, unknown>>,
+		calendarSuggestion: ICalendarSuggestionRepository,
 	) {
+		this.db = store.db;
+		this.batch = store.batch;
 		this.repos = {
-			calendarCollection: new CalendarCollectionRepo(db),
-			calendarObject: new CalendarObjectRepo(db),
-			calendarEventIndex: new CalendarEventIndexRepo(db),
-			calendarSuggestion: new CalendarSuggestionRepo(mail),
-			calendarFeedToken: new CalendarFeedTokenRepo(db),
+			calendarCollection: new CalendarCollectionRepo(store.db),
+			calendarObject: new CalendarObjectRepo(store.db),
+			calendarEventIndex: new CalendarEventIndexRepo(store.db),
+			calendarSuggestion,
+			calendarFeedToken: new CalendarFeedTokenRepo(store.db),
 		};
 	}
 
 	async commit(writes: readonly CalendarWrite[]): Promise<void> {
-		const settlements = writes.filter(
-			(write) => write.kind === "SettleSuggestion",
-		);
-		await runBatch(
-			this.db,
-			writes
-				.filter((write) => write.kind !== "SettleSuggestion")
-				.flatMap((write) => this.statements(write)),
-		);
-		await runBatch(
-			this.mail,
-			settlements.flatMap((write) => this.statements(write)),
+		await this.batch(
+			writes.filter(isBatchWrite).flatMap((write) => this.statements(write)),
 		);
+		for (const write of writes.filter(isSettlement)) {
+			await this.repos.calendarSuggestion.settle(
+				write.accountConfigId,
+				write.suggestionId,
+				write.settle,
+			);
+		}
 	}
 
 	private collection(accountConfigId: string, calendarId: string) {
@@ -97,7 +108,7 @@ export class DrizzleCalendarStore implements ICalendarStore {
 			);
 	}
 
-	private statements(write: CalendarWrite): SqliteBatchItem[] {
+	private statements(write: CalendarBatchWrite): SqliteBatchItem[] {
 		const now = Date.now();
 		switch (write.kind) {
 			case "PutObject": {
@@ -223,21 +234,6 @@ export class DrizzleCalendarStore implements ICalendarStore {
 						),
 					this.bump(write.accountConfigId, write.calendarId),
 				];
-			case "SettleSuggestion":
-				return [
-					this.mail
-						.update(calendarSuggestionTable)
-						.set({ ...write.settle, updatedAt: now })
-						.where(
-							and(
-								eq(
-									calendarSuggestionTable.accountConfigId,
-									write.accountConfigId,
-								),
-								eq(calendarSuggestionTable.suggestionId, write.suggestionId),
-							),
-						),
-				];
 			case "UpdateCollection":
 				return [
 					this.db

package/src/repos/calendar-suggestion.ts

@@ -8,13 +8,13 @@ import type {
 import { deriveCalendarSuggestionId } from "@remit/data-ports/id";
 import { CalendarSuggestionState } from "@remit/domain-enums";
 import { and, asc, desc, eq, gte, lt, or } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { decodeToken, resultList } from "../pagination.js";
 import { calendarSuggestionTable } from "../schema.js";
 import { inList } from "./in-list.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToCalendarSuggestion(
 	row: typeof calendarSuggestionTable.$inferSelect,

package/src/repos/cascade-delete.test.ts

@@ -2,6 +2,7 @@ import assert from "node:assert";
 import { after, before, describe, test } from "node:test";
 import { MailboxCursorState } from "@remit/domain-enums";
 import { eq } from "drizzle-orm";
+import { syncStores } from "../databases.js";
 import {
 	accountSettingTable,
 	accountTable,
@@ -299,7 +300,7 @@ describe("runDrizzleCascadeDelete", () => {
 
 	test("deletes every enumerated row across all tables", async () => {
 		await runDrizzleCascadeDelete(
-			{ app: db, mail: db, search: db } as never,
+			syncStores({ app: db, mail: db, search: db } as never),
 			entities,
 			log,
 		);
@@ -438,7 +439,7 @@ describe("runDrizzleCascadeDelete", () => {
 		await assert.rejects(
 			() =>
 				runDrizzleCascadeDelete(
-					{ app: db, mail: db, search: db } as never,
+					syncStores({ app: db, mail: db, search: db } as never),
 					[{ entityType: "Nonsense", key: { id: "x" } }],
 					log,
 				),

package/src/repos/cascade-delete.ts

@@ -1,8 +1,9 @@
-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";
@@ -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()) {
@@ -217,9 +220,9 @@ export const runDrizzleCascadeDelete = async (
 			),
 		);
 	}
-	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");
 };
@@ -238,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,