@freecorps/ember-email 0.5.4 → 0.5.6

package/README.md

@@ -64,7 +64,8 @@ export const signup = mutation({
   - 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 as above) and `recent` (latest threads with their messages, for offline replicas).
+  from the mailbox, answers join it as above), `recent` (latest threads with their messages, for offline replicas) and
+  `sent` (the mailbox's Sent view: threads it wrote in, by its latest send, paged with `before`).
   `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/client.d.ts

@@ -155,6 +155,17 @@ export interface EmailComponentApi {
             status?: string;
             paginationOpts?: PageOpts;
         }, Page<ThreadRecord>>;
+        /** The mailbox's Sent view: threads it wrote in, by its latest outbound message (`lastSentAt`); `next` → `before` (opaque). */
+        sent: Ref<"query", {
+            mailbox: string;
+            limit?: number;
+            before?: string;
+        }, {
+            page: Array<ThreadRecord & {
+                lastSentAt: number;
+            }>;
+            next: string | null;
+        }>;
         thread: Ref<"query", {
             threadId: string;
         }, {

package/dist/component.d.ts

@@ -718,6 +718,20 @@ export declare const emailFunctions: {
                 author?: string;
             }[];
         } | null>;
+        /**
+         * The conversations the mailbox wrote in (its Sent view): threads with a reply or a new conversation sent from it,
+         * by its latest one, newest first. `before` (the answer's `next`, an opaque cursor) goes on to older ones. Internal
+         * notes and auto-replies are not sent mail here (a note is no message out; an auto-reply is no message of the
+         * thread).
+         */
+        sent: import("@freecorps/ember-server").RegisteredQuery<"public", {
+            mailbox: string;
+            limit?: number;
+            before?: string;
+        }, {
+            page: any[];
+            next: string | null;
+        }>;
         /** Unread messages and thread counts per mailbox (aggregate: O(mailboxes)). */
         unread: import("@freecorps/ember-server").RegisteredQuery<"public", {
             mailboxes?: string[];
@@ -1511,6 +1525,20 @@ export declare const email: import("@freecorps/ember-server").ComponentDefinitio
                 author?: string;
             }[];
         } | null>;
+        /**
+         * The conversations the mailbox wrote in (its Sent view): threads with a reply or a new conversation sent from it,
+         * by its latest one, newest first. `before` (the answer's `next`, an opaque cursor) goes on to older ones. Internal
+         * notes and auto-replies are not sent mail here (a note is no message out; an auto-reply is no message of the
+         * thread).
+         */
+        sent: import("@freecorps/ember-server").RegisteredQuery<"public", {
+            mailbox: string;
+            limit?: number;
+            before?: string;
+        }, {
+            page: any[];
+            next: string | null;
+        }>;
         /** Unread messages and thread counts per mailbox (aggregate: O(mailboxes)). */
         unread: import("@freecorps/ember-server").RegisteredQuery<"public", {
             mailboxes?: string[];

package/dist/component.js

@@ -85,6 +85,29 @@ const threadReplyTo = (ctx, mb, thread) => (cfg(ctx).replyToken ? { replyTo: wit
 /** 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). */
+/** The most messages one Sent page reads past its cursor's millisecond (no mailbox sends this many in one ms). */
+const SENT_MAX_FETCH = 10_000;
+/** The Sent view's cursor: a message's time and id (`<at>:<id>`), opaque to callers. */
+function sentCursor(m) {
+    return `${m.at}:${m._id}`;
+}
+function parseSentCursor(raw) {
+    if (raw === undefined)
+        return null;
+    const k = raw.indexOf(":");
+    const at = Number(raw.slice(0, k));
+    if (k <= 0 || !Number.isFinite(at) || k === raw.length - 1)
+        fail("ValidationError", "before: not a cursor this query gave");
+    return { at, id: raw.slice(k + 1) };
+}
+/** Whether message `x` comes after `m` in the by_sender order (time, then creation, then id). */
+function isAfter(x, m) {
+    if (x.at !== m.at)
+        return x.at > m.at;
+    if (x._creationTime !== m._creationTime)
+        return x._creationTime > m._creationTime;
+    return x._id > m._id;
+}
 function attachmentRows(ctx, list) {
     return (list ?? []).map((a) => {
         const meta = ctx.storage?.getMetadata?.(a.file);
@@ -874,6 +897,82 @@ export const emailFunctions = {
                 return { thread, messages };
             },
         }),
+        /**
+         * The conversations the mailbox wrote in (its Sent view): threads with a reply or a new conversation sent from it,
+         * by its latest one, newest first. `before` (the answer's `next`, an opaque cursor) goes on to older ones. Internal
+         * notes and auto-replies are not sent mail here (a note is no message out; an auto-reply is no message of the
+         * thread).
+         */
+        sent: query({
+            args: { mailbox: v.string(), limit: v.optional(v.number()), before: v.optional(v.string()) },
+            handler: (ctx, a) => {
+                const mb = ctx.db.query("mailboxes").withIndex("by_name", (q) => q.eq("name", a.mailbox)).first();
+                if (!mb)
+                    return { page: [], next: null };
+                const limit = Math.min(Math.max(Math.trunc(a.limit ?? 30), 1), 100);
+                // The cursor is the last message looked at: its time and id. The next page starts at that time (`lte`) and
+                // skips up to and including that message, in the index's order (time, then creation, then id), so messages
+                // sharing its millisecond are neither lost nor seen twice.
+                const cursor = parseSentCursor(a.before);
+                // Messages from the mailbox's address, newest first; a thread counts at its newest outbound message only, so a
+                // later page never lists it again for an older one.
+                const scan = limit * 4 + 20;
+                const fetch = (n) => ctx.db
+                    .query("messages")
+                    .withIndex("by_sender", (q) => {
+                    const r = q.eq("mailbox", a.mailbox).eq("fromEmail", mb.address);
+                    return cursor ? r.lte("at", cursor.at) : r;
+                })
+                    .order("desc")
+                    .take(n);
+                // Past the messages sharing the cursor's millisecond: fetched until the cursor and a full window after it are in
+                // hand (or there is nothing more), so a burst in one millisecond never ends the paging early.
+                let n = scan + (cursor ? scan : 0);
+                let rows = fetch(n);
+                let start = 0;
+                for (;;) {
+                    if (cursor) {
+                        const k = rows.findIndex((m) => m._id === cursor.id);
+                        // The cursor's message is gone (deleted): start after every message of its millisecond.
+                        start = k >= 0 ? k + 1 : rows.findIndex((m) => m.at < cursor.at);
+                        if (start < 0)
+                            start = rows.length;
+                    }
+                    if (rows.length < n || rows.length - start >= scan || n >= SENT_MAX_FETCH)
+                        break;
+                    n = Math.min(n * 2, SENT_MAX_FETCH);
+                    rows = fetch(n);
+                }
+                const window = rows.slice(start, start + scan);
+                const page = [];
+                const seen = new Set();
+                let next = null;
+                for (const m of window) {
+                    if (m.direction !== "outbound" || seen.has(m.threadId))
+                        continue;
+                    seen.add(m.threadId);
+                    const newer = ctx.db
+                        .query("messages")
+                        .withIndex("by_thread", (q) => q.eq("threadId", m.threadId).gte("at", m.at))
+                        .collect()
+                        .some((x) => x._id !== m._id && x.direction === "outbound" && x.fromEmail === mb.address && isAfter(x, m));
+                    if (newer)
+                        continue;
+                    const thread = ctx.db.get(m.threadId);
+                    if (!thread)
+                        continue;
+                    page.push({ ...thread, lastSentAt: m.at });
+                    if (page.length === limit) {
+                        next = sentCursor(m);
+                        break;
+                    }
+                }
+                // A full window that did not fill the page: older messages may still hold sent threads.
+                if (next === null && window.length === scan)
+                    next = sentCursor(window[window.length - 1]);
+                return { page, next };
+            },
+        }),
         /** Unread messages and thread counts per mailbox (aggregate: O(mailboxes)). */
         unread: query({
             args: { mailboxes: v.optional(v.array(v.string())) },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freecorps/ember-email",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "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.4",
-    "@freecorps/ember-server": "0.5.4",
-    "@freecorps/ember-values": "0.5.4",
+    "@freecorps/ember-rate-limit": "0.5.6",
+    "@freecorps/ember-server": "0.5.6",
+    "@freecorps/ember-values": "0.5.6",
     "postal-mime": "^4.1.4"
   }
 }