@freecorps/ember-email 0.5.6 → 0.5.8

package/README.md

@@ -71,6 +71,10 @@ export const signup = mutation({
   (with their size). Mind the provider's message size: for a large file, put a download link in the text
   (`ctx.storage.getUrl(file, { download, expiresIn })`) and pass it with `link: true`. The email then has no MIME part
   for it, and the message still holds the file (the thread lists it, and it is not collected).
+- **Retention:** `upsertMailbox({ retention: { closedDays: 730, spamDays: 30 } })` keeps closed and spam conversations
+  that many days, counted from the latest status change or message; a daily job (`lib:purge`, 04:00
+  UTC) then deletes the conversation and its messages, and file GC deletes their `.eml` and attachments. Without
+  `retention` (or with `retention: null`) nothing is deleted.
 
 ## Domains: `@freecorps/ember-email/cloudflare`
 
@@ -97,6 +101,10 @@ What it does:
   routing subdomain, so removal is a dashboard step.
 - **Mailboxes:** it adds one literal rule per mailbox address on the domain → your Worker. It never changes a rule
   that routes somewhere else.
+- **Catch-all:** with `catchAll: true` (a mailbox of the domain is its catch-all, `upsertMailbox({ catchAll: true })`),
+  the zone's catch-all rule → your Worker, so every address no mailbox has reaches that mailbox, with the address it
+  was sent to in its To. Only for the zone apex, since the rule belongs to the zone. It never takes over a catch-all
+  that routes somewhere else. `destroyDomain`, or a sync without `catchAll`, turns it back off.
 - **Events:** it adds an `email.sending` event subscription → the component's queue.
 
 ## Offline replicas: `@freecorps/ember-email/schema`

package/dist/client.d.ts

@@ -2,6 +2,11 @@ import type { FunctionReference } from "@freecorps/ember-server";
 import type { SendInput, SendResult } from "./component.ts";
 import type { EmailStatus } from "./events.ts";
 type Ref<T extends "query" | "mutation" | "action", A, R> = FunctionReference<T, "public", A, R>;
+/** Days closed and spam conversations are kept (`upsertMailbox({ retention })`); a missing kind is kept forever. */
+export type MailboxRetention = {
+    closedDays?: number;
+    spamDays?: number;
+};
 type Page<T> = {
     page: T[];
     isDone: boolean;
@@ -133,6 +138,8 @@ export interface EmailComponentApi {
                 text: string;
                 html?: string;
             } | null;
+            catchAll?: boolean | null;
+            retention?: MailboxRetention | null;
         }, string>;
         removeMailbox: Ref<"mutation", {
             name: string;
@@ -143,6 +150,8 @@ export interface EmailComponentApi {
             address: string;
             displayName?: string;
             autoReply?: unknown;
+            catchAll?: boolean;
+            retention?: MailboxRetention;
         }>>;
         route: Ref<"query", {
             to: string;

package/dist/cloudflare/api.d.ts

@@ -54,6 +54,15 @@ export declare function ensureWorkerRule(c: CfCreds, zoneId: string, address: st
     id: string;
     created: boolean;
 }>;
+/**
+ * The zone's catch-all rule → this Worker (every address no literal rule takes). Left alone, with an error, when it
+ * is on and sends mail somewhere else; a disabled or "drop" catch-all is taken over.
+ */
+export declare function ensureCatchAllRule(c: CfCreds, zoneId: string, worker: string): Promise<{
+    created: boolean;
+}>;
+/** Turns the zone's catch-all back off (drop), only when it points at this Worker. */
+export declare function releaseCatchAllRule(c: CfCreds, zoneId: string, worker: string): Promise<boolean>;
 export declare function deleteRule(c: CfCreds, zoneId: string, id: string): Promise<void>;
 /** Queues event subscription: Email Service delivery events of `domain` → `queue` (by name). */
 export declare function ensureEventSubscription(c: CfCreds, zoneId: string, domain: string, queue: string): Promise<{

package/dist/cloudflare/api.js

@@ -118,6 +118,28 @@ export async function ensureWorkerRule(c, zoneId, address, worker) {
     });
     return { id: r.id, created: true };
 }
+const pointsAt = (r, worker) => r.actions.some((x) => x.type === "worker" && x.value?.includes(worker));
+/**
+ * The zone's catch-all rule → this Worker (every address no literal rule takes). Left alone, with an error, when it
+ * is on and sends mail somewhere else; a disabled or "drop" catch-all is taken over.
+ */
+export async function ensureCatchAllRule(c, zoneId, worker) {
+    const r = await call(c, "GET", `/zones/${zoneId}/email/routing/rules/catch_all`);
+    if (r.enabled && pointsAt(r, worker))
+        return { created: false };
+    if (r.enabled && !r.actions.every((x) => x.type === "drop"))
+        throw new CfError(`the zone's catch-all already routes mail elsewhere (${r.actions.map((x) => x.type).join(", ")}); not changing it`, 409, []);
+    await call(c, "PUT", `/zones/${zoneId}/email/routing/rules/catch_all`, { enabled: true, matchers: [{ type: "all" }], actions: [{ type: "worker", value: [worker] }] });
+    return { created: true };
+}
+/** Turns the zone's catch-all back off (drop), only when it points at this Worker. */
+export async function releaseCatchAllRule(c, zoneId, worker) {
+    const r = await call(c, "GET", `/zones/${zoneId}/email/routing/rules/catch_all`);
+    if (!pointsAt(r, worker))
+        return false;
+    await call(c, "PUT", `/zones/${zoneId}/email/routing/rules/catch_all`, { enabled: false, matchers: [{ type: "all" }], actions: [{ type: "drop" }] });
+    return true;
+}
 export async function deleteRule(c, zoneId, id) {
     await call(c, "DELETE", `/zones/${zoneId}/email/routing/rules/${id}`);
 }

package/dist/cloudflare/index.d.ts

@@ -1,4 +1,4 @@
-export { CfError, deleteEventSubscription, deleteRule, deleteSending, enableRoutingSubdomain, ensureEventSubscription, ensureSending, ensureWorkerRule, findZone, routingState, sendingDomain, type CfCreds, type DnsRecord, type RoutingState, } from "./api.ts";
+export { CfError, deleteEventSubscription, deleteRule, deleteSending, enableRoutingSubdomain, ensureEventSubscription, ensureSending, ensureWorkerRule, ensureCatchAllRule, releaseCatchAllRule, findZone, routingState, sendingDomain, type CfCreds, type DnsRecord, type RoutingState, } from "./api.ts";
 export { destroyDomain, isDomainName, syncDomain, type DomainState, type SyncDomainDeps, type SyncDomainOptions } from "./onboard.ts";
 /**
  * Names `ember deploy` gives an app's Worker and the email component's delivery-events queue (`install` is the name

package/dist/cloudflare/index.js

@@ -7,7 +7,7 @@
 //   const { worker, eventsQueue } = emailResources("acme", "prod");
 //   let d = await syncDomain(c, { name: "mail.acme.com" }, { prev: null, mailboxes: ["support@mail.acme.com"], worker, queue: eventsQueue });
 //   // keep `d` (it holds the ids of what was created); later: await destroyDomain(c, d)
-export { CfError, deleteEventSubscription, deleteRule, deleteSending, enableRoutingSubdomain, ensureEventSubscription, ensureSending, ensureWorkerRule, findZone, routingState, sendingDomain, } from "./api.js";
+export { CfError, deleteEventSubscription, deleteRule, deleteSending, enableRoutingSubdomain, ensureEventSubscription, ensureSending, ensureWorkerRule, ensureCatchAllRule, releaseCatchAllRule, findZone, routingState, sendingDomain, } from "./api.js";
 export { destroyDomain, isDomainName, syncDomain } from "./onboard.js";
 /**
  * Names `ember deploy` gives an app's Worker and the email component's delivery-events queue (`install` is the name

package/dist/cloudflare/onboard.d.ts

@@ -12,6 +12,8 @@ export type DomainState = {
     ruleIds: string[];
     subscriptionId?: string;
     createdSending?: boolean;
+    /** The zone's catch-all rule points at this Worker (set by `catchAll`; `destroyDomain` turns it off). */
+    catchAll?: string;
     notes: string[];
 };
 /** A syntactically valid (lowercase) domain name. */
@@ -35,6 +37,11 @@ export type SyncDomainDeps = {
     worker: string;
     /** The component's delivery-events queue (see `emailResources`). */
     queue: string;
+    /**
+     * A mailbox of this domain is its catch-all: the zone's catch-all rule → `worker`. Only for a zone apex (the rule
+     * is the zone's); refused when the catch-all already routes mail elsewhere.
+     */
+    catchAll?: boolean;
 };
 /**
  * Onboards (or re-checks) a domain. Idempotent: run it again until `status` is `verified` (a new sending domain

package/dist/cloudflare/onboard.js

@@ -2,7 +2,7 @@
 // subdomain only when asked), one Worker rule per mailbox address, and the delivery-event subscription to the
 // component's queue. The caller keeps the returned `DomainState` (it holds the ids of what was created) and passes it
 // back on the next sync and to `destroyDomain`. Product-agnostic: no storage, no HTTP API, no API keys.
-import { CfError, deleteEventSubscription, deleteRule, deleteSending, enableRoutingSubdomain, ensureEventSubscription, ensureSending, ensureWorkerRule, findZone, routingState } from "./api.js";
+import { CfError, deleteEventSubscription, deleteRule, deleteSending, enableRoutingSubdomain, ensureCatchAllRule, ensureEventSubscription, ensureSending, ensureWorkerRule, findZone, releaseCatchAllRule, routingState } from "./api.js";
 const NAME = /^(?=.{3,253}$)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/;
 /** A syntactically valid (lowercase) domain name. */
 export const isDomainName = (name) => NAME.test(name);
@@ -39,6 +39,7 @@ export async function syncDomain(c, a, deps) {
     let routingStatus;
     const ruleIds = [...(prev?.ruleIds ?? [])];
     let subscriptionId = prev?.subscriptionId;
+    let catchAll = prev?.catchAll;
     let recvOk = !wantRecv;
     if (wantRecv) {
         let r = await routingState(c, zone, name);
@@ -64,6 +65,27 @@ export async function syncDomain(c, a, deps) {
                     notes.push(e.message);
                 }
             }
+            if (deps.catchAll && name !== zone.name)
+                notes.push(`a catch-all is the zone's rule: only ${zone.name} can have one, not ${name}`);
+            else if (deps.catchAll) {
+                try {
+                    await ensureCatchAllRule(c, zone.id, deps.worker);
+                    catchAll = deps.worker;
+                }
+                catch (e) {
+                    notes.push(`catch-all: ${e.message}`);
+                }
+            }
+            else if (catchAll && name === zone.name) {
+                // No catch-all mailbox any more: the rule this sync set goes back off.
+                try {
+                    await releaseCatchAllRule(c, zone.id, catchAll);
+                    catchAll = undefined;
+                }
+                catch (e) {
+                    notes.push(`catch-all: ${e.message}`);
+                }
+            }
         }
     }
     if (wantSend && sendingOk) {
@@ -87,6 +109,7 @@ export async function syncDomain(c, a, deps) {
         ruleIds,
         ...(subscriptionId ? { subscriptionId } : {}),
         createdSending,
+        ...(catchAll ? { catchAll } : {}),
         notes,
     };
 }
@@ -107,6 +130,8 @@ export async function destroyDomain(c, d) {
             await attempt(`rule ${id}`, () => deleteRule(c, d.zoneId, id));
         if (d.createdSending && d.sendingTag)
             await attempt("sending domain", () => deleteSending(c, d.zoneId, d.sendingTag));
+        if (d.catchAll)
+            await attempt("catch-all", async () => void (await releaseCatchAllRule(c, d.zoneId, d.catchAll)));
     }
     if (d.subscriptionId)
         await attempt("event subscription", () => deleteEventSubscription(c, d.subscriptionId));

package/dist/component.d.ts

@@ -513,6 +513,15 @@ export declare const emailFunctions: {
         } | null>;
         /** Cron: a send claimed more than LEASE_MS ago never finished (Worker died mid-send): fail it, never resend blind. */
         sweep: import("@freecorps/ember-server").RegisteredMutation<"internal", {}, number>;
+        /**
+         * Daily: deletes the closed and spam conversations past their mailbox's retention (with their messages; the
+         * messages' files are then collected by file GC). Bounded per run; schedules itself again while there is more.
+         */
+        purge: import("@freecorps/ember-server").RegisteredMutation<"internal", {}, {
+            threads: number;
+            messages: number;
+            more: boolean;
+        }>;
         applyEvents: import("@freecorps/ember-server").RegisteredMutation<"internal", {
             events: any[];
         }, ({
@@ -596,6 +605,11 @@ export declare const emailFunctions: {
                 subject: string;
                 html?: string;
             } | null;
+            catchAll?: boolean | null;
+            retention?: {
+                closedDays?: number;
+                spamDays?: number;
+            } | null;
         }, GenericId<"mailboxes">>;
         removeMailbox: import("@freecorps/ember-server").RegisteredMutation<"public", {
             name: string;
@@ -613,6 +627,11 @@ export declare const emailFunctions: {
                 subject: string;
                 html?: string;
             };
+            catchAll?: boolean;
+            retention?: {
+                closedDays?: number;
+                spamDays?: number;
+            };
         }[]>;
         route: import("@freecorps/ember-server").RegisteredQuery<"public", {
             to: string;
@@ -642,6 +661,7 @@ export declare const emailFunctions: {
             lastMessageAt: number;
             snippet: string;
             contactName?: string;
+            activityAt?: number;
             lastInboundAt?: number;
             assignee?: string;
             assigneeName?: string;
@@ -664,6 +684,7 @@ export declare const emailFunctions: {
                 lastMessageAt: number;
                 snippet: string;
                 contactName?: string;
+                activityAt?: number;
                 lastInboundAt?: number;
                 assignee?: string;
                 assigneeName?: string;
@@ -828,6 +849,7 @@ export declare const emailFunctions: {
                 lastMessageAt: number;
                 snippet: string;
                 contactName?: string;
+                activityAt?: number;
                 lastInboundAt?: number;
                 assignee?: string;
                 assigneeName?: string;
@@ -1320,6 +1342,15 @@ export declare const email: import("@freecorps/ember-server").ComponentDefinitio
         } | null>;
         /** Cron: a send claimed more than LEASE_MS ago never finished (Worker died mid-send): fail it, never resend blind. */
         sweep: import("@freecorps/ember-server").RegisteredMutation<"internal", {}, number>;
+        /**
+         * Daily: deletes the closed and spam conversations past their mailbox's retention (with their messages; the
+         * messages' files are then collected by file GC). Bounded per run; schedules itself again while there is more.
+         */
+        purge: import("@freecorps/ember-server").RegisteredMutation<"internal", {}, {
+            threads: number;
+            messages: number;
+            more: boolean;
+        }>;
         applyEvents: import("@freecorps/ember-server").RegisteredMutation<"internal", {
             events: any[];
         }, ({
@@ -1403,6 +1434,11 @@ export declare const email: import("@freecorps/ember-server").ComponentDefinitio
                 subject: string;
                 html?: string;
             } | null;
+            catchAll?: boolean | null;
+            retention?: {
+                closedDays?: number;
+                spamDays?: number;
+            } | null;
         }, GenericId<"mailboxes">>;
         removeMailbox: import("@freecorps/ember-server").RegisteredMutation<"public", {
             name: string;
@@ -1420,6 +1456,11 @@ export declare const email: import("@freecorps/ember-server").ComponentDefinitio
                 subject: string;
                 html?: string;
             };
+            catchAll?: boolean;
+            retention?: {
+                closedDays?: number;
+                spamDays?: number;
+            };
         }[]>;
         route: import("@freecorps/ember-server").RegisteredQuery<"public", {
             to: string;
@@ -1449,6 +1490,7 @@ export declare const email: import("@freecorps/ember-server").ComponentDefinitio
             lastMessageAt: number;
             snippet: string;
             contactName?: string;
+            activityAt?: number;
             lastInboundAt?: number;
             assignee?: string;
             assigneeName?: string;
@@ -1471,6 +1513,7 @@ export declare const email: import("@freecorps/ember-server").ComponentDefinitio
                 lastMessageAt: number;
                 snippet: string;
                 contactName?: string;
+                activityAt?: number;
                 lastInboundAt?: number;
                 assignee?: string;
                 assigneeName?: string;
@@ -1635,6 +1678,7 @@ export declare const email: import("@freecorps/ember-server").ComponentDefinitio
                 lastMessageAt: number;
                 snippet: string;
                 contactName?: string;
+                activityAt?: number;
                 lastInboundAt?: number;
                 assignee?: string;
                 assigneeName?: string;

package/dist/component.js

@@ -387,10 +387,18 @@ function applyToEmail(ctx, e, ev) {
 }
 // ------------------------------------------------------------------------------------------------ inbound
 const THREAD_WINDOW = 30 * DAY;
+/** The catch-all mailbox of `domain`, if one is set. */
+function catchAllOf(ctx, domain) {
+    return ctx.db.query("mailboxes").collect().find((m) => m.catchAll && domainOf(m.address) === domain) ?? null;
+}
 function routeOf(ctx, to) {
     const { base, tag } = splitPlus(to.toLowerCase());
     const m = ctx.db.query("mailboxes").withIndex("by_address", (q) => q.eq("address", base)).first();
-    return m ? { mailbox: m.name, tag } : null;
+    if (m)
+        return { mailbox: m.name, tag };
+    // No mailbox has that address: its domain's catch-all takes it (the address it was sent to stays in its To).
+    const all = catchAllOf(ctx, domainOf(base));
+    return all ? { mailbox: all.name, tag: null } : null;
 }
 function token(ctx) {
     const abc = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -469,6 +477,7 @@ function ingest(ctx, a) {
             contact,
             ...((a.replyTo ?? a.from).name ? { contactName: (a.replyTo ?? a.from).name } : {}),
             status: spam ? "spam" : "open",
+            activityAt: ctx.now,
             token: token(ctx),
             messageCount: 0,
             unreadCount: 0,
@@ -505,6 +514,7 @@ function ingest(ctx, a) {
     const status = thread.status === "spam" ? "spam" : "open";
     ctx.db.patch(thread._id, {
         status,
+        activityAt: ctx.now,
         messageCount: thread.messageCount + 1,
         unreadCount: thread.unreadCount + 1,
         lastMessageAt: ctx.now,
@@ -593,10 +603,83 @@ function appendOutbound(ctx, thread, mb, a) {
     ctx.db.patch(thread._id, {
         messageCount: thread.messageCount + 1,
         lastMessageAt: ctx.now,
+        activityAt: ctx.now,
         ...(a.note ? {} : { status: thread.status === "spam" ? "spam" : "waiting", snippet }),
     });
     return id;
 }
+const DAY_MS = 86_400_000;
+const MAX_RETENTION_DAYS = 36_500;
+/** Rows (messages and threads) one purge transaction deletes before it schedules the rest. */
+const PURGE_BUDGET = 500;
+/** Candidates one purge run looks at per mailbox and status (some may not be due yet: see `purgeExpired`). */
+const PURGE_SCAN = 200;
+function retentionOf(r) {
+    const out = {};
+    for (const k of ["closedDays", "spamDays"]) {
+        const d = r[k];
+        if (d === undefined)
+            continue;
+        if (!Number.isInteger(d) || d < 1 || d > MAX_RETENTION_DAYS)
+            fail("ValidationError", `retention.${k}: a whole number of days in 1..${MAX_RETENTION_DAYS}`);
+        out[k] = d;
+    }
+    return out.closedDays === undefined && out.spamDays === undefined ? undefined : out;
+}
+/**
+ * One purge pass: the closed and spam threads whose latest status change or message (`activityAt`) is older than
+ * their mailbox's retention, straight from the `by_mailbox_status_activity` index (every candidate is due, so a
+ * thread kept longer never blocks the ones behind it). Threads from before `activityAt` (absent, first in the index)
+ * get it from `lastMessageAt` when they are not due yet, so they leave the head of the index.
+ */
+function purgeExpired(ctx) {
+    let budget = PURGE_BUDGET;
+    let threads = 0;
+    let messages = 0;
+    let more = false;
+    for (const mb of ctx.db.query("mailboxes").collect()) {
+        for (const [status, days] of [
+            ["closed", mb.retention?.closedDays],
+            ["spam", mb.retention?.spamDays],
+        ]) {
+            if (!days || more)
+                continue;
+            const cutoff = ctx.now - days * DAY_MS;
+            const due = ctx.db
+                .query("threads")
+                .withIndex("by_mailbox_status_activity", (q) => q.eq("mailbox", mb.name).eq("status", status).lte("activityAt", cutoff))
+                .take(PURGE_SCAN);
+            for (const t of due) {
+                if (budget <= 0) {
+                    more = true;
+                    break;
+                }
+                if (t.activityAt === undefined && t.lastMessageAt > cutoff) {
+                    ctx.db.patch(t._id, { activityAt: t.lastMessageAt });
+                    budget--;
+                    continue;
+                }
+                const batch = ctx.db.query("messages").withIndex("by_thread", (q) => q.eq("threadId", t._id)).take(budget);
+                for (const m of batch)
+                    ctx.db.delete(m._id);
+                messages += batch.length;
+                budget -= batch.length;
+                if (budget <= 0) {
+                    more = true; // the thread goes on the next run, once its last messages are gone
+                    break;
+                }
+                ctx.db.delete(t._id);
+                threads++;
+                budget--;
+            }
+            if (due.length === PURGE_SCAN)
+                more = true;
+        }
+    }
+    if (more)
+        ctx.scheduler.runAfter(0, "lib:purge", {});
+    return { threads, messages, more };
+}
 // ------------------------------------------------------------------------------------------------ functions
 const pageV = v.optional(v.object({ numItems: v.number(), cursor: v.union(v.string(), v.null()) }));
 export const emailFunctions = {
@@ -757,6 +840,14 @@ export const emailFunctions = {
                 return n;
             },
         }),
+        /**
+         * Daily: deletes the closed and spam conversations past their mailbox's retention (with their messages; the
+         * messages' files are then collected by file GC). Bounded per run; schedules itself again while there is more.
+         */
+        purge: internalMutation({
+            args: {},
+            handler: (ctx) => purgeExpired(ctx),
+        }),
         // ---------------------------------------------------------------- events
         applyEvents: internalMutation({
             args: { events: v.array(v.any()) },
@@ -842,6 +933,13 @@ export const emailFunctions = {
                 displayName: v.optional(v.union(v.null(), v.string())),
                 /** Absent: keeps the stored one; null: clears it. */
                 autoReply: v.optional(v.union(v.null(), v.object({ subject: v.string(), text: v.string(), html: v.optional(v.string()) }))),
+                /** The domain's catch-all (one per domain). Absent: keeps the stored value; false or null: clears it. */
+                catchAll: v.optional(v.union(v.null(), v.boolean())),
+                /**
+                 * Days closed and spam conversations are kept (whole days, 1..36500; a missing kind is kept forever).
+                 * Absent: keeps the stored policy; null: clears it (kept forever).
+                 */
+                retention: v.optional(v.union(v.null(), v.object({ closedDays: v.optional(v.number()), spamDays: v.optional(v.number()) }))),
             },
             handler: (ctx, a) => {
                 if (!/^[a-z][a-z0-9_-]{0,39}$/.test(a.name))
@@ -856,7 +954,23 @@ export const emailFunctions = {
                 // Patch semantics: an absent field keeps its stored value, null clears it.
                 const displayName = a.displayName === null ? undefined : (a.displayName ?? prev?.displayName);
                 const autoReply = a.autoReply === null ? undefined : (a.autoReply ?? prev?.autoReply);
-                const doc = { name: a.name, address, ...(displayName ? { displayName } : {}), ...(autoReply ? { autoReply } : {}), nextNumber: prev?.nextNumber ?? 1, createdAt: prev?.createdAt ?? ctx.now };
+                const catchAll = a.catchAll === undefined ? !!prev?.catchAll : !!a.catchAll;
+                const retention = a.retention === null ? undefined : a.retention === undefined ? prev?.retention : retentionOf(a.retention);
+                if (catchAll) {
+                    const other = catchAllOf(ctx, domainOf(address));
+                    if (other && other.name !== a.name)
+                        fail("ValidationError", `${domainOf(address)} already has a catch-all: mailbox ${other.name}`);
+                }
+                const doc = {
+                    name: a.name,
+                    address,
+                    ...(displayName ? { displayName } : {}),
+                    ...(autoReply ? { autoReply } : {}),
+                    ...(catchAll ? { catchAll: true } : {}),
+                    ...(retention ? { retention } : {}),
+                    nextNumber: prev?.nextNumber ?? 1,
+                    createdAt: prev?.createdAt ?? ctx.now,
+                };
                 if (prev) {
                     ctx.db.replace(prev._id, doc);
                     return prev._id;
@@ -1013,7 +1127,8 @@ export const emailFunctions = {
                 const t = ctx.db.get(a.threadId);
                 if (!t)
                     return fail("NotFound", "thread not found");
-                ctx.db.patch(a.threadId, { status: a.status });
+                if (t.status !== a.status)
+                    ctx.db.patch(a.threadId, { status: a.status, activityAt: ctx.now });
                 return a.status;
             },
         }),
@@ -1139,6 +1254,7 @@ export const emailFunctions = {
                     messageCount: 0,
                     unreadCount: 0,
                     lastMessageAt: ctx.now,
+                    activityAt: ctx.now,
                     snippet: snippetOf(a.text),
                 });
                 const thread = ctx.db.get(threadId);
@@ -1265,7 +1381,7 @@ export const email = defineComponent({
     bindings: (config) => (config?.transport ?? "binding") === "binding"
         ? [{ type: "send_email", name: config?.binding ?? "EMAIL", ...(config?.allowedSenders?.length ? { allowed_sender_addresses: config.allowedSenders } : {}) }]
         : [],
-    crons: (config) => cronJobs({ shard: config?.shard ?? "global:main" }).interval("sweep", { minutes: 10 }, "lib:sweep"),
+    crons: (config) => cronJobs({ shard: config?.shard ?? "global:main" }).interval("sweep", { minutes: 10 }, "lib:sweep").daily("purge", { hour: 4 }, "lib:purge"),
     queues: {
         events: { shard: (config) => config?.shard ?? "global:main", consumer: { maxBatchSize: 100, maxBatchTimeoutSeconds: 2, maxRetries: 10 }, handler: onEvents },
     },

package/dist/schema.d.ts

@@ -169,6 +169,19 @@ export declare const emailSchema: import("@freecorps/ember-server").SchemaDefini
             text: import("@freecorps/ember-values").Validator<string, "required", never>;
             html: import("@freecorps/ember-values").Validator<string, "optional", never>;
         }> | undefined>>;
+        /** Receives mail for any address of its domain that no other mailbox has (one per domain). */
+        catchAll: import("@freecorps/ember-values").Validator<boolean, "optional", never>;
+        /**
+         * How long closed and spam conversations are kept, in days, counted from the latest status change or message
+         * (`threads.activityAt`). Absent: kept forever. A daily job deletes the conversation, its messages and their files.
+         */
+        retention: import("@freecorps/ember-values").Validator<{
+            closedDays?: number;
+            spamDays?: number;
+        }, "optional", NonNullable<import("@freecorps/ember-values").ObjectFieldPaths<{
+            closedDays: import("@freecorps/ember-values").Validator<number, "optional", never>;
+            spamDays: import("@freecorps/ember-values").Validator<number, "optional", never>;
+        }> | undefined>>;
         nextNumber: import("@freecorps/ember-values").Validator<number, "required", never>;
         createdAt: import("@freecorps/ember-values").Validator<number, "required", never>;
     }>, {
@@ -185,6 +198,11 @@ export declare const emailSchema: import("@freecorps/ember-server").SchemaDefini
         contactName: import("@freecorps/ember-values").Validator<string, "optional", never>;
         /** open | waiting | closed | spam */
         status: import("@freecorps/ember-values").Validator<string, "required", never>;
+        /**
+         * The latest status change or message: retention counts from it. Absent on threads from before 0.5.8 (the first
+         * purge fills it in from `lastMessageAt`).
+         */
+        activityAt: import("@freecorps/ember-values").Validator<number, "optional", never>;
         /** Plus-address token: replies to `support+t_<token>@` join this thread from any sender. */
         token: import("@freecorps/ember-values").Validator<string, "required", never>;
         messageCount: import("@freecorps/ember-values").Validator<number, "required", never>;
@@ -198,6 +216,7 @@ export declare const emailSchema: import("@freecorps/ember-server").SchemaDefini
     }>, {
         by_mailbox_last: ["mailbox", "lastMessageAt", "_creationTime"];
         by_mailbox_status: ["mailbox", "status", "lastMessageAt", "_creationTime"];
+        by_mailbox_status_activity: ["mailbox", "status", "activityAt", "_creationTime"];
         by_token: ["token", "_creationTime"];
         by_contact_subject: ["mailbox", "contact", "subjectKey", "_creationTime"];
     }, {

package/dist/schema.js

@@ -93,6 +93,13 @@ export const emailSchema = defineSchema({
             address: v.string(),
             displayName: v.optional(v.string()),
             autoReply: v.optional(v.object({ subject: v.string(), text: v.string(), html: v.optional(v.string()) })),
+            /** Receives mail for any address of its domain that no other mailbox has (one per domain). */
+            catchAll: v.optional(v.boolean()),
+            /**
+             * How long closed and spam conversations are kept, in days, counted from the latest status change or message
+             * (`threads.activityAt`). Absent: kept forever. A daily job deletes the conversation, its messages and their files.
+             */
+            retention: v.optional(v.object({ closedDays: v.optional(v.number()), spamDays: v.optional(v.number()) })),
             nextNumber: v.number(),
             createdAt: v.number(),
         })
@@ -108,6 +115,11 @@ export const emailSchema = defineSchema({
             contactName: v.optional(v.string()),
             /** open | waiting | closed | spam */
             status: v.string(),
+            /**
+             * The latest status change or message: retention counts from it. Absent on threads from before 0.5.8 (the first
+             * purge fills it in from `lastMessageAt`).
+             */
+            activityAt: v.optional(v.number()),
             /** Plus-address token: replies to `support+t_<token>@` join this thread from any sender. */
             token: v.string(),
             messageCount: v.number(),
@@ -121,6 +133,7 @@ export const emailSchema = defineSchema({
         })
             .index("by_mailbox_last", ["mailbox", "lastMessageAt"])
             .index("by_mailbox_status", ["mailbox", "status", "lastMessageAt"])
+            .index("by_mailbox_status_activity", ["mailbox", "status", "activityAt"])
             .index("by_token", ["token"])
             .index("by_contact_subject", ["mailbox", "contact", "subjectKey"])
             .aggregate("unread", { by: ["mailbox"], count: true, sum: ["unreadCount"] }),

package/package.json

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