@remit/calendar-service 0.0.18 → 0.0.19

package/dist/put.d.ts

@@ -0,0 +1,52 @@
+import type { CalendarCollectionItem, CalendarObjectItem, DeleteCalendarObjectWrite, ICalendarStore, PutCalendarObjectWrite } from "@remit/data-ports";
+import type { CalendarResult } from "./errors.js";
+/** URL segment of the collection every account config is provisioned with. */
+export declare const DEFAULT_CALENDAR_URL_SEGMENT = "default";
+export interface PutCalendarObjectInput {
+    accountConfigId: string;
+    calendarId: string;
+    /** Last path segment of the resource's URL, e.g. `"a1b2c3.ics"`. */
+    resourceName: string;
+    /** The VCALENDAR text as it arrived, stored byte-for-byte. */
+    icalData: string;
+}
+/**
+ * Turns one calendar resource into the write that stores it, read in the
+ * collection's timezone. Every caller that stores an event goes through here —
+ * a REST handler, a DAV PUT, an accepted suggestion, a feed refresh — because
+ * the object row, its occurrence rows and the collection's sequence bump are
+ * one fact, and a caller that writes any of them alone leaves the store
+ * describing a calendar that does not exist.
+ *
+ * The bytes are stored exactly as given: parsing is for validating and
+ * projecting them, never for rewriting them. Refusing the resource is a
+ * returned value — the input is client-supplied, so malformed iCalendar is an
+ * outcome the caller renders, not a fault.
+ */
+export declare const prepareCalendarObject: (collection: Pick<CalendarCollectionItem, "timezone">, input: PutCalendarObjectInput) => Promise<CalendarResult<PutCalendarObjectWrite>>;
+/** The resource a committed put wrote, under the id its name derives to. */
+export declare const readWrittenObject: (store: ICalendarStore, write: PutCalendarObjectWrite) => Promise<CalendarObjectItem>;
+/** Writes one calendar resource into its collection. */
+export declare const putCalendarObject: (store: ICalendarStore, input: PutCalendarObjectInput) => Promise<CalendarResult<CalendarObjectItem>>;
+/**
+ * Removes a resource and the occurrences it produced — an object dropped
+ * without its occurrence rows leaves a calendar showing events no resource
+ * backs, which nothing later can attribute or clean up.
+ */
+export declare const deleteCalendarObjectWrite: (input: {
+    accountConfigId: string;
+    calendarId: string;
+    calendarObjectId: string;
+}) => DeleteCalendarObjectWrite;
+export declare const deleteCalendarObject: (store: ICalendarStore, input: {
+    accountConfigId: string;
+    calendarId: string;
+    calendarObjectId: string;
+}) => Promise<void>;
+/**
+ * The collection an account config stores events in until someone makes
+ * another. Safe to call on every request that needs a calendar: `calendarId` is
+ * derived from the account config and the URL segment, so a second call returns
+ * the collection the first one made rather than a rival copy of it.
+ */
+export declare const provisionDefaultCalendar: (store: ICalendarStore, accountConfigId: string, displayName?: string) => Promise<CalendarCollectionItem>;

package/dist/put.js

@@ -0,0 +1,78 @@
+import { deriveCalendarObjectId } from "@remit/data-ports/id";
+import { CalendarSource } from "@remit/domain-enums";
+import { computeEtag } from "./etag.js";
+import { expandCalendar } from "./expand.js";
+import { parseCalendar } from "./parse.js";
+import { projectCalendar } from "./project.js";
+/** URL segment of the collection every account config is provisioned with. */
+export const DEFAULT_CALENDAR_URL_SEGMENT = "default";
+/**
+ * Turns one calendar resource into the write that stores it, read in the
+ * collection's timezone. Every caller that stores an event goes through here —
+ * a REST handler, a DAV PUT, an accepted suggestion, a feed refresh — because
+ * the object row, its occurrence rows and the collection's sequence bump are
+ * one fact, and a caller that writes any of them alone leaves the store
+ * describing a calendar that does not exist.
+ *
+ * The bytes are stored exactly as given: parsing is for validating and
+ * projecting them, never for rewriting them. Refusing the resource is a
+ * returned value — the input is client-supplied, so malformed iCalendar is an
+ * outcome the caller renders, not a fault.
+ */
+export const prepareCalendarObject = async (collection, input) => {
+    const parsed = await parseCalendar(input.icalData);
+    if (!parsed.ok)
+        return parsed;
+    const projection = projectCalendar(parsed.value, collection.timezone);
+    if (!projection.ok)
+        return projection;
+    const expansion = expandCalendar(parsed.value, collection.timezone);
+    return {
+        ok: true,
+        value: {
+            kind: "PutObject",
+            accountConfigId: input.accountConfigId,
+            object: {
+                ...projection.value,
+                calendarId: input.calendarId,
+                resourceName: input.resourceName,
+                icalData: input.icalData,
+                etag: computeEtag(input.icalData),
+                expandedThrough: expansion.expandedThrough,
+            },
+            occurrences: expansion.occurrences,
+        },
+    };
+};
+/** The resource a committed put wrote, under the id its name derives to. */
+export const readWrittenObject = (store, write) => store.repos.calendarObject.get(write.object.calendarId, deriveCalendarObjectId(write.object.calendarId, write.object.resourceName));
+/** Writes one calendar resource into its collection. */
+export const putCalendarObject = async (store, input) => {
+    const collection = await store.repos.calendarCollection.get(input.accountConfigId, input.calendarId);
+    const write = await prepareCalendarObject(collection, input);
+    if (!write.ok)
+        return write;
+    await store.commit([write.value]);
+    return { ok: true, value: await readWrittenObject(store, write.value) };
+};
+/**
+ * Removes a resource and the occurrences it produced — an object dropped
+ * without its occurrence rows leaves a calendar showing events no resource
+ * backs, which nothing later can attribute or clean up.
+ */
+export const deleteCalendarObjectWrite = (input) => ({ kind: "DeleteObject", ...input });
+export const deleteCalendarObject = async (store, input) => {
+    await store.commit([deleteCalendarObjectWrite(input)]);
+};
+/**
+ * The collection an account config stores events in until someone makes
+ * another. Safe to call on every request that needs a calendar: `calendarId` is
+ * derived from the account config and the URL segment, so a second call returns
+ * the collection the first one made rather than a rival copy of it.
+ */
+export const provisionDefaultCalendar = (store, accountConfigId, displayName = "Calendar") => store.repos.calendarCollection.create({
+    accountConfigId,
+    urlSegment: DEFAULT_CALENDAR_URL_SEGMENT,
+    displayName,
+    source: CalendarSource.Default,
+});

package/dist/reopen.d.ts

@@ -0,0 +1,14 @@
+import type { CalendarAnswerOvertaken as CalendarAnswerOvertakenValue } from "@remit/api-openapi-types";
+import type { CalendarSuggestionItem, ICalendarStore, ICalendarSuggestionRepository } from "@remit/data-ports";
+import { type CalendarResult } from "./errors.js";
+export interface ReopenCalendarSuggestionInput {
+    accountConfigId: string;
+    suggestion: CalendarSuggestionItem;
+}
+type SuggestionHolders = Pick<ICalendarSuggestionRepository, "listByAcceptedCalendarObjects">;
+export declare const answersOvertakenBy: (calendarSuggestion: SuggestionHolders, accountConfigId: string, suggestions: CalendarSuggestionItem[]) => Promise<{
+    suggestion: CalendarSuggestionItem;
+    answerOvertakenBy: CalendarAnswerOvertakenValue;
+}[]>;
+export declare const reopenCalendarSuggestion: (store: ICalendarStore, input: ReopenCalendarSuggestionInput) => Promise<CalendarResult<CalendarSuggestionItem>>;
+export {};

package/dist/reopen.js

@@ -0,0 +1,92 @@
+import { CalendarAnswerOvertaken, CalendarInviteMethod, CalendarSuggestionState, } from "@remit/domain-enums";
+import { calendarFailure } from "./errors.js";
+import { deleteCalendarObjectWrite } from "./put.js";
+import { followingUidPrefix } from "./scope.js";
+const answeredStates = new Set([
+    CalendarSuggestionState.Accepted,
+    CalendarSuggestionState.Tentative,
+]);
+const holdersByObject = async (calendarSuggestion, accountConfigId, suggestions) => {
+    const objectIds = [
+        ...new Set(suggestions
+            .map((suggestion) => suggestion.acceptedCalendarObjectId)
+            .filter((objectId) => objectId !== "")),
+    ];
+    const byObject = new Map();
+    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, suggestion) => (byObject.get(suggestion.acceptedCalendarObjectId) ?? []).filter((other) => other.suggestionId !== suggestion.suggestionId);
+const overtakenOf = (holders) => holders.some((other) => other.method === CalendarInviteMethod.Cancel)
+    ? CalendarAnswerOvertaken.Cancellation
+    : CalendarAnswerOvertaken.None;
+export const answersOvertakenBy = async (calendarSuggestion, accountConfigId, suggestions) => {
+    const byObject = await holdersByObject(calendarSuggestion, accountConfigId, suggestions);
+    return suggestions.map((suggestion) => ({
+        suggestion,
+        answerOvertakenBy: overtakenOf(othersIn(byObject, suggestion)),
+    }));
+};
+const locateAnswered = async (repos, collections, calendarObjectId) => {
+    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, suggestion, collection, answered) => [
+    answered,
+    ...(await repos.calendarObject.listByUidPrefix(collection.calendarId, followingUidPrefix(suggestion.icalUid))),
+];
+export const reopenCalendarSuggestion = async (store, input) => {
+    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.");
+    }
+    const { repos } = store;
+    const holders = othersIn(await holdersByObject(repos.calendarSuggestion, accountConfigId, [
+        suggestion,
+    ]), suggestion);
+    if (overtakenOf(holders) === CalendarAnswerOvertaken.Cancellation) {
+        return calendarFailure("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);
+    const removals = located
+        ? (await partsOf(repos, suggestion, located.collection, located.object)).map((object) => deleteCalendarObjectWrite({
+            accountConfigId,
+            calendarId: located.collection.calendarId,
+            calendarObjectId: object.calendarObjectId,
+        }))
+        : [];
+    await store.commit([
+        ...removals,
+        {
+            kind: "SettleSuggestion",
+            accountConfigId,
+            suggestionId: suggestion.suggestionId,
+            settle: {
+                state: CalendarSuggestionState.Pending,
+                acceptedCalendarObjectId: "",
+            },
+        },
+    ]);
+    return {
+        ok: true,
+        value: await repos.calendarSuggestion.get(accountConfigId, suggestion.suggestionId),
+    };
+};

package/dist/scope.d.ts

@@ -0,0 +1,70 @@
+import { RecurrenceScope } from "@remit/domain-enums";
+import ICAL from "ical.js";
+import { type CalendarEventFields } from "./build.js";
+import { type CalendarResult } from "./errors.js";
+import { type ParsedCalendar } from "./parse.js";
+export type RecurrenceScopeValue = (typeof RecurrenceScope)[keyof typeof RecurrenceScope];
+/**
+ * What a scoped write turns into on the store.
+ *
+ * `Split` is the only one that is not a single resource: iCalendar has no way
+ * to say "the rest of this series is different", so a `Following` edit really
+ * is two resources — the truncated original and a new one under a UID of its
+ * own. Both go through the one write path rather than through a second.
+ */
+export type ScopedWrite = {
+    kind: "Replace";
+    icalData: string;
+} | {
+    kind: "Split";
+    icalData: string;
+    following: string;
+} | {
+    kind: "Delete";
+};
+export interface ScopedWriteInput {
+    scope: RecurrenceScopeValue;
+    /** ISO 8601 UTC instant naming the occurrence the write was made from, or `""`. */
+    recurrenceId: string;
+    /** UID the resource a `Following` split creates is written under. */
+    followingUid: string;
+}
+export declare const followingUidPrefix: (icalUid: string) => string;
+export declare const followingUidOf: (icalUid: string, id: string) => string;
+interface FoundOccurrence {
+    /** The rule slot, in whatever form the master's DTSTART is written in. */
+    slot: ICAL.Time;
+    slotUtc: string;
+    /** The occurrence as the series produces it; absent when only an override names the slot. */
+    details: ReturnType<ICAL.Event["getOccurrenceDetails"]> | null;
+    /** Position in the rule's own sequence, `-1` when the rule never reaches it. */
+    index: number;
+    override: ICAL.Component | null;
+}
+/**
+ * The occurrence a scoped write is anchored at.
+ *
+ * Walks the series rather than trusting the caller's instant: a RECURRENCE-ID
+ * naming no occurrence is the shape of a stale client acting on a series
+ * somebody has since edited, and writing an override or an EXDATE for a slot
+ * the rule never produces leaves a resource nothing can reconcile afterwards.
+ */
+export declare const findOccurrence: (calendar: ParsedCalendar, collectionTimezone: string, recurrenceId: string) => CalendarResult<FoundOccurrence>;
+/**
+ * Turns an edit of one drawing of a series into the resource writes it means.
+ *
+ * `All` rewrites the master, moved from the occurrence it names when it names
+ * one. `This` writes a RECURRENCE-ID override, which is
+ * the only thing iCalendar has for "this one is different". `Following` splits,
+ * because a rule cannot change halfway through.
+ */
+export declare const applyScopedUpdate: (calendar: ParsedCalendar, collectionTimezone: string, input: ScopedWriteInput, patch: Partial<CalendarEventFields>) => Promise<CalendarResult<ScopedWrite>>;
+/**
+ * Turns a delete of one drawing of a series into the resource writes it means.
+ *
+ * `This` is an EXDATE and `Following` truncates the rule; neither removes the
+ * resource, because the rest of the series is still somebody's calendar. `All`
+ * removes it.
+ */
+export declare const applyScopedDelete: (calendar: ParsedCalendar, collectionTimezone: string, input: ScopedWriteInput) => Promise<CalendarResult<ScopedWrite>>;
+export {};