@remit/calendar-service 0.0.17 → 0.0.19

package/src/memory-store.ts

@@ -1,404 +0,0 @@
-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,
-				subscriptionUrl: input.subscriptionUrl ?? "",
-				subscriptionEnabled: input.subscriptionEnabled ?? false,
-				subscriptionCheckedAt: 0,
-				subscriptionFetchedAt: 0,
-				subscriptionError: "",
-				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);
-		},
-		listEnabledSubscriptions: async () =>
-			[...this.collections.values()].filter(
-				(collection) =>
-					collection.source === "Subscribed" && collection.subscriptionEnabled,
-			),
-		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,
-		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,
-			),
-		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 ?? "",
-				supersededByMessageId: existing?.supersededByMessageId ?? "",
-				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;
-		},
-		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) =>
-					suggestion.accountConfigId === accountConfigId &&
-					suggestion.messageId === messageId,
-			),
-		listByState: async (
-			accountConfigId: string,
-			state: CalendarSuggestionItem["state"],
-			options: {
-				endsAfter: string;
-				limit?: number;
-				continuationToken?: string;
-			},
-		) => ({
-			items: [...this.suggestions.values()].filter(
-				(suggestion) =>
-					suggestion.accountConfigId === accountConfigId &&
-					suggestion.state === state &&
-					suggestion.endsAtUtc >= options.endsAfter,
-			),
-			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,
-			supersededByMessageId: 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: "",
-				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 = {
-		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

@@ -1,264 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { asLf, ical, singleEvent } from "./fixtures.js";
-import { parseCalendar, serializeCalendar } from "./parse.js";
-
-const parsed = async (icalData: string) => {
-	const result = await parseCalendar(icalData);
-	assert.ok(result.ok, `expected a parse, got ${JSON.stringify(result)}`);
-	return result.value;
-};
-
-const refusalCode = async (icalData: string) => {
-	const result = await parseCalendar(icalData);
-	assert.ok(!result.ok, "expected a refusal");
-	return result.error;
-};
-
-describe("parseCalendar", () => {
-	it("reads the master event and its UID", async () => {
-		const calendar = await parsed(
-			singleEvent("DTSTART:20260826T090000Z", "DTEND:20260826T100000Z"),
-		);
-
-		assert.equal(calendar.uid, "fixture@example.com");
-		assert.equal(calendar.master.name, "vevent");
-		assert.deepEqual(calendar.overrides, []);
-	});
-
-	it("separates the overrides from the master", async () => {
-		const calendar = await parsed(
-			ical(
-				"BEGIN:VCALENDAR",
-				"VERSION:2.0",
-				"BEGIN:VEVENT",
-				"UID:series@example.com",
-				"DTSTART:20260826T090000Z",
-				"RRULE:FREQ=WEEKLY;COUNT=3",
-				"END:VEVENT",
-				"BEGIN:VEVENT",
-				"UID:series@example.com",
-				"RECURRENCE-ID:20260902T090000Z",
-				"DTSTART:20260902T110000Z",
-				"END:VEVENT",
-				"END:VCALENDAR",
-			),
-		);
-
-		assert.equal(calendar.overrides.length, 1);
-		assert.ok(!calendar.master.hasProperty("recurrence-id"));
-	});
-
-	it("refuses bytes that are not iCalendar", async () => {
-		assert.equal(
-			(await refusalCode("this is not a calendar")).code,
-			"MalformedIcalendar",
-		);
-	});
-
-	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(
-			(
-				await refusalCode(
-					ical("BEGIN:VCARD", "VERSION:4.0", "FN:Someone", "END:VCARD"),
-				)
-			).code,
-			"NotACalendar",
-		);
-	});
-
-	it("refuses a component this collection does not store, naming it", async () => {
-		const error = await refusalCode(
-			ical(
-				"BEGIN:VCALENDAR",
-				"VERSION:2.0",
-				"BEGIN:VTODO",
-				"UID:todo@example.com",
-				"SUMMARY:Buy milk",
-				"END:VTODO",
-				"END:VCALENDAR",
-			),
-		);
-
-		assert.equal(error.code, "UnsupportedComponent");
-		assert.match(error.message, /VTODO/);
-	});
-
-	it("refuses a VCALENDAR with no VEVENT", async () => {
-		assert.equal(
-			(
-				await refusalCode(
-					ical("BEGIN:VCALENDAR", "VERSION:2.0", "END:VCALENDAR"),
-				)
-			).code,
-			"NoEvent",
-		);
-	});
-
-	it("refuses overrides with no event to override", async () => {
-		const error = await refusalCode(
-			ical(
-				"BEGIN:VCALENDAR",
-				"VERSION:2.0",
-				"BEGIN:VEVENT",
-				"UID:orphan@example.com",
-				"RECURRENCE-ID:20260902T090000Z",
-				"DTSTART:20260902T110000Z",
-				"END:VEVENT",
-				"END:VCALENDAR",
-			),
-		);
-
-		assert.equal(error.code, "NoMasterEvent");
-	});
-
-	it("refuses two unrelated events in one resource", async () => {
-		const error = await refusalCode(
-			ical(
-				"BEGIN:VCALENDAR",
-				"VERSION:2.0",
-				"BEGIN:VEVENT",
-				"UID:one@example.com",
-				"DTSTART:20260826T090000Z",
-				"END:VEVENT",
-				"BEGIN:VEVENT",
-				"UID:two@example.com",
-				"DTSTART:20260827T090000Z",
-				"END:VEVENT",
-				"END:VCALENDAR",
-			),
-		);
-
-		assert.equal(error.code, "MultipleMasterEvents");
-	});
-
-	it("refuses a VEVENT with no UID", async () => {
-		const error = await refusalCode(
-			ical(
-				"BEGIN:VCALENDAR",
-				"VERSION:2.0",
-				"BEGIN:VEVENT",
-				"DTSTART:20260826T090000Z",
-				"END:VEVENT",
-				"END:VCALENDAR",
-			),
-		);
-
-		assert.equal(error.code, "MissingUid");
-	});
-
-	it("refuses an override that belongs to a different event", async () => {
-		const error = await refusalCode(
-			ical(
-				"BEGIN:VCALENDAR",
-				"VERSION:2.0",
-				"BEGIN:VEVENT",
-				"UID:series@example.com",
-				"DTSTART:20260826T090000Z",
-				"RRULE:FREQ=WEEKLY;COUNT=3",
-				"END:VEVENT",
-				"BEGIN:VEVENT",
-				"UID:stranger@example.com",
-				"RECURRENCE-ID:20260902T090000Z",
-				"DTSTART:20260902T110000Z",
-				"END:VEVENT",
-				"END:VCALENDAR",
-			),
-		);
-
-		assert.equal(error.code, "MismatchedUid");
-	});
-
-	it("refuses a VEVENT with no DTSTART", async () => {
-		assert.equal(
-			(await refusalCode(singleEvent("SUMMARY:Undated"))).code,
-			"MissingDtStart",
-		);
-	});
-});
-
-describe("serializeCalendar", () => {
-	it("keeps the line endings RFC 5545 requires", async () => {
-		const source = singleEvent(
-			"DTSTART:20260826T090000Z",
-			"DTEND:20260826T100000Z",
-		);
-
-		const serialized = serializeCalendar((await parsed(source)).component);
-
-		assert.ok(serialized.includes("\r\n"));
-		assert.doesNotMatch(
-			serialized,
-			/(?<!\r)\n/,
-			"every line break is a CRLF, with no bare LF left behind",
-		);
-	});
-
-	it("reads an LF-only resource and writes it back as CRLF", async () => {
-		// RFC 5545 says CRLF; real files arrive both ways, and a parser that only
-		// recognises CRLF reads an LF-only resource as one enormous line.
-		const source = asLf(
-			singleEvent("DTSTART:20260826T090000Z", "DTEND:20260826T100000Z"),
-		);
-		assert.ok(!source.includes("\r"), "the fixture is LF-only");
-
-		const calendar = await parsed(source);
-		const serialized = serializeCalendar(calendar.component);
-
-		assert.equal(calendar.uid, "fixture@example.com");
-		assert.ok(calendar.master.hasProperty("dtstart"));
-		assert.doesNotMatch(serialized, /(?<!\r)\n/);
-	});
-
-	it("round-trips a resource losslessly, unknown properties included", async () => {
-		const source = singleEvent(
-			"DTSTART:20260826T090000Z",
-			"DTEND:20260826T100000Z",
-			"SUMMARY:Quarterly review",
-			"X-APPLE-TRAVEL-ADVISORY-BEHAVIOR:AUTOMATIC",
-			"X-MICROSOFT-CDO-BUSYSTATUS:BUSY",
-			"ATTENDEE;CN=Someone;X-NUM-GUESTS=0:mailto:someone@example.com",
-		);
-
-		const once = serializeCalendar((await parsed(source)).component);
-		const twice = serializeCalendar((await parsed(once)).component);
-
-		assert.equal(twice, once);
-		for (const line of [
-			"X-APPLE-TRAVEL-ADVISORY-BEHAVIOR:AUTOMATIC",
-			"X-MICROSOFT-CDO-BUSYSTATUS:BUSY",
-			"X-NUM-GUESTS=0",
-			"SUMMARY:Quarterly review",
-		]) {
-			assert.ok(once.includes(line), `${line} did not survive the round trip`);
-		}
-	});
-
-	it("keeps a whole unknown subcomponent of the event", async () => {
-		const source = singleEvent(
-			"DTSTART:20260826T090000Z",
-			"DTEND:20260826T100000Z",
-			"BEGIN:VALARM",
-			"ACTION:DISPLAY",
-			"DESCRIPTION:Reminder",
-			"TRIGGER:-PT15M",
-			"END:VALARM",
-		);
-
-		const serialized = serializeCalendar((await parsed(source)).component);
-
-		assert.ok(serialized.includes("BEGIN:VALARM"));
-		assert.ok(serialized.includes("TRIGGER:-PT15M"));
-	});
-});