@remit/drizzle-service 0.0.98 → 0.0.100

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

@@ -1,12 +1,14 @@
 import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
 import {
+	prepareCalendarObject,
 	provisionDefaultCalendar,
 	putCalendarObject,
 } from "@remit/calendar-service";
 import type {
-	CalendarUnitOfWorkRepositories,
-	ICalendarUnitOfWork,
+	CalendarRepositories,
+	CalendarWrite,
+	ICalendarStore,
 } from "@remit/data-ports";
 import type { Db } from "../db.js";
 import {
@@ -15,7 +17,7 @@ import {
 	calendarTable,
 } from "../schema.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
-import { DrizzleCalendarUnitOfWork } from "./calendar-unit-of-work.js";
+import { DrizzleCalendarStore } from "./calendar-store.js";
 
 const ACCOUNT_CONFIG_ID = "account-config-1";
 
@@ -34,35 +36,37 @@ const RESOURCE = [
 ].join("\r\n");
 
 /**
- * Fails the third of the write set's three writes. The occurrence rows are
- * written last, so a failure there is the case that proves the boundary: the
- * object row and the sequence bump are already in the transaction when it
- * happens.
+ * 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 FailingIndexUnitOfWork implements ICalendarUnitOfWork {
-	constructor(private inner: ICalendarUnitOfWork) {}
-
-	transaction<T>(
-		fn: (repos: CalendarUnitOfWorkRepositories) => Promise<T>,
-	): Promise<T> {
-		return this.inner.transaction((repos) =>
-			fn({
-				...repos,
-				calendarEventIndex: {
-					...repos.calendarEventIndex,
-					replaceForObject: () => {
-						throw new Error("the index write failed");
-					},
-				},
-			}),
+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 unitOfWork: ICalendarUnitOfWork;
+	let store: ICalendarStore;
 	let calendarId: string;
 
 	before(async () => {
@@ -73,11 +77,8 @@ describe("the calendar write path against sqlite", () => {
 		});
 		db = created.db as unknown as Db<Record<string, unknown>>;
 		close = created.close;
-		unitOfWork = new DrizzleCalendarUnitOfWork(db);
-		const collection = await provisionDefaultCalendar(
-			unitOfWork,
-			ACCOUNT_CONFIG_ID,
-		);
+		store = new DrizzleCalendarStore(db, db);
+		const collection = await provisionDefaultCalendar(store, ACCOUNT_CONFIG_ID);
 		calendarId = collection.calendarId;
 	});
 
@@ -87,7 +88,7 @@ describe("the calendar write path against sqlite", () => {
 	const occurrences = () => db.select().from(calendarEventIndexTable);
 
 	test("writes the object, its occurrences and the sequence bump together", async () => {
-		const result = await putCalendarObject(unitOfWork, {
+		const result = await putCalendarObject(store, {
 			accountConfigId: ACCOUNT_CONFIG_ID,
 			calendarId,
 			resourceName: "review.ics",
@@ -111,17 +112,17 @@ describe("the calendar write path against sqlite", () => {
 		);
 	});
 
-	test("a failing index write leaves no object behind", async () => {
+	test("a failing write in the batch leaves no object behind", async () => {
 		const before = await objects();
 
 		await assert.rejects(
-			putCalendarObject(new FailingIndexUnitOfWork(unitOfWork), {
+			putCalendarObject(new FailingLastWriteStore(store), {
 				accountConfigId: ACCOUNT_CONFIG_ID,
 				calendarId,
 				resourceName: "doomed.ics",
 				icalData: RESOURCE,
 			}),
-			/the index write failed/,
+			/NOT NULL constraint failed/,
 		);
 
 		const after = await objects();
@@ -132,17 +133,17 @@ describe("the calendar write path against sqlite", () => {
 		);
 	});
 
-	test("a failing index write leaves the collection's sequence where it was", async () => {
+	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 FailingIndexUnitOfWork(unitOfWork), {
+			putCalendarObject(new FailingLastWriteStore(store), {
 				accountConfigId: ACCOUNT_CONFIG_ID,
 				calendarId,
 				resourceName: "doomed-again.ics",
 				icalData: RESOURCE,
 			}),
-			/the index write failed/,
+			/NOT NULL constraint failed/,
 		);
 
 		const [after] = await db.select().from(calendarTable);
@@ -153,7 +154,7 @@ describe("the calendar write path against sqlite", () => {
 		const before = await objects();
 		const [collectionBefore] = await db.select().from(calendarTable);
 
-		const result = await putCalendarObject(unitOfWork, {
+		const result = await putCalendarObject(store, {
 			accountConfigId: ACCOUNT_CONFIG_ID,
 			calendarId,
 			resourceName: "backwards.ics",
@@ -178,7 +179,7 @@ describe("the calendar write path against sqlite", () => {
 	});
 
 	test("rewriting a resource replaces its occurrences rather than adding to them", async () => {
-		const first = await putCalendarObject(unitOfWork, {
+		const first = await putCalendarObject(store, {
 			accountConfigId: ACCOUNT_CONFIG_ID,
 			calendarId,
 			resourceName: "shrinking.ics",
@@ -186,7 +187,7 @@ describe("the calendar write path against sqlite", () => {
 		});
 		assert.ok(first.ok);
 
-		const second = await putCalendarObject(unitOfWork, {
+		const second = await putCalendarObject(store, {
 			accountConfigId: ACCOUNT_CONFIG_ID,
 			calendarId,
 			resourceName: "shrinking.ics",

package/src/repos/calendar-store.ts

@@ -0,0 +1,273 @@
+import type {
+	CalendarRepositories,
+	CalendarWrite,
+	ICalendarStore,
+} 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 {
+	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>>;
+
+export class DrizzleCalendarStore implements ICalendarStore {
+	readonly repos: CalendarRepositories;
+
+	constructor(
+		private db: DB,
+		private mail: DB,
+	) {
+		this.repos = {
+			calendarCollection: new CalendarCollectionRepo(db),
+			calendarObject: new CalendarObjectRepo(db),
+			calendarEventIndex: new CalendarEventIndexRepo(db),
+			calendarSuggestion: new CalendarSuggestionRepo(mail),
+			calendarFeedToken: new CalendarFeedTokenRepo(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)),
+		);
+	}
+
+	private collection(accountConfigId: string, calendarId: string) {
+		return and(
+			eq(calendarTable.accountConfigId, accountConfigId),
+			eq(calendarTable.calendarId, calendarId),
+		);
+	}
+
+	/**
+	 * The sequence the bump just wrote, read inside the batch. A collection that
+	 * is gone yields NULL, which the NOT NULL column refuses, so the whole batch
+	 * fails rather than storing an orphan.
+	 */
+	private bumpedSequence(accountConfigId: string, calendarId: string) {
+		return sql<number>`(${this.db
+			.select({ syncSequence: calendarTable.syncSequence })
+			.from(calendarTable)
+			.where(this.collection(accountConfigId, calendarId))})`;
+	}
+
+	private bump(accountConfigId: string, calendarId: string): SqliteBatchItem {
+		return this.db
+			.update(calendarTable)
+			.set({
+				syncSequence: sql`${calendarTable.syncSequence} + 1`,
+				updatedAt: Date.now(),
+			})
+			.where(this.collection(accountConfigId, calendarId));
+	}
+
+	private clearOccurrences(
+		calendarId: string,
+		calendarObjectId: string,
+	): SqliteBatchItem {
+		return this.db
+			.delete(calendarEventIndexTable)
+			.where(
+				and(
+					eq(calendarEventIndexTable.calendarId, calendarId),
+					eq(calendarEventIndexTable.calendarObjectId, calendarObjectId),
+				),
+			);
+	}
+
+	private statements(write: CalendarWrite): SqliteBatchItem[] {
+		const now = Date.now();
+		switch (write.kind) {
+			case "PutObject": {
+				const { calendarId, resourceName } = write.object;
+				const calendarObjectId = deriveCalendarObjectId(
+					calendarId,
+					resourceName,
+				);
+				const syncSequence = this.bumpedSequence(
+					write.accountConfigId,
+					calendarId,
+				);
+				const items: SqliteBatchItem[] = [
+					this.bump(write.accountConfigId, calendarId),
+					this.db
+						.insert(calendarObjectTable)
+						.values({
+							...write.object,
+							calendarObjectId,
+							syncSequence,
+							createdAt: now,
+							updatedAt: now,
+						})
+						.onConflictDoUpdate({
+							target: calendarObjectTable.calendarObjectId,
+							set: { ...write.object, syncSequence, updatedAt: now },
+						}),
+					this.clearOccurrences(calendarId, calendarObjectId),
+				];
+				if (write.occurrences.length === 0) return items;
+				return [
+					...items,
+					this.db.insert(calendarEventIndexTable).values(
+						write.occurrences.map((occurrence) => ({
+							...occurrence,
+							calendarId,
+							calendarObjectId,
+							createdAt: now,
+							updatedAt: now,
+						})),
+					),
+				];
+			}
+			case "ReprojectObject": {
+				const { calendarId, resourceName } = write.object;
+				const calendarObjectId = deriveCalendarObjectId(
+					calendarId,
+					resourceName,
+				);
+				// Every statement reads the object it rewrites at the version the
+				// caller read, so a resource edited or deleted since writes nothing.
+				const asRead = and(
+					eq(calendarObjectTable.calendarObjectId, calendarObjectId),
+					eq(calendarObjectTable.etag, write.readEtag),
+				);
+				const unchanged = exists(
+					this.db
+						.select({ id: calendarObjectTable.calendarObjectId })
+						.from(calendarObjectTable)
+						.where(asRead),
+				);
+				const value = <T>(field: T, name: string) => sql<T>`${field}`.as(name);
+				return [
+					this.bump(write.accountConfigId, calendarId),
+					this.db
+						.update(calendarObjectTable)
+						.set({
+							...write.object,
+							syncSequence: this.bumpedSequence(
+								write.accountConfigId,
+								calendarId,
+							),
+							updatedAt: now,
+						})
+						.where(asRead),
+					this.db
+						.delete(calendarEventIndexTable)
+						.where(
+							and(
+								eq(calendarEventIndexTable.calendarId, calendarId),
+								eq(calendarEventIndexTable.calendarObjectId, calendarObjectId),
+								unchanged,
+							),
+						),
+					...write.occurrences.map((occurrence) =>
+						this.db.insert(calendarEventIndexTable).select(
+							this.db
+								.select({
+									calendarId: value(calendarId, "calendar_id"),
+									calendarObjectId: value(
+										calendarObjectId,
+										"calendar_object_id",
+									),
+									recurrenceId: value(occurrence.recurrenceId, "recurrence_id"),
+									startAt: value(occurrence.startAt, "start_at"),
+									endAt: value(occurrence.endAt, "end_at"),
+									allDay: value(occurrence.allDay ? 1 : 0, "all_day"),
+									summary: value(occurrence.summary, "summary"),
+									status: value(occurrence.status, "status"),
+									transparency: value(occurrence.transparency, "transparency"),
+									createdAt: value(now, "created_at"),
+									updatedAt: value(now, "updated_at"),
+								})
+								.from(calendarObjectTable)
+								.where(asRead),
+						),
+					),
+				];
+			}
+			case "DeleteObject":
+				return [
+					this.clearOccurrences(write.calendarId, write.calendarObjectId),
+					this.db
+						.delete(calendarObjectTable)
+						.where(
+							and(
+								eq(calendarObjectTable.calendarId, write.calendarId),
+								eq(
+									calendarObjectTable.calendarObjectId,
+									write.calendarObjectId,
+								),
+							),
+						),
+					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
+						.update(calendarTable)
+						.set({ ...write.patch, updatedAt: now })
+						.where(this.collection(write.accountConfigId, write.calendarId)),
+				];
+			case "DeleteCollection":
+				return [
+					this.db
+						.delete(calendarEventIndexTable)
+						.where(eq(calendarEventIndexTable.calendarId, write.calendarId)),
+					this.db
+						.delete(calendarObjectTable)
+						.where(eq(calendarObjectTable.calendarId, write.calendarId)),
+					this.db
+						.delete(calendarFeedTokenTable)
+						.where(
+							and(
+								eq(
+									calendarFeedTokenTable.accountConfigId,
+									write.accountConfigId,
+								),
+								eq(calendarFeedTokenTable.calendarId, write.calendarId),
+							),
+						),
+					this.db
+						.delete(calendarTable)
+						.where(this.collection(write.accountConfigId, write.calendarId)),
+				];
+		}
+	}
+}

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

@@ -12,6 +12,7 @@ import {
 	mailboxTable,
 	messageTable,
 	quarantineTable,
+	syncWarningTable,
 } from "../schema.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
 import {
@@ -30,6 +31,7 @@ const CASCADE_SCHEMA = {
 	account: accountTable,
 	mailbox: mailboxTable,
 	quarantine: quarantineTable,
+	syncWarning: syncWarningTable,
 };
 
 const log = { info: () => {} };
@@ -131,7 +133,11 @@ describe("createSqliteCascadeDeleter", () => {
 			{ entityType: "Account", key: { accountId: ACCOUNT_ID } },
 		];
 
-		const deleter = await createSqliteCascadeDeleter(filename);
+		const deleter = await createSqliteCascadeDeleter({
+			app: filename,
+			mail: filename,
+			search: filename,
+		});
 		await deleter(entities, log);
 
 		const sqlite = new Database(filename);
@@ -150,14 +156,6 @@ describe("createSqliteCascadeDeleter", () => {
 		);
 		assert.equal(count("mailbox", "mailbox_id", MAILBOX_ID), 0, "mailbox gone");
 		assert.equal(count("account", "account_id", ACCOUNT_ID), 0, "account gone");
-
-		const outboxRows = (
-			sqlite.prepare("SELECT COUNT(*) AS n FROM outbox").get() as { n: number }
-		).n;
-		assert.ok(
-			outboxRows >= 1,
-			"a message-removed outbox row must be emitted for search-index cleanup",
-		);
 		sqlite.close();
 	});
 });

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

@@ -15,7 +15,6 @@ import {
 	messagePlacementMoveTable,
 	messageTable,
 	outboxMessageTable,
-	outboxTable,
 	quarantineTable,
 	threadMessageTable,
 } from "../schema.js";
@@ -299,7 +298,11 @@ describe("runDrizzleCascadeDelete", () => {
 	];
 
 	test("deletes every enumerated row across all tables", async () => {
-		await runDrizzleCascadeDelete(db as never, entities, log);
+		await runDrizzleCascadeDelete(
+			{ app: db, mail: db, search: db } as never,
+			entities,
+			log,
+		);
 
 		assert.equal(
 			(
@@ -431,21 +434,11 @@ describe("runDrizzleCascadeDelete", () => {
 		);
 	});
 
-	test("emits a message.removed outbox row for search-index cleanup", async () => {
-		const rows = await db
-			.select()
-			.from(outboxTable)
-			.where(eq(outboxTable.messageId, MESSAGE_ID));
-		assert.equal(rows.length, 1);
-		assert.equal(rows[0].event, "message.removed");
-		assert.equal(rows[0].processedAt, null);
-	});
-
 	test("rejects an unknown entity type without deleting", async () => {
 		await assert.rejects(
 			() =>
 				runDrizzleCascadeDelete(
-					db as never,
+					{ app: db, mail: db, search: db } as never,
 					[{ entityType: "Nonsense", key: { id: "x" } }],
 					log,
 				),