@remit/drizzle-service 0.0.102 → 0.0.104

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

@@ -1,206 +1,4 @@
-import assert from "node:assert/strict";
-import { after, before, describe, test } from "node:test";
-import {
-	prepareCalendarObject,
-	provisionDefaultCalendar,
-	putCalendarObject,
-} from "@remit/calendar-service";
-import type {
-	CalendarRepositories,
-	CalendarWrite,
-	ICalendarStore,
-} from "@remit/data-ports";
-import type { Db } from "../db.js";
-import {
-	calendarEventIndexTable,
-	calendarObjectTable,
-	calendarTable,
-} from "../schema.js";
-import { createSqliteTestDb } from "../test-db-sqlite.js";
-import { DrizzleCalendarStore } from "./calendar-store.js";
+import { openCalendarSqliteTestStores } from "../test-stores.js";
+import { calendarPutSuite } from "./calendar-put.suite.js";
 
-const ACCOUNT_CONFIG_ID = "account-config-1";
-
-const RESOURCE = [
-	"BEGIN:VCALENDAR",
-	"VERSION:2.0",
-	"BEGIN:VEVENT",
-	"UID:atomic@example.com",
-	"DTSTART:20260826T090000Z",
-	"DTEND:20260826T100000Z",
-	"SUMMARY:Quarterly review",
-	"RRULE:FREQ=WEEKLY;COUNT=3",
-	"END:VEVENT",
-	"END:VCALENDAR",
-	"",
-].join("\r\n");
-
-/**
- * Appends a write that fails to every commit: a resource put into a collection
- * that does not exist, which the store refuses at its last statement. Every
- * statement of the real write set has run by then, so a failure there is the
- * case that proves the boundary.
- */
-class FailingLastWriteStore implements ICalendarStore {
-	constructor(private inner: ICalendarStore) {}
-
-	get repos(): CalendarRepositories {
-		return this.inner.repos;
-	}
-
-	async commit(writes: readonly CalendarWrite[]): Promise<void> {
-		const orphan = await prepareCalendarObject(
-			{ timezone: "" },
-			{
-				accountConfigId: ACCOUNT_CONFIG_ID,
-				calendarId: "no-such-calendar",
-				resourceName: "orphan.ics",
-				icalData: RESOURCE,
-			},
-		);
-		assert.ok(orphan.ok);
-		await this.inner.commit([...writes, orphan.value]);
-	}
-}
-
-describe("the calendar write path against sqlite", () => {
-	let db: Db<Record<string, unknown>>;
-	let close: () => Promise<void>;
-	let store: ICalendarStore;
-	let calendarId: string;
-
-	before(async () => {
-		const created = await createSqliteTestDb({
-			calendars: calendarTable,
-			calendarObjects: calendarObjectTable,
-			calendarEventIndexes: calendarEventIndexTable,
-		});
-		db = created.db as unknown as Db<Record<string, unknown>>;
-		close = created.close;
-		store = new DrizzleCalendarStore(db, db);
-		const collection = await provisionDefaultCalendar(store, ACCOUNT_CONFIG_ID);
-		calendarId = collection.calendarId;
-	});
-
-	after(() => close());
-
-	const objects = () => db.select().from(calendarObjectTable);
-	const occurrences = () => db.select().from(calendarEventIndexTable);
-
-	test("writes the object, its occurrences and the sequence bump together", async () => {
-		const result = await putCalendarObject(store, {
-			accountConfigId: ACCOUNT_CONFIG_ID,
-			calendarId,
-			resourceName: "review.ics",
-			icalData: RESOURCE,
-		});
-
-		assert.ok(result.ok);
-		assert.equal(result.value.icalData, RESOURCE);
-		assert.equal(
-			(await objects())[0]?.icalData,
-			RESOURCE,
-			"the stored row holds the input bytes, CRLF and all",
-		);
-		assert.equal(result.value.syncSequence, 1);
-		assert.equal((await objects()).length, 1);
-		assert.equal(
-			(await occurrences()).filter(
-				(row) => row.calendarObjectId === result.value.calendarObjectId,
-			).length,
-			3,
-		);
-	});
-
-	test("a failing write in the batch leaves no object behind", async () => {
-		const before = await objects();
-
-		await assert.rejects(
-			putCalendarObject(new FailingLastWriteStore(store), {
-				accountConfigId: ACCOUNT_CONFIG_ID,
-				calendarId,
-				resourceName: "doomed.ics",
-				icalData: RESOURCE,
-			}),
-			/NOT NULL constraint failed/,
-		);
-
-		const after = await objects();
-		assert.equal(after.length, before.length);
-		assert.equal(
-			after.some((row) => row.resourceName === "doomed.ics"),
-			false,
-		);
-	});
-
-	test("a failing write in the batch leaves the collection's sequence where it was", async () => {
-		const [before] = await db.select().from(calendarTable);
-
-		await assert.rejects(
-			putCalendarObject(new FailingLastWriteStore(store), {
-				accountConfigId: ACCOUNT_CONFIG_ID,
-				calendarId,
-				resourceName: "doomed-again.ics",
-				icalData: RESOURCE,
-			}),
-			/NOT NULL constraint failed/,
-		);
-
-		const [after] = await db.select().from(calendarTable);
-		assert.equal(after?.syncSequence, before?.syncSequence);
-	});
-
-	test("a refused resource writes nothing at all", async () => {
-		const before = await objects();
-		const [collectionBefore] = await db.select().from(calendarTable);
-
-		const result = await putCalendarObject(store, {
-			accountConfigId: ACCOUNT_CONFIG_ID,
-			calendarId,
-			resourceName: "backwards.ics",
-			icalData: [
-				"BEGIN:VCALENDAR",
-				"VERSION:2.0",
-				"BEGIN:VEVENT",
-				"UID:backwards@example.com",
-				"DTSTART:20260826T100000Z",
-				"DTEND:20260826T090000Z",
-				"END:VEVENT",
-				"END:VCALENDAR",
-				"",
-			].join("\r\n"),
-		});
-
-		assert.ok(!result.ok);
-		assert.equal(result.error.code, "BackwardsEnd");
-		assert.equal((await objects()).length, before.length);
-		const [collectionAfter] = await db.select().from(calendarTable);
-		assert.equal(collectionAfter?.syncSequence, collectionBefore?.syncSequence);
-	});
-
-	test("rewriting a resource replaces its occurrences rather than adding to them", async () => {
-		const first = await putCalendarObject(store, {
-			accountConfigId: ACCOUNT_CONFIG_ID,
-			calendarId,
-			resourceName: "shrinking.ics",
-			icalData: RESOURCE,
-		});
-		assert.ok(first.ok);
-
-		const second = await putCalendarObject(store, {
-			accountConfigId: ACCOUNT_CONFIG_ID,
-			calendarId,
-			resourceName: "shrinking.ics",
-			icalData: RESOURCE.replace("COUNT=3", "COUNT=1"),
-		});
-		assert.ok(second.ok);
-
-		assert.equal(second.value.calendarObjectId, first.value.calendarObjectId);
-		assert.equal(
-			(await occurrences()).filter(
-				(row) => row.calendarObjectId === second.value.calendarObjectId,
-			).length,
-			1,
-		);
-	});
-});
+calendarPutSuite(openCalendarSqliteTestStores);

package/src/repos/calendar-put.suite.ts

@@ -0,0 +1,210 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import {
+	prepareCalendarObject,
+	provisionDefaultCalendar,
+	putCalendarObject,
+} from "@remit/calendar-service";
+import type {
+	CalendarRepositories,
+	CalendarWrite,
+	ICalendarStore,
+} from "@remit/data-ports";
+import type { RepositoryDb } from "../db.js";
+import {
+	calendarEventIndexTable,
+	calendarObjectTable,
+	calendarTable,
+} from "../schema.js";
+import { composeSqliteRepositories } from "../sqlite-repositories.js";
+import type { OpenTestStores } from "../test-stores.js";
+
+const ACCOUNT_CONFIG_ID = "account-config-1";
+
+const RESOURCE = [
+	"BEGIN:VCALENDAR",
+	"VERSION:2.0",
+	"BEGIN:VEVENT",
+	"UID:atomic@example.com",
+	"DTSTART:20260826T090000Z",
+	"DTEND:20260826T100000Z",
+	"SUMMARY:Quarterly review",
+	"RRULE:FREQ=WEEKLY;COUNT=3",
+	"END:VEVENT",
+	"END:VCALENDAR",
+	"",
+].join("\r\n");
+
+/**
+ * Appends a write that fails to every commit: a resource put into a collection
+ * that does not exist, which the store refuses at its last statement. Every
+ * statement of the real write set has run by then, so a failure there is the
+ * case that proves the boundary.
+ */
+class FailingLastWriteStore implements ICalendarStore {
+	constructor(private inner: ICalendarStore) {}
+
+	get repos(): CalendarRepositories {
+		return this.inner.repos;
+	}
+
+	async commit(writes: readonly CalendarWrite[]): Promise<void> {
+		const orphan = await prepareCalendarObject(
+			{ timezone: "" },
+			{
+				accountConfigId: ACCOUNT_CONFIG_ID,
+				calendarId: "no-such-calendar",
+				resourceName: "orphan.ics",
+				icalData: RESOURCE,
+			},
+		);
+		assert.ok(orphan.ok);
+		await this.inner.commit([...writes, orphan.value]);
+	}
+}
+
+export const calendarPutSuite = (open: OpenTestStores): void => {
+	describe("the calendar write path against sqlite", () => {
+		let db: RepositoryDb<Record<string, unknown>>;
+		let close: () => Promise<void>;
+		let store: ICalendarStore;
+		let calendarId: string;
+
+		before(async () => {
+			const opened = await open();
+			db = opened.stores.app.db;
+			close = opened.close;
+			store = composeSqliteRepositories(opened.stores).calendarStore;
+			const collection = await provisionDefaultCalendar(
+				store,
+				ACCOUNT_CONFIG_ID,
+			);
+			calendarId = collection.calendarId;
+		});
+
+		after(() => close());
+
+		const objects = () => db.select().from(calendarObjectTable);
+		const occurrences = () => db.select().from(calendarEventIndexTable);
+
+		test("writes the object, its occurrences and the sequence bump together", async () => {
+			const result = await putCalendarObject(store, {
+				accountConfigId: ACCOUNT_CONFIG_ID,
+				calendarId,
+				resourceName: "review.ics",
+				icalData: RESOURCE,
+			});
+
+			assert.ok(result.ok);
+			assert.equal(result.value.icalData, RESOURCE);
+			assert.equal(
+				(await objects())[0]?.icalData,
+				RESOURCE,
+				"the stored row holds the input bytes, CRLF and all",
+			);
+			assert.equal(result.value.syncSequence, 1);
+			assert.equal((await objects()).length, 1);
+			assert.equal(
+				(await occurrences()).filter(
+					(row) => row.calendarObjectId === result.value.calendarObjectId,
+				).length,
+				3,
+			);
+		});
+
+		test("a failing write in the batch leaves no object behind", async () => {
+			const before = await objects();
+
+			await assert.rejects(
+				putCalendarObject(new FailingLastWriteStore(store), {
+					accountConfigId: ACCOUNT_CONFIG_ID,
+					calendarId,
+					resourceName: "doomed.ics",
+					icalData: RESOURCE,
+				}),
+				/NOT NULL constraint failed/,
+			);
+
+			const after = await objects();
+			assert.equal(after.length, before.length);
+			assert.equal(
+				after.some((row) => row.resourceName === "doomed.ics"),
+				false,
+			);
+		});
+
+		test("a failing write in the batch leaves the collection's sequence where it was", async () => {
+			const [before] = await db.select().from(calendarTable);
+
+			await assert.rejects(
+				putCalendarObject(new FailingLastWriteStore(store), {
+					accountConfigId: ACCOUNT_CONFIG_ID,
+					calendarId,
+					resourceName: "doomed-again.ics",
+					icalData: RESOURCE,
+				}),
+				/NOT NULL constraint failed/,
+			);
+
+			const [after] = await db.select().from(calendarTable);
+			assert.equal(after?.syncSequence, before?.syncSequence);
+		});
+
+		test("a refused resource writes nothing at all", async () => {
+			const before = await objects();
+			const [collectionBefore] = await db.select().from(calendarTable);
+
+			const result = await putCalendarObject(store, {
+				accountConfigId: ACCOUNT_CONFIG_ID,
+				calendarId,
+				resourceName: "backwards.ics",
+				icalData: [
+					"BEGIN:VCALENDAR",
+					"VERSION:2.0",
+					"BEGIN:VEVENT",
+					"UID:backwards@example.com",
+					"DTSTART:20260826T100000Z",
+					"DTEND:20260826T090000Z",
+					"END:VEVENT",
+					"END:VCALENDAR",
+					"",
+				].join("\r\n"),
+			});
+
+			assert.ok(!result.ok);
+			assert.equal(result.error.code, "BackwardsEnd");
+			assert.equal((await objects()).length, before.length);
+			const [collectionAfter] = await db.select().from(calendarTable);
+			assert.equal(
+				collectionAfter?.syncSequence,
+				collectionBefore?.syncSequence,
+			);
+		});
+
+		test("rewriting a resource replaces its occurrences rather than adding to them", async () => {
+			const first = await putCalendarObject(store, {
+				accountConfigId: ACCOUNT_CONFIG_ID,
+				calendarId,
+				resourceName: "shrinking.ics",
+				icalData: RESOURCE,
+			});
+			assert.ok(first.ok);
+
+			const second = await putCalendarObject(store, {
+				accountConfigId: ACCOUNT_CONFIG_ID,
+				calendarId,
+				resourceName: "shrinking.ics",
+				icalData: RESOURCE.replace("COUNT=3", "COUNT=1"),
+			});
+			assert.ok(second.ok);
+
+			assert.equal(second.value.calendarObjectId, first.value.calendarObjectId);
+			assert.equal(
+				(await occurrences()).filter(
+					(row) => row.calendarObjectId === second.value.calendarObjectId,
+				).length,
+				1,
+			);
+		});
+	});
+};

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";
@@ -76,16 +77,18 @@ const groupByType = (
  * first, then the app rows, then the search documents of the deleted thread
  * messages. Every statement is keyed, so a rerun after a failure between two
  * batches deletes what is left. Message subtrees
- * (message + nine child tables) are deleted set-wise by message id; the remaining
+ * (message + ten child tables) are deleted set-wise by message id; the remaining
  * entity types are deleted by their enumerated primary keys. AccountConfig is
  * never deleted here — the caller removes it last through its repository, the
  * 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,