@freecorps/ember-email 0.5.3 → 0.5.4

package/README.md

@@ -51,12 +51,20 @@ export const signup = mutation({
     rejected.
   - It stores the raw `.eml` and the attachments in files (R2), and parses the message with `postal-mime`.
   - It reads DKIM, DMARC and SPF from Cloudflare's `Authentication-Results`.
-  - It threads messages by token, then by `In-Reply-To` (DMARC pass, same contact), then by subject.
+  - It threads messages like a mail client, with no token in the Reply-To by default:
+    - an answer that cites an email the mailbox sent joins its thread when the sender is the thread's contact or one
+      of that email's recipients (In-Reply-To / References against the Message-ID the provider gave it, recorded when
+      the send succeeds; DMARC not required, since only those recipients have that id);
+    - a citation of an inbound message counts with DMARC pass from the contact;
+    - then the same contact and subject, within 30 days, if the thread is not closed or spam;
+    - a plus-addressed token (`support+t_…@`) still threads from any sender.
+  - `replyToken: true` in the install config puts that token in the Reply-To of replies, composed emails and
+    auto-replies, as before 0.5.4.
   - It handles spam per sender per hour and auto-replies without loops.
   - Your `onInbound` hook runs in the same transaction (tickets, push).
 - **Inbox queries** for dashboards and mobile apps: `threads`, `thread`, `unread` (aggregate), `search`
   (`searchIndex`), `reply`, `note`, `markRead`, `markUnread`, `setStatus`, `assign`, `compose` (a new conversation
-  from the mailbox, answers join it by token) and `recent` (latest threads with their messages, for offline replicas).
+  from the mailbox, answers join it as above) and `recent` (latest threads with their messages, for offline replicas).
   `reply` and `compose` take `attachments: [{ filename, contentType, file }]`, files already stored in the shard
   (uploaded with `ctx.storage.generateUploadUrl`). They go with the email and stay on the thread's outbound message
   (with their size). Mind the provider's message size: for a large file, put a download link in the text

package/dist/component.d.ts

@@ -58,6 +58,13 @@ export type EmailInstallConfig = {
     };
     /** Default layout for stored templates without one. */
     layout?: LayoutOptions;
+    /**
+     * Put the thread's token in the Reply-To of inbox replies, composed emails and auto-replies (`support+t_…@`).
+     * Default false: the email goes with no Reply-To, and the answer joins the thread by the Message-ID the provider
+     * gave the sent email (In-Reply-To / References), else by contact + subject. A token in an old email's Reply-To
+     * still threads either way.
+     */
+    replyToken?: boolean;
 };
 export type SendInput = {
     project?: string;
@@ -1703,6 +1710,7 @@ export declare const email: import("@freecorps/ember-server").ComponentDefinitio
         onInbound?: string;
         onEvent?: string;
     };
+    replyToken?: boolean;
 }, Record<"rateLimit", import("@freecorps/ember-server").ComponentDefinition<"rateLimit", {
     lib: {
         limit: import("@freecorps/ember-server").RegisteredMutation<"public", {

package/dist/component.js

@@ -20,7 +20,7 @@
  */
 import { componentBuilders, cronJobs, defineComponent, EmberError, v } from "@freecorps/ember-server";
 import { rateLimit } from "@freecorps/ember-rate-limit";
-import { domainOf, isNoReplySender, parseAddress, parseAddressList, replySubject, splitPlus, subjectKey, withPlus, } from "./address.js";
+import { domainOf, isNoReplySender, parseAddress, parseAddressList, replySubject, splitPlus, subjectKey, normalizeMessageId, withPlus, } from "./address.js";
 import { nextStatus, parseDeliveryEvent } from "./events.js";
 import { parseInbound, snippetOf } from "./mime.js";
 import { addressV, emailSchema, errorV } from "./schema.js";
@@ -41,6 +41,7 @@ const configV = v.optional(v.object({
     spamPerHour: v.optional(v.number()),
     hooks: v.optional(v.object({ onInbound: v.optional(v.string()), onEvent: v.optional(v.string()) })),
     layout: v.optional(v.any()),
+    replyToken: v.optional(v.boolean()),
 }));
 const { query, mutation, internalQuery, internalMutation, internalAction } = componentBuilders();
 const MAX_RECIPIENTS = 50;
@@ -79,6 +80,8 @@ const HEADER_NAME = /^[A-Za-z0-9-]{1,100}$/;
  * caller puts a download link in the text, the email carries no MIME part, and the message still holds the file.
  */
 const inboxAttachmentsV = v.optional(v.array(v.object({ filename: v.string(), contentType: v.string(), file: v.file(), link: v.optional(v.boolean()) })));
+/** The Reply-To of an email in a thread: the token address only when the install asks for it (`replyToken`). */
+const threadReplyTo = (ctx, mb, thread) => (cfg(ctx).replyToken ? { replyTo: withPlus(mb.address, `t_${thread.token}`) } : {});
 /** The MIME attachments of the email: every file not sent as a link. */
 const mimeParts = (list) => (list ?? []).filter((a) => !a.link).map(({ filename, contentType, file }) => ({ filename, contentType, file }));
 /** The stored message's attachment rows (size from the file's metadata when known). */
@@ -392,14 +395,24 @@ function ingest(ctx, a) {
         thread = ctx.db.query("threads").withIndex("by_token", (q) => q.eq("token", a.tag.slice(2))).first();
     if (thread && thread.mailbox !== a.mailbox)
         thread = null;
-    if (!thread && a.auth.dmarc === "pass") {
+    if (!thread) {
         for (const ref of [a.inReplyTo, ...a.references.slice().reverse()].filter(Boolean)) {
             const m = ctx.db.query("messages").withIndex("by_message_id", (q) => q.eq("mailbox", a.mailbox).eq("messageIdHeader", ref)).first();
             if (!m)
                 continue;
             const t = ctx.db.get(m.threadId);
-            // Another contact's thread: keep looking (an older reference may be this contact's own thread).
-            if (t && t.contact === contact) {
+            if (!t)
+                continue;
+            // An answer to an email this mailbox sent: its Message-ID went only to that email's recipients, so it joins
+            // when the sender is the contact or one of them, DMARC or not (forwarders break DMARC). A reference to an
+            // inbound message is public (anyone in the conversation has it): DMARC must pass and the From be the contact.
+            // Who sent it is the From address, never the Reply-To: anyone writes a Reply-To, and DMARC vouches for the
+            // From's domain only.
+            const sender = a.from.email;
+            const sentTo = m.direction === "outbound" ? [...(m.to ?? []), ...(m.cc ?? [])].map((x) => x.email) : [];
+            const ok = m.direction === "outbound" ? sender === t.contact || sentTo.includes(sender) : a.auth.dmarc === "pass" && sender === t.contact;
+            // Otherwise keep looking (an older reference may be this contact's own thread).
+            if (ok) {
                 thread = t;
                 break;
             }
@@ -486,7 +499,7 @@ function ingest(ctx, a) {
                 project: `mailbox:${a.mailbox}`,
                 from: { email: mb.address, ...(mb.displayName ? { name: mb.displayName } : {}) },
                 to: contact,
-                replyTo: withPlus(mb.address, `t_${thread.token}`),
+                ...threadReplyTo(ctx, mb, thread),
                 subject: renderTemplateSafe(mb.autoReply.subject, data, false),
                 text,
                 html: mb.autoReply.html ? emailLayout(renderTemplateSafe(mb.autoReply.html, data, true)) : emailLayout(textToHtml(text)),
@@ -666,6 +679,19 @@ export const emailFunctions = {
                 const extra = a.droppedHeaders?.length ? { droppedHeaders: a.droppedHeaders } : {};
                 if (a.outcome === "sent") {
                     ctx.db.patch(a.emailId, { status: "sent", messageId: a.messageId, sentAt: ctx.now, error: undefined, ...extra });
+                    // The provider's id is the email's Message-ID: the thread's outbound message records it, so an answer
+                    // (In-Reply-To / References) finds its thread without a token in the Reply-To.
+                    const mid = normalizeMessageId(a.messageId);
+                    if (e.threadId && mid) {
+                        const out = ctx.db
+                            .query("messages")
+                            .withIndex("by_thread", (q) => q.eq("threadId", e.threadId))
+                            .order("desc")
+                            .filter((q) => q.eq(q.field("emailId"), a.emailId))
+                            .first();
+                        if (out && !out.messageIdHeader)
+                            ctx.db.patch(out._id, { messageIdHeader: mid });
+                    }
                     // Events can arrive before `finish` commits (the provider is fast): apply the ones already stored, exactly
                     // as `applyEvent` would have (status, suppression, onEvent hook).
                     for (const ev of ctx.db.query("events").withIndex("by_message", (q) => q.eq("messageId", a.messageId)).collect()) {
@@ -932,7 +958,7 @@ export const emailFunctions = {
                     from: { email: mb.address, ...(mb.displayName ? { name: mb.displayName } : {}) },
                     to,
                     ...(a.cc?.length ? { cc: a.cc } : {}),
-                    replyTo: withPlus(mb.address, `t_${thread.token}`),
+                    ...threadReplyTo(ctx, mb, thread),
                     subject: replySubject(thread.subject),
                     text: a.text + quote,
                     html,
@@ -1022,7 +1048,7 @@ export const emailFunctions = {
                     from: { email: mb.address, ...(mb.displayName ? { name: mb.displayName } : {}) },
                     to,
                     ...(a.cc?.length ? { cc: a.cc } : {}),
-                    replyTo: withPlus(mb.address, `t_${thread.token}`),
+                    ...threadReplyTo(ctx, mb, thread),
                     subject,
                     text: a.text,
                     html: a.html ?? emailLayout(textToHtml(a.text)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freecorps/ember-email",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Email component for Ember on Cloudflare: send (atomic from mutations, scheduled, idempotent) through Email Service, templates, suppressions and per-project rate limits, delivery events from the Queue, inbound mail (Email Routing) parsed into mailboxes and threads. `@freecorps/ember-email/cloudflare` onboards a domain (sending, routing rules, event subscription) and removes it.",
   "keywords": [
     "ember",
@@ -52,9 +52,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@freecorps/ember-rate-limit": "0.5.3",
-    "@freecorps/ember-server": "0.5.3",
-    "@freecorps/ember-values": "0.5.3",
+    "@freecorps/ember-rate-limit": "0.5.4",
+    "@freecorps/ember-server": "0.5.4",
+    "@freecorps/ember-values": "0.5.4",
     "postal-mime": "^4.1.4"
   }
 }