@spfn/notification 0.1.0-beta.23 → 0.1.0-beta.24

package/dist/server.js

@@ -210,8 +210,8 @@ import { createHmac, createHash, timingSafeEqual } from "crypto";
 function hashClickUrl(url) {
   return createHash("sha256").update(url).digest("hex").slice(0, 16);
 }
-function toBase64Url(buffer) {
-  return buffer.toString("base64url");
+function toBase64Url(buffer2) {
+  return buffer2.toString("base64url");
 }
 function fromBase64Url(str) {
   return Buffer.from(str, "base64url").toString("utf8");
@@ -620,8 +620,8 @@ function registerBuiltinTemplates() {
 }
 
 // src/services/notification.service.ts
-import { create, createMany, findOne, findMany, updateOne, count } from "@spfn/core/db";
-import { desc, eq, and, gte, lte } from "drizzle-orm";
+import { create, createMany, findOne, findMany, updateOne, count, getDatabase } from "@spfn/core/db";
+import { desc, eq, and, gte, lte, count as drizzleCount } from "drizzle-orm";
 
 // src/entities/schema.ts
 import { createSchema } from "@spfn/core/db";
@@ -863,15 +863,33 @@ async function countNotifications(options = {}) {
   return await count(notifications);
 }
 async function getNotificationStats(options = {}) {
-  const [total, scheduled, pending, sent, failed, cancelled] = await Promise.all([
-    countNotifications(options),
-    countNotifications({ ...options, status: "scheduled" }),
-    countNotifications({ ...options, status: "pending" }),
-    countNotifications({ ...options, status: "sent" }),
-    countNotifications({ ...options, status: "failed" }),
-    countNotifications({ ...options, status: "cancelled" })
-  ]);
-  return { total, scheduled, pending, sent, failed, cancelled };
+  const conditions = [];
+  if (options.channel) {
+    conditions.push(eq(notifications.channel, options.channel));
+  }
+  if (options.from) {
+    conditions.push(gte(notifications.createdAt, options.from));
+  }
+  if (options.to) {
+    conditions.push(lte(notifications.createdAt, options.to));
+  }
+  const rows = await getDatabase("read").select({ status: notifications.status, count: drizzleCount() }).from(notifications).where(conditions.length > 0 ? and(...conditions) : void 0).groupBy(notifications.status);
+  const stats = {
+    total: 0,
+    scheduled: 0,
+    pending: 0,
+    sent: 0,
+    failed: 0,
+    cancelled: 0
+  };
+  for (const row of rows) {
+    const n = Number(row.count);
+    stats.total += n;
+    if (row.status && row.status in stats) {
+      stats[row.status] = n;
+    }
+  }
+  return stats;
 }
 async function findScheduledNotifications(options = {}) {
   const conditions = [eq(notifications.status, "scheduled")];
@@ -1809,11 +1827,11 @@ function IsTemplateLiteralFinite(schema) {
 // ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.mjs
 var TemplateLiteralGenerateError = class extends TypeBoxError {
 };
-function* GenerateReduce(buffer) {
-  if (buffer.length === 1)
-    return yield* buffer[0];
-  for (const left of buffer[0]) {
-    for (const right of GenerateReduce(buffer.slice(1))) {
+function* GenerateReduce(buffer2) {
+  if (buffer2.length === 1)
+    return yield* buffer2[0];
+  for (const left of buffer2[0]) {
+    for (const right of GenerateReduce(buffer2.slice(1))) {
       yield `${left}${right}`;
     }
   }
@@ -3646,15 +3664,8 @@ async function sendEmail(params) {
     log2.error("Email send failed", { to: recipients, subject, error: result.error });
   }
   if (historyId && isHistoryEnabled()) {
-    try {
-      if (result.success) {
-        await markNotificationSent(historyId, result.messageId);
-      } else {
-        await markNotificationFailed(historyId, result.error || "Unknown error");
-      }
-    } catch (error) {
-      log2.warn("Failed to update notification history record", error);
-    }
+    const update = result.success ? markNotificationSent(historyId, result.messageId) : markNotificationFailed(historyId, result.error || "Unknown error");
+    update.catch((error) => log2.warn("Failed to update notification history record", error));
   }
   return result;
 }
@@ -3951,8 +3962,7 @@ async function sendSMS(params) {
     };
   }
   const provider = getProvider2();
-  const results = [];
-  for (const recipient of recipients) {
+  const sendOne = async (recipient) => {
     const normalizedPhone = normalizePhoneNumber(recipient);
     const internalParams = {
       to: normalizedPhone,
@@ -3981,18 +3991,12 @@ async function sendSMS(params) {
       log4.error("SMS send failed", { to: normalizedPhone, error: result.error });
     }
     if (historyId && isHistoryEnabled()) {
-      try {
-        if (result.success) {
-          await markNotificationSent(historyId, result.messageId);
-        } else {
-          await markNotificationFailed(historyId, result.error || "Unknown error");
-        }
-      } catch (error) {
-        log4.warn("Failed to update notification history record", error);
-      }
+      const update = result.success ? markNotificationSent(historyId, result.messageId) : markNotificationFailed(historyId, result.error || "Unknown error");
+      update.catch((error) => log4.warn("Failed to update notification history record", error));
     }
-    results.push(result);
-  }
+    return result;
+  };
+  const results = await runWithConcurrency(recipients, sendOne);
   const allSuccess = results.every((r) => r.success);
   const messageIds = results.filter((r) => r.messageId).map((r) => r.messageId).join(",");
   const errors = results.filter((r) => r.error).map((r) => r.error).join("; ");
@@ -4271,15 +4275,8 @@ async function sendSlack(params) {
     log6.error("Slack send failed", { error: result.error });
   }
   if (historyId && isHistoryEnabled()) {
-    try {
-      if (result.success) {
-        await markNotificationSent(historyId, result.messageId);
-      } else {
-        await markNotificationFailed(historyId, result.error || "Unknown error");
-      }
-    } catch (error) {
-      log6.warn("Failed to update notification history record", error);
-    }
+    const update = result.success ? markNotificationSent(historyId, result.messageId) : markNotificationFailed(historyId, result.error || "Unknown error");
+    update.catch((error) => log6.warn("Failed to update notification history record", error));
   }
   return result;
 }
@@ -4791,37 +4788,66 @@ import { route } from "@spfn/core/route";
 import { defineRouter } from "@spfn/core/route";
 
 // src/tracking/tracking.service.ts
-import { create as create2, getDatabase } from "@spfn/core/db";
-import { eq as eq2, and as and2, gte as gte2, lte as lte2, count as drizzleCount, countDistinct } from "drizzle-orm";
+import { getDatabase as getDatabase2 } from "@spfn/core/db";
+import { eq as eq2, and as and2, gte as gte2, lte as lte2, count as drizzleCount2, countDistinct } from "drizzle-orm";
 import { logger as logger7 } from "@spfn/core/logger";
 var log7 = logger7.child("@spfn/notification:tracking");
+var FLUSH_SIZE = 200;
+var FLUSH_INTERVAL_MS = 2e3;
+var MAX_BUFFER = 1e4;
+var buffer = [];
+var flushTimer = null;
+async function flushTrackingEvents() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  if (buffer.length === 0) {
+    return;
+  }
+  const batch = buffer.splice(0, buffer.length);
+  try {
+    await getDatabase2("write").insert(trackingEvents).values(batch);
+  } catch (error) {
+    log7.warn(`Failed to flush ${batch.length} tracking events`, error);
+  }
+}
+function enqueueTrackingEvent(event) {
+  if (buffer.length >= MAX_BUFFER) {
+    log7.warn("Tracking buffer full \u2014 dropping event");
+    return;
+  }
+  buffer.push(event);
+  if (buffer.length >= FLUSH_SIZE) {
+    void flushTrackingEvents();
+  } else if (!flushTimer) {
+    flushTimer = setTimeout(() => void flushTrackingEvents(), FLUSH_INTERVAL_MS);
+    flushTimer.unref?.();
+  }
+}
 function recordOpenEvent(notificationId, meta) {
-  create2(trackingEvents, {
+  enqueueTrackingEvent({
     notificationId,
     type: "open",
     ipAddress: meta?.ipAddress,
     userAgent: meta?.userAgent
-  }).catch((error) => {
-    log7.warn("Failed to record open event", error);
   });
 }
 function recordClickEvent(notificationId, linkIndex, linkUrl, meta) {
-  create2(trackingEvents, {
+  enqueueTrackingEvent({
     notificationId,
     type: "click",
     linkUrl,
     linkIndex,
     ipAddress: meta?.ipAddress,
     userAgent: meta?.userAgent
-  }).catch((error) => {
-    log7.warn("Failed to record click event", error);
   });
 }
 async function getTrackingStats(notificationId) {
-  const db = getDatabase("read");
+  const db = getDatabase2("read");
   const rows = await db.select({
     type: trackingEvents.type,
-    total: drizzleCount(),
+    total: drizzleCount2(),
     unique: countDistinct(trackingEvents.ipAddress)
   }).from(trackingEvents).where(eq2(trackingEvents.notificationId, notificationId)).groupBy(trackingEvents.type);
   const openRow = rows.find((r) => r.type === "open");
@@ -4834,7 +4860,7 @@ async function getTrackingStats(notificationId) {
   };
 }
 async function getEngagementStats(options = {}) {
-  const db = getDatabase("read");
+  const db = getDatabase2("read");
   const sentConditions = [eq2(notifications.status, "sent")];
   if (options.channel) {
     sentConditions.push(eq2(notifications.channel, options.channel));
@@ -4845,7 +4871,7 @@ async function getEngagementStats(options = {}) {
   if (options.to) {
     sentConditions.push(lte2(notifications.createdAt, options.to));
   }
-  const [sentResult] = await db.select({ count: drizzleCount() }).from(notifications).where(and2(...sentConditions));
+  const [sentResult] = await db.select({ count: drizzleCount2() }).from(notifications).where(and2(...sentConditions));
   const sent = Number(sentResult?.count ?? 0);
   if (sent === 0) {
     return { sent: 0, opened: 0, clicked: 0, openRate: 0, clickRate: 0 };
@@ -4880,11 +4906,11 @@ async function getEngagementStats(options = {}) {
   };
 }
 async function getClickDetails(notificationId) {
-  const db = getDatabase("read");
+  const db = getDatabase2("read");
   const rows = await db.select({
     linkUrl: trackingEvents.linkUrl,
     linkIndex: trackingEvents.linkIndex,
-    totalClicks: drizzleCount(),
+    totalClicks: drizzleCount2(),
     uniqueClicks: countDistinct(trackingEvents.ipAddress)
   }).from(trackingEvents).where(
     and2(