@remit/calendar-service 0.0.21 → 1.0.1

package/dist/accept.d.ts

@@ -1,6 +1,8 @@
 import type { CalendarInviteAnswer as CalendarInviteAnswerValue } from "@remit/api-openapi-types";
 import type { CalendarObjectItem, CalendarSuggestionItem, ICalendarStore } from "@remit/data-ports";
 import type { CalendarResult } from "./errors.js";
+/** The state a suggestion settles in for each answer. */
+export declare const SUGGESTION_STATE_OF_ANSWER: Record<CalendarInviteAnswerValue, CalendarSuggestionItem["state"]>;
 /**
  * The VCALENDAR a stored resource is made of, built from the invitation's own
  * bytes.

package/dist/accept.js

@@ -2,16 +2,15 @@ import { deriveCalendarObjectId } from "@remit/data-ports/id";
 import { CalendarInviteAnswer, CalendarInviteMethod, CalendarSuggestionState, } from "@remit/domain-enums";
 import ICAL from "ical.js";
 import { parseCalendar, serializeCalendar } from "./parse.js";
+import { PARTSTAT_OF_ANSWER } from "./participation.js";
 import { prepareCalendarObject, readWrittenObject } from "./put.js";
 import { mailAddressOf } from "./suggest.js";
 const eventsOf = (component) => component.getAllSubcomponents("vevent");
-const partstatOf = {
-    [CalendarInviteAnswer.Accepted]: "ACCEPTED",
-    [CalendarInviteAnswer.Tentative]: "TENTATIVE",
-};
-const stateOf = {
+/** The state a suggestion settles in for each answer. */
+export const SUGGESTION_STATE_OF_ANSWER = {
     [CalendarInviteAnswer.Accepted]: CalendarSuggestionState.Accepted,
     [CalendarInviteAnswer.Tentative]: CalendarSuggestionState.Tentative,
+    [CalendarInviteAnswer.Declined]: CalendarSuggestionState.Declined,
 };
 /**
  * Marks one address with its answer, on every VEVENT of the resource — the
@@ -29,7 +28,7 @@ const markAnswered = (component, attendee, answer) => {
             .find((property) => mailAddressOf(String(property.getFirstValue())).toLowerCase() ===
             wanted);
         const property = existing ?? new ICAL.Property("attendee", event);
-        property.setParameter("partstat", partstatOf[answer]);
+        property.setParameter("partstat", PARTSTAT_OF_ANSWER[answer]);
         if (!existing) {
             property.setValue(`mailto:${attendee}`);
             event.addProperty(property);
@@ -143,7 +142,7 @@ export const acceptCalendarSuggestion = async (store, input) => {
             accountConfigId: input.accountConfigId,
             suggestionId: input.suggestion.suggestionId,
             settle: {
-                state: stateOf[input.answer],
+                state: SUGGESTION_STATE_OF_ANSWER[input.answer],
                 acceptedCalendarObjectId: calendarObjectId,
             },
         },

package/dist/errors.d.ts

@@ -36,7 +36,19 @@ 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" | "NotReopenable" | "AnswerOvertaken";
+ | "InvalidSubscriptionUrl" | "NotReopenable" | "AnswerOvertaken"
+/** An answer to the rest of a series, which is not a thing an answer can be to. */
+ | "InvalidScope"
+/** A guest list change on an event somebody else organizes. */
+ | "NotOrganizer"
+/** An answer from somebody who is not on the guest list. */
+ | "NotAGuest"
+/** A guest that is not a mail address. */
+ | "InvalidGuest"
+/** A sending account that is not the caller's. */
+ | "UnknownOrganizer"
+/** A sending account with Mail turned off, or no account to send from. */
+ | "OrganizerCannotSend";
 export interface CalendarValidationError {
     code: CalendarValidationCode;
     message: string;

package/dist/index.d.ts

@@ -1,16 +1,21 @@
-export { type AcceptCalendarSuggestionInput, type AcceptedCalendarSuggestion, acceptCalendarSuggestion, buildAcceptedCalendar, } from "./accept.js";
+export { type AcceptCalendarSuggestionInput, type AcceptedCalendarSuggestion, acceptCalendarSuggestion, buildAcceptedCalendar, SUGGESTION_STATE_OF_ANSWER, } from "./accept.js";
 export { applyEventFields, buildEventCalendar, CALENDAR_PRODID, type CalendarEventFields, eventTimeFields, OFFSET_BEARING, readEventTime, readRecurrenceRule, } from "./build.js";
 export { correctCalendarSuggestion } from "./correct.js";
 export type { CalendarResult, CalendarValidationCode, CalendarValidationError, } from "./errors.js";
 export { computeEtag } from "./etag.js";
 export { CALENDAR_EXPANSION_HORIZON_DAYS, CALENDAR_EXPANSION_MAX_OCCURRENCES, CALENDAR_WINDOW_MAX_STEPS, type CalendarExpansion, expandCalendar, expandCalendarWindow, } from "./expand.js";
 export { buildCalendarFeed, CALENDAR_FEED_PATH_PREFIX, CALENDAR_FEED_PATH_SUFFIX, CALENDAR_FEED_TOKEN_BYTES, type CalendarFeed, type CalendarFeedSecret, calendarFeedIsUnchanged, calendarFeedIsUnmodifiedSince, hashCalendarFeedToken, isCalendarFeedToken, mintCalendarFeedToken, readCalendarFeedToken, redactCalendarFeedPath, } from "./feed.js";
+export { type EventSchedulingUpdate, guestListOf, invitationSenderInEffect, type PlannedEventUpdate, planCreateSends, planDeleteFanOut, planDeleteSends, planEventCreate, planEventUpdate, planGuestFanOut, planUpdateSends, type SchedulingSendPlan, type SchedulingSends, schedulingBody, sendingAccountFor, sendsMail, shapeScheduledUpdate, } from "./invitations.js";
 export { type ParsedCalendar, parseCalendar, serializeCalendar, } from "./parse.js";
+export { attendeesOf, calendarAddressOf, countAttendees, organizerOf, PARTSTAT_OF_ANSWER, participationAtSlot, participationOf, selfAddressSet, } from "./participation.js";
 export { type CalendarObjectProjection, projectCalendar, } from "./project.js";
-export { DEFAULT_CALENDAR_URL_SEGMENT, deleteCalendarObject, deleteCalendarObjectWrite, type PutCalendarObjectInput, prepareCalendarObject, provisionDefaultCalendar, putCalendarObject, readWrittenObject, } from "./put.js";
+export { DEFAULT_CALENDAR_URL_SEGMENT, deleteCalendarObject, deleteCalendarObjectWrite, type PutCalendarObjectInput, prepareCalendarObject, provisionDefaultCalendar, provisionTaskCalendar, putCalendarObject, readWrittenObject, TASK_CALENDAR_URL_SEGMENT, } from "./put.js";
 export { answersOvertakenBy, type ReopenCalendarSuggestionInput, reopenCalendarSuggestion, } from "./reopen.js";
+export { type RecordCalendarReplyInput, type RecordCalendarReplyOutcome, type ReplyRevision, recordCalendarReply, replyOvertakes, } from "./reply.js";
+export { applyAnswer, applyGuestList, buildSchedulingMessage, bumpSequence, type CalendarPerson, distinctGuests, guestAddressesOf, invalidGuestOf, type SchedulingMessage, type SchedulingMessageInput, type SchedulingMethod, schedulingSubject, } from "./scheduling.js";
 export { applyScopedDelete, applyScopedUpdate, findOccurrence, followingUidOf, followingUidPrefix, type RecurrenceScopeValue, type ScopedWrite, type ScopedWriteInput, } from "./scope.js";
 export { CALENDAR_SUBSCRIPTION_MAX_BYTES, CALENDAR_SUBSCRIPTION_TIMEOUT_MS, type CalendarFeedFetch, type CalendarFeedFetcher, type CalendarFeedResource, type CalendarFeedSplit, type CalendarFeedWrite, type CalendarSubscriptionRefresh, type CalendarSubscriptionTarget, fetchCalendarFeed, isSubscriptionDue, readCalendarFeed, readSubscriptionUrl, recordCalendarFeedFailure, refreshCalendarSubscription, splitCalendarFeed, writeCalendarFeed, } from "./subscribe.js";
 export { type CalendarSuggestionProjection, inviteMethodOf, mailAddressOf, projectSuggestion, type RecordCalendarSuggestionInput, type RecordedCalendarSuggestion, recordCalendarSuggestion, } from "./suggest.js";
+export { buildTaskCalendar, type CalendarTaskFields, listTasksInWindow, parseTaskCalendar, prepareCalendarTask, updateTaskCalendar, } from "./task.js";
 export { civilInZone, isResolvableZone, type ResolvedTime, resolveTime, toOffsetIso, toUtcIso, } from "./time.js";
 export { type BusySpan, CALENDAR_WINDOW_LOOKBACK_DAYS, type CalendarInstance, type CalendarWindow, type CalendarWindowRepositories, isBusy, listBusySpans, listCalendarInstances, listObjectInstances, mergeBusySpans, } from "./window.js";

package/dist/index.js

@@ -1,15 +1,20 @@
-export { acceptCalendarSuggestion, buildAcceptedCalendar, } from "./accept.js";
+export { acceptCalendarSuggestion, buildAcceptedCalendar, SUGGESTION_STATE_OF_ANSWER, } from "./accept.js";
 export { applyEventFields, buildEventCalendar, CALENDAR_PRODID, eventTimeFields, OFFSET_BEARING, readEventTime, readRecurrenceRule, } from "./build.js";
 export { correctCalendarSuggestion } from "./correct.js";
 export { computeEtag } from "./etag.js";
 export { CALENDAR_EXPANSION_HORIZON_DAYS, CALENDAR_EXPANSION_MAX_OCCURRENCES, CALENDAR_WINDOW_MAX_STEPS, expandCalendar, expandCalendarWindow, } from "./expand.js";
 export { buildCalendarFeed, CALENDAR_FEED_PATH_PREFIX, CALENDAR_FEED_PATH_SUFFIX, CALENDAR_FEED_TOKEN_BYTES, calendarFeedIsUnchanged, calendarFeedIsUnmodifiedSince, hashCalendarFeedToken, isCalendarFeedToken, mintCalendarFeedToken, readCalendarFeedToken, redactCalendarFeedPath, } from "./feed.js";
+export { guestListOf, invitationSenderInEffect, planCreateSends, planDeleteFanOut, planDeleteSends, planEventCreate, planEventUpdate, planGuestFanOut, planUpdateSends, schedulingBody, sendingAccountFor, sendsMail, shapeScheduledUpdate, } from "./invitations.js";
 export { parseCalendar, serializeCalendar, } from "./parse.js";
+export { attendeesOf, calendarAddressOf, countAttendees, organizerOf, PARTSTAT_OF_ANSWER, participationAtSlot, participationOf, selfAddressSet, } from "./participation.js";
 export { projectCalendar, } from "./project.js";
-export { DEFAULT_CALENDAR_URL_SEGMENT, deleteCalendarObject, deleteCalendarObjectWrite, prepareCalendarObject, provisionDefaultCalendar, putCalendarObject, readWrittenObject, } from "./put.js";
+export { DEFAULT_CALENDAR_URL_SEGMENT, deleteCalendarObject, deleteCalendarObjectWrite, prepareCalendarObject, provisionDefaultCalendar, provisionTaskCalendar, putCalendarObject, readWrittenObject, TASK_CALENDAR_URL_SEGMENT, } from "./put.js";
 export { answersOvertakenBy, reopenCalendarSuggestion, } from "./reopen.js";
+export { recordCalendarReply, replyOvertakes, } from "./reply.js";
+export { applyAnswer, applyGuestList, buildSchedulingMessage, bumpSequence, distinctGuests, guestAddressesOf, invalidGuestOf, schedulingSubject, } from "./scheduling.js";
 export { applyScopedDelete, applyScopedUpdate, findOccurrence, followingUidOf, followingUidPrefix, } from "./scope.js";
 export { CALENDAR_SUBSCRIPTION_MAX_BYTES, CALENDAR_SUBSCRIPTION_TIMEOUT_MS, fetchCalendarFeed, isSubscriptionDue, readCalendarFeed, readSubscriptionUrl, recordCalendarFeedFailure, refreshCalendarSubscription, splitCalendarFeed, writeCalendarFeed, } from "./subscribe.js";
 export { inviteMethodOf, mailAddressOf, projectSuggestion, recordCalendarSuggestion, } from "./suggest.js";
+export { buildTaskCalendar, listTasksInWindow, parseTaskCalendar, prepareCalendarTask, updateTaskCalendar, } from "./task.js";
 export { civilInZone, isResolvableZone, resolveTime, toOffsetIso, toUtcIso, } from "./time.js";
 export { CALENDAR_WINDOW_LOOKBACK_DAYS, isBusy, listBusySpans, listCalendarInstances, listObjectInstances, mergeBusySpans, } from "./window.js";

package/dist/invitations.d.ts

@@ -0,0 +1,120 @@
+import type { CalendarInviteAnswer as CalendarInviteAnswerValue } from "@remit/api-openapi-types";
+import type { AccountItem } from "@remit/data-ports";
+import type { CalendarEventFields } from "./build.js";
+import { type CalendarResult } from "./errors.js";
+import { type ParsedCalendar } from "./parse.js";
+import { type CalendarPerson, type SchedulingMethod } from "./scheduling.js";
+import type { RecurrenceScopeValue, ScopedWrite } from "./scope.js";
+type Account = Pick<AccountItem, "accountId" | "email" | "syncedServices">;
+/** Whether an account can send: a scheduling message goes out as mail. */
+export declare const sendsMail: (account: Pick<AccountItem, "syncedServices">) => boolean;
+/**
+ * The account invitations go out from by default: the one the reader set, while
+ * it still sends mail, and otherwise the account an event is on. A calendar
+ * belongs to the account config rather than to one account, so a new event is
+ * on the config's first account that sends mail.
+ */
+export declare const invitationSenderInEffect: <A extends Account>(accounts: readonly A[], settingAccountId: string | undefined) => A | undefined;
+/** The account a request names to send from, refused when it cannot send. */
+export declare const sendingAccountFor: <A extends Account>(accounts: readonly A[], accountId: string) => CalendarResult<A>;
+/** A guest list as the editor sent it, refused when an entry is not an address. */
+export declare const guestListOf: (organizer: string, attendees: readonly CalendarPerson[]) => CalendarResult<CalendarPerson[]>;
+/**
+ * Who gets which scheduling message after an organizer saves an event.
+ *
+ * Every guest still on the list gets the event as it now stands: a save is a
+ * revision, and a guest who keeps the old one keeps the old time. A guest the
+ * save took off the list gets a cancellation, and only them.
+ */
+export declare const planGuestFanOut: (previousGuests: readonly string[], currentGuests: readonly string[]) => {
+    request: string[];
+    cancel: string[];
+};
+/**
+ * What a delete sends. Removing the whole event cancels it for every guest.
+ * Removing one occurrence or the rest of a series leaves an event behind, and
+ * the guests get that event — with the EXDATE or the shortened rule — rather
+ * than a cancellation of a series that still exists.
+ */
+export declare const planDeleteFanOut: (removedWhole: boolean, guests: readonly string[]) => {
+    method: SchedulingMethod;
+    recipients: string[];
+};
+/** One message to queue: about which stored resource, to whom, saying what. */
+export interface SchedulingSendPlan {
+    method: SchedulingMethod;
+    calendarObjectId: string;
+    /** The stored resource the message is built from. */
+    icalData: string;
+    collectionTimezone: string;
+    recipient: CalendarPerson;
+    /** For a REPLY: the guest answering. For the rest: the recipient. */
+    attendee: CalendarPerson;
+    recurrenceId: string;
+    answer?: CalendarInviteAnswerValue;
+}
+/** The messages a write queues, and the account they go out from. */
+export interface SchedulingSends<A> {
+    from: A;
+    plans: SchedulingSendPlan[];
+}
+/** The plain-text body a scheduling message carries beside its calendar part. */
+export declare const schedulingBody: (subject: string, icalData: string) => string;
+/** What a create must know before it writes: who sends, and to whom. */
+export declare const planEventCreate: <A extends Account>(accounts: readonly A[], settingAccountId: string | undefined, attendees: readonly CalendarPerson[], organizerAccountId: string | undefined) => CalendarResult<{
+    organizer: A;
+    guests: CalendarPerson[];
+} | null>;
+export declare const planCreateSends: <A extends Account>(planned: {
+    organizer: A;
+    guests: CalendarPerson[];
+}, stored: {
+    calendarObjectId: string;
+    icalData: string;
+}, collectionTimezone: string) => SchedulingSends<A>;
+/** The scheduling half of an event update. */
+export interface EventSchedulingUpdate {
+    attendees?: CalendarPerson[];
+    organizerAccountId?: string;
+    answer?: CalendarInviteAnswerValue;
+}
+/** What an update decided about scheduling before anything is written. */
+export interface PlannedEventUpdate<A> {
+    storedOrganizer: string;
+    previousGuests: CalendarPerson[];
+    guests: CalendarPerson[];
+    /** The account the organizer's messages go out from; absent when none are owed. */
+    organizer: A | undefined;
+    /** The reader's own address on the guest list, when they answer. */
+    answeringAs: string;
+    /** Whether the organizer's guests are owed the revision. */
+    organized: boolean;
+}
+/**
+ * Decides who an update writes as and owes messages to, refused before
+ * anything is written: a guest list only its organizer may change, an answer
+ * only a guest may give, and nobody to send from refuses the save rather than
+ * leaving guests uninvited.
+ */
+export declare const planEventUpdate: <A extends Account>(calendar: ParsedCalendar, accounts: readonly A[], settingAccountId: string | undefined, scope: RecurrenceScopeValue, update: EventSchedulingUpdate) => CalendarResult<PlannedEventUpdate<A>>;
+/**
+ * The bytes an update stores: the guest list on the resource the patch applied
+ * to, SEQUENCE moved past the last revision when the organizer reschedules, and
+ * the reader's own answer on the occurrence or the series they answered.
+ */
+export declare const shapeScheduledUpdate: <A extends Account>(write: Exclude<ScopedWrite, {
+    kind: "Delete";
+}>, planned: PlannedEventUpdate<A>, update: EventSchedulingUpdate, patch: Partial<CalendarEventFields>, collectionTimezone: string, scope: RecurrenceScopeValue, recurrenceId: string) => Promise<CalendarResult<ScopedWrite>>;
+interface StoredResource {
+    calendarObjectId: string;
+    icalData: string;
+}
+/**
+ * The messages an update owes: the revision to every guest of each resource
+ * it wrote, a cancellation to each guest it removed, and the reader's reply to
+ * the organizer when they answered as a guest.
+ */
+export declare const planUpdateSends: <A extends Account>(planned: PlannedEventUpdate<A>, accounts: readonly A[], update: EventSchedulingUpdate, original: StoredResource, written: readonly StoredResource[], collectionTimezone: string, scope: RecurrenceScopeValue, recurrenceId: string) => Promise<SchedulingSends<A> | null>;
+/** The messages a delete owes, only on an event the reader organizes. */
+export declare const planDeleteSends: <A extends Account>(calendar: ParsedCalendar, accounts: readonly A[], original: StoredResource, remaining: StoredResource | null, collectionTimezone: string) => SchedulingSends<A> | null;
+export {};

package/dist/invitations.js

@@ -0,0 +1,321 @@
+import { AccountService, CalendarInviteMethod, CalendarParticipation, RecurrenceScope, } from "@remit/domain-enums";
+import { calendarFailure } from "./errors.js";
+import { parseCalendar } from "./parse.js";
+import { attendeesOf, calendarAddressOf, organizerOf, participationOf, selfAddressSet, } from "./participation.js";
+import { applyAnswer, applyGuestList, bumpSequence, distinctGuests, guestAddressesOf, invalidGuestOf, } from "./scheduling.js";
+/** Whether an account can send: a scheduling message goes out as mail. */
+export const sendsMail = (account) => account.syncedServices.includes(AccountService.Mail);
+/**
+ * The account invitations go out from by default: the one the reader set, while
+ * it still sends mail, and otherwise the account an event is on. A calendar
+ * belongs to the account config rather than to one account, so a new event is
+ * on the config's first account that sends mail.
+ */
+export const invitationSenderInEffect = (accounts, settingAccountId) => accounts.find((account) => account.accountId === settingAccountId && sendsMail(account)) ?? accounts.find(sendsMail);
+/** The account a request names to send from, refused when it cannot send. */
+export const sendingAccountFor = (accounts, accountId) => {
+    const account = accounts.find((candidate) => candidate.accountId === accountId);
+    if (!account) {
+        return calendarFailure("UnknownOrganizer", `no account ${accountId} on this account config to send the invitations from`);
+    }
+    if (!sendsMail(account)) {
+        return calendarFailure("OrganizerCannotSend", `${account.email} has Mail turned off, so it cannot send invitations. Turn Mail on for it in Settings, or send from another account.`);
+    }
+    return { ok: true, value: account };
+};
+const accountByAddress = (accounts, address) => accounts.find((account) => account.email.toLowerCase() === address);
+/** A guest list as the editor sent it, refused when an entry is not an address. */
+export const guestListOf = (organizer, attendees) => {
+    const invalid = invalidGuestOf(attendees);
+    if (invalid) {
+        return calendarFailure("InvalidGuest", `"${invalid.email}" is not a mail address, so no invitation can go to it`);
+    }
+    return { ok: true, value: distinctGuests(organizer, attendees) };
+};
+const guestPeopleOf = (calendar) => attendeesOf(calendar.master)
+    .filter((attendee) => attendee.role === "Guest")
+    .map((attendee) => ({
+    email: attendee.email,
+    displayName: attendee.displayName,
+}));
+const personOf = (people, email) => people.find((person) => person.email === email) ?? { email, displayName: "" };
+/**
+ * Who gets which scheduling message after an organizer saves an event.
+ *
+ * Every guest still on the list gets the event as it now stands: a save is a
+ * revision, and a guest who keeps the old one keeps the old time. A guest the
+ * save took off the list gets a cancellation, and only them.
+ */
+export const planGuestFanOut = (previousGuests, currentGuests) => {
+    const current = new Set(currentGuests);
+    return {
+        request: [...current],
+        cancel: [...new Set(previousGuests)].filter((guest) => !current.has(guest)),
+    };
+};
+/**
+ * What a delete sends. Removing the whole event cancels it for every guest.
+ * Removing one occurrence or the rest of a series leaves an event behind, and
+ * the guests get that event — with the EXDATE or the shortened rule — rather
+ * than a cancellation of a series that still exists.
+ */
+export const planDeleteFanOut = (removedWhole, guests) => ({
+    method: removedWhole
+        ? CalendarInviteMethod.Cancel
+        : CalendarInviteMethod.Request,
+    recipients: [...new Set(guests)],
+});
+/** The plain-text body a scheduling message carries beside its calendar part. */
+export const schedulingBody = (subject, icalData) => {
+    const start = /\r?\nDTSTART[^:]*:([^\r\n]+)/.exec(icalData)?.[1] ?? "";
+    return start === "" ? `${subject}\n` : `${subject}\nWhen: ${start}\n`;
+};
+const requests = (guests, resource, collectionTimezone) => guests.map((guest) => ({
+    method: CalendarInviteMethod.Request,
+    calendarObjectId: resource.calendarObjectId,
+    icalData: resource.icalData,
+    collectionTimezone,
+    recipient: guest,
+    attendee: guest,
+    recurrenceId: "",
+}));
+/** What a create must know before it writes: who sends, and to whom. */
+export const planEventCreate = (accounts, settingAccountId, attendees, organizerAccountId) => {
+    if (organizerAccountId !== undefined) {
+        const named = sendingAccountFor(accounts, organizerAccountId);
+        if (!named.ok)
+            return named;
+    }
+    if (attendees.length === 0)
+        return { ok: true, value: null };
+    const organizer = organizerAccountId !== undefined
+        ? sendingAccountFor(accounts, organizerAccountId)
+        : (() => {
+            const inEffect = invitationSenderInEffect(accounts, settingAccountId);
+            return inEffect
+                ? { ok: true, value: inEffect }
+                : calendarFailure("OrganizerCannotSend", "none of your accounts sends mail, so no invitation can go out");
+        })();
+    if (!organizer.ok)
+        return organizer;
+    const guests = guestListOf(organizer.value.email, attendees);
+    if (!guests.ok)
+        return guests;
+    return {
+        ok: true,
+        value: { organizer: organizer.value, guests: guests.value },
+    };
+};
+export const planCreateSends = (planned, stored, collectionTimezone) => ({
+    from: planned.organizer,
+    plans: requests(planned.guests, stored, collectionTimezone),
+});
+/**
+ * Decides who an update writes as and owes messages to, refused before
+ * anything is written: a guest list only its organizer may change, an answer
+ * only a guest may give, and nobody to send from refuses the save rather than
+ * leaving guests uninvited.
+ */
+export const planEventUpdate = (calendar, accounts, settingAccountId, scope, update) => {
+    const self = selfAddressSet(accounts.map((account) => account.email));
+    const storedOrganizer = organizerOf(calendar.master);
+    const previousGuests = guestPeopleOf(calendar);
+    let answeringAs = "";
+    if (update.answer !== undefined) {
+        if (scope === RecurrenceScope.Following) {
+            return calendarFailure("InvalidScope", "an answer is to one occurrence (This) or to the series (All), never to the rest of it");
+        }
+        const participation = participationOf(calendar.master, self);
+        if (participation === CalendarParticipation.Organizer ||
+            participation === CalendarParticipation.Unscheduled) {
+            return calendarFailure("NotAGuest", "you are not a guest of this event, so there is no invitation to answer");
+        }
+        answeringAs =
+            calendar.master
+                .getAllProperties("attendee")
+                .map((line) => calendarAddressOf(line.getFirstValue()))
+                .find((address) => self.has(address)) ?? "";
+    }
+    if (update.organizerAccountId !== undefined) {
+        const named = sendingAccountFor(accounts, update.organizerAccountId);
+        if (!named.ok)
+            return named;
+    }
+    let organizer;
+    if (storedOrganizer !== "" && self.has(storedOrganizer)) {
+        organizer = accountByAddress(accounts, storedOrganizer);
+    }
+    if (update.attendees !== undefined) {
+        if (storedOrganizer !== "" && !organizer) {
+            return calendarFailure("NotOrganizer", `${storedOrganizer} organizes this event, so only they can change its guests`);
+        }
+        if (organizer &&
+            update.organizerAccountId !== undefined &&
+            update.organizerAccountId !== organizer.accountId) {
+            return calendarFailure("NotOrganizer", `${storedOrganizer} organizes this event; the organizer of an event never changes`);
+        }
+        if (!organizer) {
+            organizer =
+                update.organizerAccountId !== undefined
+                    ? accounts.find((account) => account.accountId === update.organizerAccountId)
+                    : invitationSenderInEffect(accounts, settingAccountId);
+        }
+    }
+    if (organizer &&
+        (update.attendees !== undefined || previousGuests.length > 0)) {
+        const sending = sendingAccountFor(accounts, organizer.accountId);
+        if (!sending.ok)
+            return sending;
+    }
+    if (update.attendees !== undefined && !organizer) {
+        return calendarFailure("OrganizerCannotSend", "none of your accounts sends mail, so no invitation can go out");
+    }
+    let guests = previousGuests;
+    if (update.attendees !== undefined && organizer) {
+        const listed = guestListOf(organizer.email, update.attendees);
+        if (!listed.ok)
+            return listed;
+        guests = listed.value;
+    }
+    return {
+        ok: true,
+        value: {
+            storedOrganizer,
+            previousGuests,
+            guests,
+            organizer,
+            answeringAs,
+            organized: organizer !== undefined && guests.length + previousGuests.length > 0,
+        },
+    };
+};
+const touchesSchedule = (patch) => patch.start !== undefined ||
+    patch.end !== undefined ||
+    patch.allDay !== undefined ||
+    patch.timeZone !== undefined ||
+    patch.recurrenceRule !== undefined;
+/**
+ * The bytes an update stores: the guest list on the resource the patch applied
+ * to, SEQUENCE moved past the last revision when the organizer reschedules, and
+ * the reader's own answer on the occurrence or the series they answered.
+ */
+export const shapeScheduledUpdate = async (write, planned, update, patch, collectionTimezone, scope, recurrenceId) => {
+    const reschedules = planned.organized && touchesSchedule(patch);
+    const finish = async (icalData, patched) => {
+        let next = icalData;
+        if (patched && planned.organizer && update.attendees !== undefined) {
+            next = await applyGuestList(next, { email: planned.organizer.email, displayName: "" }, planned.guests);
+        }
+        if (reschedules)
+            next = await bumpSequence(next);
+        return next;
+    };
+    if (write.kind === "Split") {
+        return {
+            ok: true,
+            value: {
+                kind: "Split",
+                icalData: await finish(write.icalData, false),
+                following: await finish(write.following, true),
+            },
+        };
+    }
+    const replaced = await finish(write.icalData, true);
+    if (update.answer === undefined) {
+        return { ok: true, value: { kind: "Replace", icalData: replaced } };
+    }
+    const answered = await applyAnswer(replaced, collectionTimezone, planned.answeringAs, update.answer, scope === RecurrenceScope.This ? recurrenceId : "");
+    if (!answered.ok)
+        return answered;
+    return { ok: true, value: { kind: "Replace", icalData: answered.value } };
+};
+const guestsOfStored = async (icalData) => {
+    const parsed = await parseCalendar(icalData);
+    if (!parsed.ok) {
+        throw new Error(`a calendar resource this server wrote no longer parses: ${parsed.error.message}`);
+    }
+    return guestAddressesOf(parsed.value);
+};
+/**
+ * The messages an update owes: the revision to every guest of each resource
+ * it wrote, a cancellation to each guest it removed, and the reader's reply to
+ * the organizer when they answered as a guest.
+ */
+export const planUpdateSends = async (planned, accounts, update, original, written, collectionTimezone, scope, recurrenceId) => {
+    if (planned.organized && planned.organizer) {
+        const fanOut = planGuestFanOut(planned.previousGuests.map((guest) => guest.email), planned.guests.map((guest) => guest.email));
+        const plans = [];
+        for (const resource of written) {
+            const current = await guestsOfStored(resource.icalData);
+            plans.push(...requests(fanOut.request
+                .filter((email) => current.includes(email))
+                .map((email) => personOf(planned.guests, email)), resource, collectionTimezone));
+        }
+        for (const email of fanOut.cancel) {
+            const person = personOf(planned.previousGuests, email);
+            plans.push({
+                method: CalendarInviteMethod.Cancel,
+                calendarObjectId: original.calendarObjectId,
+                icalData: original.icalData,
+                collectionTimezone,
+                recipient: person,
+                attendee: person,
+                recurrenceId: "",
+            });
+        }
+        return { from: planned.organizer, plans };
+    }
+    const result = written.at(-1);
+    if (update.answer === undefined ||
+        !result ||
+        planned.storedOrganizer === "") {
+        return null;
+    }
+    const from = accountByAddress(accounts, planned.answeringAs);
+    if (!from) {
+        throw new Error(`${planned.answeringAs} answered as the reader but is none of their accounts`);
+    }
+    return {
+        from,
+        plans: [
+            {
+                method: CalendarInviteMethod.Reply,
+                calendarObjectId: result.calendarObjectId,
+                icalData: result.icalData,
+                collectionTimezone,
+                recipient: { email: planned.storedOrganizer, displayName: "" },
+                attendee: { email: planned.answeringAs, displayName: "" },
+                recurrenceId: scope === RecurrenceScope.This ? recurrenceId : "",
+                answer: update.answer,
+            },
+        ],
+    };
+};
+/** The messages a delete owes, only on an event the reader organizes. */
+export const planDeleteSends = (calendar, accounts, original, remaining, collectionTimezone) => {
+    const self = selfAddressSet(accounts.map((account) => account.email));
+    const storedOrganizer = organizerOf(calendar.master);
+    const guests = guestPeopleOf(calendar);
+    const organizer = self.has(storedOrganizer)
+        ? accountByAddress(accounts, storedOrganizer)
+        : undefined;
+    if (!organizer || guests.length === 0)
+        return null;
+    const fanOut = planDeleteFanOut(remaining === null, guests.map((guest) => guest.email));
+    const source = remaining ?? original;
+    return {
+        from: organizer,
+        plans: fanOut.recipients.map((email) => {
+            const person = personOf(guests, email);
+            return {
+                method: fanOut.method,
+                calendarObjectId: original.calendarObjectId,
+                icalData: source.icalData,
+                collectionTimezone,
+                recipient: person,
+                attendee: person,
+                recurrenceId: "",
+            };
+        }),
+    };
+};

package/dist/memory-store.d.ts

@@ -1,4 +1,4 @@
-import type { CalendarRepositories, CalendarWrite, ICalendarStore, ICalendarSuggestionRepository } from "@remit/data-ports";
+import type { CalendarCommitReport, CalendarRepositories, CalendarWrite, ICalendarStore, ICalendarSuggestionRepository } from "@remit/data-ports";
 import { NotFoundError } from "@remit/data-ports/errors";
 export declare class MissingRow extends NotFoundError {
 }
@@ -14,7 +14,7 @@ export declare class MemoryCalendarStore implements ICalendarStore {
         urlSegment: string;
         displayName: string;
         color: "Cal1" | "Cal2" | "Cal3" | "Cal4" | "Cal5" | "Cal6";
-        componentSet: "VeventOnly";
+        componentSet: "VeventOnly" | "VtodoOnly";
         source: "Default" | "UserCreated" | "MailDerived" | "Subscribed";
         timezone: string;
         syncSequence: number;
@@ -100,6 +100,6 @@ export declare class MemoryCalendarStore implements ICalendarStore {
     private readonly feedTokenRepo;
     get calendarSuggestion(): ICalendarSuggestionRepository;
     get repos(): CalendarRepositories;
-    commit(writes: readonly CalendarWrite[]): Promise<void>;
+    commit(writes: readonly CalendarWrite[]): Promise<CalendarCommitReport>;
     private apply;
 }

package/dist/memory-store.js

@@ -266,8 +266,14 @@ export class MemoryCalendarStore {
         };
     }
     async commit(writes) {
-        for (const write of writes)
-            await this.apply(write);
+        const staleReprojections = [];
+        for (const write of writes) {
+            const applied = await this.apply(write);
+            if (!applied && write.kind === "ReprojectObject") {
+                staleReprojections.push(deriveCalendarObjectId(write.object.calendarId, write.object.resourceName));
+            }
+        }
+        return { staleReprojections };
     }
     async apply(write) {
         switch (write.kind) {
@@ -279,32 +285,32 @@ export class MemoryCalendarStore {
                     syncSequence,
                 });
                 await this.eventIndexRepo.replaceForObject(calendarId, object.calendarObjectId, write.occurrences);
-                return;
+                return true;
             }
             case "ReprojectObject": {
                 const { calendarId, resourceName } = write.object;
                 const stored = await this.objectRepo.findByResourceName(calendarId, resourceName);
                 if (stored === null || stored.etag !== write.readEtag)
-                    return;
+                    return false;
                 await this.apply({
                     kind: "PutObject",
                     accountConfigId: write.accountConfigId,
                     object: write.object,
                     occurrences: write.occurrences,
                 });
-                return;
+                return true;
             }
             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;
+                return true;
             case "SettleSuggestion":
                 await this.suggestionRepo.settle(write.accountConfigId, write.suggestionId, write.settle);
-                return;
+                return true;
             case "UpdateCollection":
                 await this.collectionRepo.update(write.accountConfigId, write.calendarId, write.patch);
-                return;
+                return true;
             case "DeleteCollection": {
                 for (const object of await this.objectRepo.listByCalendar(write.calendarId)) {
                     await this.eventIndexRepo.deleteForObject(write.calendarId, object.calendarObjectId);
@@ -312,7 +318,7 @@ export class MemoryCalendarStore {
                 }
                 await this.feedTokenRepo.delete(write.accountConfigId, write.calendarId);
                 await this.collectionRepo.delete(write.accountConfigId, write.calendarId);
-                return;
+                return true;
             }
         }
     }