@remit/backend 0.0.142 → 0.0.144

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

@@ -0,0 +1,84 @@
+import type { BodyPartResponse } from "@remit/api-openapi-types";
+import { type ContentSigner } from "../derive/contentSignature.js";
+import type { MessageBulkOperationIds, MessageOperationIds, OperationHandler } from "../types.js";
+export declare const isStorageNotFoundError: (error: unknown) => boolean;
+/**
+ * Decode the raw `.eml` bytes into a string for inspection. RFC822/MIME
+ * sources are 7-bit/8-bit ASCII-compatible (non-ASCII bytes are encoded via
+ * quoted-printable / base64 inside the body), so `latin1` round-trips every
+ * byte 1:1 without loss or replacement characters — unlike `utf8`, which would
+ * mangle raw 8-bit bytes. Headers and structure stay byte-accurate.
+ */
+export declare const decodeRawEml: (body: Buffer) => string;
+/**
+ * Extract the accountConfigId + accountId segments from a bodyStorageKey URI
+ * such as
+ * `s3://bucket/accounts/{accountConfigId}/{accountId}/messages/{messageId}/body.eml`.
+ * Returns null when the URI shape doesn't match — caller falls back to the
+ * slow path without writing a parsed-body cache.
+ */
+export declare const extractAccountIdsFromBodyKey: (uri: string) => {
+    accountConfigId: string;
+    accountId: string;
+} | null;
+/**
+ * Map a list of stored `BodyPart` rows to API `BodyPartResponse` objects,
+ * populating `contentUrl` from the CloudFront distribution domain. Pure
+ * function so the URL-construction contract can be pinned in tests without
+ * standing up the full handler. The contract requires every `contentUrl`
+ * to be a real URL (#299) — `getContentDeliveryDomain` throws when the
+ * Lambda env is missing the domain, and this function expects a non-empty
+ * string from the caller.
+ */
+export interface BodyPartLike {
+    bodyPartId: string;
+    mediaType: string;
+    mediaSubtype: string;
+    sizeOctets: number;
+    disposition?: string;
+    dispositionFilename?: string;
+    isMultipart: boolean;
+    contentId?: string;
+    partPath: string;
+}
+export declare const isMediaType: (value: unknown) => value is BodyPartResponse["mediaType"];
+export declare const isContentDisposition: (value: unknown) => value is NonNullable<BodyPartResponse["disposition"]>;
+export declare const FORWARDED_MESSAGE_FILENAME = "Forwarded message.eml";
+export declare const buildBodyPartResponses: (parts: readonly BodyPartLike[], context: {
+    contentDeliveryDomain: string;
+    accountConfigId: string;
+    accountId: string;
+    messageId: string;
+    sign?: ContentSigner;
+}) => BodyPartResponse[];
+export interface SpamReportBulkFailure {
+    messageId: string;
+    reason: string;
+}
+export interface SpamReportBulkOutcome {
+    successCount: number;
+    failureCount: number;
+    failures?: SpamReportBulkFailure[];
+}
+/**
+ * The fallback for a failure nobody designed copy for — an AWS SDK message
+ * naming a queue URL, an `ECONNREFUSED host:port`, a programmer error.
+ * Everything reaching it is flattened, same policy as `error.ts`'s "Internal
+ * server error" flattening, because `SpamReportBulkResult.reason` is shown to
+ * the user as-is. It says "try again" because retrying is the only thing left
+ * to say about a cause we cannot name; an outcome the service DOES understand
+ * carries its own text through `DESIGNED_FAILURES` instead of landing here.
+ */
+export declare const GENERIC_FAILURE_REASON = "This message could not be processed. Please try again. If it keeps failing, report it.";
+/**
+ * Drive one report-spam/not-spam operation per message, concurrently. Each
+ * message's own wait for its move to settle (SpamReportService's R2 wait) is
+ * bounded on its own, but running the batch sequentially would let those
+ * waits accumulate across the whole request — 50 messages could each wait
+ * seconds, serializing into minutes and dying at the proxy. Running them
+ * concurrently instead bounds the whole request by a single message's wait,
+ * regardless of batch size.
+ */
+export declare const settleSpamReportBulk: (messageIds: string[], run: (messageId: string) => Promise<void>) => Promise<SpamReportBulkOutcome>;
+export declare const MessageOperations: Record<MessageOperationIds, OperationHandler<MessageOperationIds>>;
+export declare const MessageBulkOperations: Record<MessageBulkOperationIds, OperationHandler<MessageBulkOperationIds>>;