@remit/backend 0.0.143 → 0.0.145

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

@@ -0,0 +1,47 @@
+import type { CalendarSuggestionResponse } from "@remit/api-openapi-types";
+import { type CalendarSuggestionItem, type ICalendarSuggestionRepository, type IEnvelopeRepository, type IFilterRepository, type IThreadMessageRepository } from "@remit/data-ports";
+import type { CalendarSuggestionActionOperationIds, CalendarSuggestionOperationIds, MessageCalendarSuggestionOperationIds, OperationHandler } from "../types.js";
+/**
+ * The raw invitation bytes stay on the server. A client renders the projected
+ * fields; the bytes exist so accepting can write them into a calendar
+ * unchanged, and shipping them would invite a second, divergent renderer.
+ */
+export declare const toCalendarSuggestionResponse: (item: CalendarSuggestionItem, answerOvertakenBy: CalendarSuggestionResponse["answerOvertakenBy"]) => CalendarSuggestionResponse;
+export declare const toCalendarSuggestionResponses: (deps: {
+    threadMessage: Pick<IThreadMessageRepository, "findByMessageId">;
+    calendarSuggestion: Pick<ICalendarSuggestionRepository, "listByAcceptedCalendarObjects">;
+}, accountConfigId: string, items: CalendarSuggestionItem[]) => Promise<CalendarSuggestionResponse[]>;
+/**
+ * The states a person can move a pending card into. `Superseded` is the
+ * producer's alone — a revision retires a card, a person never does — and the
+ * rest are terminal.
+ */
+export declare const assertSettleable: (suggestion: CalendarSuggestionItem, target: CalendarSuggestionItem["state"]) => void;
+/** What muting a sender needs, so it can be driven without a live table. */
+export interface MuteSenderDeps {
+    envelope: Pick<IEnvelopeRepository, "getMessageData">;
+    filter: Pick<IFilterRepository, "create" | "listByAccountAndState">;
+}
+/**
+ * The standing rule `dismiss{muteSender:true}` writes: the user saying they do
+ * not want this sender's invitations offered. It goes through the existing
+ * `Filter` entity rather than a second rules table, so it is visible and
+ * editable beside every other rule the user has, and matches on the message's
+ * From address rather than on the invitation's ORGANIZER — a `PUBLISH` names
+ * no organizer at all, and the sender is who the user is refusing.
+ *
+ * At most one rule per sender. Dismissing the same card twice, or muting a
+ * sender already muted from another card, is the same instruction repeated —
+ * a second identical rule would only be a second row for the settings page to
+ * show and the user to delete twice.
+ */
+export declare const muteSender: (deps: MuteSenderDeps, accountConfigId: string, messageId: string) => Promise<void>;
+/**
+ * Moves a card to a decision. Idempotent by design: a client that retries a
+ * decline gets the same answer rather than a 400, and only a card in a
+ * different terminal state is refused.
+ */
+export declare const settleSuggestion: (repo: ICalendarSuggestionRepository, accountConfigId: string, suggestionId: string, state: CalendarSuggestionItem["state"]) => Promise<CalendarSuggestionItem>;
+export declare const CalendarSuggestionOperations: Record<CalendarSuggestionOperationIds, OperationHandler<CalendarSuggestionOperationIds>>;
+export declare const MessageCalendarSuggestionOperations: Record<MessageCalendarSuggestionOperationIds, OperationHandler<MessageCalendarSuggestionOperationIds>>;
+export declare const CalendarSuggestionActionOperations: Record<CalendarSuggestionActionOperationIds, OperationHandler<CalendarSuggestionActionOperationIds>>;

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

@@ -0,0 +1,204 @@
+import { acceptCalendarSuggestion, answersOvertakenBy, correctCalendarSuggestion, reopenCalendarSuggestion, } from "@remit/calendar-service";
+import { isSenderMuted, } from "@remit/data-ports";
+import { BadRequestError } from "@remit/data-ports/errors";
+import { CalendarInviteAnswer, CalendarInviteMethod, CalendarSource, CalendarSuggestionState, FilterClauseField, FilterMatchOperator, FilterScope, FilterState, } from "@remit/domain-enums";
+import { pickEventUpdate } from "./calendar-event.js";
+/**
+ * The raw invitation bytes stay on the server. A client renders the projected
+ * fields; the bytes exist so accepting can write them into a calendar
+ * unchanged, and shipping them would invite a second, divergent renderer.
+ */
+export const toCalendarSuggestionResponse = (item, answerOvertakenBy) => {
+    const { icalData: _icalData, ...response } = item;
+    return { ...response, supersededByThreadId: "", answerOvertakenBy };
+};
+export const toCalendarSuggestionResponses = async (deps, accountConfigId, items) => Promise.all((await answersOvertakenBy(deps.calendarSuggestion, accountConfigId, items)).map(async ({ suggestion, answerOvertakenBy }) => {
+    const response = toCalendarSuggestionResponse(suggestion, answerOvertakenBy);
+    if (suggestion.supersededByMessageId === "")
+        return response;
+    const newer = await deps.threadMessage.findByMessageId(accountConfigId, suggestion.supersededByMessageId);
+    return { ...response, supersededByThreadId: newer?.threadId ?? "" };
+}));
+const respondOne = async (client, accountConfigId, item) => {
+    const [response] = await toCalendarSuggestionResponses(client, accountConfigId, [item]);
+    if (!response)
+        throw new Error("unreachable: one item in, one response out");
+    return response;
+};
+/**
+ * The states a person can move a pending card into. `Superseded` is the
+ * producer's alone — a revision retires a card, a person never does — and the
+ * rest are terminal.
+ */
+export const assertSettleable = (suggestion, target) => {
+    if (suggestion.state === CalendarSuggestionState.Pending)
+        return;
+    if (suggestion.state === target)
+        return;
+    throw new BadRequestError(`This suggestion was already ${suggestion.state.toLowerCase()}, so it can't be ${target.toLowerCase()}.`);
+};
+/**
+ * The mail address the card's event should name as the accepting attendee: the
+ * account the invitation arrived on. Resolved from the message rather than
+ * asked of the client, so an ATTENDEE line can never name an address the user
+ * does not own.
+ */
+const accountEmailForMessage = async (client, messageId) => {
+    const message = await client.message.get(messageId);
+    const accountId = await client.mailbox.resolveAccountId(message.mailboxId);
+    if (!accountId) {
+        throw new BadRequestError("The folder this invitation arrived in is gone, so there is no address to accept as.");
+    }
+    const account = await client.account.get(accountId);
+    return account.email;
+};
+/**
+ * The standing rule `dismiss{muteSender:true}` writes: the user saying they do
+ * not want this sender's invitations offered. It goes through the existing
+ * `Filter` entity rather than a second rules table, so it is visible and
+ * editable beside every other rule the user has, and matches on the message's
+ * From address rather than on the invitation's ORGANIZER — a `PUBLISH` names
+ * no organizer at all, and the sender is who the user is refusing.
+ *
+ * At most one rule per sender. Dismissing the same card twice, or muting a
+ * sender already muted from another card, is the same instruction repeated —
+ * a second identical rule would only be a second row for the settings page to
+ * show and the user to delete twice.
+ */
+export const muteSender = async (deps, accountConfigId, messageId) => {
+    const data = await deps.envelope.getMessageData(messageId);
+    const from = data.envelopeAddress.find((address) => address.addressRole === "from");
+    if (!from) {
+        throw new BadRequestError("This message names no sender, so there is nobody to mute.");
+    }
+    const active = await deps.filter.listByAccountAndState(accountConfigId, FilterState.Active);
+    if (isSenderMuted(active, from.normalizedEmail))
+        return;
+    await deps.filter.create({
+        accountConfigId,
+        name: `Muted invitations from ${from.normalizedEmail}`,
+        scope: FilterScope.Standing,
+        matchOperator: FilterMatchOperator.And,
+        literalClauses: [
+            { field: FilterClauseField.From, value: from.normalizedEmail },
+        ],
+    });
+};
+/**
+ * Moves a card to a decision. Idempotent by design: a client that retries a
+ * decline gets the same answer rather than a 400, and only a card in a
+ * different terminal state is refused.
+ */
+export const settleSuggestion = async (repo, accountConfigId, suggestionId, state) => {
+    const suggestion = await repo.get(accountConfigId, suggestionId);
+    assertSettleable(suggestion, state);
+    if (suggestion.state === state)
+        return suggestion;
+    return repo.settle(accountConfigId, suggestionId, {
+        state,
+        acceptedCalendarObjectId: "",
+    });
+};
+export const CalendarSuggestionOperations = {
+    CalendarSuggestionOperations_listCalendarSuggestions: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const { state, continuationToken } = context.request.query;
+        const client = ctx.client;
+        const page = await client.calendarSuggestion.listByState(accountConfigId, state, {
+            continuationToken,
+            endsAfter: state === CalendarSuggestionState.Pending
+                ? new Date().toISOString()
+                : new Date(0).toISOString(),
+        });
+        return {
+            items: await toCalendarSuggestionResponses(client, accountConfigId, page.items),
+            continuationToken: page.continuationToken,
+        };
+    },
+};
+export const MessageCalendarSuggestionOperations = {
+    MessageCalendarSuggestionOperations_listMessageCalendarSuggestions: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const { messageId } = context.request.params;
+        const client = ctx.client;
+        const items = await client.calendarSuggestion.listByMessage(accountConfigId, messageId);
+        return {
+            items: await toCalendarSuggestionResponses(client, accountConfigId, items),
+            continuationToken: undefined,
+        };
+    },
+};
+export const CalendarSuggestionActionOperations = {
+    CalendarSuggestionActionOperations_acceptCalendarSuggestion: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const { suggestionId } = context.request.params;
+        const { calendarId, answer = CalendarInviteAnswer.Accepted } = context
+            .request.requestBody;
+        const client = ctx.client;
+        const suggestion = await client.calendarSuggestion.get(accountConfigId, suggestionId);
+        if (answer === CalendarInviteAnswer.Tentative &&
+            suggestion.method === CalendarInviteMethod.Cancel) {
+            throw new BadRequestError("This is a cancellation, so there is nothing to answer maybe to.");
+        }
+        assertSettleable(suggestion, answer === CalendarInviteAnswer.Tentative
+            ? CalendarSuggestionState.Tentative
+            : CalendarSuggestionState.Accepted);
+        // Reads the collection through the caller's own account config, so a
+        // calendarId naming somebody else's collection is a 404 before anything
+        // is written into it.
+        const collection = await client.calendarCollection.get(accountConfigId, calendarId);
+        if (collection.source === CalendarSource.Subscribed) {
+            throw new BadRequestError(`"${collection.displayName}" is subscribed to a feed and is read-only — accept the invitation into another calendar`);
+        }
+        const { event: corrections } = context.request.requestBody;
+        const corrected = corrections === undefined
+            ? { ok: true, value: suggestion }
+            : await correctCalendarSuggestion(suggestion, pickEventUpdate(corrections), collection.timezone);
+        if (!corrected.ok) {
+            throw new BadRequestError(corrected.error.message);
+        }
+        const accepted = await acceptCalendarSuggestion(client.calendarStore, {
+            accountConfigId,
+            calendarId,
+            suggestion: corrected.value,
+            attendee: await accountEmailForMessage(client, suggestion.messageId),
+            answer,
+        });
+        if (!accepted.ok) {
+            throw new BadRequestError(accepted.error.message);
+        }
+        return respondOne(client, accountConfigId, accepted.value.suggestion);
+    },
+    CalendarSuggestionActionOperations_declineCalendarSuggestion: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const { suggestionId } = context.request.params;
+        const client = ctx.client;
+        const declined = await settleSuggestion(client.calendarSuggestion, accountConfigId, suggestionId, CalendarSuggestionState.Declined);
+        return respondOne(client, accountConfigId, declined);
+    },
+    CalendarSuggestionActionOperations_dismissCalendarSuggestion: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const { suggestionId } = context.request.params;
+        const body = (context.request.requestBody ?? {});
+        const client = ctx.client;
+        const dismissed = await settleSuggestion(client.calendarSuggestion, accountConfigId, suggestionId, CalendarSuggestionState.Dismissed);
+        if (body.muteSender) {
+            await muteSender(client, accountConfigId, dismissed.messageId);
+        }
+        return respondOne(client, accountConfigId, dismissed);
+    },
+    CalendarSuggestionActionOperations_reopenCalendarSuggestion: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const { suggestionId } = context.request.params;
+        const client = ctx.client;
+        const suggestion = await client.calendarSuggestion.get(accountConfigId, suggestionId);
+        const reopened = await reopenCalendarSuggestion(client.calendarStore, {
+            accountConfigId,
+            suggestion,
+        });
+        if (!reopened.ok) {
+            throw new BadRequestError(reopened.error.message);
+        }
+        return respondOne(client, accountConfigId, reopened.value);
+    },
+};

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

@@ -0,0 +1,116 @@
+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 { RemitClient } from "../service/data-client.js";
+import type { CalendarCollectionDetailOperationIds, CalendarDetailOperationIds, CalendarOperationIds, OperationHandler } from "../types.js";
+/** The calendar store, as the handlers reach it. */
+export interface CalendarDeps {
+    calendarCollection: ICalendarCollectionRepository;
+    calendarObject: ICalendarObjectRepository;
+    calendarEventIndex: ICalendarEventIndexRepository;
+    calendarFeedToken: ICalendarFeedTokenRepository;
+    calendarStore: ICalendarStore;
+}
+/** Why a calendar request was refused, in a form a client can branch on. */
+export interface CalendarRefusal {
+    code: string;
+    message: string;
+}
+/**
+ * A refusal is a value here, not a throw. Every one of these is something the
+ * caller sent — a window that runs backwards, a segment already taken, a
+ * RECURRENCE-ID naming no occurrence — so it is an ordinary outcome of the
+ * request rather than a fault of the server's.
+ */
+export type CalendarOutcome<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: CalendarRefusal;
+};
+export declare const refuseCalendar: <T>(code: string, message: string) => CalendarOutcome<T>;
+/**
+ * A 400 keeps the refusal's own code — `unknown_time_zone` and
+ * `url_segment_taken` are what a client branches on, and the status class alone
+ * would not distinguish them. A 404 and a 412 have nothing to add to their
+ * status, so they take the shared token.
+ */
+export declare const badRequest: (error: CalendarRefusal) => {
+    statusCode: number;
+    body: {
+        code: string;
+        message: string;
+    };
+};
+export declare const notFound: (message: string) => {
+    statusCode: number;
+    body: {
+        code: string;
+        message: string;
+    };
+};
+export declare const preconditionFailed: (message: string) => {
+    statusCode: number;
+    body: {
+        code: string;
+        message: string;
+    };
+};
+/** The calendar half of the client, named so a handler takes only what it uses. */
+export declare const calendarDepsOf: (client: RemitClient<never>) => CalendarDeps;
+/**
+ * Every collection the account config holds, provisioning the default one when
+ * it holds none.
+ *
+ * Safe to race with itself: `calendarId` is derived from the account config and
+ * the URL segment, so two first reads arriving together write the same row
+ * rather than two, and the loser's write is a no-op instead of a second
+ * calendar nobody asked for.
+ */
+export declare const listCalendarsFor: (deps: CalendarDeps, accountConfigId: string) => Promise<CalendarCollectionItem[]>;
+/** One of the caller's collections, or a refusal naming the one they asked for. */
+export declare const findCalendarFor: (deps: CalendarDeps, accountConfigId: string, calendarId: string) => Promise<CalendarOutcome<CalendarCollectionItem>>;
+/**
+ * One of the caller's collections that a person may write events into. A
+ * subscribed collection holds what its feed holds: an edit made here would be
+ * overwritten by the next refresh, so it is refused rather than accepted and
+ * silently lost.
+ */
+export declare const findWritableCalendarFor: (deps: CalendarDeps, accountConfigId: string, calendarId: string) => Promise<CalendarOutcome<CalendarCollectionItem>>;
+/**
+ * A collection's timezone is what every floating time in it is read in, so a
+ * name this server cannot resolve is not a cosmetic setting — it silently moves
+ * every all-day and unzoned event in the calendar. A Windows zone name, which
+ * is what a client that has not normalised its input sends, is refused here
+ * rather than stored and quietly read as UTC.
+ */
+export declare const readCollectionTimezone: (timezone: string | undefined) => CalendarOutcome<string>;
+export declare const createCalendarFor: (deps: CalendarDeps, accountConfigId: string, input: CreateCalendarInput, fetcher?: CalendarFeedFetcher, now?: number) => Promise<CalendarOutcome<CalendarCollectionItem>>;
+/**
+ * Removes a collection with everything in it, in one unit.
+ *
+ * The default collection stays: it is where an accepted invitation and a first
+ * event land, and an account config with no calendar has nowhere to put one.
+ */
+export declare const deleteCalendarFor: (deps: CalendarDeps, accountConfigId: string, calendarId: string) => Promise<CalendarOutcome<null>>;
+/**
+ * Reduce a PATCH body to the fields a collection update may set. `urlSegment`
+ * is deliberately absent: it is the collection's identity and the path a client
+ * has bookmarked, so moving it is making a different calendar.
+ */
+export declare const pickCalendarUpdate: (body: Partial<UpdateCalendarInput>) => UpdateCalendarCollectionInput;
+/**
+ * Applies a collection patch, rewriting what the collection's timezone decides.
+ *
+ * The timezone is not a label. Every floating and all-day time in the
+ * collection is read in it, so changing it moves every occurrence row those
+ * resources produced — and a row left at the old zone is an event drawn hours
+ * from where the calendar now says it is. Each resource is therefore written
+ * again from its own stored bytes, which re-projects and re-expands it and
+ * bumps the collection's sequence so a syncing client sees the change. The
+ * whole set is one unit: a half-converted calendar is worse than either zone.
+ */
+export declare const updateCalendarFor: (deps: CalendarDeps, accountConfigId: string, calendarId: string, body: Partial<UpdateCalendarInput>) => Promise<CalendarOutcome<CalendarCollectionItem>>;
+export declare const CalendarOperations: Record<CalendarOperationIds, OperationHandler<CalendarOperationIds>>;
+export declare const CalendarDetailOperations: Record<CalendarCollectionDetailOperationIds, OperationHandler<CalendarDetailOperationIds>>;