fix(notifications): harden resend delivery

Author: RavelloH

src/lib/edge/scheduled-task-runner.ts

@@ -30,6 +30,7 @@ export interface ScheduledTaskContext {
   scheduledTime: number | null;
   startedAt: number;
   logger: ScheduledTaskLogger;
+  externalFetch: typeof fetch;
 }
 
 export interface ScheduledTaskDefinition {
@@ -236,6 +237,7 @@ export async function runScheduledTask(
       scheduledTime: scheduledAt,
       startedAt,
       logger,
+      externalFetch: fetch.bind(globalThis),
     })) ?? { status: "success" as const };
     const finishedAt = Date.now();
     const status = outcome.status ?? "success";

src/lib/notifications/__tests__/delivery.test.ts

@@ -568,7 +568,8 @@ describe("notification delivery", () => {
     decryptNotificationSecret.mockResolvedValue("re_secret");
     vi.spyOn(globalThis, "fetch").mockRejectedValue(new TypeError("offline"));
 
-    await deliverNotificationMessage(
+    vi.useFakeTimers();
+    const delivery = deliverNotificationMessage(
       {} as never,
       message(),
       {
@@ -578,13 +579,21 @@ describe("notification delivery", () => {
       },
       {},
     );
+    await vi.runAllTimersAsync();
+    await delivery;
+    vi.useRealTimers();
 
     expect(updateNotificationDeliveryResult).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({
         status: "failed",
-        errorMessage: "Unable to reach Resend email API",
+        errorMessage: expect.stringContaining(
+          "Unable to reach Resend email API",
+        ),
       }),
     );
+    expect(
+      updateNotificationDeliveryResult.mock.calls[0]?.[1].errorMessage,
+    ).toContain("TypeError: offline");
   });
 });

src/lib/notifications/__tests__/notification-task.test.ts

@@ -128,6 +128,7 @@ function context(): ScheduledTaskContext & {
     scheduledTime: null,
     startedAt: Date.now(),
     logger,
+    externalFetch: fetch.bind(globalThis),
     events,
   };
 }

src/lib/notifications/__tests__/resend-client.test.ts

@@ -10,12 +10,12 @@ const payload = {
   html: "<p>Text</p>",
 };
 
-async function send(fetchImpl: typeof fetch, deadlineMs = 9_000) {
+async function send(fetchImpl: typeof fetch, deadlineMs?: number) {
   const promise = sendResendEmailWithRetry({
     apiKey: "re_secret",
     body: payload,
     fetchImpl,
-    deadlineMs,
+    ...(deadlineMs === undefined ? {} : { deadlineMs }),
   });
   await vi.runAllTimersAsync();
   return promise;
@@ -24,7 +24,6 @@ async function send(fetchImpl: typeof fetch, deadlineMs = 9_000) {
 describe("sendResendEmailWithRetry", () => {
   beforeEach(() => {
     vi.useFakeTimers();
-    vi.spyOn(Math, "random").mockReturnValue(0);
   });
 
   afterEach(() => {
@@ -47,6 +46,7 @@ describe("sendResendEmailWithRetry", () => {
       attempts: 2,
       retryCount: 1,
       providerMessageId: "email-1",
+      durationMs: 1_000,
     });
   });
 
@@ -113,11 +113,13 @@ describe("sendResendEmailWithRetry", () => {
 
     expect(result).toMatchObject({
       ok: false,
-      attempts: 3,
-      retryCount: 2,
+      attempts: 15,
+      retryCount: 14,
       reason: "network_failed",
-      errorMessage: "Unable to reach Resend email API",
     });
+    expect(result.durationMs).toBe(14_000);
+    expect(result.errorMessage).toContain("Unable to reach Resend email API");
+    expect(result.errorMessage).toContain("Error: network");
   });
 
   it("stops when a short deadline leaves no retry budget", async () => {

src/lib/notifications/delivery.ts

@@ -54,7 +54,7 @@ export async function deliverNotificationMessage(
   env: Env,
   message: NotificationMessage,
   user: NotificationDeliveryUser,
-  context: { logger?: NotificationDeliveryLogger },
+  context: { logger?: NotificationDeliveryLogger; fetchImpl?: typeof fetch },
 ): Promise<NotificationMessage | null> {
   const preferences = normalizeNotificationPreferences(user.preferencesJson);
   const channels = { inApp: true, email: preferences.email };
@@ -207,6 +207,7 @@ export async function deliverNotificationMessage(
 
     const sendResult = await sendResendEmailWithRetry({
       apiKey,
+      fetchImpl: context.fetchImpl,
       body: {
         from: buildResendFromAddress(config),
         to: [user.email],

src/lib/notifications/notification-task.ts

@@ -189,6 +189,7 @@ async function createAndDeliverMessages(input: {
     );
     const delivered = await deliverNotificationMessage(env, message, user, {
       logger: context.logger,
+      fetchImpl: context.externalFetch,
     });
     collectDeliveryStats(summary, delivered);
     if (delivered) messages.push(delivered);
@@ -479,6 +480,7 @@ export async function createManualTestNotification(input: {
   );
   const delivered = await deliverNotificationMessage(env, message, user, {
     logger: context.logger,
+    fetchImpl: context.externalFetch,
   });
   collectDeliveryStats(summary, delivered);
   summary.durationMs = Date.now() - context.startedAt;

src/lib/notifications/resend-client.ts

@@ -2,6 +2,9 @@ import { clampString } from "@/lib/edge/utils";
 
 const RESEND_EMAILS_API_URL = "https://api.resend.com/emails";
 const NETWORK_ERROR_MESSAGE = "Unable to reach Resend email API";
+const DEFAULT_RETRY_DEADLINE_MS = 15_000;
+const DEFAULT_MAX_ATTEMPTS = 15;
+const RETRY_INTERVAL_MS = 1_000;
 
 export interface ResendEmailPayload {
   from: string;
@@ -47,6 +50,15 @@ export function sanitizeProviderError(value: unknown): string {
   return clampString(message, 180);
 }
 
+function sanitizeNetworkError(error: unknown): string {
+  if (error instanceof Error) {
+    const name = error.name || "Error";
+    const message = error.message || "network_failed";
+    return clampString(`${name}: ${message}`, 180);
+  }
+  return clampString(String(error || "network_failed"), 180);
+}
+
 function isRetryableStatus(status: number): boolean {
   return status === 429 || status >= 500;
 }
@@ -55,12 +67,6 @@ function delay(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function backoffMs(attempts: number): number {
-  const base = attempts <= 1 ? 450 : 1_350;
-  const jitter = Math.floor(Math.random() * (attempts <= 1 ? 151 : 451));
-  return base + jitter;
-}
-
 async function fetchWithTimeout(input: {
   apiKey: string;
   body: ResendEmailPayload;
@@ -92,8 +98,12 @@ export async function sendResendEmailWithRetry(input: {
   maxAttempts?: number;
 }): Promise<ResendSendResult> {
   const startedAt = Date.now();
-  const deadlineAt = startedAt + Math.max(500, input.deadlineMs ?? 9_000);
-  const maxAttempts = Math.max(1, Math.trunc(input.maxAttempts ?? 3));
+  const deadlineAt =
+    startedAt + Math.max(500, input.deadlineMs ?? DEFAULT_RETRY_DEADLINE_MS);
+  const maxAttempts = Math.max(
+    1,
+    Math.trunc(input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS),
+  );
   const fetchImpl = input.fetchImpl ?? fetch;
   let attempts = 0;
   let status = 0;
@@ -145,15 +155,15 @@ export async function sendResendEmailWithRetry(input: {
           reason,
         };
       }
-    } catch {
+    } catch (error) {
       status = 0;
       payload = {};
       reason = "network_failed";
-      errorMessage = NETWORK_ERROR_MESSAGE;
+      errorMessage = `${NETWORK_ERROR_MESSAGE}: ${sanitizeNetworkError(error)}`;
     }
 
     if (attempts >= maxAttempts) break;
-    const waitMs = backoffMs(attempts);
+    const waitMs = RETRY_INTERVAL_MS;
     if (Date.now() + waitMs >= deadlineAt) break;
     await delay(waitMs);
   }