@remit/calendar-service 0.0.2 → 0.0.4

package/src/memory-store.ts

@@ -0,0 +1,350 @@
+import type {
+	CalendarCollectionItem,
+	CalendarEventIndexItem,
+	CalendarFeedTokenItem,
+	CalendarObjectItem,
+	CalendarOccurrenceInput,
+	CalendarSuggestionItem,
+	CreateCalendarCollectionInput,
+	ICalendarCollectionRepository,
+	ICalendarEventIndexRepository,
+	ICalendarFeedTokenRepository,
+	ICalendarObjectRepository,
+	ICalendarSuggestionRepository,
+	ICalendarUnitOfWork,
+	PutCalendarFeedTokenInput,
+	PutCalendarObjectInput as PutCalendarObjectRow,
+	PutCalendarSuggestionInput,
+	SettleCalendarSuggestionInput,
+	UpdateCalendarCollectionInput,
+} from "@remit/data-ports";
+import { NotFoundError } from "@remit/data-ports/errors";
+import {
+	deriveCalendarFeedTokenId,
+	deriveCalendarId,
+	deriveCalendarObjectId,
+	deriveCalendarSuggestionId,
+	normalizeCalendarUrlSegment,
+} from "@remit/data-ports/id";
+import { CalendarSuggestionState } from "@remit/domain-enums";
+
+// The class the port's conformance suite requires a repository to throw for an
+// absent row, so a caller that branches on it — the calendar feed answers 404 to
+// a token whose collection is gone — behaves the same against this double as
+// against a real one.
+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
+ * drizzle-service's calendar-put.sqlite.test.ts.
+ */
+export class MemoryCalendarStore implements ICalendarUnitOfWork {
+	readonly collections = new Map<string, CalendarCollectionItem>();
+	readonly objects = new Map<string, CalendarObjectItem>();
+	readonly occurrences = new Map<string, CalendarEventIndexItem[]>();
+	readonly suggestions = new Map<string, CalendarSuggestionItem>();
+	readonly feedTokens = new Map<string, CalendarFeedTokenItem>();
+
+	private readonly collectionRepo: ICalendarCollectionRepository = {
+		create: async (input: CreateCalendarCollectionInput) => {
+			const urlSegment = normalizeCalendarUrlSegment(input.urlSegment);
+			const calendarId = deriveCalendarId(input.accountConfigId, urlSegment);
+			const existing = this.collections.get(calendarId);
+			if (existing) return existing;
+			const now = Date.now();
+			const collection: CalendarCollectionItem = {
+				calendarId,
+				accountConfigId: input.accountConfigId,
+				urlSegment,
+				displayName: input.displayName,
+				color: input.color ?? "Cal1",
+				componentSet: input.componentSet ?? "VeventOnly",
+				source: input.source ?? "UserCreated",
+				timezone: input.timezone ?? "",
+				syncSequence: 0,
+				createdAt: now,
+				updatedAt: now,
+			};
+			this.collections.set(calendarId, collection);
+			return collection;
+		},
+		get: async (_accountConfigId: string, calendarId: string) => {
+			const collection = this.collections.get(calendarId);
+			if (!collection) throw new MissingRow(calendarId);
+			return collection;
+		},
+		update: async (
+			_accountConfigId: string,
+			calendarId: string,
+			input: UpdateCalendarCollectionInput,
+		) => {
+			const collection = this.collections.get(calendarId);
+			if (!collection) throw new MissingRow(calendarId);
+			const updated = { ...collection, ...input };
+			this.collections.set(calendarId, updated);
+			return updated;
+		},
+		delete: async (_accountConfigId: string, calendarId: string) => {
+			this.collections.delete(calendarId);
+		},
+		listByAccountConfig: async (accountConfigId: string) =>
+			[...this.collections.values()].filter(
+				(collection) => collection.accountConfigId === accountConfigId,
+			),
+		createExclusive: async (input: CreateCalendarCollectionInput) => {
+			const calendarId = deriveCalendarId(
+				input.accountConfigId,
+				input.urlSegment,
+			);
+			if (this.collections.has(calendarId)) return null;
+			return this.collectionRepo.create(input);
+		},
+		findByUrlSegment: async (accountConfigId: string, urlSegment: string) =>
+			this.collections.get(deriveCalendarId(accountConfigId, urlSegment)) ??
+			null,
+		bumpSyncSequence: async (_accountConfigId: string, calendarId: string) => {
+			const collection = this.collections.get(calendarId);
+			if (!collection) throw new MissingRow(calendarId);
+			const bumped = {
+				...collection,
+				syncSequence: collection.syncSequence + 1,
+				updatedAt: Date.now(),
+			};
+			this.collections.set(calendarId, bumped);
+			return bumped.syncSequence;
+		},
+	};
+
+	private readonly objectRepo: ICalendarObjectRepository = {
+		put: async (input: PutCalendarObjectRow) => {
+			const calendarObjectId = deriveCalendarObjectId(
+				input.calendarId,
+				input.resourceName,
+			);
+			const now = Date.now();
+			const object: CalendarObjectItem = {
+				...input,
+				calendarObjectId,
+				createdAt: this.objects.get(calendarObjectId)?.createdAt ?? now,
+				updatedAt: now,
+			};
+			this.objects.set(calendarObjectId, object);
+			return object;
+		},
+		listIncompleteExpansions: async (calendarId: string, instant: string) =>
+			[...this.objects.values()].filter(
+				(object) =>
+					object.calendarId === calendarId &&
+					object.expandedThrough !== "" &&
+					object.expandedThrough < instant,
+			),
+		find: async (_calendarId: string, calendarObjectId: string) =>
+			this.objects.get(calendarObjectId) ?? null,
+		get: async (_calendarId: string, calendarObjectId: string) => {
+			const object = this.objects.get(calendarObjectId);
+			if (!object) throw new MissingRow(calendarObjectId);
+			return object;
+		},
+		delete: async (_calendarId: string, calendarObjectId: string) => {
+			this.objects.delete(calendarObjectId);
+		},
+		findByResourceName: async (calendarId: string, resourceName: string) =>
+			this.objects.get(deriveCalendarObjectId(calendarId, resourceName)) ??
+			null,
+		findByUid: async (calendarId: string, icalUid: string) =>
+			[...this.objects.values()].find(
+				(object) =>
+					object.calendarId === calendarId && object.icalUid === icalUid,
+			) ?? null,
+		listByCalendar: async (calendarId: string) =>
+			[...this.objects.values()].filter(
+				(object) => object.calendarId === calendarId,
+			),
+		listChangedSince: async (calendarId: string, syncSequence: number) =>
+			[...this.objects.values()]
+				.filter(
+					(object) =>
+						object.calendarId === calendarId &&
+						object.syncSequence > syncSequence,
+				)
+				.sort((left, right) => left.syncSequence - right.syncSequence),
+	};
+
+	private readonly eventIndexRepo: ICalendarEventIndexRepository = {
+		replaceForObject: async (
+			calendarId: string,
+			calendarObjectId: string,
+			occurrences: CalendarOccurrenceInput[],
+		) => {
+			const now = Date.now();
+			this.occurrences.set(
+				calendarObjectId,
+				occurrences.map((occurrence) => ({
+					...occurrence,
+					calendarId,
+					calendarObjectId,
+					createdAt: now,
+					updatedAt: now,
+				})),
+			);
+		},
+		deleteForObject: async (_calendarId: string, calendarObjectId: string) => {
+			this.occurrences.delete(calendarObjectId);
+		},
+		listForObject: async (_calendarId: string, calendarObjectId: string) =>
+			this.occurrences.get(calendarObjectId) ?? [],
+		listByStartRange: async (
+			calendarId: string,
+			startAt: string,
+			endAt: string,
+		) =>
+			[...this.occurrences.values()]
+				.flat()
+				.filter(
+					(row) =>
+						row.calendarId === calendarId &&
+						row.startAt >= startAt &&
+						row.startAt < endAt,
+				)
+				.sort((left, right) => left.startAt.localeCompare(right.startAt)),
+	};
+
+	private readonly suggestionRepo: ICalendarSuggestionRepository = {
+		put: async (input: PutCalendarSuggestionInput) => {
+			const suggestionId = deriveCalendarSuggestionId(
+				input.messageId,
+				input.bodyPartId,
+				input.icalUid,
+			);
+			const now = Date.now();
+			const existing = this.suggestions.get(suggestionId);
+			const suggestion: CalendarSuggestionItem = {
+				...input,
+				suggestionId,
+				state: existing?.state ?? CalendarSuggestionState.Pending,
+				acceptedCalendarObjectId: existing?.acceptedCalendarObjectId ?? "",
+				createdAt: existing?.createdAt ?? now,
+				updatedAt: now,
+			};
+			this.suggestions.set(suggestionId, suggestion);
+			return suggestion;
+		},
+		get: async (accountConfigId: string, suggestionId: string) => {
+			const suggestion = this.suggestions.get(suggestionId);
+			if (!suggestion || suggestion.accountConfigId !== accountConfigId) {
+				throw new MissingRow(suggestionId);
+			}
+			return suggestion;
+		},
+		listByMessage: async (accountConfigId: string, messageId: string) =>
+			[...this.suggestions.values()].filter(
+				(suggestion) =>
+					suggestion.accountConfigId === accountConfigId &&
+					suggestion.messageId === messageId,
+			),
+		listByState: async (
+			accountConfigId: string,
+			state: CalendarSuggestionItem["state"],
+		) => ({
+			items: [...this.suggestions.values()].filter(
+				(suggestion) =>
+					suggestion.accountConfigId === accountConfigId &&
+					suggestion.state === state,
+			),
+			continuationToken: undefined,
+		}),
+		settle: async (
+			accountConfigId: string,
+			suggestionId: string,
+			input: SettleCalendarSuggestionInput,
+		) => {
+			const suggestion = this.suggestions.get(suggestionId);
+			if (!suggestion || suggestion.accountConfigId !== accountConfigId) {
+				throw new MissingRow(suggestionId);
+			}
+			const settled = { ...suggestion, ...input, updatedAt: Date.now() };
+			this.suggestions.set(suggestionId, settled);
+			return settled;
+		},
+		supersedeIfPending: async (
+			accountConfigId: string,
+			suggestionId: string,
+		) => {
+			const suggestion = this.suggestions.get(suggestionId);
+			if (
+				!suggestion ||
+				suggestion.accountConfigId !== accountConfigId ||
+				suggestion.state !== CalendarSuggestionState.Pending
+			) {
+				return null;
+			}
+			const retired = {
+				...suggestion,
+				state: CalendarSuggestionState.Superseded,
+				acceptedCalendarObjectId: "",
+				updatedAt: Date.now(),
+			};
+			this.suggestions.set(suggestionId, retired);
+			return retired;
+		},
+	};
+
+	private readonly feedTokenRepo: ICalendarFeedTokenRepository = {
+		put: async (input: PutCalendarFeedTokenInput) => {
+			const feedTokenId = deriveCalendarFeedTokenId(input.calendarId);
+			const now = Date.now();
+			const existing = this.feedTokens.get(feedTokenId);
+			const token: CalendarFeedTokenItem = {
+				feedTokenId,
+				accountConfigId: input.accountConfigId,
+				calendarId: input.calendarId,
+				tokenHash: input.tokenHash,
+				createdAt: existing?.createdAt ?? now,
+				rotatedAt: existing ? now : 0,
+				updatedAt: now,
+			};
+			this.feedTokens.set(feedTokenId, token);
+			return token;
+		},
+		findByCalendar: async (accountConfigId: string, calendarId: string) => {
+			const token = this.feedTokens.get(deriveCalendarFeedTokenId(calendarId));
+			if (!token || token.accountConfigId !== accountConfigId) return null;
+			return token;
+		},
+		findByTokenHash: async (tokenHash: string) =>
+			[...this.feedTokens.values()].find(
+				(token) => token.tokenHash === tokenHash,
+			) ?? null,
+		delete: async (accountConfigId: string, calendarId: string) => {
+			const feedTokenId = deriveCalendarFeedTokenId(calendarId);
+			const token = this.feedTokens.get(feedTokenId);
+			if (!token || token.accountConfigId !== accountConfigId) return;
+			this.feedTokens.delete(feedTokenId);
+		},
+	};
+
+	get calendarSuggestion(): ICalendarSuggestionRepository {
+		return this.suggestionRepo;
+	}
+
+	transaction<T>(
+		fn: (repos: {
+			calendarCollection: ICalendarCollectionRepository;
+			calendarObject: ICalendarObjectRepository;
+			calendarEventIndex: ICalendarEventIndexRepository;
+			calendarSuggestion: ICalendarSuggestionRepository;
+			calendarFeedToken: ICalendarFeedTokenRepository;
+		}) => Promise<T>,
+	): Promise<T> {
+		return fn({
+			calendarCollection: this.collectionRepo,
+			calendarObject: this.objectRepo,
+			calendarEventIndex: this.eventIndexRepo,
+			calendarSuggestion: this.suggestionRepo,
+			calendarFeedToken: this.feedTokenRepo,
+		});
+	}
+}

package/src/parse.test.ts

@@ -56,6 +56,17 @@ describe("parseCalendar", () => {
 		);
 	});
 
+	it("refuses empty bytes as a value, naming nothing rather than crashing", async () => {
+		// A suggestion read out of prose carries no iCalendar at all, and the
+		// accept path reaches this with `""`. ical.js reads empty bytes as a
+		// component with no name, so naming what arrived would throw here — a
+		// crash on ordinary input rather than the refusal every caller renders.
+		const refusal = await refusalCode("");
+
+		assert.equal(refusal.code, "NotACalendar");
+		assert.match(refusal.message, /found nothing/);
+	});
+
 	it("refuses a document whose root is not a VCALENDAR", async () => {
 		assert.equal(
 			(

package/src/parse.ts

@@ -64,9 +64,15 @@ export const parseCalendar = async (
 	const component = read.value;
 
 	if (component.name !== "vcalendar") {
+		// A document with nothing in it names nothing: ical.js reads empty bytes
+		// as a component with no name at all, and a suggestion read out of prose
+		// carries exactly that. Naming what arrived is for a document that has a
+		// root to name.
 		return calendarFailure(
 			"NotACalendar",
-			`expected a VCALENDAR, found ${component.name.toUpperCase()}`,
+			component.name
+				? `expected a VCALENDAR, found ${component.name.toUpperCase()}`
+				: "expected a VCALENDAR, found nothing",
 		);
 	}
 

package/src/put.test.ts

@@ -1,25 +1,8 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import type {
-	CalendarCollectionItem,
-	CalendarEventIndexItem,
-	CalendarObjectItem,
-	CalendarOccurrenceInput,
-	CreateCalendarCollectionInput,
-	ICalendarCollectionRepository,
-	ICalendarEventIndexRepository,
-	ICalendarObjectRepository,
-	ICalendarUnitOfWork,
-	PutCalendarObjectInput as PutCalendarObjectRow,
-	UpdateCalendarCollectionInput,
-} from "@remit/data-ports";
-import {
-	deriveCalendarId,
-	deriveCalendarObjectId,
-	normalizeCalendarUrlSegment,
-} from "@remit/data-ports/id";
 import { computeEtag } from "./etag.js";
 import { asLf, singleEvent } from "./fixtures.js";
+import { MemoryCalendarStore, MissingRow } from "./memory-store.js";
 import { parseCalendar, serializeCalendar } from "./parse.js";
 import {
 	DEFAULT_CALENDAR_URL_SEGMENT,
@@ -28,198 +11,6 @@ import {
 	putCalendarObject,
 } from "./put.js";
 
-class MissingRow extends Error {}
-
-/**
- * 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
- * drizzle-service's calendar-put.sqlite.test.ts.
- */
-class MemoryCalendarStore implements ICalendarUnitOfWork {
-	readonly collections = new Map<string, CalendarCollectionItem>();
-	readonly objects = new Map<string, CalendarObjectItem>();
-	readonly occurrences = new Map<string, CalendarEventIndexItem[]>();
-
-	private readonly collectionRepo: ICalendarCollectionRepository = {
-		create: async (input: CreateCalendarCollectionInput) => {
-			const urlSegment = normalizeCalendarUrlSegment(input.urlSegment);
-			const calendarId = deriveCalendarId(input.accountConfigId, urlSegment);
-			const existing = this.collections.get(calendarId);
-			if (existing) return existing;
-			const now = Date.now();
-			const collection: CalendarCollectionItem = {
-				calendarId,
-				accountConfigId: input.accountConfigId,
-				urlSegment,
-				displayName: input.displayName,
-				color: input.color ?? "Cal1",
-				componentSet: input.componentSet ?? "VeventOnly",
-				source: input.source ?? "UserCreated",
-				timezone: input.timezone ?? "",
-				syncSequence: 0,
-				createdAt: now,
-				updatedAt: now,
-			};
-			this.collections.set(calendarId, collection);
-			return collection;
-		},
-		get: async (_accountConfigId: string, calendarId: string) => {
-			const collection = this.collections.get(calendarId);
-			if (!collection) throw new MissingRow(calendarId);
-			return collection;
-		},
-		update: async (
-			_accountConfigId: string,
-			calendarId: string,
-			input: UpdateCalendarCollectionInput,
-		) => {
-			const collection = this.collections.get(calendarId);
-			if (!collection) throw new MissingRow(calendarId);
-			const updated = { ...collection, ...input };
-			this.collections.set(calendarId, updated);
-			return updated;
-		},
-		delete: async (_accountConfigId: string, calendarId: string) => {
-			this.collections.delete(calendarId);
-		},
-		listByAccountConfig: async (accountConfigId: string) =>
-			[...this.collections.values()].filter(
-				(collection) => collection.accountConfigId === accountConfigId,
-			),
-		createExclusive: async (input: CreateCalendarCollectionInput) => {
-			const calendarId = deriveCalendarId(
-				input.accountConfigId,
-				input.urlSegment,
-			);
-			if (this.collections.has(calendarId)) return null;
-			return this.collectionRepo.create(input);
-		},
-		findByUrlSegment: async (accountConfigId: string, urlSegment: string) =>
-			this.collections.get(deriveCalendarId(accountConfigId, urlSegment)) ??
-			null,
-		bumpSyncSequence: async (_accountConfigId: string, calendarId: string) => {
-			const collection = this.collections.get(calendarId);
-			if (!collection) throw new MissingRow(calendarId);
-			const bumped = {
-				...collection,
-				syncSequence: collection.syncSequence + 1,
-			};
-			this.collections.set(calendarId, bumped);
-			return bumped.syncSequence;
-		},
-	};
-
-	private readonly objectRepo: ICalendarObjectRepository = {
-		put: async (input: PutCalendarObjectRow) => {
-			const calendarObjectId = deriveCalendarObjectId(
-				input.calendarId,
-				input.resourceName,
-			);
-			const now = Date.now();
-			const object: CalendarObjectItem = {
-				...input,
-				calendarObjectId,
-				createdAt: this.objects.get(calendarObjectId)?.createdAt ?? now,
-				updatedAt: now,
-			};
-			this.objects.set(calendarObjectId, object);
-			return object;
-		},
-		listIncompleteExpansions: async (calendarId: string, instant: string) =>
-			[...this.objects.values()].filter(
-				(object) =>
-					object.calendarId === calendarId &&
-					object.expandedThrough !== "" &&
-					object.expandedThrough < instant,
-			),
-		find: async (_calendarId: string, calendarObjectId: string) =>
-			this.objects.get(calendarObjectId) ?? null,
-		get: async (_calendarId: string, calendarObjectId: string) => {
-			const object = this.objects.get(calendarObjectId);
-			if (!object) throw new MissingRow(calendarObjectId);
-			return object;
-		},
-		delete: async (_calendarId: string, calendarObjectId: string) => {
-			this.objects.delete(calendarObjectId);
-		},
-		findByResourceName: async (calendarId: string, resourceName: string) =>
-			this.objects.get(deriveCalendarObjectId(calendarId, resourceName)) ??
-			null,
-		findByUid: async (calendarId: string, icalUid: string) =>
-			[...this.objects.values()].find(
-				(object) =>
-					object.calendarId === calendarId && object.icalUid === icalUid,
-			) ?? null,
-		listByCalendar: async (calendarId: string) =>
-			[...this.objects.values()].filter(
-				(object) => object.calendarId === calendarId,
-			),
-		listChangedSince: async (calendarId: string, syncSequence: number) =>
-			[...this.objects.values()]
-				.filter(
-					(object) =>
-						object.calendarId === calendarId &&
-						object.syncSequence > syncSequence,
-				)
-				.sort((left, right) => left.syncSequence - right.syncSequence),
-	};
-
-	private readonly eventIndexRepo: ICalendarEventIndexRepository = {
-		replaceForObject: async (
-			calendarId: string,
-			calendarObjectId: string,
-			occurrences: CalendarOccurrenceInput[],
-		) => {
-			const now = Date.now();
-			this.occurrences.set(
-				calendarObjectId,
-				occurrences.map((occurrence) => ({
-					...occurrence,
-					calendarId,
-					calendarObjectId,
-					createdAt: now,
-					updatedAt: now,
-				})),
-			);
-		},
-		deleteForObject: async (_calendarId: string, calendarObjectId: string) => {
-			this.occurrences.delete(calendarObjectId);
-		},
-		listForObject: async (_calendarId: string, calendarObjectId: string) =>
-			this.occurrences.get(calendarObjectId) ?? [],
-		listByStartRange: async (
-			calendarId: string,
-			startAt: string,
-			endAt: string,
-		) =>
-			[...this.occurrences.values()]
-				.flat()
-				.filter(
-					(row) =>
-						row.calendarId === calendarId &&
-						row.startAt >= startAt &&
-						row.startAt < endAt,
-				)
-				.sort((left, right) => left.startAt.localeCompare(right.startAt)),
-	};
-
-	transaction<T>(
-		fn: (repos: {
-			calendarCollection: ICalendarCollectionRepository;
-			calendarObject: ICalendarObjectRepository;
-			calendarEventIndex: ICalendarEventIndexRepository;
-		}) => Promise<T>,
-	): Promise<T> {
-		return fn({
-			calendarCollection: this.collectionRepo,
-			calendarObject: this.objectRepo,
-			calendarEventIndex: this.eventIndexRepo,
-		});
-	}
-}
-
 const ACCOUNT_CONFIG_ID = "account-config-1";
 
 const provisioned = async (): Promise<{