@bumail/queue 0.9.0 → 0.11.0

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   QueueError2,
   invalid,
   checkOwner
-} from "./chunks/index-9yp15arf.js";
+} from "./chunks/index-t6q7zxgj.js";
 
 // src/dsn/build.ts
 import {
@@ -306,31 +306,48 @@ function asked(kind, notify) {
   return notify.includes(event[kind]);
 }
 var returnOf = (ret, fallback) => ret === "HDRS" ? "headers" : ret === "FULL" ? "full" : fallback;
+var DEFAULT_MAX_RETURN = 64 * 1024;
 
-// src/dsn/delivered.ts
-function deliveredDsn(input) {
-  const wanted = input.recipients.filter((r) => asked("delivered", r.notify));
-  if (input.to === "" || wanted.length === 0)
+// src/dsn/for.ts
+function dsnFor(kind, input, recipients, returnContent) {
+  if (input.to === "" || recipients.length === 0)
     return;
-  const date = input.date ?? new Date;
   return buildDsn({
-    kind: "delivered",
+    kind,
     reportingMta: input.reportingMta,
     from: input.from,
     to: input.to,
     arrival: input.arrival,
-    date,
+    date: input.date ?? new Date,
     ...input.envid === undefined ? {} : { envid: input.envid },
-    recipients: wanted.map((r) => ({
-      address: r.address,
-      lastAttempt: date,
-      ...r.orcpt ? { orcpt: r.orcpt } : {}
-    })),
+    recipients,
     ...input.original ? { original: input.original } : {},
-    returnContent: "headers",
-    maxReturn: input.maxReturn ?? 64 * 1024
+    returnContent,
+    maxReturn: input.maxReturn ?? DEFAULT_MAX_RETURN
   });
 }
+
+// src/dsn/delivered.ts
+function deliveredDsn(input) {
+  const date = input.date ?? new Date;
+  const wanted = input.recipients.filter((r) => asked("delivered", r.notify));
+  return dsnFor("delivered", { ...input, date }, wanted.map((r) => ({
+    address: r.address,
+    lastAttempt: date,
+    ...r.orcpt ? { orcpt: r.orcpt } : {}
+  })), "headers");
+}
+// src/dsn/failed.ts
+function failedDsn(input) {
+  const date = input.date ?? new Date;
+  const wanted = input.recipients.filter((r) => asked("failed", r.notify));
+  return dsnFor("failed", { ...input, date }, wanted.map((r) => ({
+    address: r.address,
+    reply: r.reply,
+    lastAttempt: date,
+    ...r.orcpt ? { orcpt: r.orcpt } : {}
+  })), returnOf(input.ret, "headers"));
+}
 // src/queue/envelope.ts
 import { isMailbox } from "@bumail/smtp/client";
 var ADDRESS = /^[^\s<>]{1,64}@[^\s<>@]{1,253}$/u;
@@ -504,7 +521,7 @@ function limitsOf(options) {
     maxRecipients: numberOf("limits.maxRecipients", l.maxRecipients, 100, 1),
     maxItems: l.maxItems === undefined ? undefined : numberOf("limits.maxItems", l.maxItems, 0, 1),
     maxReplyText: numberOf("limits.maxReplyText", l.maxReplyText, 512, 64, 900),
-    maxDsnReturn: numberOf("limits.maxDsnReturn", l.maxDsnReturn, 64 * 1024, 0)
+    maxDsnReturn: numberOf("limits.maxDsnReturn", l.maxDsnReturn, DEFAULT_MAX_RETURN, 0)
   };
 }
 
@@ -921,12 +938,12 @@ function reported(r, kind) {
     text: [reply.text, ...said].filter((t) => t !== "").join(" ")
   };
 }
-async function notify(ctx, item, message, kind, recipients, now) {
+function dsnsFor(ctx, item, message, kind, recipients, now, failures) {
   const states = new Map(item.recipients.map((r) => [r.address, r]));
   const wanted = recipients.filter((r) => asked(kind, states.get(r.address)?.notify));
   if (item.from === "" || wanted.length === 0)
-    return;
-  const { settings, store, events } = ctx;
+    return [];
+  const { settings } = ctx;
   try {
     const lastAttempt = new Date(now);
     const dsn = buildDsn({
@@ -952,21 +969,61 @@ async function notify(ctx, item, message, kind, recipients, now) {
       returnContent: kind === "relayed" ? "headers" : returnOf(item.ret, settings.dsn.returnContent),
       maxReturn: settings.limits.maxDsnReturn
     });
-    const added = await store.add({
-      from: "",
-      to: [item.from],
-      message: dsn,
-      createdAt: now
-    });
+    return [
+      {
+        item: { from: "", to: [item.from], message: dsn, createdAt: now },
+        kind,
+        to: item.from,
+        recipients: wanted.map((r) => r.address)
+      }
+    ];
+  } catch (error) {
+    failures.push(error);
+    return [];
+  }
+}
+function dsnsOf(ctx, item, message, settled, now) {
+  const failures = [];
+  const build = (kind, recipients) => dsnsFor(ctx, item, message, kind, recipients, now, failures);
+  const pending = [
+    ...build("failed", settled.failed),
+    ...build("relayed", settled.delivered.filter((u) => u.dsnOffered === false)),
+    ...settled.delayDsn ? build("delayed", settled.deferred) : []
+  ];
+  return { pending, failures };
+}
+async function tellDsns(ctx, item, pending, completed) {
+  const { store, events } = ctx;
+  const stored = completed.dsns;
+  const outdated = !Array.isArray(stored);
+  if (outdated && pending.length > 0) {
+    const error = new QueueError2("INVALID", "Queue store outdated: complete returned the item alone, not { item, dsns }; its DSNs are added one by one, outside the step that records the outcome");
+    events.emit("error", { error, id: item.id });
+  }
+  for (const [index, dsn] of pending.entries()) {
+    let id;
+    if (outdated) {
+      try {
+        id = (await store.add(dsn.item)).id;
+      } catch (error) {
+        events.emit("error", { error, id: item.id });
+        continue;
+      }
+    } else {
+      id = stored[index]?.id;
+      if (id === undefined) {
+        const error = new QueueError2("INVALID", `The queue store stored ${stored.length} of the ${pending.length} DSNs of ${item.id}: a ${dsn.kind} DSN to ${dsn.to} is lost`);
+        events.emit("error", { error, id: item.id });
+        continue;
+      }
+    }
     events.emit("dsn", {
-      kind,
-      id: added.id,
+      kind: dsn.kind,
+      id,
       of: item.id,
-      to: item.from,
-      recipients: wanted.map((r) => r.address)
+      to: dsn.to,
+      recipients: dsn.recipients
     });
-  } catch (error) {
-    events.emit("error", { error, id: item.id });
   }
 }
 
@@ -1099,9 +1156,10 @@ async function record(ctx, item, updates, skipped, message, used) {
   const { settings, store, events } = ctx;
   const now = settings.now();
   const settled = settle(item, updates, skipped, now, settings);
-  const after = await store.complete(item.id, settings.owner, settled.result);
+  const { pending, failures } = dsnsOf(ctx, item, message, settled, now);
+  const completed = await store.complete(item.id, settings.owner, settled.result, pending.map((p) => p.item));
   ctx.recorded();
-  if (!after && await store.get(item.id) === undefined) {
+  if (!completed && await store.get(item.id) === undefined) {
     const lapse = await ctx.leaseLapsed(now);
     if (lapse) {
       events.emit("error", { error: goneAfter(lapse, item.id), id: item.id });
@@ -1112,7 +1170,7 @@ async function record(ctx, item, updates, skipped, message, used) {
     emitOutcomes(events, item, settled, used);
     return;
   }
-  if (!after) {
+  if (!completed) {
     const error = new QueueError2("LEASE_LOST", `The lease on ${item.id} was lost before its outcome was recorded; another worker will try it again`);
     events.emit("error", { error, id: item.id });
     return;
@@ -1121,12 +1179,9 @@ async function record(ctx, item, updates, skipped, message, used) {
     events.emit("error", { error: unreadableError(item.id), id: item.id });
   }
   emitOutcomes(events, item, settled, used);
-  await notify(ctx, item, message, "failed", settled.failed, now);
-  const relayed = settled.delivered.filter((u) => u.dsnOffered === false);
-  await notify(ctx, item, message, "relayed", relayed, now);
-  if (settled.delayDsn) {
-    await notify(ctx, item, message, "delayed", settled.deferred, now);
-  }
+  for (const error of failures)
+    events.emit("error", { error, id: item.id });
+  await tellDsns(ctx, item, pending, completed);
 }
 
 // src/queue/lease.ts
@@ -1414,10 +1469,12 @@ function createQueue(options) {
   };
 }
 export {
+  DEFAULT_MAX_RETURN,
   QueueError2 as QueueError,
   createQueue,
-  deliveredDsn
+  deliveredDsn,
+  failedDsn
 };
 
-//# debugId=D24C84F35DEF0E8164756E2164756E21
+//# debugId=9190A6EB36D3FC0664756E2164756E21
 //# sourceMappingURL=index.js.map