@remit/calendar-service 0.0.18 → 0.0.19

package/src/memory-store.ts

@@ -1,485 +0,0 @@
-import type {
-	CalendarCollectionItem,
-	CalendarEventIndexItem,
-	CalendarFeedTokenItem,
-	CalendarObjectItem,
-	CalendarOccurrenceInput,
-	CalendarRepositories,
-	CalendarSuggestionItem,
-	CalendarWrite,
-	CreateCalendarCollectionInput,
-	ICalendarCollectionRepository,
-	ICalendarEventIndexRepository,
-	ICalendarFeedTokenRepository,
-	ICalendarObjectRepository,
-	ICalendarStore,
-	ICalendarSuggestionRepository,
-	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 {}
-
-/**
- * The calendar store over plain maps. A commit applies its writes in order;
- * that they stand or fall together on a real database is proven in
- * drizzle-service's calendar-put.sqlite.test.ts.
- */
-export class MemoryCalendarStore implements ICalendarStore {
-	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;
-	}
-
-	get repos(): CalendarRepositories {
-		return {
-			calendarCollection: this.collectionRepo,
-			calendarObject: this.objectRepo,
-			calendarEventIndex: this.eventIndexRepo,
-			calendarSuggestion: this.suggestionRepo,
-			calendarFeedToken: this.feedTokenRepo,
-		};
-	}
-
-	async commit(writes: readonly CalendarWrite[]): Promise<void> {
-		for (const write of writes) await this.apply(write);
-	}
-
-	private async apply(write: CalendarWrite): Promise<void> {
-		switch (write.kind) {
-			case "PutObject": {
-				const { calendarId } = write.object;
-				const syncSequence = await this.collectionRepo.bumpSyncSequence(
-					write.accountConfigId,
-					calendarId,
-				);
-				const object = await this.objectRepo.put({
-					...write.object,
-					syncSequence,
-				});
-				await this.eventIndexRepo.replaceForObject(
-					calendarId,
-					object.calendarObjectId,
-					write.occurrences,
-				);
-				return;
-			}
-			case "ReprojectObject": {
-				const { calendarId, resourceName } = write.object;
-				const stored = await this.objectRepo.findByResourceName(
-					calendarId,
-					resourceName,
-				);
-				if (stored === null || stored.etag !== write.readEtag) return;
-				await this.apply({
-					kind: "PutObject",
-					accountConfigId: write.accountConfigId,
-					object: write.object,
-					occurrences: write.occurrences,
-				});
-				return;
-			}
-			case "DeleteObject":
-				await this.eventIndexRepo.deleteForObject(
-					write.calendarId,
-					write.calendarObjectId,
-				);
-				await this.objectRepo.delete(write.calendarId, write.calendarObjectId);
-				await this.collectionRepo.bumpSyncSequence(
-					write.accountConfigId,
-					write.calendarId,
-				);
-				return;
-			case "SettleSuggestion":
-				await this.suggestionRepo.settle(
-					write.accountConfigId,
-					write.suggestionId,
-					write.settle,
-				);
-				return;
-			case "UpdateCollection":
-				await this.collectionRepo.update(
-					write.accountConfigId,
-					write.calendarId,
-					write.patch,
-				);
-				return;
-			case "DeleteCollection": {
-				for (const object of await this.objectRepo.listByCalendar(
-					write.calendarId,
-				)) {
-					await this.eventIndexRepo.deleteForObject(
-						write.calendarId,
-						object.calendarObjectId,
-					);
-					await this.objectRepo.delete(
-						write.calendarId,
-						object.calendarObjectId,
-					);
-				}
-				await this.feedTokenRepo.delete(
-					write.accountConfigId,
-					write.calendarId,
-				);
-				await this.collectionRepo.delete(
-					write.accountConfigId,
-					write.calendarId,
-				);
-				return;
-			}
-		}
-	}
-}