@remit/calendar-service 0.0.14 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/calendar-service",
-  "version": "0.0.14",
+  "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/accept.test.ts

@@ -64,6 +64,7 @@ const suggestionOf = (
 	zoneCertainty: "Explicit",
 	icalData,
 	acceptedCalendarObjectId: "",
+	supersededByMessageId: "",
 	createdAt: 0,
 	updatedAt: 0,
 	...overrides,

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,
@@ -236,6 +241,7 @@ export class MemoryCalendarStore implements ICalendarUnitOfWork {
 				suggestionId,
 				state: existing?.state ?? CalendarSuggestionState.Pending,
 				acceptedCalendarObjectId: existing?.acceptedCalendarObjectId ?? "",
+				supersededByMessageId: existing?.supersededByMessageId ?? "",
 				createdAt: existing?.createdAt ?? now,
 				updatedAt: now,
 			};
@@ -249,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) =>
@@ -282,6 +297,7 @@ export class MemoryCalendarStore implements ICalendarUnitOfWork {
 		supersedeIfPending: async (
 			accountConfigId: string,
 			suggestionId: string,
+			supersededByMessageId: string,
 		) => {
 			const suggestion = this.suggestions.get(suggestionId);
 			if (
@@ -295,11 +311,33 @@ export class MemoryCalendarStore implements ICalendarUnitOfWork {
 				...suggestion,
 				state: CalendarSuggestionState.Superseded,
 				acceptedCalendarObjectId: "",
+				supersededByMessageId,
 				updatedAt: Date.now(),
 			};
 			this.suggestions.set(suggestionId, retired);
 			return retired;
 		},
+		repointSuperseded: async (
+			accountConfigId: string,
+			suggestionId: string,
+			supersededByMessageId: string,
+		) => {
+			const suggestion = this.suggestions.get(suggestionId);
+			if (
+				!suggestion ||
+				suggestion.accountConfigId !== accountConfigId ||
+				suggestion.state !== CalendarSuggestionState.Superseded
+			) {
+				return null;
+			}
+			const repointed = {
+				...suggestion,
+				supersededByMessageId,
+				updatedAt: Date.now(),
+			};
+			this.suggestions.set(suggestionId, repointed);
+			return repointed;
+		},
 	};
 
 	private readonly feedTokenRepo: ICalendarFeedTokenRepository = {

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;

package/src/suggest.test.ts

@@ -180,6 +180,28 @@ describe("recordCalendarSuggestion", () => {
 			first.value.suggestion.suggestionId,
 		);
 		assert.equal(superseded.state, CalendarSuggestionState.Superseded);
+		assert.equal(
+			superseded.supersededByMessageId,
+			second.value.suggestion.messageId,
+		);
+	});
+
+	it("points every retired revision at the newest one", async () => {
+		const store = new MemoryCalendarStore();
+
+		const first = await record(store, invitation({ sequence: 0 }), "message-1");
+		await record(store, invitation({ sequence: 1 }), "message-2");
+		await record(store, invitation({ sequence: 2 }), "message-3");
+
+		assert.ok(first.ok);
+		const retired = [...store.suggestions.values()]
+			.filter((row) => row.state === CalendarSuggestionState.Superseded)
+			.map((row) => [row.messageId, row.supersededByMessageId])
+			.sort();
+		assert.deepEqual(retired, [
+			["message-1", "message-3"],
+			["message-2", "message-3"],
+		]);
 	});
 
 	it("leaves the earlier revision alone when the sequence did not move", async () => {

package/src/suggest.ts

@@ -111,23 +111,22 @@ export interface RecordedCalendarSuggestion {
 }
 
 /**
- * Every pending suggestion the account holds. Drained rather than read as one
- * page: the page size is a repository detail, and a supersession that missed
- * the older revision because it sat on page two would leave two live cards for
- * one event.
+ * Every suggestion the account holds in one state. Drained rather than read as
+ * one page: the page size is a repository detail, and a supersession that
+ * missed the older revision because it sat on page two would leave two live
+ * cards for one event.
  */
-const listPending = async (
+const listInState = async (
 	repo: ICalendarSuggestionRepository,
 	accountConfigId: string,
+	state: CalendarSuggestionItem["state"],
 ): Promise<CalendarSuggestionItem[]> => {
 	const items: CalendarSuggestionItem[] = [];
 	let continuationToken: string | undefined;
 	do {
-		const page = await repo.listByState(
-			accountConfigId,
-			CalendarSuggestionState.Pending,
-			{ continuationToken },
-		);
+		const page = await repo.listByState(accountConfigId, state, {
+			continuationToken,
+		});
 		items.push(...page.items);
 		continuationToken = page.continuationToken;
 	} while (continuationToken);
@@ -157,6 +156,10 @@ const listPending = async (
  * write would replace their acceptance with `Superseded` and blank the id of
  * the event it put in their calendar. A card answered in the gap keeps its
  * answer and is simply not reported as superseded.
+ *
+ * Every earlier revision already retired is pointed at this one too, so a
+ * card three revisions back opens the newest in one step rather than walking
+ * the chain a revision at a time.
  */
 export const recordCalendarSuggestion = async (
 	repo: ICalendarSuggestionRepository,
@@ -174,21 +177,47 @@ export const recordCalendarSuggestion = async (
 		...projection.value,
 	});
 
-	const stale = (await listPending(repo, input.accountConfigId)).filter(
-		(candidate) =>
-			candidate.icalUid === suggestion.icalUid &&
-			candidate.suggestionId !== suggestion.suggestionId &&
-			candidate.sequence < suggestion.sequence,
-	);
+	const olderRevision = (candidate: CalendarSuggestionItem): boolean =>
+		candidate.icalUid === suggestion.icalUid &&
+		candidate.suggestionId !== suggestion.suggestionId &&
+		candidate.sequence < suggestion.sequence;
+
+	const stale = (
+		await listInState(
+			repo,
+			input.accountConfigId,
+			CalendarSuggestionState.Pending,
+		)
+	).filter(olderRevision);
 
 	const superseded: CalendarSuggestionItem[] = [];
 	for (const candidate of stale) {
 		const retired = await repo.supersedeIfPending(
 			input.accountConfigId,
 			candidate.suggestionId,
+			suggestion.messageId,
 		);
 		if (retired) superseded.push(retired);
 	}
 
+	const retiredEarlier = (
+		await listInState(
+			repo,
+			input.accountConfigId,
+			CalendarSuggestionState.Superseded,
+		)
+	).filter(
+		(candidate) =>
+			olderRevision(candidate) &&
+			candidate.supersededByMessageId !== suggestion.messageId,
+	);
+	for (const candidate of retiredEarlier) {
+		await repo.repointSuperseded(
+			input.accountConfigId,
+			candidate.suggestionId,
+			suggestion.messageId,
+		);
+	}
+
 	return { ok: true, value: { suggestion, superseded } };
 };