mailery 0.3.1 → 0.4.0

package/dist/index.cjs

@@ -831,6 +831,11 @@ function adaptBullQueue(q) {
   return {
     add: (name, data, opts) => q.add(name, data, opts),
     getWaitingCount: () => q.getWaitingCount(),
+    getInFlightCount: async () => {
+      const [active, waiting] = await Promise.all([q.getActiveCount(), q.getWaitingCount()]);
+      return active + waiting;
+    },
+    getDelayedCount: () => q.getDelayedCount(),
     close: () => q.close()
   };
 }
@@ -3261,43 +3266,131 @@ function createAdminRouter(mailer, opts = {}) {
 function apiRouter(mailer) {
   const r = express.Router();
   const c = mailer.collections;
-  r.get("/me", (req, res) => {
-    res.json({
-      actor: req.actor,
-      permissions: { canPublish: true, canSendBroadcasts: true, canManageSuppressions: true }
-    });
-  });
+  r.get(
+    "/me",
+    asyncHandler(async (req, res) => {
+      const [flows, templates, broadcasts, contacts, suppressions, health] = await Promise.all([
+        c.flows.estimatedDocumentCount(),
+        c.templates.estimatedDocumentCount(),
+        c.broadcasts.estimatedDocumentCount(),
+        c.subscriptions.countDocuments({ status: "subscribed" }),
+        c.suppressions.estimatedDocumentCount(),
+        c.health.findOne({ _id: "singleton" })
+      ]);
+      res.json({
+        actor: req.actor,
+        counts: { flows, templates, broadcasts, contacts, suppressions },
+        health: { status: health?.status ?? null },
+        providers: {
+          names: Object.keys(mailer.config.providers),
+          default: mailer.config.defaultProvider
+        },
+        broadcastConfirmationThreshold: mailer.config.broadcastConfirmationThreshold
+      });
+    })
+  );
   r.get(
     "/dashboard",
     asyncHandler(async (_req, res) => {
-      const since24h = new Date(Date.now() - 24 * 60 * 60 * 1e3);
-      const [sentTotal, deliveredCount, bouncedCount, openedCount, clickedCount] = await Promise.all([
+      const now = Date.now();
+      const HOUR = 60 * 60 * 1e3;
+      const since24h = new Date(now - 24 * HOUR);
+      const since48h = new Date(now - 48 * HOUR);
+      const [
+        sentTotal,
+        deliveredCount,
+        bouncedCount,
+        openedCount,
+        clickedCount,
+        sentPrev,
+        deliveredPrev,
+        openedPrev,
+        clickedPrev,
+        hourly
+      ] = await Promise.all([
         c.sends.countDocuments({ queuedAt: { $gt: since24h } }),
         c.sends.countDocuments({ queuedAt: { $gt: since24h }, status: "delivered" }),
         c.sends.countDocuments({ queuedAt: { $gt: since24h }, status: "bounced" }),
         c.sends.countDocuments({ queuedAt: { $gt: since24h }, openedAt: { $ne: null } }),
-        c.sends.countDocuments({ queuedAt: { $gt: since24h }, firstClickAt: { $ne: null } })
+        c.sends.countDocuments({ queuedAt: { $gt: since24h }, firstClickAt: { $ne: null } }),
+        c.sends.countDocuments({ queuedAt: { $gt: since48h, $lte: since24h } }),
+        c.sends.countDocuments({ queuedAt: { $gt: since48h, $lte: since24h }, status: "delivered" }),
+        c.sends.countDocuments({ queuedAt: { $gt: since48h, $lte: since24h }, openedAt: { $ne: null } }),
+        c.sends.countDocuments({ queuedAt: { $gt: since48h, $lte: since24h }, firstClickAt: { $ne: null } }),
+        c.sends.aggregate([
+          { $match: { queuedAt: { $gt: since24h } } },
+          {
+            $project: {
+              hour: {
+                $toInt: {
+                  $divide: [{ $subtract: [now, { $toLong: "$queuedAt" }] }, HOUR]
+                }
+              },
+              opened: { $cond: [{ $ifNull: ["$openedAt", false] }, 1, 0] }
+            }
+          },
+          { $group: { _id: "$hour", sends: { $sum: 1 }, opens: { $sum: "$opened" } } }
+        ]).toArray()
       ]);
+      const sendSeries = new Array(24).fill(0);
+      const openSeries = new Array(24).fill(0);
+      for (const row of hourly) {
+        const idx = 23 - Math.max(0, Math.min(23, row._id));
+        sendSeries[idx] = row.sends;
+        openSeries[idx] = row.opens;
+      }
+      const delta = (cur, prev) => {
+        if (prev === 0) return null;
+        return (cur - prev) / prev;
+      };
+      const rateDelta = (curN, curD, prevN, prevD) => {
+        if (prevD === 0 || curD === 0) return null;
+        return curN / curD - prevN / prevD;
+      };
       const health = await c.health.findOne({ _id: "singleton" });
-      const recentFlows = await c.flows.find({ enabled: true }).limit(5).toArray();
+      const recentFlowsRaw = await c.flows.find({ enabled: true }).limit(5).toArray();
+      const flowStatsMap = await computeFlowStats(mailer);
+      const recentFlows = recentFlowsRaw.map((f) => ({ ...f, stats: flowStatsMap.get(f.slug) ?? emptyFlowStats() }));
       const recentSends = await c.sends.find().sort({ queuedAt: -1 }).limit(6).toArray();
       const recentAudit = await c.auditLog.find().sort({ occurredAt: -1 }).limit(5).toArray();
+      const queueCounts = await collectQueueCounts(mailer);
+      const lastSendError = await c.sends.findOne({ status: { $in: ["bounced", "failed"] } }, { sort: { queuedAt: -1 } });
+      const lastSendOk = await c.sends.findOne({ status: "delivered" }, { sort: { queuedAt: -1 } });
+      const providerOk = lastSendOk && lastSendError ? new Date(lastSendOk.queuedAt).getTime() >= new Date(lastSendError.queuedAt).getTime() : lastSendOk ? true : lastSendError ? false : null;
       res.json({
         kpis: {
-          sends: { value: sentTotal, delta: null },
+          sends: { value: sentTotal, delta: delta(sentTotal, sentPrev) },
           deliveredRate: {
-            value: sentTotal === 0 ? 1 : deliveredCount / sentTotal,
-            delta: null,
+            value: sentTotal === 0 ? null : deliveredCount / sentTotal,
+            delta: rateDelta(deliveredCount, sentTotal, deliveredPrev, sentPrev),
             bounced: bouncedCount
           },
-          openRate: { value: sentTotal === 0 ? 0 : openedCount / sentTotal, delta: null, exclBots: false },
-          clickRate: { value: sentTotal === 0 ? 0 : clickedCount / sentTotal, delta: null }
+          openRate: {
+            value: sentTotal === 0 ? null : openedCount / sentTotal,
+            delta: rateDelta(openedCount, sentTotal, openedPrev, sentPrev)
+          },
+          clickRate: {
+            value: sentTotal === 0 ? null : clickedCount / sentTotal,
+            delta: rateDelta(clickedCount, sentTotal, clickedPrev, sentPrev)
+          }
+        },
+        series: { hourly: { sends: sendSeries, opens: openSeries } },
+        health: {
+          status: health?.status ?? null,
+          rates: health?.rates ?? null,
+          thresholds: {
+            hardBounceRatePctTrip: mailer.config.circuitBreaker.hardBounceRatePctTrip,
+            complaintRatePctTrip: mailer.config.circuitBreaker.complaintRatePctTrip,
+            combinedBounceRatePctTrip: mailer.config.circuitBreaker.combinedBounceRatePctTrip,
+            failedToSendRatePctDegrade: mailer.config.circuitBreaker.failedToSendRatePctDegrade
+          }
         },
-        health: health ? { status: health.status, rates: health.rates } : {
-          status: "healthy",
-          rates: { hardBounceRate: 0, complaintRate: 0, combinedBounceRate: 0, failureRate: 0 }
+        queue: {
+          inFlight: queueCounts?.inFlight ?? null,
+          delayed: queueCounts?.delayed ?? null,
+          providerOk,
+          providerName: mailer.config.defaultProvider
         },
-        queue: { inFlight: 0, delayed: 0, providerOk: true, providerName: mailer.config.defaultProvider },
         recentFlows,
         recentSends,
         recentAudit
@@ -3308,7 +3401,8 @@ function apiRouter(mailer) {
     "/flows",
     asyncHandler(async (_req, res) => {
       const flows = await c.flows.find().sort({ updatedAt: -1 }).toArray();
-      res.json(flows);
+      const stats = await computeFlowStats(mailer);
+      res.json(flows.map((f) => ({ ...f, stats: stats.get(f.slug) ?? emptyFlowStats() })));
     })
   );
   r.get(
@@ -3316,7 +3410,8 @@ function apiRouter(mailer) {
     asyncHandler(async (req, res) => {
       const flow = await c.flows.findOne({ slug: req.params.slug });
       if (!flow) return res.status(404).json({ error: "not_found" });
-      return res.json(flow);
+      const stats = (await computeFlowStats(mailer, flow.slug)).get(flow.slug) ?? emptyFlowStats();
+      return res.json({ ...flow, stats });
     })
   );
   r.post(
@@ -3351,7 +3446,8 @@ function apiRouter(mailer) {
     "/templates",
     asyncHandler(async (_req, res) => {
       const templates = await c.templates.find().sort({ updatedAt: -1 }).toArray();
-      res.json(templates);
+      const stats = await computeTemplateStats(mailer);
+      res.json(templates.map((t) => ({ ...t, stats: stats.get(t.slug) ?? emptyTemplateStats() })));
     })
   );
   r.get(
@@ -3359,14 +3455,16 @@ function apiRouter(mailer) {
     asyncHandler(async (req, res) => {
       const template = await c.templates.findOne({ slug: req.params.slug });
       if (!template) return res.status(404).json({ error: "not_found" });
-      return res.json(template);
+      const stats = (await computeTemplateStats(mailer, template.slug)).get(template.slug) ?? emptyTemplateStats();
+      return res.json({ ...template, stats });
     })
   );
   r.get(
     "/broadcasts",
     asyncHandler(async (_req, res) => {
       const broadcasts = await c.broadcasts.find().sort({ createdAt: -1 }).toArray();
-      res.json(broadcasts);
+      const stats = await computeBroadcastStats(mailer);
+      res.json(broadcasts.map((b) => ({ ...b, stats: stats.get(String(b._id)) ?? emptyBroadcastStats() })));
     })
   );
   r.get(
@@ -3374,7 +3472,8 @@ function apiRouter(mailer) {
     asyncHandler(async (req, res) => {
       const broadcast = await c.broadcasts.findOne({ slug: req.params.slug });
       if (!broadcast) return res.status(404).json({ error: "not_found" });
-      return res.json(broadcast);
+      const stats = (await computeBroadcastStats(mailer, broadcast._id)).get(String(broadcast._id)) ?? emptyBroadcastStats();
+      return res.json({ ...broadcast, stats });
     })
   );
   r.get(
@@ -3382,8 +3481,20 @@ function apiRouter(mailer) {
     asyncHandler(async (req, res) => {
       const cursor = typeof req.query.cursor === "string" ? req.query.cursor : void 0;
       const limit = Math.min(Number(req.query.limit ?? 50), 200);
-      const { contacts, nextCursor } = await mailer.adapter.query({}, { limit, cursor });
-      res.json({ contacts, nextCursor });
+      const [{ contacts, nextCursor }, counts] = await Promise.all([
+        mailer.adapter.query({}, { limit, cursor }),
+        (async () => {
+          const rows = await c.subscriptions.aggregate([{ $group: { _id: "$status", n: { $sum: 1 } } }]).toArray();
+          const out = { subscribed: 0, pending_doi: 0, unsubscribed: 0, bounced: 0, complained: 0 };
+          let total = 0;
+          for (const r2 of rows) {
+            if (r2._id) out[r2._id] = r2.n;
+            total += r2.n;
+          }
+          return { ...out, total };
+        })()
+      ]);
+      res.json({ contacts, nextCursor, counts });
     })
   );
   r.get(
@@ -3462,16 +3573,25 @@ function apiRouter(mailer) {
     "/health",
     asyncHandler(async (_req, res) => {
       const h = await c.health.findOne({ _id: "singleton" });
-      res.json(
-        h ?? {
-          _id: "singleton",
-          status: "healthy",
-          windowStartedAt: new Date(Date.now() - 60 * 60 * 1e3),
-          windowDurationMs: 60 * 60 * 1e3,
-          counters: { sent: 0, delivered: 0, bounced: 0, hardBounced: 0, softBounced: 0, complained: 0, failedToSend: 0 },
-          rates: { bounceRate: 0, hardBounceRate: 0, complaintRate: 0, failureRate: 0 }
-        }
-      );
+      const cb = mailer.config.circuitBreaker;
+      const thresholds = {
+        hardBounceRatePctTrip: cb.hardBounceRatePctTrip,
+        complaintRatePctTrip: cb.complaintRatePctTrip,
+        combinedBounceRatePctTrip: cb.combinedBounceRatePctTrip,
+        failedToSendRatePctDegrade: cb.failedToSendRatePctDegrade
+      };
+      if (!h) {
+        res.json({ status: null, rates: null, counters: null, thresholds });
+        return;
+      }
+      res.json({ ...h, thresholds });
+    })
+  );
+  r.get(
+    "/health/trips",
+    asyncHandler(async (_req, res) => {
+      const rows = await c.auditLog.find({ action: { $in: ["health.trip", "health.resume"] } }).sort({ occurredAt: -1 }).limit(50).toArray();
+      res.json(rows);
     })
   );
   r.post(
@@ -3807,6 +3927,9 @@ function apiRouter(mailer) {
         html = compiled.html;
         plainText = compiled.plainText;
       } else {
+        if (!tpl.body?.html) {
+          return res.status(409).json({ error: "not_published", message: "Template has not been published yet." });
+        }
         html = tpl.body.html;
         plainText = tpl.body.plainText;
       }
@@ -3938,8 +4061,15 @@ function apiRouter(mailer) {
         if (f.kind === "hasTag") hostFilter.hasTag = f.tag;
         if (f.kind === "fieldEquals") hostFilter.fieldEquals = { field: f.field, value: f.value };
       }
-      const stageA = await mailer.adapter.count(hostFilter);
-      return res.json({ stageA, stageB: stageA, afterSuppression: stageA, computedMs: Date.now() - t0 });
+      const hasMailerFilters = segmentDefinition.filters.some(
+        (f) => ["subscriptionStatus", "firedEvent", "notFiredEvent", "notHasTag", "opened", "notOpened", "subscribedAfter", "subscribedBefore"].includes(f.kind)
+      );
+      const upperBound = await mailer.adapter.count(hostFilter);
+      return res.json({
+        upperBound,
+        approximate: hasMailerFilters,
+        computedMs: Date.now() - t0
+      });
     })
   );
   r.post(
@@ -3997,6 +4127,141 @@ function asyncHandler(fn) {
     fn(req, res, next).catch(next);
   };
 }
+async function collectQueueCounts(mailer) {
+  const qs = Object.values(mailer.queues);
+  const sum = async (key) => {
+    let total = 0;
+    let supported = false;
+    for (const q of qs) {
+      const fn = q[key];
+      if (!fn) continue;
+      try {
+        const v = await fn.call(q);
+        if (v == null) continue;
+        total += v;
+        supported = true;
+      } catch {
+        return null;
+      }
+    }
+    return supported ? total : null;
+  };
+  const [inFlight, delayed] = await Promise.all([sum("getInFlightCount"), sum("getDelayedCount")]);
+  return { inFlight, delayed };
+}
+function emptyFlowStats() {
+  return { activeRuns: 0, completedRuns: 0, sendsLast7Days: 0, sendsTotal: 0 };
+}
+async function computeFlowStats(mailer, slugFilter) {
+  const out = /* @__PURE__ */ new Map();
+  const match = slugFilter ? { flowSlug: slugFilter } : {};
+  const runRows = await mailer.collections.flowRuns.aggregate([
+    { $match: match },
+    { $group: { _id: { flowSlug: "$flowSlug", status: "$status" }, count: { $sum: 1 } } }
+  ]).toArray();
+  for (const row of runRows) {
+    const slug = row._id.flowSlug;
+    if (!slug) continue;
+    const cur = out.get(slug) ?? emptyFlowStats();
+    if (row._id.status === "active") cur.activeRuns += row.count;
+    else if (row._id.status === "completed") cur.completedRuns += row.count;
+    out.set(slug, cur);
+  }
+  const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3);
+  const sendRows = await mailer.collections.sends.aggregate([
+    { $match: { flowRunId: { $ne: null } } },
+    {
+      $lookup: {
+        from: mailer.collections.flowRuns.collectionName,
+        localField: "flowRunId",
+        foreignField: "_id",
+        as: "run",
+        pipeline: slugFilter ? [{ $match: { flowSlug: slugFilter } }, { $project: { flowSlug: 1 } }] : [{ $project: { flowSlug: 1 } }]
+      }
+    },
+    { $unwind: "$run" },
+    {
+      $group: {
+        _id: "$run.flowSlug",
+        total: { $sum: 1 },
+        last7: { $sum: { $cond: [{ $gte: ["$queuedAt", sevenDaysAgo] }, 1, 0] } }
+      }
+    }
+  ]).toArray();
+  for (const row of sendRows) {
+    if (!row._id) continue;
+    const cur = out.get(row._id) ?? emptyFlowStats();
+    cur.sendsTotal = row.total;
+    cur.sendsLast7Days = row.last7;
+    out.set(row._id, cur);
+  }
+  return out;
+}
+function emptyTemplateStats() {
+  return { sent: 0, opened: 0, clicked: 0, bounced: 0, sentLast7Days: 0, lastSentAt: null };
+}
+async function computeTemplateStats(mailer, slugFilter) {
+  const out = /* @__PURE__ */ new Map();
+  const match = {};
+  if (slugFilter) match.templateSlug = slugFilter;
+  const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3);
+  const rows = await mailer.collections.sends.aggregate([
+    { $match: match },
+    {
+      $group: {
+        _id: "$templateSlug",
+        sent: { $sum: 1 },
+        opened: { $sum: { $cond: [{ $ifNull: ["$openedAt", false] }, 1, 0] } },
+        clicked: { $sum: { $cond: [{ $ifNull: ["$firstClickAt", false] }, 1, 0] } },
+        bounced: { $sum: { $cond: [{ $eq: ["$status", "bounced"] }, 1, 0] } },
+        sentLast7Days: { $sum: { $cond: [{ $gte: ["$queuedAt", sevenDaysAgo] }, 1, 0] } },
+        lastSentAt: { $max: "$queuedAt" }
+      }
+    }
+  ]).toArray();
+  for (const row of rows) {
+    if (!row._id) continue;
+    out.set(row._id, {
+      sent: row.sent,
+      opened: row.opened,
+      clicked: row.clicked,
+      bounced: row.bounced,
+      sentLast7Days: row.sentLast7Days,
+      lastSentAt: row.lastSentAt ?? null
+    });
+  }
+  return out;
+}
+function emptyBroadcastStats() {
+  return { delivered: 0, opened: 0, clicked: 0, bounced: 0 };
+}
+async function computeBroadcastStats(mailer, idFilter) {
+  const out = /* @__PURE__ */ new Map();
+  const match = { broadcastId: { $ne: null } };
+  if (idFilter) match.broadcastId = idFilter;
+  const rows = await mailer.collections.sends.aggregate([
+    { $match: match },
+    {
+      $group: {
+        _id: "$broadcastId",
+        delivered: { $sum: { $cond: [{ $eq: ["$status", "delivered"] }, 1, 0] } },
+        opened: { $sum: { $cond: [{ $ifNull: ["$openedAt", false] }, 1, 0] } },
+        clicked: { $sum: { $cond: [{ $ifNull: ["$firstClickAt", false] }, 1, 0] } },
+        bounced: { $sum: { $cond: [{ $eq: ["$status", "bounced"] }, 1, 0] } }
+      }
+    }
+  ]).toArray();
+  for (const row of rows) {
+    if (!row._id) continue;
+    out.set(String(row._id), {
+      delivered: row.delivered,
+      opened: row.opened,
+      clicked: row.clicked,
+      bounced: row.bounced
+    });
+  }
+  return out;
+}
 var PIXEL = Buffer.from(
   "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=",
   "base64"