@remit/calendar-service 0.0.13 → 0.0.15

package/package.json

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

@@ -0,0 +1,173 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { CalendarSuggestionItem } from "@remit/data-ports";
+import {
+	CalendarInviteAnswer,
+	CalendarSuggestionSource,
+	CalendarSuggestionState,
+	ZoneCertainty,
+} from "@remit/domain-enums";
+import { acceptCalendarSuggestion } from "./accept.js";
+import type { CalendarEventFields } from "./build.js";
+import { correctCalendarSuggestion } from "./correct.js";
+import { ical } from "./fixtures.js";
+import { MemoryCalendarStore } from "./memory-store.js";
+import { provisionDefaultCalendar } from "./put.js";
+import { recordCalendarSuggestion } from "./suggest.js";
+
+const ACCOUNT_CONFIG_ID = "account-config-1";
+const ATTENDEE = "user@example.test";
+const UID = "invite-5120@example.test";
+
+const invitation = ({
+	method = "REQUEST",
+	start = "DTSTART:20260901T080000Z",
+	end = "DTEND:20260901T090000Z",
+}: {
+	method?: string;
+	start?: string;
+	end?: string;
+}): string =>
+	ical(
+		"BEGIN:VCALENDAR",
+		"VERSION:2.0",
+		"PRODID:-//Example Corp//Scheduler//EN",
+		`METHOD:${method}`,
+		"BEGIN:VEVENT",
+		`UID:${UID}`,
+		"DTSTAMP:20260801T090000Z",
+		"SEQUENCE:2",
+		start,
+		end,
+		"SUMMARY:Quarterly review",
+		"LOCATION:Room 4",
+		"ORGANIZER:mailto:organizer@example.test",
+		"ATTENDEE;PARTSTAT=NEEDS-ACTION:mailto:user@example.test",
+		"X-EXAMPLE-TICKET:AB-5120",
+		"END:VEVENT",
+		"END:VCALENDAR",
+	);
+
+const pendingIn = async (icalData: string) => {
+	const store = new MemoryCalendarStore();
+	const collection = await provisionDefaultCalendar(store, ACCOUNT_CONFIG_ID);
+	const recorded = await recordCalendarSuggestion(store.calendarSuggestion, {
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		messageId: "message-1",
+		bodyPartId: "body-part-1",
+		source: CalendarSuggestionSource.IcalendarPart,
+		icalData,
+		timezone: "UTC",
+	});
+	assert.ok(recorded.ok);
+	return {
+		store,
+		calendarId: collection.calendarId,
+		suggestion: recorded.value.suggestion,
+	};
+};
+
+const acceptCorrected = async (
+	store: MemoryCalendarStore,
+	calendarId: string,
+	suggestion: CalendarSuggestionItem,
+	patch: Partial<CalendarEventFields>,
+) => {
+	const corrected = await correctCalendarSuggestion(suggestion, patch, "UTC");
+	if (!corrected.ok) return corrected;
+	return acceptCalendarSuggestion(store, {
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		calendarId,
+		suggestion: corrected.value,
+		attendee: ATTENDEE,
+		answer: CalendarInviteAnswer.Accepted,
+	});
+};
+
+describe("correctCalendarSuggestion", () => {
+	it("writes the corrected event and settles the card as accepted", async () => {
+		const { store, calendarId, suggestion } = await pendingIn(invitation({}));
+
+		const accepted = await acceptCorrected(store, calendarId, suggestion, {
+			summary: "Quarterly review, moved",
+			start: "2026-09-01T13:00:00+00:00",
+			end: "2026-09-01T14:30:00+00:00",
+			allDay: false,
+			timeZone: "",
+		});
+
+		assert.ok(accepted.ok);
+		const object = accepted.value.object;
+		assert.ok(object);
+		assert.equal(object.summary, "Quarterly review, moved");
+		assert.equal(Date.parse(object.dtStart), Date.parse("2026-09-01T13:00Z"));
+		assert.equal(Date.parse(object.dtEnd), Date.parse("2026-09-01T14:30Z"));
+		assert.equal(object.icalUid, UID);
+		assert.match(object.icalData, /LOCATION:Room 4/);
+		assert.match(object.icalData, /X-EXAMPLE-TICKET:AB-5120/);
+		assert.match(object.icalData, /PARTSTAT=ACCEPTED/);
+
+		const settled = await store.calendarSuggestion.get(
+			ACCOUNT_CONFIG_ID,
+			suggestion.suggestionId,
+		);
+		assert.equal(settled.state, CalendarSuggestionState.Accepted);
+		assert.equal(settled.acceptedCalendarObjectId, object.calendarObjectId);
+	});
+
+	it("places an unresolvable zone on the clock the reader picked", async () => {
+		const { store, calendarId, suggestion } = await pendingIn(
+			invitation({
+				start: "DTSTART;TZID=Nowhere Standard Time:20260901T090000",
+				end: "DTEND;TZID=Nowhere Standard Time:20260901T100000",
+			}),
+		);
+		assert.equal(suggestion.zoneCertainty, ZoneCertainty.Ambiguous);
+
+		const accepted = await acceptCorrected(store, calendarId, suggestion, {
+			start: "2026-09-01T09:00:00+02:00",
+			end: "2026-09-01T10:00:00+02:00",
+			allDay: false,
+			timeZone: "Europe/Amsterdam",
+		});
+
+		assert.ok(accepted.ok);
+		const object = accepted.value.object;
+		assert.ok(object);
+		assert.equal(object.zoneCertainty, ZoneCertainty.Explicit);
+		assert.equal(Date.parse(object.dtStart), Date.parse("2026-09-01T07:00Z"));
+		assert.match(
+			object.icalData,
+			/DTSTART;TZID=Europe\/Amsterdam:20260901T090000/,
+		);
+	});
+
+	it("refuses a cancellation and leaves the card waiting", async () => {
+		const { store, calendarId, suggestion } = await pendingIn(
+			invitation({ method: "CANCEL" }),
+		);
+
+		const refused = await acceptCorrected(store, calendarId, suggestion, {
+			summary: "Anything",
+		});
+
+		assert.equal(refused.ok, false);
+		assert.equal(store.objects.size, 0);
+		const untouched = await store.calendarSuggestion.get(
+			ACCOUNT_CONFIG_ID,
+			suggestion.suggestionId,
+		);
+		assert.equal(untouched.state, CalendarSuggestionState.Pending);
+	});
+
+	it("refuses a correction the event cannot take and writes nothing", async () => {
+		const { store, calendarId, suggestion } = await pendingIn(invitation({}));
+
+		const refused = await acceptCorrected(store, calendarId, suggestion, {
+			start: "2026-09-01T13:00:00",
+		});
+
+		assert.equal(refused.ok, false);
+		assert.equal(store.objects.size, 0);
+	});
+});

package/src/correct.ts

@@ -0,0 +1,40 @@
+import type { CalendarSuggestionItem } from "@remit/data-ports";
+import { CalendarInviteMethod, RecurrenceScope } from "@remit/domain-enums";
+import type { CalendarEventFields } from "./build.js";
+import { type CalendarResult, calendarFailure } from "./errors.js";
+import { parseCalendar } from "./parse.js";
+import { applyScopedUpdate } from "./scope.js";
+
+export const correctCalendarSuggestion = async (
+	suggestion: CalendarSuggestionItem,
+	patch: Partial<CalendarEventFields>,
+	collectionTimezone: string,
+): Promise<CalendarResult<CalendarSuggestionItem>> => {
+	if (suggestion.method === CalendarInviteMethod.Cancel) {
+		return calendarFailure(
+			"UneditableCancellation",
+			"a cancellation names no event to correct — add it or dismiss it as it is",
+		);
+	}
+
+	const parsed = await parseCalendar(suggestion.icalData);
+	if (!parsed.ok) return parsed;
+
+	const edited = await applyScopedUpdate(
+		parsed.value,
+		collectionTimezone,
+		{ scope: RecurrenceScope.All, recurrenceId: "", followingUid: "" },
+		patch,
+	);
+	if (!edited.ok) return edited;
+	if (edited.value.kind !== "Replace") {
+		throw new Error(
+			`an edit to the whole invitation resolved to a ${edited.value.kind}`,
+		);
+	}
+
+	return {
+		ok: true,
+		value: { ...suggestion, icalData: edited.value.icalData },
+	};
+};

package/src/errors.ts

@@ -36,6 +36,7 @@ export type CalendarValidationCode =
 	/** A RECURRENCE-ID naming no occurrence this series produces. */
 	| "UnknownOccurrence"
 	| "UnmovableRecurrenceRule"
+	| "UneditableCancellation"
 	/** A subscription address that is not an http, https or webcal URL. */
 	| "InvalidSubscriptionUrl";
 

package/src/index.ts

@@ -14,6 +14,7 @@ export {
 	readEventTime,
 	readRecurrenceRule,
 } from "./build.js";
+export { correctCalendarSuggestion } from "./correct.js";
 export type {
 	CalendarResult,
 	CalendarValidationCode,

package/src/memory-store.ts

@@ -236,6 +236,7 @@ export class MemoryCalendarStore implements ICalendarUnitOfWork {
 				suggestionId,
 				state: existing?.state ?? CalendarSuggestionState.Pending,
 				acceptedCalendarObjectId: existing?.acceptedCalendarObjectId ?? "",
+				supersededByMessageId: existing?.supersededByMessageId ?? "",
 				createdAt: existing?.createdAt ?? now,
 				updatedAt: now,
 			};
@@ -282,6 +283,7 @@ export class MemoryCalendarStore implements ICalendarUnitOfWork {
 		supersedeIfPending: async (
 			accountConfigId: string,
 			suggestionId: string,
+			supersededByMessageId: string,
 		) => {
 			const suggestion = this.suggestions.get(suggestionId);
 			if (
@@ -295,11 +297,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/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 } };
 };