@remit/calendar-service 0.0.15 → 0.0.16

package/package.json

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

package/src/errors.ts

@@ -38,7 +38,9 @@ export type CalendarValidationCode =
 	| "UnmovableRecurrenceRule"
 	| "UneditableCancellation"
 	/** A subscription address that is not an http, https or webcal URL. */
-	| "InvalidSubscriptionUrl";
+	| "InvalidSubscriptionUrl"
+	| "NotReopenable"
+	| "AnswerOvertaken";
 
 export interface CalendarValidationError {
 	code: CalendarValidationCode;

package/src/index.ts

@@ -60,10 +60,17 @@ export {
 	provisionDefaultCalendar,
 	putCalendarObject,
 } from "./put.js";
+export {
+	answersOvertakenBy,
+	type ReopenCalendarSuggestionInput,
+	reopenCalendarSuggestion,
+} from "./reopen.js";
 export {
 	applyScopedDelete,
 	applyScopedUpdate,
 	findOccurrence,
+	followingUidOf,
+	followingUidPrefix,
 	type RecurrenceScopeValue,
 	type ScopedWrite,
 	type ScopedWriteInput,

package/src/memory-store.ts

@@ -169,6 +169,11 @@ export class MemoryCalendarStore implements ICalendarUnitOfWork {
 				(object) =>
 					object.calendarId === calendarId && object.icalUid === icalUid,
 			) ?? null,
+		listByUidPrefix: async (calendarId: string, prefix: string) =>
+			[...this.objects.values()].filter(
+				(object) =>
+					object.calendarId === calendarId && object.icalUid.startsWith(prefix),
+			),
 		listByCalendar: async (calendarId: string) =>
 			[...this.objects.values()].filter(
 				(object) => object.calendarId === calendarId,
@@ -250,6 +255,15 @@ export class MemoryCalendarStore implements ICalendarUnitOfWork {
 			}
 			return suggestion;
 		},
+		listByAcceptedCalendarObjects: async (
+			accountConfigId: string,
+			calendarObjectIds: string[],
+		) =>
+			[...this.suggestions.values()].filter(
+				(suggestion) =>
+					suggestion.accountConfigId === accountConfigId &&
+					calendarObjectIds.includes(suggestion.acceptedCalendarObjectId),
+			),
 		listByMessage: async (accountConfigId: string, messageId: string) =>
 			[...this.suggestions.values()].filter(
 				(suggestion) =>

package/src/reopen.test.ts

@@ -0,0 +1,531 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { CalendarInviteAnswer as CalendarInviteAnswerValue } from "@remit/api-openapi-types";
+import type { CalendarSuggestionItem } from "@remit/data-ports";
+import {
+	CalendarAnswerOvertaken,
+	CalendarInviteAnswer,
+	CalendarSuggestionSource,
+	CalendarSuggestionState,
+} from "@remit/domain-enums";
+import { acceptCalendarSuggestion } from "./accept.js";
+import { ical } from "./fixtures.js";
+import { MemoryCalendarStore } from "./memory-store.js";
+import {
+	deleteCalendarObject,
+	provisionDefaultCalendar,
+	putCalendarObject,
+} from "./put.js";
+import { answersOvertakenBy, reopenCalendarSuggestion } from "./reopen.js";
+import { followingUidOf, followingUidPrefix } from "./scope.js";
+import { recordCalendarSuggestion } from "./suggest.js";
+
+const ACCOUNT_CONFIG_ID = "account-config-1";
+const ATTENDEE = "user@example.test";
+
+const invitation = (
+	uid: string,
+	{
+		method = "REQUEST",
+		sequence = 0,
+	}: { method?: "REQUEST" | "CANCEL"; sequence?: number } = {},
+): string =>
+	ical(
+		"BEGIN:VCALENDAR",
+		"VERSION:2.0",
+		"PRODID:-//Example Corp//Scheduler//EN",
+		`METHOD:${method}`,
+		"BEGIN:VEVENT",
+		`UID:${uid}`,
+		"DTSTAMP:20260801T090000Z",
+		`SEQUENCE:${sequence}`,
+		"DTSTART:20260901T080000Z",
+		"DTEND:20260901T090000Z",
+		"RRULE:FREQ=WEEKLY;COUNT=4",
+		"SUMMARY:Quarterly review",
+		"ORGANIZER:mailto:organizer@example.test",
+		"ATTENDEE;PARTSTAT=NEEDS-ACTION:mailto:user@example.test",
+		"END:VEVENT",
+		"END:VCALENDAR",
+	);
+
+const provisioned = async (): Promise<{
+	store: MemoryCalendarStore;
+	calendarId: string;
+}> => {
+	const store = new MemoryCalendarStore();
+	const collection = await provisionDefaultCalendar(store, ACCOUNT_CONFIG_ID);
+	return { store, calendarId: collection.calendarId };
+};
+
+const recorded = async (
+	store: MemoryCalendarStore,
+	uid: string,
+	messageId: string,
+	options: { method?: "REQUEST" | "CANCEL"; sequence?: number } = {},
+): Promise<CalendarSuggestionItem> => {
+	const result = await recordCalendarSuggestion(store.calendarSuggestion, {
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		messageId,
+		bodyPartId: "body-part-1",
+		source: CalendarSuggestionSource.IcalendarPart,
+		icalData: invitation(uid, options),
+		timezone: "UTC",
+	});
+	assert.ok(result.ok);
+	return result.value.suggestion;
+};
+
+const answered = async (
+	store: MemoryCalendarStore,
+	calendarId: string,
+	suggestion: CalendarSuggestionItem,
+	answer: CalendarInviteAnswerValue,
+): Promise<CalendarSuggestionItem> => {
+	const result = await acceptCalendarSuggestion(store, {
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		calendarId,
+		suggestion,
+		attendee: ATTENDEE,
+		answer,
+	});
+	assert.ok(result.ok);
+	return result.value.suggestion;
+};
+
+const reopen = (
+	store: MemoryCalendarStore,
+	suggestion: CalendarSuggestionItem,
+) =>
+	reopenCalendarSuggestion(store, {
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		suggestion,
+	});
+
+const reopened = async (
+	store: MemoryCalendarStore,
+	suggestion: CalendarSuggestionItem,
+): Promise<CalendarSuggestionItem> => {
+	const result = await reopen(store, suggestion);
+	assert.ok(result.ok, JSON.stringify(result));
+	return result.value;
+};
+
+const answerOf = async (
+	store: MemoryCalendarStore,
+	suggestion: CalendarSuggestionItem,
+) => {
+	const [answered] = await answersOvertakenBy(
+		store.calendarSuggestion,
+		ACCOUNT_CONFIG_ID,
+		[suggestion],
+	);
+	return answered?.answerOvertakenBy;
+};
+
+const secondCalendar = (store: MemoryCalendarStore) =>
+	store.transaction((repos) =>
+		repos.calendarCollection.create({
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			urlSegment: "personal",
+			displayName: "Personal",
+		}),
+	);
+
+describe("reopenCalendarSuggestion", () => {
+	for (const answer of [
+		CalendarInviteAnswer.Accepted,
+		CalendarInviteAnswer.Tentative,
+	]) {
+		it(`takes a ${answer} answer back: the event and its occurrences leave, the card is Pending`, async () => {
+			const { store, calendarId } = await provisioned();
+			const card = await answered(
+				store,
+				calendarId,
+				await recorded(store, "invite-1@example.test", "message-1"),
+				answer,
+			);
+			const written = card.acceptedCalendarObjectId;
+			const sequenceBefore = store.collections.get(calendarId)?.syncSequence;
+
+			const back = await reopened(store, card);
+
+			assert.equal(back.state, CalendarSuggestionState.Pending);
+			assert.equal(back.acceptedCalendarObjectId, "");
+			assert.equal(store.objects.has(written), false);
+			assert.equal(store.occurrences.get(written)?.length ?? 0, 0);
+			assert.ok(
+				(store.collections.get(calendarId)?.syncSequence ?? 0) >
+					(sequenceBefore ?? 0),
+			);
+			assert.equal(
+				store.suggestions.get(card.suggestionId)?.state,
+				CalendarSuggestionState.Pending,
+			);
+		});
+	}
+
+	it("a reopened card can be answered again", async () => {
+		const { store, calendarId } = await provisioned();
+		const card = await answered(
+			store,
+			calendarId,
+			await recorded(store, "invite-1@example.test", "message-1"),
+			CalendarInviteAnswer.Accepted,
+		);
+
+		const again = await answered(
+			store,
+			calendarId,
+			await reopened(store, card),
+			CalendarInviteAnswer.Tentative,
+		);
+
+		assert.equal(again.state, CalendarSuggestionState.Tentative);
+		assert.equal(store.objects.size, 1);
+		assert.ok(store.objects.has(again.acceptedCalendarObjectId));
+	});
+
+	it("removes the remainder a this-and-following edit split off, so a re-add does not duplicate", async () => {
+		const { store, calendarId } = await provisioned();
+		const uid = "invite-1@example.test";
+		const card = await answered(
+			store,
+			calendarId,
+			await recorded(store, uid, "message-1"),
+			CalendarInviteAnswer.Accepted,
+		);
+		const head = store.objects.get(card.acceptedCalendarObjectId);
+		assert.ok(head);
+		const tailUid = followingUidOf(uid, "split-1@reader.remit");
+		const tail = await putCalendarObject(store, {
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			calendarId,
+			resourceName: "split-1.ics",
+			icalData: head.icalData.replace(`UID:${uid}`, `UID:${tailUid}`),
+		});
+		assert.ok(tail.ok);
+		const tailOfTail = await putCalendarObject(store, {
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			calendarId,
+			resourceName: "split-2.ics",
+			icalData: head.icalData.replace(
+				`UID:${uid}`,
+				`UID:${followingUidOf(tailUid, "split-2@reader.remit")}`,
+			),
+		});
+		assert.ok(tailOfTail.ok);
+		assert.equal(store.objects.size, 3);
+
+		const back = await reopened(store, card);
+		assert.equal(store.objects.size, 0);
+		assert.equal(
+			store.occurrences.get(tail.value.calendarObjectId)?.length ?? 0,
+			0,
+		);
+
+		await answered(store, calendarId, back, CalendarInviteAnswer.Accepted);
+		assert.equal(store.objects.size, 1);
+	});
+
+	for (const second of [
+		{ name: "a resend at the same SEQUENCE", sequence: 0 },
+		{ name: "a later revision", sequence: 1 },
+	]) {
+		it(`keeps the event while ${second.name} still holds it, and removes it with the last answer`, async () => {
+			const { store, calendarId } = await provisioned();
+			const uid = "invite-1@example.test";
+			const first = await answered(
+				store,
+				calendarId,
+				await recorded(store, uid, "message-1"),
+				CalendarInviteAnswer.Accepted,
+			);
+			const other = await answered(
+				store,
+				calendarId,
+				await recorded(store, uid, "message-2", { sequence: second.sequence }),
+				CalendarInviteAnswer.Tentative,
+			);
+			const event = first.acceptedCalendarObjectId;
+			assert.equal(other.acceptedCalendarObjectId, event);
+			assert.equal(await answerOf(store, first), CalendarAnswerOvertaken.None);
+
+			const firstBack = await reopened(store, first);
+
+			assert.equal(firstBack.state, CalendarSuggestionState.Pending);
+			assert.equal(firstBack.acceptedCalendarObjectId, "");
+			assert.ok(store.objects.has(event), "the other answer still holds it");
+			assert.equal(
+				store.suggestions.get(other.suggestionId)?.acceptedCalendarObjectId,
+				event,
+			);
+
+			const otherBack = await reopened(store, other);
+
+			assert.equal(otherBack.state, CalendarSuggestionState.Pending);
+			assert.equal(store.objects.has(event), false);
+		});
+	}
+
+	it("takes back only the parts in the calendar that holds the answered event", async () => {
+		const { store, calendarId: work } = await provisioned();
+		const personal = (await secondCalendar(store)).calendarId;
+		const uid = "invite-1@example.test";
+		const first = await answered(
+			store,
+			work,
+			await recorded(store, uid, "message-1"),
+			CalendarInviteAnswer.Accepted,
+		);
+		const second = await answered(
+			store,
+			personal,
+			await recorded(store, uid, "message-2", { sequence: 1 }),
+			CalendarInviteAnswer.Accepted,
+		);
+		assert.notEqual(
+			first.acceptedCalendarObjectId,
+			second.acceptedCalendarObjectId,
+		);
+		const personalHead = store.objects.get(second.acceptedCalendarObjectId);
+		assert.ok(personalHead);
+		const personalTail = await putCalendarObject(store, {
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			calendarId: personal,
+			resourceName: "split-1.ics",
+			icalData: personalHead.icalData.replace(
+				`UID:${uid}`,
+				`UID:${followingUidOf(uid, "split-1@reader.remit")}`,
+			),
+		});
+		assert.ok(personalTail.ok);
+
+		await reopened(store, first);
+
+		assert.equal(store.objects.has(first.acceptedCalendarObjectId), false);
+		assert.ok(store.objects.has(second.acceptedCalendarObjectId));
+		assert.ok(store.objects.has(personalTail.value.calendarObjectId));
+	});
+
+	it("leaves a remainder split off before split UIDs were derived", async () => {
+		const { store, calendarId } = await provisioned();
+		const uid = "invite-1@example.test";
+		const card = await answered(
+			store,
+			calendarId,
+			await recorded(store, uid, "message-1"),
+			CalendarInviteAnswer.Accepted,
+		);
+		const head = store.objects.get(card.acceptedCalendarObjectId);
+		assert.ok(head);
+		const legacy = await putCalendarObject(store, {
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			calendarId,
+			resourceName: "legacy.ics",
+			icalData: head.icalData
+				.replace(`UID:${uid}`, "UID:legacy-1@reader.remit")
+				.replace("DTSTART:20260901T080000Z", "DTSTART:20260915T080000Z")
+				.replace("DTEND:20260901T090000Z", "DTEND:20260915T090000Z"),
+		});
+		assert.ok(legacy.ok, JSON.stringify(legacy));
+
+		await reopened(store, card);
+
+		assert.equal(store.objects.has(card.acceptedCalendarObjectId), false);
+		assert.ok(store.objects.has(legacy.value.calendarObjectId));
+	});
+
+	it("refuses to take back a request's answer once its cancellation was answered into the same event", async () => {
+		const { store, calendarId } = await provisioned();
+		const uid = "invite-1@example.test";
+		const request = await answered(
+			store,
+			calendarId,
+			await recorded(store, uid, "message-1"),
+			CalendarInviteAnswer.Accepted,
+		);
+		const cancel = await answered(
+			store,
+			calendarId,
+			await recorded(store, uid, "message-2", { method: "CANCEL" }),
+			CalendarInviteAnswer.Accepted,
+		);
+		assert.equal(
+			request.acceptedCalendarObjectId,
+			cancel.acceptedCalendarObjectId,
+		);
+
+		const refused = await reopen(store, request);
+
+		assert.equal(refused.ok, false);
+		assert.equal(!refused.ok && refused.error.code, "AnswerOvertaken");
+		assert.ok(store.objects.has(cancel.acceptedCalendarObjectId));
+		assert.equal(
+			await answerOf(store, request),
+			CalendarAnswerOvertaken.Cancellation,
+		);
+	});
+
+	it("refuses a superseded card and a cancellation card", async () => {
+		const { store } = await provisioned();
+		const pending = await recorded(store, "invite-1@example.test", "message-1");
+		const cancel = await recorded(store, "invite-2@example.test", "message-2", {
+			method: "CANCEL",
+		});
+
+		for (const card of [
+			{ ...pending, state: CalendarSuggestionState.Superseded },
+			{ ...cancel, state: CalendarSuggestionState.Dismissed },
+		]) {
+			const refused = await reopen(store, card);
+			assert.equal(!refused.ok && refused.error.code, "NotReopenable");
+		}
+	});
+
+	it("leaves every other event in the calendar alone", async () => {
+		const { store, calendarId } = await provisioned();
+		const other = await answered(
+			store,
+			calendarId,
+			await recorded(store, "invite-2@example.test", "message-2"),
+			CalendarInviteAnswer.Accepted,
+		);
+		const card = await answered(
+			store,
+			calendarId,
+			await recorded(store, "invite-1@example.test", "message-1"),
+			CalendarInviteAnswer.Accepted,
+		);
+
+		await reopened(store, card);
+
+		assert.deepEqual(
+			[...store.objects.keys()],
+			[other.acceptedCalendarObjectId],
+		);
+	});
+
+	it("reopens a declined card without touching the calendar", async () => {
+		const { store, calendarId } = await provisioned();
+		const kept = await answered(
+			store,
+			calendarId,
+			await recorded(store, "invite-2@example.test", "message-2"),
+			CalendarInviteAnswer.Accepted,
+		);
+		const pending = await recorded(store, "invite-1@example.test", "message-1");
+		const declined = await store.calendarSuggestion.settle(
+			ACCOUNT_CONFIG_ID,
+			pending.suggestionId,
+			{ state: CalendarSuggestionState.Declined, acceptedCalendarObjectId: "" },
+		);
+		const sequenceBefore = store.collections.get(calendarId)?.syncSequence;
+
+		const back = await reopened(store, declined);
+
+		assert.equal(back.state, CalendarSuggestionState.Pending);
+		assert.ok(store.objects.has(kept.acceptedCalendarObjectId));
+		assert.equal(
+			store.collections.get(calendarId)?.syncSequence,
+			sequenceBefore,
+		);
+	});
+
+	it("still reopens when the event was already deleted from the calendar", async () => {
+		const { store, calendarId } = await provisioned();
+		const card = await answered(
+			store,
+			calendarId,
+			await recorded(store, "invite-1@example.test", "message-1"),
+			CalendarInviteAnswer.Accepted,
+		);
+		await deleteCalendarObject(store, {
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			calendarId,
+			calendarObjectId: card.acceptedCalendarObjectId,
+		});
+
+		const back = await reopened(store, card);
+
+		assert.equal(back.state, CalendarSuggestionState.Pending);
+		assert.equal(back.acceptedCalendarObjectId, "");
+	});
+
+	it("returns a Pending card as it is", async () => {
+		const { store } = await provisioned();
+		const pending = await recorded(store, "invite-1@example.test", "message-1");
+
+		assert.deepEqual(await reopened(store, pending), pending);
+	});
+});
+
+describe("followingUidOf", () => {
+	it("keeps every split of a series under the first event's UID", () => {
+		const once = followingUidOf("root@example.test", "a");
+		const twice = followingUidOf(once, "b");
+
+		assert.ok(once.startsWith(followingUidPrefix("root@example.test")));
+		assert.ok(twice.startsWith(followingUidPrefix("root@example.test")));
+		assert.equal(followingUidPrefix(twice), followingUidPrefix(once));
+	});
+});
+
+describe("answersOvertakenBy", () => {
+	it("reads the holders of a whole page in one lookup", async () => {
+		const { store, calendarId } = await provisioned();
+		const request = await answered(
+			store,
+			calendarId,
+			await recorded(store, "invite-1@example.test", "message-1"),
+			CalendarInviteAnswer.Accepted,
+		);
+		await answered(
+			store,
+			calendarId,
+			await recorded(store, "invite-1@example.test", "message-2", {
+				method: "CANCEL",
+			}),
+			CalendarInviteAnswer.Accepted,
+		);
+		const other = await answered(
+			store,
+			calendarId,
+			await recorded(store, "invite-2@example.test", "message-3"),
+			CalendarInviteAnswer.Accepted,
+		);
+		const pending = await recorded(store, "invite-3@example.test", "message-4");
+		const reads: string[][] = [];
+		const counting = {
+			listByAcceptedCalendarObjects: (
+				accountConfigId: string,
+				calendarObjectIds: string[],
+			) => {
+				reads.push(calendarObjectIds);
+				return store.calendarSuggestion.listByAcceptedCalendarObjects(
+					accountConfigId,
+					calendarObjectIds,
+				);
+			},
+		};
+
+		const page = await answersOvertakenBy(counting, ACCOUNT_CONFIG_ID, [
+			request,
+			other,
+			pending,
+		]);
+
+		assert.equal(reads.length, 1);
+		assert.deepEqual(
+			page.map((entry) => [
+				entry.suggestion.suggestionId,
+				entry.answerOvertakenBy,
+			]),
+			[
+				[request.suggestionId, CalendarAnswerOvertaken.Cancellation],
+				[other.suggestionId, CalendarAnswerOvertaken.None],
+				[pending.suggestionId, CalendarAnswerOvertaken.None],
+			],
+		);
+	});
+});

package/src/reopen.ts

@@ -0,0 +1,190 @@
+import type { CalendarAnswerOvertaken as CalendarAnswerOvertakenValue } from "@remit/api-openapi-types";
+import type {
+	CalendarCollectionItem,
+	CalendarObjectItem,
+	CalendarSuggestionItem,
+	CalendarUnitOfWorkRepositories,
+	ICalendarSuggestionRepository,
+	ICalendarUnitOfWork,
+} from "@remit/data-ports";
+import {
+	CalendarAnswerOvertaken,
+	CalendarInviteMethod,
+	CalendarSuggestionState,
+} from "@remit/domain-enums";
+import { type CalendarResult, calendarFailure } from "./errors.js";
+import { deleteCalendarObject } from "./put.js";
+import { followingUidPrefix } from "./scope.js";
+
+export interface ReopenCalendarSuggestionInput {
+	accountConfigId: string;
+	suggestion: CalendarSuggestionItem;
+}
+
+const answeredStates: ReadonlySet<CalendarSuggestionItem["state"]> = new Set([
+	CalendarSuggestionState.Accepted,
+	CalendarSuggestionState.Tentative,
+]);
+
+type SuggestionHolders = Pick<
+	ICalendarSuggestionRepository,
+	"listByAcceptedCalendarObjects"
+>;
+
+const holdersByObject = async (
+	calendarSuggestion: SuggestionHolders,
+	accountConfigId: string,
+	suggestions: CalendarSuggestionItem[],
+): Promise<Map<string, CalendarSuggestionItem[]>> => {
+	const objectIds = [
+		...new Set(
+			suggestions
+				.map((suggestion) => suggestion.acceptedCalendarObjectId)
+				.filter((objectId) => objectId !== ""),
+		),
+	];
+	const byObject = new Map<string, CalendarSuggestionItem[]>();
+	for (const holder of await calendarSuggestion.listByAcceptedCalendarObjects(
+		accountConfigId,
+		objectIds,
+	)) {
+		if (!answeredStates.has(holder.state)) continue;
+		const held = byObject.get(holder.acceptedCalendarObjectId) ?? [];
+		held.push(holder);
+		byObject.set(holder.acceptedCalendarObjectId, held);
+	}
+	return byObject;
+};
+
+const othersIn = (
+	byObject: Map<string, CalendarSuggestionItem[]>,
+	suggestion: CalendarSuggestionItem,
+): CalendarSuggestionItem[] =>
+	(byObject.get(suggestion.acceptedCalendarObjectId) ?? []).filter(
+		(other) => other.suggestionId !== suggestion.suggestionId,
+	);
+
+const overtakenOf = (
+	holders: CalendarSuggestionItem[],
+): CalendarAnswerOvertakenValue =>
+	holders.some((other) => other.method === CalendarInviteMethod.Cancel)
+		? CalendarAnswerOvertaken.Cancellation
+		: CalendarAnswerOvertaken.None;
+
+export const answersOvertakenBy = async (
+	calendarSuggestion: SuggestionHolders,
+	accountConfigId: string,
+	suggestions: CalendarSuggestionItem[],
+): Promise<
+	{
+		suggestion: CalendarSuggestionItem;
+		answerOvertakenBy: CalendarAnswerOvertakenValue;
+	}[]
+> => {
+	const byObject = await holdersByObject(
+		calendarSuggestion,
+		accountConfigId,
+		suggestions,
+	);
+	return suggestions.map((suggestion) => ({
+		suggestion,
+		answerOvertakenBy: overtakenOf(othersIn(byObject, suggestion)),
+	}));
+};
+
+const locateAnswered = async (
+	repos: CalendarUnitOfWorkRepositories,
+	collections: CalendarCollectionItem[],
+	calendarObjectId: string,
+): Promise<
+	{ collection: CalendarCollectionItem; object: CalendarObjectItem } | undefined
+> => {
+	for (const collection of collections) {
+		const object = await repos.calendarObject.find(
+			collection.calendarId,
+			calendarObjectId,
+		);
+		if (object !== null) return { collection, object };
+	}
+	return undefined;
+};
+
+const partsOf = async (
+	repos: CalendarUnitOfWorkRepositories,
+	suggestion: CalendarSuggestionItem,
+	collection: CalendarCollectionItem,
+	answered: CalendarObjectItem,
+): Promise<CalendarObjectItem[]> => [
+	answered,
+	...(await repos.calendarObject.listByUidPrefix(
+		collection.calendarId,
+		followingUidPrefix(suggestion.icalUid),
+	)),
+];
+
+export const reopenCalendarSuggestion = async (
+	unitOfWork: ICalendarUnitOfWork,
+	input: ReopenCalendarSuggestionInput,
+): Promise<CalendarResult<CalendarSuggestionItem>> => {
+	const { accountConfigId, suggestion } = input;
+	if (suggestion.state === CalendarSuggestionState.Pending) {
+		return { ok: true, value: suggestion };
+	}
+	if (suggestion.state === CalendarSuggestionState.Superseded) {
+		return calendarFailure(
+			"NotReopenable",
+			"A later message replaced this invitation, so answer that one instead.",
+		);
+	}
+	if (suggestion.method === CalendarInviteMethod.Cancel) {
+		return calendarFailure(
+			"NotReopenable",
+			"This is a cancellation, so there is no answer to take back.",
+		);
+	}
+
+	return unitOfWork.transaction(async (repos) => {
+		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.",
+			);
+		}
+
+		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, {
+					accountConfigId,
+					calendarId: located.collection.calendarId,
+					calendarObjectId: object.calendarObjectId,
+				});
+			}
+		}
+
+		const settled = await repos.calendarSuggestion.settle(
+			accountConfigId,
+			suggestion.suggestionId,
+			{ state: CalendarSuggestionState.Pending, acceptedCalendarObjectId: "" },
+		);
+		return { ok: true, value: settled };
+	});
+};

package/src/scope.ts

@@ -35,6 +35,14 @@ export interface ScopedWriteInput {
 	followingUid: string;
 }
 
+const FOLLOWING_UID_SEPARATOR = "/following/";
+
+export const followingUidPrefix = (icalUid: string): string =>
+	`${icalUid.split(FOLLOWING_UID_SEPARATOR)[0]}${FOLLOWING_UID_SEPARATOR}`;
+
+export const followingUidOf = (icalUid: string, id: string): string =>
+	`${followingUidPrefix(icalUid)}${id}`;
+
 interface FoundOccurrence {
 	/** The rule slot, in whatever form the master's DTSTART is written in. */
 	slot: ICAL.Time;