@remit/backend 0.0.156 → 1.0.0

package/dist/src/handlers/calendar-event.d.ts

@@ -1,6 +1,7 @@
-import type { CreateCalendarEventInput, UpdateCalendarEventInput } from "@remit/api-openapi-types";
-import { type CalendarEventFields, type CalendarWindow, type RecurrenceScopeValue, type ScopedWrite } from "@remit/calendar-service";
-import type { CalendarCollectionItem, CalendarObjectItem } from "@remit/data-ports";
+import type { CalendarEventResponse, CalendarSchedulingSend, CreateCalendarEventInput, UpdateCalendarEventInput } from "@remit/api-openapi-types";
+import { type CalendarEventFields, type CalendarWindow, type EventSchedulingUpdate, type RecurrenceScopeValue, type ScopedWrite } from "@remit/calendar-service";
+import type { CalendarCollectionItem, CalendarObjectItem, CreateOutboxSchedulingPartInput, OutboxMessageItem } from "@remit/data-ports";
+import type { CreateDraftInput } from "@remit/mailbox-service";
 import type { CalendarEventDetailOperationIds, CalendarEventOperationIds, CalendarFreeBusyOperationIds, OperationHandler } from "../types.js";
 import { type CalendarDeps, type CalendarOutcome } from "./calendar.js";
 /**
@@ -9,12 +10,15 @@ import { type CalendarDeps, type CalendarOutcome } from "./calendar.js";
  * the server to expand a decade of a daily series.
  */
 export declare const CALENDAR_MAX_WINDOW_DAYS = 366;
-/** Mints the id a new resource is named and identified by. */
+/** Queues one scheduling message with its part; a failed enqueue answers with the failed row. */
+export type QueueScheduled = (input: CreateDraftInput, part: CreateOutboxSchedulingPartInput) => Promise<OutboxMessageItem>;
+/** What an event write needs beyond the reads: ids, a clock, and the outbox. */
 export interface CalendarEventDeps extends CalendarDeps {
     newId: () => string;
     now: () => Date;
+    queueScheduled: QueueScheduled;
 }
-export declare const calendarEventDepsOf: (deps: CalendarDeps) => CalendarEventDeps;
+export declare const calendarEventDepsOf: (deps: CalendarDeps, queueScheduled: QueueScheduled) => CalendarEventDeps;
 /**
  * Reads the window a listing asked for.
  *
@@ -23,14 +27,23 @@ export declare const calendarEventDepsOf: (deps: CalendarDeps) => CalendarEventD
  * apparently empty morning rather than an error.
  */
 export declare const readWindow: (from: unknown, to: unknown) => CalendarOutcome<CalendarWindow>;
-/** The collections a listing covers, defaulting to every one the caller holds. */
-export declare const collectionsForListing: (deps: CalendarDeps, accountConfigId: string, calendarIds: string[]) => Promise<CalendarOutcome<CalendarCollectionItem[]>>;
+/**
+ * The collections a listing covers, defaulting to every one the caller holds
+ * of the component set asked for.
+ */
+export declare const collectionsForListing: (deps: CalendarDeps, accountConfigId: string, calendarIds: string[], componentSet?: CalendarCollectionItem["componentSet"]) => Promise<CalendarOutcome<CalendarCollectionItem[]>>;
+/**
+ * An event as the API returns it: the stored row, plus the guest list read
+ * from its bytes and the reader's own place on it.
+ */
+export declare const toEventResponse: (object: CalendarObjectItem, self: ReadonlySet<string>, sends: CalendarSchedulingSend[]) => Promise<CalendarEventResponse>;
 /**
  * Reduce a PATCH body to the event fields an update may set, preserving
  * absence: a body carrying only `summary` yields only `summary`, and the
  * resource's times are then left exactly as they were.
  */
 export declare const pickEventUpdate: (body: Partial<UpdateCalendarEventInput>) => Partial<CalendarEventFields>;
+export declare const pickSchedulingUpdate: (body: Partial<UpdateCalendarEventInput>) => EventSchedulingUpdate;
 /**
  * Whether an `If-Match` header lets the write through.
  *
@@ -55,7 +68,12 @@ export declare const readScope: (value: unknown) => CalendarOutcome<RecurrenceSc
  * user sees twice or not at all.
  */
 export declare const commitScopedWrite: (deps: CalendarEventDeps, accountConfigId: string, object: CalendarObjectItem, collectionTimezone: string, write: ScopedWrite) => Promise<CalendarOutcome<CalendarObjectItem | null>>;
-export declare const createCalendarEventFor: (deps: CalendarEventDeps, accountConfigId: string, input: CreateCalendarEventInput) => Promise<CalendarOutcome<CalendarObjectItem>>;
+/** An event write, and the scheduling messages it queued. */
+export interface ScheduledWrite<T> {
+    object: T;
+    sends: CalendarSchedulingSend[];
+}
+export declare const createCalendarEventFor: (deps: CalendarEventDeps, accountConfigId: string, input: CreateCalendarEventInput) => Promise<CalendarOutcome<ScheduledWrite<CalendarObjectItem>>>;
 export interface ScopedRequest {
     calendarId: string;
     calendarObjectId: string;
@@ -63,8 +81,36 @@ export interface ScopedRequest {
     recurrenceId: string;
     ifMatch: string | undefined;
 }
-export declare const updateCalendarEventFor: (deps: CalendarEventDeps, accountConfigId: string, request: ScopedRequest, patch: Partial<CalendarEventFields>) => Promise<CalendarOutcome<CalendarObjectItem | null>>;
-export declare const deleteCalendarEventFor: (deps: CalendarEventDeps, accountConfigId: string, request: ScopedRequest) => Promise<CalendarOutcome<CalendarObjectItem | null>>;
-export declare const CalendarEventOperations: Record<CalendarEventOperationIds, OperationHandler<CalendarEventOperationIds>>;
-export declare const CalendarEventDetailOperations: Record<CalendarEventDetailOperationIds, OperationHandler<CalendarEventDetailOperationIds>>;
+/**
+ * Edits an event, and queues what the edit owes its guests.
+ *
+ * The calendar row is local truth and is written first. The outbox rows are
+ * the pending records of the messages that follow it: an invitation to every
+ * guest of an event the reader organizes, a cancellation to a guest the edit
+ * removed, a reply to the organizer when the reader answers as a guest. The
+ * outbox lives in another database and is not written in the calendar's
+ * commit; a later edit made while an earlier message is still queued does not
+ * wait for it, and each message carries the SEQUENCE of the bytes it was built
+ * from, so a recipient keeps the newest.
+ */
+export declare const updateCalendarEventFor: (deps: CalendarEventDeps, accountConfigId: string, request: ScopedRequest, patch: Partial<CalendarEventFields>, scheduling?: EventSchedulingUpdate) => Promise<CalendarOutcome<ScheduledWrite<CalendarObjectItem | null>>>;
+/**
+ * Deletes an event, or one occurrence of it, and queues what that owes its
+ * guests: a cancellation each when the whole event goes, the shortened event
+ * when part of a series does. Only an event the reader organizes owes anything.
+ */
+export declare const deleteCalendarEventFor: (deps: CalendarEventDeps, accountConfigId: string, request: ScopedRequest) => Promise<CalendarOutcome<ScheduledWrite<CalendarObjectItem | null>>>;
+export declare const answerRefusal: (error: {
+    code: string;
+    message: string;
+}) => {
+    statusCode: number;
+    body: {
+        code: string;
+        message: string;
+    };
+};
+export declare const readIfMatch: (context: Parameters<OperationHandler>[0]) => string | undefined;
+export declare const CalendarEventOperations: Record<CalendarEventOperationIds, OperationHandler<CalendarEventOperationIds, "smtp">>;
+export declare const CalendarEventDetailOperations: Record<CalendarEventDetailOperationIds, OperationHandler<CalendarEventDetailOperationIds, "smtp">>;
 export declare const CalendarFreeBusyOperations: Record<CalendarFreeBusyOperationIds, OperationHandler<CalendarFreeBusyOperationIds>>;

package/dist/src/handlers/calendar-event.js

@@ -1,7 +1,8 @@
-import { applyScopedDelete, applyScopedUpdate, buildEventCalendar, deleteCalendarObject, followingUidOf, listBusySpans, listCalendarInstances, listObjectInstances, OFFSET_BEARING, parseCalendar, prepareCalendarObject, putCalendarObject, readWrittenObject, toOffsetIso, toUtcIso, } from "@remit/calendar-service";
+import { applyGuestList, applyScopedDelete, applyScopedUpdate, attendeesOf, buildEventCalendar, buildSchedulingMessage, countAttendees, deleteCalendarObject, followingUidOf, listBusySpans, listCalendarInstances, listObjectInstances, OFFSET_BEARING, organizerOf, parseCalendar, participationOf, planCreateSends, planDeleteSends, planEventCreate, planEventUpdate, planUpdateSends, prepareCalendarObject, putCalendarObject, readWrittenObject, SUGGESTION_STATE_OF_ANSWER, schedulingBody, schedulingSubject, selfAddressSet, shapeScheduledUpdate, toOffsetIso, toUtcIso, } from "@remit/calendar-service";
 import { base36uuid } from "@remit/data-ports/id";
-import { RecurrenceScope } from "@remit/domain-enums";
+import { CalendarComponentSet, RecurrenceScope } from "@remit/domain-enums";
 import { badRequest, calendarDepsOf, findCalendarFor, findWritableCalendarFor, listCalendarsFor, notFound, preconditionFailed, refuseCalendar, } from "./calendar.js";
+import { chosenInvitationSender } from "./user-settings.js";
 /**
  * The widest window a single read may ask for. A year covers every view the
  * client has — a year grid is the coarsest — and keeps one request from asking
@@ -9,10 +10,11 @@ import { badRequest, calendarDepsOf, findCalendarFor, findWritableCalendarFor, l
  */
 export const CALENDAR_MAX_WINDOW_DAYS = 366;
 const MAX_WINDOW_MS = CALENDAR_MAX_WINDOW_DAYS * 24 * 60 * 60 * 1000;
-export const calendarEventDepsOf = (deps) => ({
+export const calendarEventDepsOf = (deps, queueScheduled) => ({
     ...deps,
     newId: base36uuid,
     now: () => new Date(),
+    queueScheduled,
 });
 /**
  * Reads the window a listing asked for.
@@ -41,11 +43,18 @@ export const readWindow = (from, to) => {
     }
     return { ok: true, value: { from: toUtcIso(fromMs), to: toUtcIso(toMs) } };
 };
-/** The collections a listing covers, defaulting to every one the caller holds. */
-export const collectionsForListing = async (deps, accountConfigId, calendarIds) => {
+/**
+ * The collections a listing covers, defaulting to every one the caller holds
+ * of the component set asked for.
+ */
+export const collectionsForListing = async (deps, accountConfigId, calendarIds, componentSet = CalendarComponentSet.VeventOnly) => {
     const held = await listCalendarsFor(deps, accountConfigId);
-    if (calendarIds.length === 0)
-        return { ok: true, value: held };
+    if (calendarIds.length === 0) {
+        return {
+            ok: true,
+            value: held.filter((collection) => collection.componentSet === componentSet),
+        };
+    }
     const selected = held.filter((collection) => calendarIds.includes(collection.calendarId));
     const missing = calendarIds.find((calendarId) => !held.some((collection) => collection.calendarId === calendarId));
     if (missing) {
@@ -53,6 +62,9 @@ export const collectionsForListing = async (deps, accountConfigId, calendarIds)
     }
     return { ok: true, value: selected };
 };
+/** The account config's accounts: who the reader is, and who can send. */
+const accountsOf = (deps, accountConfigId) => deps.accounts.listAllByAccountConfig(accountConfigId);
+const selfOf = (accounts) => selfAddressSet(accounts.map((account) => account.email));
 const toInstanceResponse = (instance) => ({
     calendarId: instance.calendarId,
     calendarObjectId: instance.calendarObjectId,
@@ -67,28 +79,70 @@ const toInstanceResponse = (instance) => ({
     zoneCertainty: instance.zoneCertainty,
     etag: instance.etag,
     hasRecurrence: instance.hasRecurrence,
+    participation: instance.participation,
 });
-const toEventResponse = (object) => ({
-    calendarObjectId: object.calendarObjectId,
-    calendarId: object.calendarId,
-    resourceName: object.resourceName,
-    icalUid: object.icalUid,
-    icalData: object.icalData,
-    etag: object.etag,
-    sequence: object.sequence,
-    syncSequence: object.syncSequence,
-    summary: object.summary,
-    dtStart: object.dtStart,
-    dtEnd: object.dtEnd,
-    allDay: object.allDay,
-    zoneCertainty: object.zoneCertainty,
-    status: object.status,
-    transparency: object.transparency,
-    hasRecurrence: object.hasRecurrence,
-    expandedThrough: object.expandedThrough,
-    createdAt: object.createdAt,
-    updatedAt: object.updatedAt,
-});
+const parsedOrThrow = async (object) => {
+    const parsed = await parseCalendar(object.icalData);
+    if (!parsed.ok) {
+        throw new Error(`stored calendar object ${object.calendarObjectId} no longer parses: ${parsed.error.message}`);
+    }
+    return parsed.value;
+};
+/** The scheduling messages about an event still in the outbox. */
+const pendingSends = async (deps, accountConfigId, calendarObjectId) => {
+    const parts = await deps.outboxSchedulingPart.listByCalendarObject(accountConfigId, calendarObjectId);
+    if (parts.length === 0)
+        return [];
+    const rows = await deps.outboxMessage.get(accountConfigId, parts.map((part) => part.outboxMessageId));
+    const byId = new Map(rows.map((row) => [row.outboxMessageId, row]));
+    return parts.flatMap((part) => {
+        const row = byId.get(part.outboxMessageId);
+        return row
+            ? [
+                {
+                    email: part.recipient,
+                    outboxMessageId: row.outboxMessageId,
+                    method: part.method,
+                    status: row.status,
+                },
+            ]
+            : [];
+    });
+};
+/**
+ * An event as the API returns it: the stored row, plus the guest list read
+ * from its bytes and the reader's own place on it.
+ */
+export const toEventResponse = async (object, self, sends) => {
+    const { master } = await parsedOrThrow(object);
+    const attendees = attendeesOf(master);
+    return {
+        calendarObjectId: object.calendarObjectId,
+        calendarId: object.calendarId,
+        resourceName: object.resourceName,
+        icalUid: object.icalUid,
+        icalData: object.icalData,
+        etag: object.etag,
+        sequence: object.sequence,
+        syncSequence: object.syncSequence,
+        summary: object.summary,
+        dtStart: object.dtStart,
+        dtEnd: object.dtEnd,
+        allDay: object.allDay,
+        zoneCertainty: object.zoneCertainty,
+        status: object.status,
+        transparency: object.transparency,
+        hasRecurrence: object.hasRecurrence,
+        expandedThrough: object.expandedThrough,
+        createdAt: object.createdAt,
+        updatedAt: object.updatedAt,
+        participation: participationOf(master, self),
+        organizer: organizerOf(master),
+        attendees,
+        attendeeCounts: countAttendees(attendees),
+        sends,
+    };
+};
 const eventFieldsOf = (input) => ({
     summary: input.summary,
     description: input.description ?? "",
@@ -127,6 +181,13 @@ export const pickEventUpdate = (body) => {
     }
     return patch;
 };
+export const pickSchedulingUpdate = (body) => ({
+    ...(body.attendees !== undefined && { attendees: body.attendees }),
+    ...(body.organizerAccountId !== undefined && {
+        organizerAccountId: body.organizerAccountId,
+    }),
+    ...(body.answer !== undefined && { answer: body.answer }),
+});
 /**
  * Whether an `If-Match` header lets the write through.
  *
@@ -161,23 +222,14 @@ export const readScope = (value) => {
     return refuseCalendar("InvalidScope", `scope must be one of This, Following or All, and this request sent "${String(value)}"`);
 };
 /**
- * Writes what a scoped edit resolved to.
+ * Turns what a scoped edit resolved to into the store writes it is.
  *
- * A split is two resources and one write set: the truncated original and the
- * remainder land together or not at all, because half a split is a series the
- * user sees twice or not at all.
+ * Both halves of a split are prepared before either is written, so a refusal
+ * of either one commits nothing: half a split is never stored.
  */
-export const commitScopedWrite = async (deps, accountConfigId, object, collectionTimezone, write) => {
-    if (write.kind === "Delete") {
-        await deleteCalendarObject(deps.calendarStore, {
-            accountConfigId,
-            calendarId: object.calendarId,
-            calendarObjectId: object.calendarObjectId,
-        });
-        return { ok: true, value: null };
-    }
-    // Both resources are prepared before either is written, so a refusal of
-    // either one commits nothing: half a split is never stored.
+const prepareScopedWrite = async (deps, accountConfigId, object, collectionTimezone, write) => {
+    if (write.kind === "Delete")
+        return { ok: true, value: { kind: "Delete", puts: [] } };
     const zone = { timezone: collectionTimezone };
     const head = await prepareCalendarObject(zone, {
         accountConfigId,
@@ -188,11 +240,7 @@ export const commitScopedWrite = async (deps, accountConfigId, object, collectio
     if (!head.ok)
         return head;
     if (write.kind === "Replace") {
-        await deps.calendarStore.commit([head.value]);
-        return {
-            ok: true,
-            value: await readWrittenObject(deps.calendarStore, head.value),
-        };
+        return { ok: true, value: { kind: "Replace", puts: [head.value] } };
     }
     const following = await prepareCalendarObject(zone, {
         accountConfigId,
@@ -202,29 +250,112 @@ export const commitScopedWrite = async (deps, accountConfigId, object, collectio
     });
     if (!following.ok)
         return following;
-    await deps.calendarStore.commit([head.value, following.value]);
-    // The remainder is what the patch applied to, and it lives under an id the
-    // caller has never seen — returning the truncated head instead would leave
-    // them holding the resource their edit is not in.
     return {
         ok: true,
-        value: await readWrittenObject(deps.calendarStore, following.value),
+        value: { kind: "Split", puts: [head.value, following.value] },
     };
 };
+/**
+ * Commits a prepared write and reads back what it stored, in write order. The
+ * last one is what the patch applied to: for a split, the remainder, under an
+ * id the caller has never seen.
+ */
+const commitPrepared = async (deps, accountConfigId, object, prepared) => {
+    if (prepared.kind === "Delete") {
+        await deleteCalendarObject(deps.calendarStore, {
+            accountConfigId,
+            calendarId: object.calendarId,
+            calendarObjectId: object.calendarObjectId,
+        });
+        return [];
+    }
+    await deps.calendarStore.commit(prepared.puts);
+    const written = [];
+    for (const put of prepared.puts) {
+        written.push(await readWrittenObject(deps.calendarStore, put));
+    }
+    return written;
+};
+/**
+ * Writes what a scoped edit resolved to.
+ *
+ * A split is two resources and one write set: the truncated original and the
+ * remainder land together or not at all, because half a split is a series the
+ * user sees twice or not at all.
+ */
+export const commitScopedWrite = async (deps, accountConfigId, object, collectionTimezone, write) => {
+    const prepared = await prepareScopedWrite(deps, accountConfigId, object, collectionTimezone, write);
+    if (!prepared.ok)
+        return prepared;
+    const written = await commitPrepared(deps, accountConfigId, object, prepared.value);
+    return { ok: true, value: written.at(-1) ?? null };
+};
+/**
+ * Queues every planned message, one outbox row each, from the account the plan
+ * names. The rows are the pending records; the send worker settles each one.
+ */
+const queueSends = async (deps, accountConfigId, sends) => {
+    if (!sends)
+        return [];
+    const queued = [];
+    for (const plan of sends.plans) {
+        const message = await buildSchedulingMessage(plan.icalData, {
+            method: plan.method,
+            now: deps.now(),
+            attendee: plan.attendee,
+            recurrenceId: plan.recurrenceId,
+            collectionTimezone: plan.collectionTimezone,
+        });
+        const subject = schedulingSubject(plan.method, message.summary, plan.answer);
+        const row = await deps.queueScheduled({
+            accountId: sends.from.accountId,
+            accountConfigId,
+            fromAddress: sends.from.email,
+            toAddresses: [plan.recipient.email],
+            subject,
+            textBody: schedulingBody(subject, message.icalData),
+        }, {
+            calendarObjectId: plan.calendarObjectId,
+            recipient: plan.recipient.email,
+            method: plan.method,
+            sequence: message.sequence,
+            icalData: message.icalData,
+        });
+        queued.push({
+            email: plan.recipient.email,
+            outboxMessageId: row.outboxMessageId,
+            method: plan.method,
+            status: row.status,
+        });
+    }
+    return queued;
+};
 export const createCalendarEventFor = async (deps, accountConfigId, input) => {
     const collection = await findWritableCalendarFor(deps, accountConfigId, input.calendarId);
     if (!collection.ok)
         return collection;
+    const planned = planEventCreate(await accountsOf(deps, accountConfigId), await chosenInvitationSender(deps.accountSetting, accountConfigId), input.attendees ?? [], input.organizerAccountId);
+    if (!planned.ok)
+        return planned;
     const id = deps.newId();
     const built = await buildEventCalendar(eventFieldsOf(input), `${id}@reader.remit`, deps.now());
     if (!built.ok)
         return built;
-    return putCalendarObject(deps.calendarStore, {
+    const icalData = planned.value
+        ? await applyGuestList(built.value, { email: planned.value.organizer.email, displayName: "" }, planned.value.guests)
+        : built.value;
+    const stored = await putCalendarObject(deps.calendarStore, {
         accountConfigId,
         calendarId: collection.value.calendarId,
         resourceName: `${id}.ics`,
-        icalData: built.value,
+        icalData,
     });
+    if (!stored.ok)
+        return stored;
+    const sends = planned.value
+        ? await queueSends(deps, accountConfigId, planCreateSends(planned.value, stored.value, collection.value.timezone))
+        : [];
+    return { ok: true, value: { object: stored.value, sends } };
 };
 const resolveResource = async (deps, accountConfigId, request, intent) => {
     const collection = intent === "write"
@@ -238,47 +369,102 @@ const resolveResource = async (deps, accountConfigId, request, intent) => {
     }
     return { ok: true, value: { collection: collection.value, object } };
 };
-export const updateCalendarEventFor = async (deps, accountConfigId, request, patch) => {
+/**
+ * A card whose answer wrote this event follows a later answer given on the
+ * event, so the mail and the calendar never disagree about what was said.
+ */
+const settleAnsweredSuggestions = async (deps, accountConfigId, calendarObjectId, answer) => {
+    const cards = await deps.calendarStore.repos.calendarSuggestion.listByAcceptedCalendarObjects(accountConfigId, [calendarObjectId]);
+    if (cards.length === 0)
+        return;
+    await deps.calendarStore.commit(cards.map((card) => ({
+        kind: "SettleSuggestion",
+        accountConfigId,
+        suggestionId: card.suggestionId,
+        settle: {
+            state: SUGGESTION_STATE_OF_ANSWER[answer],
+            acceptedCalendarObjectId: calendarObjectId,
+        },
+    })));
+};
+const refuseStale = () => refuseCalendar("EtagMismatch", "this event has been written since you read it — read it again and reapply the change");
+/**
+ * Edits an event, and queues what the edit owes its guests.
+ *
+ * The calendar row is local truth and is written first. The outbox rows are
+ * the pending records of the messages that follow it: an invitation to every
+ * guest of an event the reader organizes, a cancellation to a guest the edit
+ * removed, a reply to the organizer when the reader answers as a guest. The
+ * outbox lives in another database and is not written in the calendar's
+ * commit; a later edit made while an earlier message is still queued does not
+ * wait for it, and each message carries the SEQUENCE of the bytes it was built
+ * from, so a recipient keeps the newest.
+ */
+export const updateCalendarEventFor = async (deps, accountConfigId, request, patch, scheduling = {}) => {
     const resolved = await resolveResource(deps, accountConfigId, request, "write");
     if (!resolved.ok)
         return resolved;
     const { collection, object } = resolved.value;
-    if (!etagMatches(request.ifMatch, object.etag)) {
-        return refuseCalendar("EtagMismatch", "this event has been written since you read it — read it again and reapply the change");
-    }
-    const parsed = await parseCalendar(object.icalData);
-    if (!parsed.ok) {
-        throw new Error(`stored calendar object ${object.calendarObjectId} no longer parses: ${parsed.error.message}`);
-    }
-    const write = await applyScopedUpdate(parsed.value, collection.timezone, {
+    if (!etagMatches(request.ifMatch, object.etag))
+        return refuseStale();
+    const parsed = await parsedOrThrow(object);
+    const accounts = await accountsOf(deps, accountConfigId);
+    const planned = planEventUpdate(parsed, accounts, await chosenInvitationSender(deps.accountSetting, accountConfigId), request.scope, scheduling);
+    if (!planned.ok)
+        return planned;
+    const write = await applyScopedUpdate(parsed, collection.timezone, {
         scope: request.scope,
         recurrenceId: request.recurrenceId,
         followingUid: followingUidOf(object.icalUid, `${deps.newId()}@reader.remit`),
     }, patch);
     if (!write.ok)
         return write;
-    return commitScopedWrite(deps, accountConfigId, object, collection.timezone, write.value);
+    if (write.value.kind === "Delete") {
+        throw new Error("a scoped update resolved to a delete");
+    }
+    const shaped = await shapeScheduledUpdate(write.value, planned.value, scheduling, patch, collection.timezone, request.scope, request.recurrenceId);
+    if (!shaped.ok)
+        return shaped;
+    const prepared = await prepareScopedWrite(deps, accountConfigId, object, collection.timezone, shaped.value);
+    if (!prepared.ok)
+        return prepared;
+    const written = await commitPrepared(deps, accountConfigId, object, prepared.value);
+    const result = written.at(-1) ?? null;
+    if (scheduling.answer !== undefined &&
+        request.scope === RecurrenceScope.All &&
+        result) {
+        await settleAnsweredSuggestions(deps, accountConfigId, result.calendarObjectId, scheduling.answer);
+    }
+    const sends = await queueSends(deps, accountConfigId, await planUpdateSends(planned.value, accounts, scheduling, object, written, collection.timezone, request.scope, request.recurrenceId));
+    return { ok: true, value: { object: result, sends } };
 };
+/**
+ * Deletes an event, or one occurrence of it, and queues what that owes its
+ * guests: a cancellation each when the whole event goes, the shortened event
+ * when part of a series does. Only an event the reader organizes owes anything.
+ */
 export const deleteCalendarEventFor = async (deps, accountConfigId, request) => {
     const resolved = await resolveResource(deps, accountConfigId, request, "write");
     if (!resolved.ok)
         return resolved;
     const { collection, object } = resolved.value;
-    if (!etagMatches(request.ifMatch, object.etag)) {
-        return refuseCalendar("EtagMismatch", "this event has been written since you read it — read it again and reapply the change");
-    }
-    const parsed = await parseCalendar(object.icalData);
-    if (!parsed.ok) {
-        throw new Error(`stored calendar object ${object.calendarObjectId} no longer parses: ${parsed.error.message}`);
-    }
-    const write = await applyScopedDelete(parsed.value, collection.timezone, {
+    if (!etagMatches(request.ifMatch, object.etag))
+        return refuseStale();
+    const parsed = await parsedOrThrow(object);
+    const write = await applyScopedDelete(parsed, collection.timezone, {
         scope: request.scope,
         recurrenceId: request.recurrenceId,
         followingUid: "",
     });
     if (!write.ok)
         return write;
-    return commitScopedWrite(deps, accountConfigId, object, collection.timezone, write.value);
+    const prepared = await prepareScopedWrite(deps, accountConfigId, object, collection.timezone, write.value);
+    if (!prepared.ok)
+        return prepared;
+    const written = await commitPrepared(deps, accountConfigId, object, prepared.value);
+    const result = written.at(-1) ?? null;
+    const sends = await queueSends(deps, accountConfigId, planDeleteSends(parsed, await accountsOf(deps, accountConfigId), object, result, collection.timezone));
+    return { ok: true, value: { object: result, sends } };
 };
 /** The collection holding a resource, found among the ones given. */
 const locateResource = async (deps, collections, calendarObjectId) => {
@@ -296,19 +482,21 @@ const readCalendarIds = (value) => {
         return value.filter((id) => typeof id === "string");
     return [];
 };
-const answerRefusal = (error) => error.code === "NotFound"
+export const answerRefusal = (error) => error.code === "NotFound"
     ? notFound(error.message)
     : error.code === "EtagMismatch"
         ? preconditionFailed(error.message)
         : badRequest(error);
+export const readIfMatch = (context) => {
+    const headers = (context.request.headers ?? {});
+    return Object.entries(headers).find(([name]) => name.toLowerCase() === "if-match")?.[1];
+};
 const scopedRequestOf = (context) => {
     const params = context.request.params;
     const query = context.request.query;
     const scope = readScope(query.scope);
     if (!scope.ok)
         return scope;
-    const headers = (context.request.headers ?? {});
-    const ifMatch = Object.entries(headers).find(([name]) => name.toLowerCase() === "if-match")?.[1];
     return {
         ok: true,
         value: {
@@ -316,10 +504,11 @@ const scopedRequestOf = (context) => {
             calendarObjectId: params.calendarObjectId,
             scope: scope.value,
             recurrenceId: query.recurrenceId ?? "",
-            ifMatch,
+            ifMatch: readIfMatch(context),
         },
     };
 };
+const writeDepsOf = (ctx) => calendarEventDepsOf(calendarDepsOf(ctx.client), (input, part) => ctx.client.outboxQueue.createAndSendScheduled(input, part));
 export const CalendarEventOperations = {
     CalendarEventOperations_listCalendarEvents: async (context, ctx) => {
         const accountConfigId = ctx.identity.accountConfigId;
@@ -331,24 +520,25 @@ export const CalendarEventOperations = {
         const collections = await collectionsForListing(deps, accountConfigId, readCalendarIds(query.calendarId));
         if (!collections.ok)
             return answerRefusal(collections.error);
+        const self = selfOf(await accountsOf(deps, accountConfigId));
         if (query.calendarObjectId) {
             const located = await locateResource(deps, collections.value, query.calendarObjectId);
             if (!located)
                 return { items: [] };
-            const own = await listObjectInstances(deps, located.collection, located.object, window.value);
+            const own = await listObjectInstances(deps, located.collection, located.object, window.value, self);
             return { items: own.map(toInstanceResponse) };
         }
-        const instances = await listCalendarInstances(deps, collections.value, window.value);
+        const instances = await listCalendarInstances(deps, collections.value, window.value, self);
         return { items: instances.map(toInstanceResponse) };
     },
     CalendarEventOperations_createCalendarEvent: async (context, ctx) => {
         const accountConfigId = ctx.identity.accountConfigId;
         const input = context.request.requestBody;
-        const deps = calendarEventDepsOf(calendarDepsOf(ctx.client));
+        const deps = writeDepsOf(ctx);
         const created = await createCalendarEventFor(deps, accountConfigId, input);
         if (!created.ok)
             return answerRefusal(created.error);
-        return toEventResponse(created.value);
+        return toEventResponse(created.value.object, selfOf(await accountsOf(deps, accountConfigId)), created.value.sends);
     },
 };
 export const CalendarEventDetailOperations = {
@@ -357,18 +547,20 @@ export const CalendarEventDetailOperations = {
         const request = scopedRequestOf(context);
         if (!request.ok)
             return badRequest(request.error);
-        const deps = calendarEventDepsOf(calendarDepsOf(ctx.client));
-        if (request.value.calendarId === "") {
-            const located = await locateResource(deps, await listCalendarsFor(deps, accountConfigId), request.value.calendarObjectId);
-            if (!located) {
-                return notFound(`no event ${request.value.calendarObjectId} on this account`);
-            }
-            return toEventResponse(located.object);
+        const deps = calendarDepsOf(ctx.client);
+        const self = selfOf(await accountsOf(deps, accountConfigId));
+        const found = request.value.calendarId === ""
+            ? await locateResource(deps, await listCalendarsFor(deps, accountConfigId), request.value.calendarObjectId)
+            : undefined;
+        if (request.value.calendarId === "" && !found) {
+            return notFound(`no event ${request.value.calendarObjectId} on this account`);
         }
-        const resolved = await resolveResource(deps, accountConfigId, request.value, "read");
+        const resolved = found
+            ? { ok: true, value: found }
+            : await resolveResource(deps, accountConfigId, request.value, "read");
         if (!resolved.ok)
             return answerRefusal(resolved.error);
-        return toEventResponse(resolved.value.object);
+        return toEventResponse(resolved.value.object, self, await pendingSends(deps, accountConfigId, resolved.value.object.calendarObjectId));
     },
     CalendarEventDetailOperations_updateCalendarEvent: async (context, ctx) => {
         const accountConfigId = ctx.identity.accountConfigId;
@@ -377,25 +569,24 @@ export const CalendarEventDetailOperations = {
         const request = scopedRequestOf(context);
         if (!request.ok)
             return badRequest(request.error);
-        const deps = calendarEventDepsOf(calendarDepsOf(ctx.client));
-        const updated = await updateCalendarEventFor(deps, accountConfigId, request.value, pickEventUpdate(body));
+        const deps = writeDepsOf(ctx);
+        const updated = await updateCalendarEventFor(deps, accountConfigId, request.value, pickEventUpdate(body), pickSchedulingUpdate(body));
         if (!updated.ok)
             return answerRefusal(updated.error);
-        if (!updated.value) {
+        if (!updated.value.object) {
             throw new Error("a scoped update resolved to a delete");
         }
-        return toEventResponse(updated.value);
+        return toEventResponse(updated.value.object, selfOf(await accountsOf(deps, accountConfigId)), updated.value.sends);
     },
     CalendarEventDetailOperations_deleteCalendarEvent: async (context, ctx) => {
         const accountConfigId = ctx.identity.accountConfigId;
         const request = scopedRequestOf(context);
         if (!request.ok)
             return badRequest(request.error);
-        const deps = calendarEventDepsOf(calendarDepsOf(ctx.client));
-        const removed = await deleteCalendarEventFor(deps, accountConfigId, request.value);
+        const removed = await deleteCalendarEventFor(writeDepsOf(ctx), accountConfigId, request.value);
         if (!removed.ok)
             return answerRefusal(removed.error);
-        return { statusCode: 204 };
+        return { statusCode: 200, body: { sends: removed.value.sends } };
     },
 };
 export const CalendarFreeBusyOperations = {
@@ -406,8 +597,8 @@ export const CalendarFreeBusyOperations = {
         if (!window.ok)
             return badRequest(window.error);
         const deps = calendarDepsOf(ctx.client);
-        const collections = await listCalendarsFor(deps, accountConfigId);
-        const spans = await listBusySpans(deps, collections, window.value);
+        const collections = (await listCalendarsFor(deps, accountConfigId)).filter((collection) => collection.componentSet === CalendarComponentSet.VeventOnly);
+        const spans = await listBusySpans(deps, collections, window.value, selfOf(await accountsOf(deps, accountConfigId)));
         const items = spans.map((span) => ({
             start: toOffsetIso(span.startMs, "UTC"),
             end: toOffsetIso(span.endMs, "UTC"),

package/dist/src/handlers/calendar-suggestion.js

@@ -136,6 +136,9 @@ export const CalendarSuggestionActionOperations = {
             .request.requestBody;
         const client = ctx.client;
         const suggestion = await client.calendarSuggestion.get(accountConfigId, suggestionId);
+        if (answer === CalendarInviteAnswer.Declined) {
+            throw new BadRequestError("Accepting cannot decline an invitation. Decline it with decline instead.");
+        }
         if (answer === CalendarInviteAnswer.Tentative &&
             suggestion.method === CalendarInviteMethod.Cancel) {
             throw new BadRequestError("This is a cancellation, so there is nothing to answer maybe to.");

package/dist/src/handlers/calendar-task.d.ts

@@ -0,0 +1,17 @@
+import type { CreateCalendarTaskInput } from "@remit/api-openapi-types";
+import { type CalendarTaskFields } from "@remit/calendar-service";
+import type { CalendarCollectionItem, CalendarTaskItem } from "@remit/data-ports";
+import type { CalendarTaskDetailOperationIds, CalendarTaskOperationIds, OperationHandler } from "../types.js";
+import { type CalendarDeps, type CalendarOutcome } from "./calendar.js";
+/** The task collection a write goes to: the one named, or the account's own. */
+export declare const taskCalendarFor: (deps: CalendarDeps, accountConfigId: string, calendarId: string) => Promise<CalendarOutcome<CalendarCollectionItem>>;
+export declare const createCalendarTaskFor: (deps: CalendarDeps, accountConfigId: string, input: CreateCalendarTaskInput, newId?: () => string, now?: Date) => Promise<CalendarOutcome<CalendarTaskItem>>;
+interface TaskRequest {
+    calendarId: string;
+    calendarTaskId: string;
+    ifMatch: string | undefined;
+}
+export declare const updateCalendarTaskFor: (deps: CalendarDeps, accountConfigId: string, request: TaskRequest, patch: Partial<CalendarTaskFields>, now?: Date) => Promise<CalendarOutcome<CalendarTaskItem>>;
+export declare const CalendarTaskOperations: Record<CalendarTaskOperationIds, OperationHandler<CalendarTaskOperationIds>>;
+export declare const CalendarTaskDetailOperations: Record<CalendarTaskDetailOperationIds, OperationHandler<CalendarTaskDetailOperationIds>>;
+export {};

package/dist/src/handlers/calendar-task.js

@@ -0,0 +1,175 @@
+import { buildTaskCalendar, listTasksInWindow, prepareCalendarTask, updateTaskCalendar, } from "@remit/calendar-service";
+import { base36uuid } from "@remit/data-ports/id";
+import { CalendarComponentSet } from "@remit/domain-enums";
+import { calendarDepsOf, listCalendarsFor, notFound, refuseCalendar, } from "./calendar.js";
+import { answerRefusal, collectionsForListing, etagMatches, readIfMatch, readWindow, } from "./calendar-event.js";
+const toTaskResponse = (task) => ({
+    calendarTaskId: task.calendarTaskId,
+    calendarId: task.calendarId,
+    resourceName: task.resourceName,
+    icalUid: task.icalUid,
+    icalData: task.icalData,
+    etag: task.etag,
+    summary: task.summary,
+    description: task.description,
+    due: task.due,
+    dueAt: task.dueAt,
+    allDay: task.allDay,
+    completed: task.completed,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+});
+const isTaskCollection = (collection) => collection.componentSet === CalendarComponentSet.VtodoOnly;
+/** The task collection a write goes to: the one named, or the account's own. */
+export const taskCalendarFor = async (deps, accountConfigId, calendarId) => {
+    const held = await listCalendarsFor(deps, accountConfigId);
+    if (calendarId === "") {
+        const own = held.find(isTaskCollection);
+        if (!own)
+            throw new Error("listCalendarsFor provisioned no task collection");
+        return { ok: true, value: own };
+    }
+    const named = held.find((collection) => collection.calendarId === calendarId);
+    if (!named) {
+        return refuseCalendar("NotFound", `no calendar ${calendarId} on this account`);
+    }
+    if (!isTaskCollection(named)) {
+        return refuseCalendar("NotATaskCalendar", `"${named.displayName}" holds events, so a task cannot be written into it`);
+    }
+    return { ok: true, value: named };
+};
+const pickTaskUpdate = (body) => {
+    const patch = {};
+    for (const field of [
+        "summary",
+        "description",
+        "due",
+        "allDay",
+        "timeZone",
+        "completed",
+    ]) {
+        if (!Object.hasOwn(body, field))
+            continue;
+        Object.assign(patch, { [field]: body[field] });
+    }
+    return patch;
+};
+export const createCalendarTaskFor = async (deps, accountConfigId, input, newId = base36uuid, now = new Date()) => {
+    const collection = await taskCalendarFor(deps, accountConfigId, input.calendarId ?? "");
+    if (!collection.ok)
+        return collection;
+    const id = newId();
+    const built = buildTaskCalendar({
+        summary: input.summary,
+        description: input.description ?? "",
+        due: input.due,
+        allDay: input.allDay ?? false,
+        timeZone: input.timeZone ?? "",
+        completed: false,
+    }, `${id}@reader.remit`, now);
+    if (!built.ok)
+        return built;
+    const row = await prepareCalendarTask(collection.value, `${id}.ics`, built.value);
+    if (!row.ok)
+        return row;
+    return { ok: true, value: await deps.calendarTask.put(row.value) };
+};
+const resolveTask = async (deps, accountConfigId, request) => {
+    const collection = await taskCalendarFor(deps, accountConfigId, request.calendarId);
+    if (!collection.ok)
+        return collection;
+    const task = await deps.calendarTask.find(collection.value.calendarId, request.calendarTaskId);
+    if (!task) {
+        return refuseCalendar("NotFound", `no task ${request.calendarTaskId} in this calendar`);
+    }
+    if (!etagMatches(request.ifMatch, task.etag)) {
+        return refuseCalendar("EtagMismatch", "this task has been written since you read it — read it again and reapply the change");
+    }
+    return { ok: true, value: { collection: collection.value, task } };
+};
+export const updateCalendarTaskFor = async (deps, accountConfigId, request, patch, now = new Date()) => {
+    const resolved = await resolveTask(deps, accountConfigId, request);
+    if (!resolved.ok)
+        return resolved;
+    const { collection, task } = resolved.value;
+    const rewritten = await updateTaskCalendar(task.icalData, patch, collection.timezone, now);
+    if (!rewritten.ok)
+        return rewritten;
+    const row = await prepareCalendarTask(collection, task.resourceName, rewritten.value);
+    if (!row.ok)
+        return row;
+    return { ok: true, value: await deps.calendarTask.put(row.value) };
+};
+const taskRequestOf = (context) => {
+    const { calendarTaskId } = context.request.params;
+    const { calendarId } = context.request.query;
+    return {
+        calendarId: calendarId ?? "",
+        calendarTaskId,
+        ifMatch: readIfMatch(context),
+    };
+};
+const readCalendarIds = (value) => {
+    if (typeof value === "string")
+        return value === "" ? [] : [value];
+    if (Array.isArray(value))
+        return value.filter((id) => typeof id === "string");
+    return [];
+};
+export const CalendarTaskOperations = {
+    CalendarTaskOperations_listCalendarTasks: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const query = context.request.query;
+        const window = readWindow(query.from, query.to);
+        if (!window.ok)
+            return answerRefusal(window.error);
+        const deps = calendarDepsOf(ctx.client);
+        const collections = await collectionsForListing(deps, accountConfigId, readCalendarIds(query.calendarId), CalendarComponentSet.VtodoOnly);
+        if (!collections.ok)
+            return answerRefusal(collections.error);
+        const tasks = await listTasksInWindow(deps.calendarTask, collections.value.filter(isTaskCollection), window.value);
+        return { items: tasks.map(toTaskResponse) };
+    },
+    CalendarTaskOperations_createCalendarTask: async (context, ctx) => {
+        const created = await createCalendarTaskFor(calendarDepsOf(ctx.client), ctx.identity.accountConfigId, context.request.requestBody);
+        if (!created.ok)
+            return answerRefusal(created.error);
+        return toTaskResponse(created.value);
+    },
+};
+export const CalendarTaskDetailOperations = {
+    CalendarTaskDetailOperations_getCalendarTask: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const deps = calendarDepsOf(ctx.client);
+        const request = taskRequestOf(context);
+        if (request.calendarId === "") {
+            for (const collection of (await listCalendarsFor(deps, accountConfigId)).filter(isTaskCollection)) {
+                const task = await deps.calendarTask.find(collection.calendarId, request.calendarTaskId);
+                if (task)
+                    return toTaskResponse(task);
+            }
+            return notFound(`no task ${request.calendarTaskId} on this account`);
+        }
+        const resolved = await resolveTask(deps, accountConfigId, {
+            ...request,
+            ifMatch: undefined,
+        });
+        if (!resolved.ok)
+            return answerRefusal(resolved.error);
+        return toTaskResponse(resolved.value.task);
+    },
+    CalendarTaskDetailOperations_updateCalendarTask: async (context, ctx) => {
+        const updated = await updateCalendarTaskFor(calendarDepsOf(ctx.client), ctx.identity.accountConfigId, taskRequestOf(context), pickTaskUpdate(context.request.requestBody));
+        if (!updated.ok)
+            return answerRefusal(updated.error);
+        return toTaskResponse(updated.value);
+    },
+    CalendarTaskDetailOperations_deleteCalendarTask: async (context, ctx) => {
+        const deps = calendarDepsOf(ctx.client);
+        const resolved = await resolveTask(deps, ctx.identity.accountConfigId, taskRequestOf(context));
+        if (!resolved.ok)
+            return answerRefusal(resolved.error);
+        await deps.calendarTask.delete(resolved.value.collection.calendarId, resolved.value.task.calendarTaskId);
+        return { statusCode: 204 };
+    },
+};

package/dist/src/handlers/calendar.d.ts

@@ -1,6 +1,6 @@
 import type { CreateCalendarInput, UpdateCalendarInput } from "@remit/api-openapi-types";
 import { type CalendarFeedFetcher } from "@remit/calendar-service";
-import type { CalendarCollectionItem, ICalendarCollectionRepository, ICalendarEventIndexRepository, ICalendarFeedTokenRepository, ICalendarObjectRepository, ICalendarStore, UpdateCalendarCollectionInput } from "@remit/data-ports";
+import type { CalendarCollectionItem, IAccountRepository, IAccountSettingRepository, ICalendarCollectionRepository, ICalendarEventIndexRepository, ICalendarFeedTokenRepository, ICalendarObjectRepository, ICalendarStore, ICalendarTaskRepository, IOutboxMessageRepository, IOutboxSchedulingPartRepository, UpdateCalendarCollectionInput } from "@remit/data-ports";
 import type { RemitClient } from "../service/data-client.js";
 import type { CalendarCollectionDetailOperationIds, CalendarDetailOperationIds, CalendarOperationIds, OperationHandler } from "../types.js";
 /** The calendar store, as the handlers reach it. */
@@ -10,6 +10,11 @@ export interface CalendarDeps {
     calendarEventIndex: ICalendarEventIndexRepository;
     calendarFeedToken: ICalendarFeedTokenRepository;
     calendarStore: ICalendarStore;
+    calendarTask: ICalendarTaskRepository;
+    accounts: Pick<IAccountRepository, "listAllByAccountConfig">;
+    accountSetting: Pick<IAccountSettingRepository, "get">;
+    outboxMessage: Pick<IOutboxMessageRepository, "get">;
+    outboxSchedulingPart: Pick<IOutboxSchedulingPartRepository, "listByCalendarObject">;
 }
 /** Why a calendar request was refused, in a form a client can branch on. */
 export interface CalendarRefusal {

package/dist/src/handlers/calendar.js

@@ -1,6 +1,6 @@
-import { DEFAULT_CALENDAR_URL_SEGMENT, isResolvableZone, prepareCalendarObject, provisionDefaultCalendar, readCalendarFeed, readSubscriptionUrl, writeCalendarFeed, } from "@remit/calendar-service";
+import { DEFAULT_CALENDAR_URL_SEGMENT, isResolvableZone, prepareCalendarObject, provisionDefaultCalendar, provisionTaskCalendar, readCalendarFeed, readSubscriptionUrl, writeCalendarFeed, } from "@remit/calendar-service";
 import { normalizeCalendarUrlSegment } from "@remit/data-ports/id";
-import { CalendarSource } from "@remit/domain-enums";
+import { CalendarComponentSet, CalendarSource } from "@remit/domain-enums";
 import { defaultErrorCode } from "../error.js";
 export const refuseCalendar = (code, message) => ({ ok: false, error: { code, message } });
 /**
@@ -36,6 +36,11 @@ export const calendarDepsOf = (client) => ({
     calendarEventIndex: client.calendarEventIndex,
     calendarFeedToken: client.calendarFeedToken,
     calendarStore: client.calendarStore,
+    calendarTask: client.calendarTask,
+    accounts: client.account,
+    accountSetting: client.accountSetting,
+    outboxMessage: client.outboxMessage,
+    outboxSchedulingPart: client.outboxSchedulingPart,
 });
 const toCalendarResponse = (item) => ({
     calendarId: item.calendarId,
@@ -66,9 +71,15 @@ const toCalendarResponse = (item) => ({
  */
 export const listCalendarsFor = async (deps, accountConfigId) => {
     const existing = await deps.calendarCollection.listByAccountConfig(accountConfigId);
-    if (existing.length > 0)
+    const hasEvents = existing.some((collection) => collection.componentSet === CalendarComponentSet.VeventOnly);
+    const hasTasks = existing.some((collection) => collection.componentSet === CalendarComponentSet.VtodoOnly);
+    if (hasEvents && hasTasks)
         return existing;
-    await provisionDefaultCalendar(deps.calendarStore, accountConfigId);
+    if (!hasEvents) {
+        await provisionDefaultCalendar(deps.calendarStore, accountConfigId);
+    }
+    if (!hasTasks)
+        await provisionTaskCalendar(deps.calendarStore, accountConfigId);
     return deps.calendarCollection.listByAccountConfig(accountConfigId);
 };
 /** One of the caller's collections, or a refusal naming the one they asked for. */
@@ -90,6 +101,9 @@ export const findWritableCalendarFor = async (deps, accountConfigId, calendarId)
     const found = await findCalendarFor(deps, accountConfigId, calendarId);
     if (!found.ok)
         return found;
+    if (found.value.componentSet === CalendarComponentSet.VtodoOnly) {
+        return refuseCalendar("NotAnEventCalendar", `"${found.value.displayName}" holds tasks, so an event cannot be written into it`);
+    }
     if (found.value.source === CalendarSource.Subscribed) {
         return refuseCalendar("ReadOnlyCalendar", `"${found.value.displayName}" is subscribed to a feed and is read-only — change the event where the feed comes from`);
     }

package/dist/src/handlers/index.d.ts

@@ -117,12 +117,20 @@ export declare const handlers: {
     TrashOperations_emptyTrash: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
         deletedCount: number;
     }>;
+    CalendarTaskDetailOperations_getCalendarTask: OperationHandler<import("../types.js").CalendarTaskDetailOperationIds>;
+    CalendarTaskDetailOperations_updateCalendarTask: OperationHandler<import("../types.js").CalendarTaskDetailOperationIds>;
+    CalendarTaskDetailOperations_deleteCalendarTask: OperationHandler<import("../types.js").CalendarTaskDetailOperationIds>;
+    CalendarTaskOperations_listCalendarTasks: OperationHandler<import("../types.js").CalendarTaskOperationIds>;
+    CalendarTaskOperations_createCalendarTask: OperationHandler<import("../types.js").CalendarTaskOperationIds>;
+    UserSettingsOperations_getUserSettings: OperationHandler<import("../types.js").UserSettingsOperationIds>;
+    UserSettingsOperations_updateUserSettings: OperationHandler<import("../types.js").UserSettingsOperationIds>;
+    UserSettingsOperations_clearDefaultInvitationSender: OperationHandler<import("../types.js").UserSettingsOperationIds>;
     CalendarFreeBusyOperations_listCalendarFreeBusy: OperationHandler<"CalendarFreeBusyOperations_listCalendarFreeBusy">;
-    CalendarEventDetailOperations_getCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds>;
-    CalendarEventDetailOperations_updateCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds>;
-    CalendarEventDetailOperations_deleteCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds>;
-    CalendarEventOperations_listCalendarEvents: OperationHandler<import("../types.js").CalendarEventOperationIds>;
-    CalendarEventOperations_createCalendarEvent: OperationHandler<import("../types.js").CalendarEventOperationIds>;
+    CalendarEventDetailOperations_getCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds, "smtp">;
+    CalendarEventDetailOperations_updateCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds, "smtp">;
+    CalendarEventDetailOperations_deleteCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds, "smtp">;
+    CalendarEventOperations_listCalendarEvents: OperationHandler<import("../types.js").CalendarEventOperationIds, "smtp">;
+    CalendarEventOperations_createCalendarEvent: OperationHandler<import("../types.js").CalendarEventOperationIds, "smtp">;
     CalendarDetailOperations_getCalendarFeed: OperationHandler<import("../types.js").CalendarDetailOperationIds>;
     CalendarDetailOperations_putCalendarFeed: OperationHandler<import("../types.js").CalendarDetailOperationIds>;
     CalendarDetailOperations_revokeCalendarFeed: OperationHandler<import("../types.js").CalendarDetailOperationIds>;

package/dist/src/handlers/index.js

@@ -5,6 +5,7 @@ import { CalendarDetailOperations, CalendarOperations } from "./calendar.js";
 import { CalendarEventDetailOperations, CalendarEventOperations, CalendarFreeBusyOperations, } from "./calendar-event.js";
 import { CalendarFeedDetailOperations, getCalendarFeedIcal, } from "./calendar-feed.js";
 import { CalendarSuggestionActionOperations, CalendarSuggestionOperations, MessageCalendarSuggestionOperations, } from "./calendar-suggestion.js";
+import { CalendarTaskDetailOperations, CalendarTaskOperations, } from "./calendar-task.js";
 import { ConfigOperations } from "./config.js";
 import { FilterDetailOperations, FilterOperations } from "./filter.js";
 import { FolderRoleOperations } from "./folder-role.js";
@@ -18,6 +19,7 @@ import { SyncOperations } from "./sync.js";
 import { SystemOperations } from "./system-update.js";
 import { ThreadDetailOperations, ThreadOperations } from "./thread.js";
 import { UnifiedThreadOperations } from "./unified-threads.js";
+import { UserSettingsOperations } from "./user-settings.js";
 export const handlers = {
     ...MeOperations,
     ...ConfigOperations,
@@ -40,6 +42,9 @@ export const handlers = {
     ...CalendarEventOperations,
     ...CalendarEventDetailOperations,
     ...CalendarFreeBusyOperations,
+    ...UserSettingsOperations,
+    ...CalendarTaskOperations,
+    ...CalendarTaskDetailOperations,
     ...TrashOperations,
     ...SyncOperations,
     ...ThreadDetailOperations,

package/dist/src/handlers/user-settings.d.ts

@@ -0,0 +1,22 @@
+import type { UpdateUserSettingsInput, UserSettingsResponse } from "@remit/api-openapi-types";
+import type { IAccountRepository, IAccountSettingRepository } from "@remit/data-ports";
+import type { OperationHandler, UserSettingsOperationIds } from "../types.js";
+export interface UserSettingsDeps {
+    accountSetting: Pick<IAccountSettingRepository, "get" | "upsert" | "delete">;
+    accounts: Pick<IAccountRepository, "listAllByAccountConfig">;
+}
+/** The account the reader chose to send invitations from, if they chose one. */
+export declare const chosenInvitationSender: (accountSetting: Pick<IAccountSettingRepository, "get">, accountConfigId: string) => Promise<string | undefined>;
+export declare const readUserSettings: (deps: UserSettingsDeps, accountConfigId: string) => Promise<UserSettingsResponse>;
+export type UserSettingsOutcome = {
+    ok: true;
+    value: UserSettingsResponse;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export declare const updateUserSettingsFor: (deps: UserSettingsDeps, accountConfigId: string, input: UpdateUserSettingsInput) => Promise<UserSettingsOutcome>;
+export declare const UserSettingsOperations: Record<UserSettingsOperationIds, OperationHandler<UserSettingsOperationIds>>;

package/dist/src/handlers/user-settings.js

@@ -0,0 +1,55 @@
+import { invitationSenderInEffect, sendingAccountFor, } from "@remit/calendar-service";
+import { parseAccountSettingValue } from "@remit/data-ports/account-settings";
+import { AccountSettingName } from "@remit/domain-enums";
+import { badRequest } from "./calendar.js";
+/** The account the reader chose to send invitations from, if they chose one. */
+export const chosenInvitationSender = async (accountSetting, accountConfigId) => {
+    const stored = await accountSetting.get(accountConfigId, AccountSettingName.DefaultInvitationSenderAccountId);
+    return stored
+        ? parseAccountSettingValue(AccountSettingName.DefaultInvitationSenderAccountId, stored.value).value
+        : undefined;
+};
+export const readUserSettings = async (deps, accountConfigId) => {
+    const chosen = await chosenInvitationSender(deps.accountSetting, accountConfigId);
+    const inEffect = invitationSenderInEffect(await deps.accounts.listAllByAccountConfig(accountConfigId), chosen);
+    return {
+        ...(inEffect && { defaultInvitationSenderAccountId: inEffect.accountId }),
+        defaultInvitationSenderChosen: inEffect !== undefined && inEffect.accountId === chosen,
+    };
+};
+export const updateUserSettingsFor = async (deps, accountConfigId, input) => {
+    const sender = input.defaultInvitationSenderAccountId;
+    if (sender !== undefined) {
+        const account = sendingAccountFor(await deps.accounts.listAllByAccountConfig(accountConfigId), sender);
+        if (!account.ok) {
+            return {
+                ok: false,
+                error: { code: "UnknownSender", message: account.error.message },
+            };
+        }
+        await deps.accountSetting.upsert({
+            accountConfigId,
+            name: AccountSettingName.DefaultInvitationSenderAccountId,
+            value: { kind: "String", value: sender },
+        });
+    }
+    return { ok: true, value: await readUserSettings(deps, accountConfigId) };
+};
+const depsOf = (ctx) => ({
+    accountSetting: ctx.client.accountSetting,
+    accounts: ctx.client.account,
+});
+export const UserSettingsOperations = {
+    UserSettingsOperations_getUserSettings: async (_context, ctx) => readUserSettings(depsOf(ctx), ctx.identity.accountConfigId),
+    UserSettingsOperations_updateUserSettings: async (context, ctx) => {
+        const updated = await updateUserSettingsFor(depsOf(ctx), ctx.identity.accountConfigId, context.request.requestBody);
+        if (!updated.ok)
+            return badRequest(updated.error);
+        return updated.value;
+    },
+    UserSettingsOperations_clearDefaultInvitationSender: async (_context, ctx) => {
+        const deps = depsOf(ctx);
+        await deps.accountSetting.delete(ctx.identity.accountConfigId, AccountSettingName.DefaultInvitationSenderAccountId);
+        return readUserSettings(deps, ctx.identity.accountConfigId);
+    },
+};

package/dist/src/service/create-remit-client.d.ts

@@ -1,4 +1,4 @@
-import type { IAccountConfigRepository, IAccountExportRequestRepository, IAccountRepository, IAccountSettingRepository, IAddressRepository, ICalendarCollectionRepository, ICalendarEventIndexRepository, ICalendarFeedTokenRepository, ICalendarObjectRepository, ICalendarStore, ICalendarSuggestionRepository, IConfigImportRepository, IEnvelopeRepository, IFilterRepository, ILabelRepository, IMailboxLockRepository, IMailboxRepository, IMailboxSpecialUseRepository, IMessageFlagPushRepository, IMessageFlagRepository, IMessageLabelRepository, IMessagePlacementMoveRepository, IMessageRepository, IOrganizeJobRequestRepository, IOutboxAttachmentRepository, IOutboxMessageRepository, IQuarantineRepository, ISenderSignerStandingRepository, ISyncWarningRepository, IThreadMessageRepository } from "@remit/data-ports";
+import type { IAccountConfigRepository, IAccountExportRequestRepository, IAccountRepository, IAccountSettingRepository, IAddressRepository, ICalendarCollectionRepository, ICalendarEventIndexRepository, ICalendarFeedTokenRepository, ICalendarObjectRepository, ICalendarStore, ICalendarSuggestionRepository, ICalendarTaskRepository, IConfigImportRepository, IEnvelopeRepository, IFilterRepository, ILabelRepository, IMailboxLockRepository, IMailboxRepository, IMailboxSpecialUseRepository, IMessageFlagPushRepository, IMessageFlagRepository, IMessageLabelRepository, IMessagePlacementMoveRepository, IMessageRepository, IOrganizeJobRequestRepository, IOutboxAttachmentRepository, IOutboxMessageRepository, IOutboxSchedulingPartRepository, IQuarantineRepository, ISenderSignerStandingRepository, ISyncWarningRepository, IThreadMessageRepository } from "@remit/data-ports";
 import { BodySyncQueueService, BodySyncService, type ConnectionScope, type FilterConfig, FlagQueueService, type ImapTransport, MailboxQueueService, MessageMoveService, OutboxAttachmentService, OutboxQueueService, SpamReportService } from "@remit/mailbox-service";
 import { type SecretsService } from "@remit/secrets-service";
 import type { SmtpGetSocket } from "@remit/smtp-service";
@@ -21,6 +21,7 @@ export interface RemitClientCore {
     message: IMessageRepository;
     messageFlag: IMessageFlagRepository;
     outboxMessage: IOutboxMessageRepository;
+    outboxSchedulingPart: IOutboxSchedulingPartRepository;
     threadMessage: IThreadMessageRepository;
     envelope: IEnvelopeRepository;
     accountExportRequest: IAccountExportRequestRepository;
@@ -38,6 +39,7 @@ export interface RemitClientCore {
     calendarFeedToken: ICalendarFeedTokenRepository;
     calendarSuggestion: ICalendarSuggestionRepository;
     calendarStore: ICalendarStore;
+    calendarTask: ICalendarTaskRepository;
     storage: StorageService;
     secrets: SecretsService;
     placementMove: IMessagePlacementMoveRepository;
@@ -75,6 +77,7 @@ export interface RemitClientRepositories {
     message: IMessageRepository;
     messageFlag: IMessageFlagRepository;
     outboxMessage: IOutboxMessageRepository;
+    outboxSchedulingPart: IOutboxSchedulingPartRepository;
     outboxAttachment: IOutboxAttachmentRepository;
     threadMessage: IThreadMessageRepository;
     envelope: IEnvelopeRepository;
@@ -95,6 +98,7 @@ export interface RemitClientRepositories {
     calendarFeedToken: ICalendarFeedTokenRepository;
     calendarSuggestion: ICalendarSuggestionRepository;
     calendarStore: ICalendarStore;
+    calendarTask: ICalendarTaskRepository;
 }
 export interface RemitClientSharedDeps {
     storage: StorageService;

package/dist/src/service/create-remit-client.js

@@ -57,6 +57,7 @@ export const createRemitCore = (deps) => {
         message: repositories.message,
         messageFlag: repositories.messageFlag,
         outboxMessage: repositories.outboxMessage,
+        outboxSchedulingPart: repositories.outboxSchedulingPart,
         threadMessage: repositories.threadMessage,
         envelope: repositories.envelope,
         accountExportRequest: repositories.accountExportRequest,
@@ -74,6 +75,7 @@ export const createRemitCore = (deps) => {
         calendarFeedToken: repositories.calendarFeedToken,
         calendarSuggestion: repositories.calendarSuggestion,
         calendarStore: repositories.calendarStore,
+        calendarTask: repositories.calendarTask,
         storage,
         secrets,
         placementMove: repositories.placementMove,
@@ -155,6 +157,7 @@ export const composeReadPathServices = (core, queues, sync) => ({
         calendarSuggestionService: core.calendarSuggestion,
         calendarStore: core.calendarStore,
         filterService: core.filter,
+        accountService: core.account,
     }),
 });
 export const createRemitClient = (deps) => {

package/dist/src/types.d.ts

@@ -3,7 +3,7 @@ import type { ApiConfig } from "./config/api-config.js";
 import type { RemitClient } from "./service/create-remit-client.js";
 import type { QueueName } from "./service/queues.js";
 type MatchPrefix<Prefix extends string, S extends string> = S extends `${Prefix}${infer _}` ? S : never;
-export type OperationIds = "MeOperations_deleteMe" | "MeOperations_listVipSuggestions" | "MeOperations_createExport" | "MeOperations_getExport" | "MeOperations_listQuarantine" | "ConfigOperations_getConfig" | "ConfigOperations_exportConfig" | "ConfigOperations_importConfig" | "SystemOperations_getSystemUpdate" | "SystemOperations_applySystemUpdate" | "AccountOperations_createAccount" | "AccountOperations_testConnection" | "AccountDetailOperations_updateAccount" | "AccountDetailOperations_deleteAccount" | "MicrosoftOAuthOperations_microsoftOAuthStart" | "MicrosoftOAuthOperations_microsoftOAuthCallback" | "MailboxOperations_listMailboxes" | "MailboxOperations_createMailbox" | "MailboxDetailOperations_getMailbox" | "MailboxDetailOperations_renameMailbox" | "MailboxDetailOperations_deleteMailbox" | "FolderRoleOperations_appointFolderRole" | "FilterOperations_listFilters" | "FilterOperations_createFilter" | "FilterDetailOperations_getFilter" | "FilterDetailOperations_updateFilter" | "FilterDetailOperations_deleteFilter" | "LabelOperations_listLabels" | "LabelOperations_createLabel" | "LabelDetailOperations_getLabel" | "LabelDetailOperations_updateLabel" | "LabelDetailOperations_deleteLabel" | "OrganizeOperations_createOrganizeJob" | "OrganizeOperations_previewOrganize" | "OrganizeJobDetailOperations_getOrganizeJob" | "SyncOperations_triggerSync" | "SyncOperations_getSyncStatus" | "ThreadDetailOperations_listThreadMessages" | "UnifiedThreadOperations_listAllThreads" | "ThreadOperations_listThreads" | "ThreadOperations_searchThreads" | "MessageOperations_describeMessage" | "MessageOperations_getRawMessage" | "MessageOperations_updateMessageFlags" | "MessageBulkOperations_deleteMessages" | "MessageBulkOperations_moveMessages" | "MessageBulkOperations_updateFlags" | "MessageBulkOperations_copyMessages" | "MessageBulkOperations_updateMessageLabels" | "MessageBulkOperations_reportSpam" | "MessageBulkOperations_notSpam" | "CalendarOperations_listCalendars" | "CalendarOperations_createCalendar" | "CalendarDetailOperations_getCalendar" | "CalendarDetailOperations_updateCalendar" | "CalendarDetailOperations_deleteCalendar" | "CalendarDetailOperations_getCalendarFeed" | "CalendarDetailOperations_putCalendarFeed" | "CalendarDetailOperations_revokeCalendarFeed" | "CalendarFeedOperations_getCalendarFeedIcal" | "CalendarEventOperations_listCalendarEvents" | "CalendarEventOperations_createCalendarEvent" | "CalendarEventDetailOperations_getCalendarEvent" | "CalendarEventDetailOperations_updateCalendarEvent" | "CalendarEventDetailOperations_deleteCalendarEvent" | "CalendarFreeBusyOperations_listCalendarFreeBusy" | "TrashOperations_emptyTrash" | "OutboxOperations_createOutboxMessage" | "OutboxOperations_listOutboxMessages" | "OutboxDetailOperations_getOutboxMessage" | "OutboxDetailOperations_updateOutboxMessage" | "OutboxDetailOperations_deleteOutboxMessage" | "OutboxDetailOperations_sendOutboxMessage" | "OutboxDetailOperations_mintOutboxAttachment" | "OutboxAttachmentOperations_completeOutboxAttachment" | "AddressOperations_searchAddresses" | "AddressDetailOperations_updateAddress" | "CalendarSuggestionOperations_listCalendarSuggestions" | "MessageCalendarSuggestionOperations_listMessageCalendarSuggestions" | "CalendarSuggestionActionOperations_acceptCalendarSuggestion" | "CalendarSuggestionActionOperations_declineCalendarSuggestion" | "CalendarSuggestionActionOperations_dismissCalendarSuggestion" | "CalendarSuggestionActionOperations_reopenCalendarSuggestion";
+export type OperationIds = "MeOperations_deleteMe" | "MeOperations_listVipSuggestions" | "MeOperations_createExport" | "MeOperations_getExport" | "MeOperations_listQuarantine" | "ConfigOperations_getConfig" | "ConfigOperations_exportConfig" | "ConfigOperations_importConfig" | "SystemOperations_getSystemUpdate" | "SystemOperations_applySystemUpdate" | "AccountOperations_createAccount" | "AccountOperations_testConnection" | "AccountDetailOperations_updateAccount" | "AccountDetailOperations_deleteAccount" | "MicrosoftOAuthOperations_microsoftOAuthStart" | "MicrosoftOAuthOperations_microsoftOAuthCallback" | "MailboxOperations_listMailboxes" | "MailboxOperations_createMailbox" | "MailboxDetailOperations_getMailbox" | "MailboxDetailOperations_renameMailbox" | "MailboxDetailOperations_deleteMailbox" | "FolderRoleOperations_appointFolderRole" | "FilterOperations_listFilters" | "FilterOperations_createFilter" | "FilterDetailOperations_getFilter" | "FilterDetailOperations_updateFilter" | "FilterDetailOperations_deleteFilter" | "LabelOperations_listLabels" | "LabelOperations_createLabel" | "LabelDetailOperations_getLabel" | "LabelDetailOperations_updateLabel" | "LabelDetailOperations_deleteLabel" | "OrganizeOperations_createOrganizeJob" | "OrganizeOperations_previewOrganize" | "OrganizeJobDetailOperations_getOrganizeJob" | "SyncOperations_triggerSync" | "SyncOperations_getSyncStatus" | "ThreadDetailOperations_listThreadMessages" | "UnifiedThreadOperations_listAllThreads" | "ThreadOperations_listThreads" | "ThreadOperations_searchThreads" | "MessageOperations_describeMessage" | "MessageOperations_getRawMessage" | "MessageOperations_updateMessageFlags" | "MessageBulkOperations_deleteMessages" | "MessageBulkOperations_moveMessages" | "MessageBulkOperations_updateFlags" | "MessageBulkOperations_copyMessages" | "MessageBulkOperations_updateMessageLabels" | "MessageBulkOperations_reportSpam" | "MessageBulkOperations_notSpam" | "CalendarOperations_listCalendars" | "CalendarOperations_createCalendar" | "CalendarDetailOperations_getCalendar" | "CalendarDetailOperations_updateCalendar" | "CalendarDetailOperations_deleteCalendar" | "CalendarDetailOperations_getCalendarFeed" | "CalendarDetailOperations_putCalendarFeed" | "CalendarDetailOperations_revokeCalendarFeed" | "CalendarFeedOperations_getCalendarFeedIcal" | "CalendarEventOperations_listCalendarEvents" | "CalendarEventOperations_createCalendarEvent" | "CalendarEventDetailOperations_getCalendarEvent" | "CalendarEventDetailOperations_updateCalendarEvent" | "CalendarEventDetailOperations_deleteCalendarEvent" | "CalendarFreeBusyOperations_listCalendarFreeBusy" | "UserSettingsOperations_getUserSettings" | "UserSettingsOperations_updateUserSettings" | "UserSettingsOperations_clearDefaultInvitationSender" | "CalendarTaskOperations_listCalendarTasks" | "CalendarTaskOperations_createCalendarTask" | "CalendarTaskDetailOperations_getCalendarTask" | "CalendarTaskDetailOperations_updateCalendarTask" | "CalendarTaskDetailOperations_deleteCalendarTask" | "TrashOperations_emptyTrash" | "OutboxOperations_createOutboxMessage" | "OutboxOperations_listOutboxMessages" | "OutboxDetailOperations_getOutboxMessage" | "OutboxDetailOperations_updateOutboxMessage" | "OutboxDetailOperations_deleteOutboxMessage" | "OutboxDetailOperations_sendOutboxMessage" | "OutboxDetailOperations_mintOutboxAttachment" | "OutboxAttachmentOperations_completeOutboxAttachment" | "AddressOperations_searchAddresses" | "AddressDetailOperations_updateAddress" | "CalendarSuggestionOperations_listCalendarSuggestions" | "MessageCalendarSuggestionOperations_listMessageCalendarSuggestions" | "CalendarSuggestionActionOperations_acceptCalendarSuggestion" | "CalendarSuggestionActionOperations_declineCalendarSuggestion" | "CalendarSuggestionActionOperations_dismissCalendarSuggestion" | "CalendarSuggestionActionOperations_reopenCalendarSuggestion";
 export type MeOperationIds = MatchPrefix<"MeOperations_", OperationIds>;
 export type ConfigOperationIds = MatchPrefix<"ConfigOperations_", OperationIds>;
 export type SystemOperationIds = MatchPrefix<"SystemOperations_", OperationIds>;
@@ -44,6 +44,9 @@ export type OutboxAttachmentOperationIds = MatchPrefix<"OutboxAttachmentOperatio
 export type AddressOperationIds = MatchPrefix<"AddressOperations_", OperationIds>;
 export type AddressDetailOperationIds = MatchPrefix<"AddressDetailOperations_", OperationIds>;
 export type MicrosoftOAuthOperationIds = MatchPrefix<"MicrosoftOAuthOperations_", OperationIds>;
+export type UserSettingsOperationIds = MatchPrefix<"UserSettingsOperations_", OperationIds>;
+export type CalendarTaskOperationIds = MatchPrefix<"CalendarTaskOperations_", OperationIds>;
+export type CalendarTaskDetailOperationIds = MatchPrefix<"CalendarTaskDetailOperations_", OperationIds>;
 export type CalendarSuggestionOperationIds = MatchPrefix<"CalendarSuggestionOperations_", OperationIds>;
 export type MessageCalendarSuggestionOperationIds = MatchPrefix<"MessageCalendarSuggestionOperations_", OperationIds>;
 export type CalendarSuggestionActionOperationIds = MatchPrefix<"CalendarSuggestionActionOperations_", OperationIds>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remit/backend",
-	"version": "0.0.156",
+	"version": "1.0.0",
 	"description": "Remit Mail Inspector API backend",
 	"license": "MIT",
 	"author": "",