@remit/mailbox-service 0.0.123 → 1.0.0

package/dist/body-sync.d.ts

@@ -1,4 +1,4 @@
-import { type IAddressRepository, type ICalendarStore, type ICalendarSuggestionRepository, type IEnvelopeRepository, type IFilterRepository, type IMailboxSpecialUseRepository, type IMessageRepository, type IThreadMessageRepository } from "@remit/data-ports";
+import { type IAccountRepository, type IAddressRepository, type ICalendarStore, type ICalendarSuggestionRepository, type IEnvelopeRepository, type IFilterRepository, type IMailboxSpecialUseRepository, type IMessageRepository, type IThreadMessageRepository } from "@remit/data-ports";
 import { type ParsedBody, type StorageService } from "@remit/storage-service";
 import { type ParsedMail } from "mailparser";
 import { type FilterConfig } from "./filters/pipeline.js";
@@ -116,6 +116,8 @@ export interface CalendarSuggestionConfig {
     calendarSuggestionService: ICalendarSuggestionRepository;
     calendarStore: ICalendarStore;
     filterService: Pick<IFilterRepository, "listByAccountAndState">;
+    /** The account config's addresses: a guest's REPLY lands only on an event the reader organizes. */
+    accountService: Pick<IAccountRepository, "listAllByAccountConfig">;
 }
 export declare class BodySyncService {
     private messageService;
@@ -236,10 +238,10 @@ export declare class BodySyncService {
      * `syncBodies(..., force: true)`) reach this with `bodyStorageKey` already
      * set, and re-offering there would resurrect a card the user dismissed.
      *
-     * Isolated the same way placement and filters are: a card is auxiliary to
-     * storing the mail, which is already durable by the time this runs. A
-     * repository failure here is logged loudly with the messageId rather than
-     * failing a body store that otherwise succeeded.
+     * Nothing here is caught. A failure is a fault in this code or its store,
+     * so it fails the body-sync job loudly and the job takes the queue's own
+     * dead-letter path. A part the sender's client wrote badly is not a failure:
+     * it is read as `Unreadable` and offered nothing.
      */
     private deriveCalendarSuggestions;
     private deriveSenderUnsubscribed;

package/dist/body-sync.js

@@ -1,5 +1,5 @@
 import { inspect } from "node:util";
-import { provisionDefaultCalendar, recordCalendarSuggestion, } from "@remit/calendar-service";
+import { provisionDefaultCalendar, recordCalendarReply, recordCalendarSuggestion, } from "@remit/calendar-service";
 import { isSenderMuted, } from "@remit/data-ports";
 import { MessageGoneFromServerError, MessagePlacementUnsettledError, NotFoundError, } from "@remit/data-ports/errors";
 import { deriveAddressId, deriveBodyPartId } from "@remit/data-ports/id";
@@ -822,10 +822,10 @@ export class BodySyncService {
      * `syncBodies(..., force: true)`) reach this with `bodyStorageKey` already
      * set, and re-offering there would resurrect a card the user dismissed.
      *
-     * Isolated the same way placement and filters are: a card is auxiliary to
-     * storing the mail, which is already durable by the time this runs. A
-     * repository failure here is logged loudly with the messageId rather than
-     * failing a body store that otherwise succeeded.
+     * Nothing here is caught. A failure is a fault in this code or its store,
+     * so it fails the body-sync job loudly and the job takes the queue's own
+     * dead-letter path. A part the sender's client wrote badly is not a failure:
+     * it is read as `Unreadable` and offered nothing.
      */
     async deriveCalendarSuggestions(lookups, messageId, accountConfigId, parsed, storedBodyKey) {
         if (!this.calendarConfig)
@@ -835,49 +835,60 @@ export class BodySyncService {
         const parts = calendarParts(parsed);
         if (parts.length === 0)
             return;
-        const { calendarStore, calendarSuggestionService } = this.calendarConfig;
-        await Promise.resolve()
-            .then(async () => {
-            // `dismiss{muteSender:true}` wrote a standing rule naming this
-            // sender. Honouring it here is what makes that button do anything:
-            // the index-time filter pipeline skips a rule with no label and no
-            // move, so this is the only reader such a rule has.
-            const sender = extractPrimaryFromEmail(parsed);
-            if (sender) {
-                const active = await lookups.activeFilters();
-                if (isSenderMuted(active, sender)) {
-                    this.log.debug?.({ messageId, sender }, "Sender is muted; offering no calendar suggestion");
-                    return;
-                }
+        const { calendarStore, calendarSuggestionService, accountService } = this.calendarConfig;
+        // A guest answering the reader's own invitation moves their answer on the
+        // organizer's copy, whoever the reader muted. Local only: nothing goes
+        // back to the guest. A reply proposes nothing to add, so it is never
+        // offered as a card.
+        const selfAddresses = (await accountService.listAllByAccountConfig(accountConfigId)).map((account) => account.email);
+        const offered = [];
+        for (const part of parts) {
+            const replied = await recordCalendarReply(calendarStore, {
+                accountConfigId,
+                icalData: part.icalData,
+                selfAddresses,
+            });
+            if (replied === "NotAReply")
+                offered.push(part);
+        }
+        if (offered.length === 0)
+            return;
+        // `dismiss{muteSender:true}` wrote a standing rule naming this
+        // sender. Honouring it here is what makes that button do anything:
+        // the index-time filter pipeline skips a rule with no label and no
+        // move, so this is the only reader such a rule has.
+        const sender = extractPrimaryFromEmail(parsed);
+        if (sender) {
+            const active = await lookups.activeFilters();
+            if (isSenderMuted(active, sender)) {
+                this.log.debug?.({ messageId, sender }, "Sender is muted; offering no calendar suggestion");
+                return;
             }
-            // Provisioned rather than looked up, through the one function every
-            // caller provisions with. A missing collection has no timezone, and
-            // a floating DTSTART read in UTC puts the meeting hours from where
-            // the organizer meant it. Idempotent: the id is derived, so a second
-            // first use returns the collection the first one made.
-            const collection = await provisionDefaultCalendar(calendarStore, accountConfigId);
-            for (const part of parts) {
-                const recorded = await recordCalendarSuggestion(calendarSuggestionService, {
-                    accountConfigId,
+        }
+        // Provisioned rather than looked up, through the one function every
+        // caller provisions with. A missing collection has no timezone, and
+        // a floating DTSTART read in UTC puts the meeting hours from where
+        // the organizer meant it. Idempotent: the id is derived, so a second
+        // first use returns the collection the first one made.
+        const collection = await provisionDefaultCalendar(calendarStore, accountConfigId);
+        for (const part of offered) {
+            const recorded = await recordCalendarSuggestion(calendarSuggestionService, {
+                accountConfigId,
+                messageId,
+                bodyPartId: deriveBodyPartId(messageId, part.partPath),
+                source: part.source,
+                icalData: part.icalData,
+                timezone: collection.timezone,
+            });
+            if (!recorded.ok) {
+                this.log.info({
                     messageId,
-                    bodyPartId: deriveBodyPartId(messageId, part.partPath),
-                    source: part.source,
-                    icalData: part.icalData,
-                    timezone: collection.timezone,
-                });
-                if (!recorded.ok) {
-                    this.log.info({
-                        messageId,
-                        partPath: part.partPath,
-                        code: recorded.error.code,
-                        reason: recorded.error.message,
-                    }, "Message carries iCalendar this cannot read; no suggestion offered");
-                }
+                    partPath: part.partPath,
+                    code: recorded.error.code,
+                    reason: recorded.error.message,
+                }, "Message carries iCalendar this cannot read; no suggestion offered");
             }
-        })
-            .catch((error) => {
-            this.log.error?.({ messageId, accountConfigId, error: inspect(error) }, "Calendar suggestion derivation failed; body is stored without a card");
-        });
+        }
     }
     async deriveSenderUnsubscribed(accountConfigId, fromEmail) {
         try {

package/dist/outbox-queue.d.ts

@@ -1,4 +1,4 @@
-import type { IAccountRepository, IOutboxMessageRepository, OutboxMessageItem, QueueProducer } from "@remit/data-ports";
+import type { CreateOutboxSchedulingPartInput, IAccountRepository, IOutboxMessageRepository, OutboxMessageItem, QueueProducer } from "@remit/data-ports";
 import type { OutboxAttachmentService } from "./outbox-attachment.js";
 export interface SendMessageEvent {
     type: "SEND_MESSAGE";
@@ -54,6 +54,17 @@ export declare class OutboxQueueService {
     private refuseWithoutMail;
     send: (accountConfigId: string, outboxMessageId: string) => Promise<OutboxMessageItem>;
     createAndSend: (input: CreateDraftInput) => Promise<OutboxMessageItem>;
+    /**
+     * Queues one calendar scheduling message — an invitation, a cancellation or
+     * a reply — with its `text/calendar` part.
+     *
+     * The row is the pending record and lands first. An enqueue that fails
+     * settles it `failed` and answers with that row rather than throwing: the
+     * calendar write it follows is already committed, and the person needs the
+     * failed send in front of them, with `send` as the retry, not an error that
+     * hides which guests were reached.
+     */
+    createAndSendScheduled: (input: CreateDraftInput, schedulingPart: CreateOutboxSchedulingPartInput) => Promise<OutboxMessageItem>;
     deleteDraft: (accountConfigId: string, outboxMessageId: string) => Promise<void>;
     /**
      * Take a row back out of `queued` after the enqueue reported a failure.

package/dist/outbox-queue.js

@@ -221,6 +221,38 @@ export class OutboxQueueService {
         this.log.info({ outboxMessageId: outbox.outboxMessageId, accountId: input.accountId }, "Created and queued outbox message for sending");
         return outbox;
     };
+    /**
+     * Queues one calendar scheduling message — an invitation, a cancellation or
+     * a reply — with its `text/calendar` part.
+     *
+     * The row is the pending record and lands first. An enqueue that fails
+     * settles it `failed` and answers with that row rather than throwing: the
+     * calendar write it follows is already committed, and the person needs the
+     * failed send in front of them, with `send` as the retry, not an error that
+     * hides which guests were reached.
+     */
+    createAndSendScheduled = async (input, schedulingPart) => {
+        const domain = extractDomain(input.fromAddress);
+        const outbox = await this.outboxMessageService.create({
+            accountId: input.accountId,
+            accountConfigId: input.accountConfigId,
+            fromAddress: input.fromAddress,
+            fromName: input.fromName,
+            toAddresses: input.toAddresses,
+            subject: input.subject,
+            textBody: input.textBody,
+            messageIdValue: generateMessageId(domain),
+            status: OutboxMessageStatus.queued,
+        }, schedulingPart);
+        const queued = await this.enqueueSend(input.accountId, outbox.outboxMessageId).then(() => true, async (error) => {
+            this.log.error({ outboxMessageId: outbox.outboxMessageId, error: String(error) }, "The queue refused a calendar scheduling message; settling it failed");
+            await this.settleUnqueued(input.accountConfigId, outbox.outboxMessageId, OutboxMessageStatus.failed);
+            return false;
+        });
+        if (queued)
+            return outbox;
+        return this.outboxMessageService.get(input.accountConfigId, outbox.outboxMessageId);
+    };
     deleteDraft = async (accountConfigId, outboxMessageId) => {
         const existing = await this.outboxMessageService.get(accountConfigId, outboxMessageId, "act");
         // `unfiled` is discardable: the message was delivered but never landed in

package/dist/test-helpers/test-store.d.ts

@@ -16,6 +16,7 @@ export declare const openStore: () => Promise<{
     message: import("@remit/drizzle-service").DrizzleMessageRepository;
     messageFlag: import("@remit/drizzle-service").DrizzleMessageFlagRepository;
     outboxMessage: import("@remit/drizzle-service").OutboxMessageRepo;
+    outboxSchedulingPart: import("@remit/drizzle-service").OutboxSchedulingPartRepo;
     outboxAttachment: import("@remit/drizzle-service").OutboxAttachmentRepo;
     threadMessage: import("@remit/drizzle-service").DrizzleThreadMessageRepository;
     envelope: import("@remit/drizzle-service").DrizzleEnvelopeRepository;
@@ -34,6 +35,7 @@ export declare const openStore: () => Promise<{
     calendarObject: import("@remit/drizzle-service").CalendarObjectRepo;
     calendarEventIndex: import("@remit/drizzle-service").CalendarEventIndexRepo;
     calendarFeedToken: import("@remit/drizzle-service").CalendarFeedTokenRepo;
+    calendarTask: import("@remit/drizzle-service").CalendarTaskRepo;
     calendarSuggestion: import("@remit/drizzle-service").CalendarSuggestionRepo;
     calendarStore: import("@remit/drizzle-service").DrizzleCalendarStore;
 }>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remit/mailbox-service",
-	"version": "0.0.123",
+	"version": "1.0.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",