@remit/calendar-service 0.0.17 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/calendar-service",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "iCalendar (RFC 5545) parsing, projection and recurrence expansion over the calendar store",
   "type": "module",
   "main": "src/index.ts",

package/src/accept.ts

@@ -2,8 +2,9 @@ import type { CalendarInviteAnswer as CalendarInviteAnswerValue } from "@remit/a
 import type {
 	CalendarObjectItem,
 	CalendarSuggestionItem,
-	ICalendarUnitOfWork,
+	ICalendarStore,
 } from "@remit/data-ports";
+import { deriveCalendarObjectId } from "@remit/data-ports/id";
 import {
 	CalendarInviteAnswer,
 	CalendarInviteMethod,
@@ -12,7 +13,7 @@ import {
 import ICAL from "ical.js";
 import type { CalendarResult } from "./errors.js";
 import { parseCalendar, serializeCalendar } from "./parse.js";
-import { putCalendarObject } from "./put.js";
+import { prepareCalendarObject, readWrittenObject } from "./put.js";
 import { mailAddressOf } from "./suggest.js";
 
 const eventsOf = (component: ICAL.Component): ICAL.Component[] =>
@@ -132,15 +133,16 @@ export interface AcceptedCalendarSuggestion {
 }
 
 /**
- * Adds a suggested event to a calendar, as one unit.
+ * Adds a suggested event to a calendar, then settles the suggestion.
  *
  * The resource is written through `putCalendarObject`, the same function every
  * other calendar write goes through, so an event added from a mail and one
  * added from the week grid are the same kind of row — and a native client
- * editing it afterwards edits the same bytes. The suggestion's own state is
- * settled inside that transaction: a suggestion marked `Accepted` with no
- * resource behind it, or a resource with the card still asking, is a state
- * nothing later can repair.
+ * editing it afterwards edits the same bytes. The event and the suggestion
+ * live in different databases, so the commit writes the event first and
+ * settles the card second. A failure between the two leaves the card still
+ * asking with the event in the calendar, and accepting again repairs it: the
+ * event write lands on the same resource and the settle follows.
  *
  * Accepting a `Cancel` suggestion writes `STATUS:CANCELLED` through that same
  * path, but only onto a resource that is already there. Nothing withdraws an
@@ -157,7 +159,7 @@ export interface AcceptedCalendarSuggestion {
  * leaving the calendar showing the meeting twice.
  */
 export const acceptCalendarSuggestion = async (
-	unitOfWork: ICalendarUnitOfWork,
+	store: ICalendarStore,
 	input: AcceptCalendarSuggestionInput,
 ): Promise<CalendarResult<AcceptedCalendarSuggestion>> => {
 	const icalData = await buildAcceptedCalendar(
@@ -167,63 +169,82 @@ export const acceptCalendarSuggestion = async (
 	);
 	if (!icalData.ok) return icalData;
 
-	return unitOfWork.transaction(async (repos) => {
-		const existing = await repos.calendarObject.findByUid(
-			input.calendarId,
-			input.suggestion.icalUid,
-		);
-
-		// A cancellation cancels something. With no resource carrying this UID
-		// there is nothing in the calendar to withdraw, and writing one would
-		// invent a meeting the user never had purely to mark it cancelled. Clear
-		// the card and leave the calendar untouched.
-		if (
-			input.suggestion.method === CalendarInviteMethod.Cancel &&
-			existing === null
-		) {
-			const cleared = await repos.calendarSuggestion.settle(
-				input.accountConfigId,
-				input.suggestion.suggestionId,
-				{
+	const existing = await store.repos.calendarObject.findByUid(
+		input.calendarId,
+		input.suggestion.icalUid,
+	);
+
+	// A cancellation cancels something. With no resource carrying this UID
+	// there is nothing in the calendar to withdraw, and writing one would
+	// invent a meeting the user never had purely to mark it cancelled. Clear
+	// the card and leave the calendar untouched.
+	if (
+		input.suggestion.method === CalendarInviteMethod.Cancel &&
+		existing === null
+	) {
+		await store.commit([
+			{
+				kind: "SettleSuggestion",
+				accountConfigId: input.accountConfigId,
+				suggestionId: input.suggestion.suggestionId,
+				settle: {
 					state: CalendarSuggestionState.Dismissed,
 					acceptedCalendarObjectId: "",
 				},
-			);
-			return {
-				ok: true,
-				value: {
-					suggestion: cleared,
-					outcome: "NothingToCancel",
-					object: null,
-				},
-			};
-		}
-
-		const written = await putCalendarObject(unitOfWork, {
-			accountConfigId: input.accountConfigId,
-			calendarId: input.calendarId,
-			resourceName:
-				existing?.resourceName ?? `${input.suggestion.suggestionId}.ics`,
-			icalData: icalData.value,
-		});
-		if (!written.ok) return written;
-
-		const settled = await repos.calendarSuggestion.settle(
-			input.accountConfigId,
-			input.suggestion.suggestionId,
-			{
-				state: stateOf[input.answer],
-				acceptedCalendarObjectId: written.value.calendarObjectId,
 			},
-		);
-
+		]);
 		return {
 			ok: true,
 			value: {
-				suggestion: settled,
-				outcome: "Written",
-				object: written.value,
+				suggestion: await store.repos.calendarSuggestion.get(
+					input.accountConfigId,
+					input.suggestion.suggestionId,
+				),
+				outcome: "NothingToCancel",
+				object: null,
 			},
 		};
+	}
+
+	const collection = await store.repos.calendarCollection.get(
+		input.accountConfigId,
+		input.calendarId,
+	);
+	const write = await prepareCalendarObject(collection, {
+		accountConfigId: input.accountConfigId,
+		calendarId: input.calendarId,
+		resourceName:
+			existing?.resourceName ?? `${input.suggestion.suggestionId}.ics`,
+		icalData: icalData.value,
 	});
+	if (!write.ok) return write;
+
+	const calendarObjectId = deriveCalendarObjectId(
+		write.value.object.calendarId,
+		write.value.object.resourceName,
+	);
+	await store.commit([
+		write.value,
+		{
+			kind: "SettleSuggestion",
+			accountConfigId: input.accountConfigId,
+			suggestionId: input.suggestion.suggestionId,
+			settle: {
+				state: stateOf[input.answer],
+				acceptedCalendarObjectId: calendarObjectId,
+			},
+		},
+	]);
+
+	return {
+		ok: true,
+		value: {
+			suggestion: await store.repos.calendarSuggestion.get(
+				input.accountConfigId,
+				input.suggestion.suggestionId,
+			),
+			outcome: "Written",
+			object: await readWrittenObject(store, write.value),
+		},
+	};
 };

package/src/index.ts

@@ -56,9 +56,12 @@ export {
 export {
 	DEFAULT_CALENDAR_URL_SEGMENT,
 	deleteCalendarObject,
+	deleteCalendarObjectWrite,
 	type PutCalendarObjectInput,
+	prepareCalendarObject,
 	provisionDefaultCalendar,
 	putCalendarObject,
+	readWrittenObject,
 } from "./put.js";
 export {
 	answersOvertakenBy,

package/src/memory-store.ts

@@ -4,14 +4,16 @@ import type {
 	CalendarFeedTokenItem,
 	CalendarObjectItem,
 	CalendarOccurrenceInput,
+	CalendarRepositories,
 	CalendarSuggestionItem,
+	CalendarWrite,
 	CreateCalendarCollectionInput,
 	ICalendarCollectionRepository,
 	ICalendarEventIndexRepository,
 	ICalendarFeedTokenRepository,
 	ICalendarObjectRepository,
+	ICalendarStore,
 	ICalendarSuggestionRepository,
-	ICalendarUnitOfWork,
 	PutCalendarFeedTokenInput,
 	PutCalendarObjectInput as PutCalendarObjectRow,
 	PutCalendarSuggestionInput,
@@ -35,13 +37,11 @@ import { CalendarSuggestionState } from "@remit/domain-enums";
 export class MissingRow extends NotFoundError {}
 
 /**
- * A pass-through unit of work over plain maps — the shape the port documents
- * for a backend with no cross-entity transaction. It proves the write path
- * calls what it should, in the order it should; that the three writes stand or
- * fall together is proven against a real transaction, in
+ * The calendar store over plain maps. A commit applies its writes in order;
+ * that they stand or fall together on a real database is proven in
  * drizzle-service's calendar-put.sqlite.test.ts.
  */
-export class MemoryCalendarStore implements ICalendarUnitOfWork {
+export class MemoryCalendarStore implements ICalendarStore {
 	readonly collections = new Map<string, CalendarCollectionItem>();
 	readonly objects = new Map<string, CalendarObjectItem>();
 	readonly occurrences = new Map<string, CalendarEventIndexItem[]>();
@@ -384,21 +384,102 @@ export class MemoryCalendarStore implements ICalendarUnitOfWork {
 		return this.suggestionRepo;
 	}
 
-	transaction<T>(
-		fn: (repos: {
-			calendarCollection: ICalendarCollectionRepository;
-			calendarObject: ICalendarObjectRepository;
-			calendarEventIndex: ICalendarEventIndexRepository;
-			calendarSuggestion: ICalendarSuggestionRepository;
-			calendarFeedToken: ICalendarFeedTokenRepository;
-		}) => Promise<T>,
-	): Promise<T> {
-		return fn({
+	get repos(): CalendarRepositories {
+		return {
 			calendarCollection: this.collectionRepo,
 			calendarObject: this.objectRepo,
 			calendarEventIndex: this.eventIndexRepo,
 			calendarSuggestion: this.suggestionRepo,
 			calendarFeedToken: this.feedTokenRepo,
-		});
+		};
+	}
+
+	async commit(writes: readonly CalendarWrite[]): Promise<void> {
+		for (const write of writes) await this.apply(write);
+	}
+
+	private async apply(write: CalendarWrite): Promise<void> {
+		switch (write.kind) {
+			case "PutObject": {
+				const { calendarId } = write.object;
+				const syncSequence = await this.collectionRepo.bumpSyncSequence(
+					write.accountConfigId,
+					calendarId,
+				);
+				const object = await this.objectRepo.put({
+					...write.object,
+					syncSequence,
+				});
+				await this.eventIndexRepo.replaceForObject(
+					calendarId,
+					object.calendarObjectId,
+					write.occurrences,
+				);
+				return;
+			}
+			case "ReprojectObject": {
+				const { calendarId, resourceName } = write.object;
+				const stored = await this.objectRepo.findByResourceName(
+					calendarId,
+					resourceName,
+				);
+				if (stored === null || stored.etag !== write.readEtag) return;
+				await this.apply({
+					kind: "PutObject",
+					accountConfigId: write.accountConfigId,
+					object: write.object,
+					occurrences: write.occurrences,
+				});
+				return;
+			}
+			case "DeleteObject":
+				await this.eventIndexRepo.deleteForObject(
+					write.calendarId,
+					write.calendarObjectId,
+				);
+				await this.objectRepo.delete(write.calendarId, write.calendarObjectId);
+				await this.collectionRepo.bumpSyncSequence(
+					write.accountConfigId,
+					write.calendarId,
+				);
+				return;
+			case "SettleSuggestion":
+				await this.suggestionRepo.settle(
+					write.accountConfigId,
+					write.suggestionId,
+					write.settle,
+				);
+				return;
+			case "UpdateCollection":
+				await this.collectionRepo.update(
+					write.accountConfigId,
+					write.calendarId,
+					write.patch,
+				);
+				return;
+			case "DeleteCollection": {
+				for (const object of await this.objectRepo.listByCalendar(
+					write.calendarId,
+				)) {
+					await this.eventIndexRepo.deleteForObject(
+						write.calendarId,
+						object.calendarObjectId,
+					);
+					await this.objectRepo.delete(
+						write.calendarId,
+						object.calendarObjectId,
+					);
+				}
+				await this.feedTokenRepo.delete(
+					write.accountConfigId,
+					write.calendarId,
+				);
+				await this.collectionRepo.delete(
+					write.accountConfigId,
+					write.calendarId,
+				);
+				return;
+			}
+		}
 	}
 }

package/src/put.test.ts

@@ -275,14 +275,12 @@ describe("putCalendarObject", () => {
 
 	it("projects the event in the collection's timezone", async () => {
 		const store = new MemoryCalendarStore();
-		const collection = await store.transaction((repos) =>
-			repos.calendarCollection.create({
-				accountConfigId: ACCOUNT_CONFIG_ID,
-				urlSegment: "berlin",
-				displayName: "Berlin",
-				timezone: "Europe/Berlin",
-			}),
-		);
+		const collection = await store.repos.calendarCollection.create({
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			urlSegment: "berlin",
+			displayName: "Berlin",
+			timezone: "Europe/Berlin",
+		});
 
 		const result = await putCalendarObject(store, {
 			accountConfigId: ACCOUNT_CONFIG_ID,

package/src/put.ts

@@ -1,8 +1,11 @@
 import type {
 	CalendarCollectionItem,
 	CalendarObjectItem,
-	ICalendarUnitOfWork,
+	DeleteCalendarObjectWrite,
+	ICalendarStore,
+	PutCalendarObjectWrite,
 } from "@remit/data-ports";
+import { deriveCalendarObjectId } from "@remit/data-ports/id";
 import { CalendarSource } from "@remit/domain-enums";
 import type { CalendarResult } from "./errors.js";
 import { computeEtag } from "./etag.js";
@@ -23,83 +26,92 @@ export interface PutCalendarObjectInput {
 }
 
 /**
- * Writes one calendar resource. Every caller that stores an event goes through
- * here — a REST handler, a DAV PUT, an accepted suggestion — because the object
- * row, its occurrence rows and the collection's sequence bump are one fact, and
- * a caller that writes any of them alone leaves the store describing a calendar
- * that does not exist.
+ * Turns one calendar resource into the write that stores it, read in the
+ * collection's timezone. Every caller that stores an event goes through here —
+ * a REST handler, a DAV PUT, an accepted suggestion, a feed refresh — because
+ * the object row, its occurrence rows and the collection's sequence bump are
+ * one fact, and a caller that writes any of them alone leaves the store
+ * describing a calendar that does not exist.
  *
  * The bytes are stored exactly as given: parsing is for validating and
  * projecting them, never for rewriting them. Refusing the resource is a
  * returned value — the input is client-supplied, so malformed iCalendar is an
  * outcome the caller renders, not a fault.
  */
-export const putCalendarObject = async (
-	unitOfWork: ICalendarUnitOfWork,
+export const prepareCalendarObject = async (
+	collection: Pick<CalendarCollectionItem, "timezone">,
 	input: PutCalendarObjectInput,
-): Promise<CalendarResult<CalendarObjectItem>> => {
+): Promise<CalendarResult<PutCalendarObjectWrite>> => {
 	const parsed = await parseCalendar(input.icalData);
 	if (!parsed.ok) return parsed;
 
-	return unitOfWork.transaction(async (repos) => {
-		const collection = await repos.calendarCollection.get(
-			input.accountConfigId,
-			input.calendarId,
-		);
-
-		const projection = projectCalendar(parsed.value, collection.timezone);
-		if (!projection.ok) return projection;
+	const projection = projectCalendar(parsed.value, collection.timezone);
+	if (!projection.ok) return projection;
 
-		const expansion = expandCalendar(parsed.value, collection.timezone);
-		const syncSequence = await repos.calendarCollection.bumpSyncSequence(
-			input.accountConfigId,
-			input.calendarId,
-		);
-
-		const object = await repos.calendarObject.put({
-			...projection.value,
-			calendarId: input.calendarId,
-			resourceName: input.resourceName,
-			icalData: input.icalData,
-			etag: computeEtag(input.icalData),
-			syncSequence,
-			expandedThrough: expansion.expandedThrough,
-		});
+	const expansion = expandCalendar(parsed.value, collection.timezone);
+	return {
+		ok: true,
+		value: {
+			kind: "PutObject",
+			accountConfigId: input.accountConfigId,
+			object: {
+				...projection.value,
+				calendarId: input.calendarId,
+				resourceName: input.resourceName,
+				icalData: input.icalData,
+				etag: computeEtag(input.icalData),
+				expandedThrough: expansion.expandedThrough,
+			},
+			occurrences: expansion.occurrences,
+		},
+	};
+};
 
-		await repos.calendarEventIndex.replaceForObject(
-			input.calendarId,
-			object.calendarObjectId,
-			expansion.occurrences,
-		);
+/** The resource a committed put wrote, under the id its name derives to. */
+export const readWrittenObject = (
+	store: ICalendarStore,
+	write: PutCalendarObjectWrite,
+): Promise<CalendarObjectItem> =>
+	store.repos.calendarObject.get(
+		write.object.calendarId,
+		deriveCalendarObjectId(write.object.calendarId, write.object.resourceName),
+	);
 
-		return { ok: true, value: object };
-	});
+/** Writes one calendar resource into its collection. */
+export const putCalendarObject = async (
+	store: ICalendarStore,
+	input: PutCalendarObjectInput,
+): Promise<CalendarResult<CalendarObjectItem>> => {
+	const collection = await store.repos.calendarCollection.get(
+		input.accountConfigId,
+		input.calendarId,
+	);
+	const write = await prepareCalendarObject(collection, input);
+	if (!write.ok) return write;
+	await store.commit([write.value]);
+	return { ok: true, value: await readWrittenObject(store, write.value) };
 };
 
 /**
- * Removes a resource and the occurrences it produced, in one unit — an object
- * dropped without its occurrence rows leaves a calendar showing events no
- * resource backs, which nothing later can attribute or clean up.
+ * Removes a resource and the occurrences it produced — an object dropped
+ * without its occurrence rows leaves a calendar showing events no resource
+ * backs, which nothing later can attribute or clean up.
  */
+export const deleteCalendarObjectWrite = (input: {
+	accountConfigId: string;
+	calendarId: string;
+	calendarObjectId: string;
+}): DeleteCalendarObjectWrite => ({ kind: "DeleteObject", ...input });
+
 export const deleteCalendarObject = async (
-	unitOfWork: ICalendarUnitOfWork,
+	store: ICalendarStore,
 	input: {
 		accountConfigId: string;
 		calendarId: string;
 		calendarObjectId: string;
 	},
 ): Promise<void> => {
-	await unitOfWork.transaction(async (repos) => {
-		await repos.calendarEventIndex.deleteForObject(
-			input.calendarId,
-			input.calendarObjectId,
-		);
-		await repos.calendarObject.delete(input.calendarId, input.calendarObjectId);
-		await repos.calendarCollection.bumpSyncSequence(
-			input.accountConfigId,
-			input.calendarId,
-		);
-	});
+	await store.commit([deleteCalendarObjectWrite(input)]);
 };
 
 /**
@@ -109,15 +121,13 @@ export const deleteCalendarObject = async (
  * the collection the first one made rather than a rival copy of it.
  */
 export const provisionDefaultCalendar = (
-	unitOfWork: ICalendarUnitOfWork,
+	store: ICalendarStore,
 	accountConfigId: string,
 	displayName = "Calendar",
 ): Promise<CalendarCollectionItem> =>
-	unitOfWork.transaction((repos) =>
-		repos.calendarCollection.create({
-			accountConfigId,
-			urlSegment: DEFAULT_CALENDAR_URL_SEGMENT,
-			displayName,
-			source: CalendarSource.Default,
-		}),
-	);
+	store.repos.calendarCollection.create({
+		accountConfigId,
+		urlSegment: DEFAULT_CALENDAR_URL_SEGMENT,
+		displayName,
+		source: CalendarSource.Default,
+	});

package/src/reopen.test.ts

@@ -124,13 +124,11 @@ const answerOf = async (
 };
 
 const secondCalendar = (store: MemoryCalendarStore) =>
-	store.transaction((repos) =>
-		repos.calendarCollection.create({
-			accountConfigId: ACCOUNT_CONFIG_ID,
-			urlSegment: "personal",
-			displayName: "Personal",
-		}),
-	);
+	store.repos.calendarCollection.create({
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		urlSegment: "personal",
+		displayName: "Personal",
+	});
 
 describe("reopenCalendarSuggestion", () => {
 	for (const answer of [

package/src/reopen.ts

@@ -2,10 +2,10 @@ import type { CalendarAnswerOvertaken as CalendarAnswerOvertakenValue } from "@r
 import type {
 	CalendarCollectionItem,
 	CalendarObjectItem,
+	CalendarRepositories,
 	CalendarSuggestionItem,
-	CalendarUnitOfWorkRepositories,
+	ICalendarStore,
 	ICalendarSuggestionRepository,
-	ICalendarUnitOfWork,
 } from "@remit/data-ports";
 import {
 	CalendarAnswerOvertaken,
@@ -13,7 +13,7 @@ import {
 	CalendarSuggestionState,
 } from "@remit/domain-enums";
 import { type CalendarResult, calendarFailure } from "./errors.js";
-import { deleteCalendarObject } from "./put.js";
+import { deleteCalendarObjectWrite } from "./put.js";
 import { followingUidPrefix } from "./scope.js";
 
 export interface ReopenCalendarSuggestionInput {
@@ -93,7 +93,7 @@ export const answersOvertakenBy = async (
 };
 
 const locateAnswered = async (
-	repos: CalendarUnitOfWorkRepositories,
+	repos: CalendarRepositories,
 	collections: CalendarCollectionItem[],
 	calendarObjectId: string,
 ): Promise<
@@ -110,7 +110,7 @@ const locateAnswered = async (
 };
 
 const partsOf = async (
-	repos: CalendarUnitOfWorkRepositories,
+	repos: CalendarRepositories,
 	suggestion: CalendarSuggestionItem,
 	collection: CalendarCollectionItem,
 	answered: CalendarObjectItem,
@@ -123,7 +123,7 @@ const partsOf = async (
 ];
 
 export const reopenCalendarSuggestion = async (
-	unitOfWork: ICalendarUnitOfWork,
+	store: ICalendarStore,
 	input: ReopenCalendarSuggestionInput,
 ): Promise<CalendarResult<CalendarSuggestionItem>> => {
 	const { accountConfigId, suggestion } = input;
@@ -143,48 +143,57 @@ export const reopenCalendarSuggestion = async (
 		);
 	}
 
-	return unitOfWork.transaction(async (repos) => {
-		const holders = othersIn(
-			await holdersByObject(repos.calendarSuggestion, accountConfigId, [
-				suggestion,
-			]),
+	const { repos } = store;
+	const holders = othersIn(
+		await holdersByObject(repos.calendarSuggestion, accountConfigId, [
 			suggestion,
+		]),
+		suggestion,
+	);
+	if (overtakenOf(holders) === CalendarAnswerOvertaken.Cancellation) {
+		return calendarFailure<CalendarSuggestionItem>(
+			"AnswerOvertaken",
+			"The cancellation of this event was answered into the same event, so this answer can no longer be taken back.",
 		);
-		if (overtakenOf(holders) === CalendarAnswerOvertaken.Cancellation) {
-			return calendarFailure<CalendarSuggestionItem>(
-				"AnswerOvertaken",
-				"The cancellation of this event was answered into the same event, so this answer can no longer be taken back.",
-			);
-		}
+	}
 
-		const located =
-			suggestion.acceptedCalendarObjectId === "" || holders.length > 0
-				? undefined
-				: await locateAnswered(
-						repos,
-						await repos.calendarCollection.listByAccountConfig(accountConfigId),
-						suggestion.acceptedCalendarObjectId,
-					);
-		if (located) {
-			for (const object of await partsOf(
-				repos,
-				suggestion,
-				located.collection,
-				located.object,
-			)) {
-				await deleteCalendarObject(unitOfWork, {
+	const located =
+		suggestion.acceptedCalendarObjectId === "" || holders.length > 0
+			? undefined
+			: await locateAnswered(
+					repos,
+					await repos.calendarCollection.listByAccountConfig(accountConfigId),
+					suggestion.acceptedCalendarObjectId,
+				);
+	const removals = located
+		? (
+				await partsOf(repos, suggestion, located.collection, located.object)
+			).map((object) =>
+				deleteCalendarObjectWrite({
 					accountConfigId,
 					calendarId: located.collection.calendarId,
 					calendarObjectId: object.calendarObjectId,
-				});
-			}
-		}
+				}),
+			)
+		: [];
 
-		const settled = await repos.calendarSuggestion.settle(
+	await store.commit([
+		...removals,
+		{
+			kind: "SettleSuggestion",
+			accountConfigId,
+			suggestionId: suggestion.suggestionId,
+			settle: {
+				state: CalendarSuggestionState.Pending,
+				acceptedCalendarObjectId: "",
+			},
+		},
+	]);
+	return {
+		ok: true,
+		value: await repos.calendarSuggestion.get(
 			accountConfigId,
 			suggestion.suggestionId,
-			{ state: CalendarSuggestionState.Pending, acceptedCalendarObjectId: "" },
-		);
-		return { ok: true, value: settled };
-	});
+		),
+	};
 };

package/src/subscribe.test.ts

@@ -39,16 +39,14 @@ const subscribed = async (): Promise<{
 	collection: CalendarCollectionItem;
 }> => {
 	const store = new MemoryCalendarStore();
-	const collection = await store.transaction((repos) =>
-		repos.calendarCollection.create({
-			accountConfigId: ACCOUNT_CONFIG_ID,
-			urlSegment: "harbour-rota",
-			displayName: "Harbour rota",
-			source: CalendarSource.Subscribed,
-			subscriptionUrl: SECRET_URL,
-			subscriptionEnabled: true,
-		}),
-	);
+	const collection = await store.repos.calendarCollection.create({
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		urlSegment: "harbour-rota",
+		displayName: "Harbour rota",
+		source: CalendarSource.Subscribed,
+		subscriptionUrl: SECRET_URL,
+		subscriptionEnabled: true,
+	});
 	return { store, collection };
 };
 
@@ -56,12 +54,11 @@ const drawn = async (
 	store: MemoryCalendarStore,
 	collection: CalendarCollectionItem,
 ) => {
-	const current = await store.transaction((repos) =>
-		repos.calendarCollection.get(ACCOUNT_CONFIG_ID, collection.calendarId),
-	);
-	const instances = await store.transaction((repos) =>
-		listCalendarInstances(repos, [current], WINDOW),
+	const current = await store.repos.calendarCollection.get(
+		ACCOUNT_CONFIG_ID,
+		collection.calendarId,
 	);
+	const instances = await listCalendarInstances(store.repos, [current], WINDOW);
 	return instances.map((instance) => ({
 		summary: instance.summary,
 		startAt: instance.startAt,
@@ -352,8 +349,9 @@ describe("writeCalendarFeed", () => {
 			},
 		]);
 
-		const stored = await store.transaction((repos) =>
-			repos.calendarCollection.get(ACCOUNT_CONFIG_ID, collection.calendarId),
+		const stored = await store.repos.calendarCollection.get(
+			ACCOUNT_CONFIG_ID,
+			collection.calendarId,
 		);
 		assert.equal(stored.subscriptionCheckedAt, 5_000);
 		assert.equal(stored.subscriptionFetchedAt, 5_000);
@@ -364,8 +362,9 @@ describe("writeCalendarFeed", () => {
 		const { store, collection } = await subscribed();
 		await writeFeed(store, collection, GOOGLE_FEED, 5_000);
 		const sequenceBefore = (
-			await store.transaction((repos) =>
-				repos.calendarCollection.get(ACCOUNT_CONFIG_ID, collection.calendarId),
+			await store.repos.calendarCollection.get(
+				ACCOUNT_CONFIG_ID,
+				collection.calendarId,
 			)
 		).syncSequence;
 
@@ -387,8 +386,9 @@ describe("writeCalendarFeed", () => {
 		);
 		assert.equal(summaries.includes("Tide table review"), false);
 		assert.equal(summaries.length, 6);
-		const after = await store.transaction((repos) =>
-			repos.calendarCollection.get(ACCOUNT_CONFIG_ID, collection.calendarId),
+		const after = await store.repos.calendarCollection.get(
+			ACCOUNT_CONFIG_ID,
+			collection.calendarId,
 		);
 		assert.equal(after.syncSequence, sequenceBefore + 1);
 	});
@@ -396,8 +396,9 @@ describe("writeCalendarFeed", () => {
 	it("writes nothing when a second fetch differs only in its export stamps", async () => {
 		const { store, collection } = await subscribed();
 		await writeFeed(store, collection, GOOGLE_FEED, 5_000);
-		const before = await store.transaction((repos) =>
-			repos.calendarCollection.get(ACCOUNT_CONFIG_ID, collection.calendarId),
+		const before = await store.repos.calendarCollection.get(
+			ACCOUNT_CONFIG_ID,
+			collection.calendarId,
 		);
 
 		const restamped = GOOGLE_FEED.replaceAll(
@@ -413,8 +414,9 @@ describe("writeCalendarFeed", () => {
 			removed: 0,
 			skipped: 0,
 		});
-		const after = await store.transaction((repos) =>
-			repos.calendarCollection.get(ACCOUNT_CONFIG_ID, collection.calendarId),
+		const after = await store.repos.calendarCollection.get(
+			ACCOUNT_CONFIG_ID,
+			collection.calendarId,
 		);
 		assert.equal(after.syncSequence, before.syncSequence);
 		assert.equal(after.subscriptionFetchedAt, 9_000);
@@ -422,12 +424,10 @@ describe("writeCalendarFeed", () => {
 
 	it("writes nothing for a subscription paused while its feed was read", async () => {
 		const { store, collection } = await subscribed();
-		await store.transaction((repos) =>
-			repos.calendarCollection.update(
-				ACCOUNT_CONFIG_ID,
-				collection.calendarId,
-				{ subscriptionEnabled: false },
-			),
+		await store.repos.calendarCollection.update(
+			ACCOUNT_CONFIG_ID,
+			collection.calendarId,
+			{ subscriptionEnabled: false },
 		);
 
 		const write = await writeFeed(store, collection, GOOGLE_FEED, 5_000);
@@ -440,8 +440,9 @@ describe("writeCalendarFeed", () => {
 			skipped: 0,
 		});
 		assert.deepEqual(await drawn(store, collection), []);
-		const stored = await store.transaction((repos) =>
-			repos.calendarCollection.get(ACCOUNT_CONFIG_ID, collection.calendarId),
+		const stored = await store.repos.calendarCollection.get(
+			ACCOUNT_CONFIG_ID,
+			collection.calendarId,
 		);
 		assert.equal(stored.subscriptionFetchedAt, 0);
 	});
@@ -479,8 +480,9 @@ describe("writeCalendarFeed", () => {
 
 		assert.equal(write.written, 1);
 		assert.equal(write.skipped, 2);
-		const stored = await store.transaction((repos) =>
-			repos.calendarCollection.get(ACCOUNT_CONFIG_ID, collection.calendarId),
+		const stored = await store.repos.calendarCollection.get(
+			ACCOUNT_CONFIG_ID,
+			collection.calendarId,
 		);
 		assert.equal(
 			stored.subscriptionError,
@@ -509,8 +511,9 @@ describe("refreshCalendarSubscription", () => {
 			ok: false,
 			reason: "the feed answered HTTP 503",
 		});
-		const stored = await store.transaction((repos) =>
-			repos.calendarCollection.get(ACCOUNT_CONFIG_ID, collection.calendarId),
+		const stored = await store.repos.calendarCollection.get(
+			ACCOUNT_CONFIG_ID,
+			collection.calendarId,
 		);
 		assert.equal(stored.subscriptionCheckedAt, 9_000);
 		assert.equal(stored.subscriptionFetchedAt, 5_000);
@@ -557,8 +560,9 @@ describe("refreshCalendarSubscription", () => {
 
 		assert.deepEqual(asked, [SECRET_URL]);
 		assert.ok(refreshed.ok);
-		const stored = await store.transaction((repos) =>
-			repos.calendarCollection.get(ACCOUNT_CONFIG_ID, collection.calendarId),
+		const stored = await store.repos.calendarCollection.get(
+			ACCOUNT_CONFIG_ID,
+			collection.calendarId,
 		);
 		assert.equal(stored.subscriptionError, "");
 		assert.equal(stored.subscriptionFetchedAt, 6_000);

package/src/subscribe.ts

@@ -1,12 +1,13 @@
 import { createHash } from "node:crypto";
 import type {
 	CalendarCollectionItem,
-	ICalendarUnitOfWork,
+	CalendarWrite,
+	ICalendarStore,
 } from "@remit/data-ports";
 import ICAL from "ical.js";
 import { type CalendarResult, calendarFailure } from "./errors.js";
 import { readCalendarComponent, serializeCalendar } from "./parse.js";
-import { deleteCalendarObject, putCalendarObject } from "./put.js";
+import { deleteCalendarObjectWrite, prepareCalendarObject } from "./put.js";
 
 export const CALENDAR_SUBSCRIPTION_TIMEOUT_MS = 30_000;
 
@@ -271,99 +272,111 @@ const feedErrorOf = (write: CalendarFeedWrite): string =>
 		: `${write.skipped} ${write.skipped === 1 ? "event" : "events"} in the feed could not be stored`;
 
 /**
- * Makes a subscribed collection hold what the feed holds, in one unit.
+ * Makes a subscribed collection hold what the feed holds, in one commit.
  *
- * Every resource goes through `putCalendarObject`, the one write path, so a
- * subscribed event is stored, projected and expanded the way any other event
+ * Every resource goes through `prepareCalendarObject`, the one write path, so
+ * a subscribed event is stored, projected and expanded the way any other event
  * is. A resource whose bytes have not changed is left alone, and one the feed
  * no longer carries is removed. A resource the write path refuses is counted
  * and recorded on the collection rather than failing the whole refresh.
+ *
+ * Repeating a refresh converges: a resource is keyed by its name, so a second
+ * run over the same feed finds every resource unchanged.
  */
 export const writeCalendarFeed = async (
-	unitOfWork: ICalendarUnitOfWork,
+	store: ICalendarStore,
 	target: CalendarSubscriptionTarget,
 	split: CalendarFeedSplit,
 	now: number,
-): Promise<CalendarFeedWrite> =>
-	unitOfWork.transaction(async (repos) => {
-		const current = await repos.calendarCollection.get(
-			target.accountConfigId,
-			target.calendarId,
-		);
-		if (!current.subscriptionEnabled) {
-			return { paused: true, written: 0, unchanged: 0, removed: 0, skipped: 0 };
-		}
-		const stored = await repos.calendarObject.listByCalendar(target.calendarId);
-		const storedByName = new Map(
-			stored.map((object) => [object.resourceName, object]),
-		);
-		const kept = new Set<string>();
-		const write: CalendarFeedWrite = {
-			paused: false,
-			written: 0,
-			unchanged: 0,
-			removed: 0,
-			skipped: split.unreadable,
-		};
+): Promise<CalendarFeedWrite> => {
+	const current = await store.repos.calendarCollection.get(
+		target.accountConfigId,
+		target.calendarId,
+	);
+	if (!current.subscriptionEnabled) {
+		return { paused: true, written: 0, unchanged: 0, removed: 0, skipped: 0 };
+	}
+	const stored = await store.repos.calendarObject.listByCalendar(
+		target.calendarId,
+	);
+	const storedByName = new Map(
+		stored.map((object) => [object.resourceName, object]),
+	);
+	const kept = new Set<string>();
+	const writes: CalendarWrite[] = [];
+	const write: CalendarFeedWrite = {
+		paused: false,
+		written: 0,
+		unchanged: 0,
+		removed: 0,
+		skipped: split.unreadable,
+	};
 
-		for (const resource of split.resources) {
-			const existing = storedByName.get(resource.resourceName);
-			if (
-				existing &&
-				comparable(existing.icalData) === comparable(resource.icalData)
-			) {
-				kept.add(resource.resourceName);
-				write.unchanged += 1;
-				continue;
-			}
-			const put = await putCalendarObject(unitOfWork, {
-				accountConfigId: target.accountConfigId,
-				calendarId: target.calendarId,
-				resourceName: resource.resourceName,
-				icalData: resource.icalData,
-			});
-			if (!put.ok) {
-				write.skipped += 1;
-				continue;
-			}
+	for (const resource of split.resources) {
+		const existing = storedByName.get(resource.resourceName);
+		if (
+			existing &&
+			comparable(existing.icalData) === comparable(resource.icalData)
+		) {
 			kept.add(resource.resourceName);
-			write.written += 1;
+			write.unchanged += 1;
+			continue;
 		}
+		const put = await prepareCalendarObject(current, {
+			accountConfigId: target.accountConfigId,
+			calendarId: target.calendarId,
+			resourceName: resource.resourceName,
+			icalData: resource.icalData,
+		});
+		if (!put.ok) {
+			write.skipped += 1;
+			continue;
+		}
+		writes.push(put.value);
+		kept.add(resource.resourceName);
+		write.written += 1;
+	}
 
-		for (const object of stored) {
-			if (kept.has(object.resourceName)) continue;
-			await deleteCalendarObject(unitOfWork, {
+	for (const object of stored) {
+		if (kept.has(object.resourceName)) continue;
+		writes.push(
+			deleteCalendarObjectWrite({
 				accountConfigId: target.accountConfigId,
 				calendarId: target.calendarId,
 				calendarObjectId: object.calendarObjectId,
-			});
-			write.removed += 1;
-		}
-
-		await repos.calendarCollection.update(
-			target.accountConfigId,
-			target.calendarId,
-			{
-				subscriptionCheckedAt: now,
-				subscriptionFetchedAt: now,
-				subscriptionError: truncate(feedErrorOf(write)),
-			},
+			}),
 		);
-		return write;
+		write.removed += 1;
+	}
+
+	writes.push({
+		kind: "UpdateCollection",
+		accountConfigId: target.accountConfigId,
+		calendarId: target.calendarId,
+		patch: {
+			subscriptionCheckedAt: now,
+			subscriptionFetchedAt: now,
+			subscriptionError: truncate(feedErrorOf(write)),
+		},
 	});
+	await store.commit(writes);
+	return write;
+};
 
 /** Records a refresh that stored nothing, and why. Every stored event stays. */
 export const recordCalendarFeedFailure = async (
-	unitOfWork: ICalendarUnitOfWork,
+	store: ICalendarStore,
 	target: CalendarSubscriptionTarget,
 	reason: string,
 	now: number,
 ): Promise<void> => {
-	await unitOfWork.transaction((repos) =>
-		repos.calendarCollection.update(target.accountConfigId, target.calendarId, {
+	await store.repos.calendarCollection.update(
+		target.accountConfigId,
+		target.calendarId,
+		{
 			subscriptionCheckedAt: now,
 			subscriptionError: truncate(reason),
-		}),
+		},
 	);
 };
 
@@ -391,7 +404,7 @@ export const readCalendarFeed = async (
  * records its reason on the collection and removes nothing.
  */
 export const refreshCalendarSubscription = async (
-	unitOfWork: ICalendarUnitOfWork,
+	store: ICalendarStore,
 	collection: CalendarCollectionItem,
 	now: number,
 	fetcher: CalendarFeedFetcher = fetch,
@@ -402,10 +415,10 @@ export const refreshCalendarSubscription = async (
 	};
 	const feed = await readCalendarFeed(collection.subscriptionUrl, fetcher);
 	if (!feed.ok) {
-		await recordCalendarFeedFailure(unitOfWork, target, feed.reason, now);
+		await recordCalendarFeedFailure(store, target, feed.reason, now);
 		return feed;
 	}
-	const write = await writeCalendarFeed(unitOfWork, target, feed.value, now);
+	const write = await writeCalendarFeed(store, target, feed.value, now);
 	return { ok: true, value: write };
 };