apps/backend/src/lib/email-rendering.tsx (1)

179-180: Batch resilience: avoid all-or-nothing on render failures

If one render throws, Promise.all fails the whole batch. Consider Promise.allSettled with aggregated errors or partial successes.

Example keeping all-or-nothing but with better diagnostics:

-        return await Promise.all(inputs.map(renderOne));
+        const settled = await Promise.allSettled(inputs.map(renderOne));
+        const failures = settled
+          .map((r, i) => ({ r, i }))
+          .filter(x => x.r.status === "rejected");
+        if (failures.length) {
+          throw new Error(`renderAll failed for ${failures.length}/${inputs.length} inputs at indexes: ${failures.map(f => f.i).join(", ")}`);
+        }
+        return settled.map(r => (r as PromiseFulfilledResult<any>).value);

If you want partial success semantics, we can update the return type to include per-item status.

apps/e2e/tests/backend/endpoints/api/v1/send-email.test.ts (2)

593-600: Broadcast test: poll for each user instead of sleeping.

This reduces timing-related flakes across three mailboxes.

The automated suggestion to wrap with runAsynchronously isn’t appropriate here—we need to await delivery before assertions. Polling is the right fit.

-    await wait(2000);
-    const messagesA = await userA.mailbox.fetchMessages();
-    const messagesB = await userB.mailbox.fetchMessages();
-    const messagesC = await userC.mailbox.fetchMessages();
-    expect(messagesA.find(m => m.subject === subject)).toBeDefined();
-    expect(messagesB.find(m => m.subject === subject)).toBeDefined();
-    expect(messagesC.find(m => m.subject === subject)).toBeDefined();
+    const waitForSubject = async (user: any) => {
+      for (let i = 0; i < 40; i++) {
+        const msgs = await user.mailbox.fetchMessages();
+        if (msgs.find(m => m.subject === subject)) return;
+        await wait(250);
+      }
+      throw new Error("Timed out waiting for email");
+    };
+    await Promise.all([waitForSubject(userA), waitForSubject(userB), waitForSubject(userC)]);
+    const messagesA = await userA.mailbox.fetchMessages();
+    const messagesB = await userB.mailbox.fetchMessages();
+    const messagesC = await userC.mailbox.fetchMessages();
+    expect(messagesA.find(m => m.subject === subject)).toBeDefined();
+    expect(messagesB.find(m => m.subject === subject)).toBeDefined();
+    expect(messagesC.find(m => m.subject === subject)).toBeDefined();

---

743-747: Same: poll mailbox instead of a fixed 2s sleep.

-    await wait(2000);
-    const messages = await user.mailbox.fetchMessages();
-    const sentEmail = messages.find(msg => msg.subject === "Transactional Test Subject");
-    expect(sentEmail).toBeDefined();
+    let sentEmail: any | undefined;
+    for (let i = 0; i < 40; i++) {
+      const msgs = await user.mailbox.fetchMessages();
+      sentEmail = msgs.find(m => m.subject === "Transactional Test Subject");
+      if (sentEmail) break;
+      await wait(250);
+    }
+    expect(sentEmail).toBeDefined();

apps/backend/src/lib/emails.tsx (1)

287-334: Don’t swallow batch send errors; include sender name in “from”; store full error object.

Returning ok(null) on non-429/500 errors hides failures from callers and logs only the message string, unlike sendEmailWithoutRetries. Also, set a proper “From” with sender name for deliverability.

 export async function sendEmailResendBatched(resendApiKey: string, emailOptions: SendEmailOptions[]) {
@@
   const result = await Result.retry(async (_) => {
     const { data, error } = await resend.batch.send(emailOptions.map((option) => ({
-      from: option.emailConfig.senderEmail,
-      to: option.to,
+      from: `"${option.emailConfig.senderName}" <${option.emailConfig.senderEmail}>`,
+      to: Array.isArray(option.to) ? option.to : [option.to],
       subject: option.subject,
       html: option.html ?? "",
       text: option.text,
     })));
 
-    if (data) {
-      return Result.ok(data.data);
-    }
-    if (error.name === "rate_limit_exceeded" || error.name === "internal_server_error") {
-      return Result.error(error);
-    }
-    return Result.ok(null);
+    if (data) return Result.ok(data.data);
+    // Propagate all errors so callers can act on them; retry policy is governed by Result.retry.
+    return Result.error(error);
   }, 3, { exponentialDelayBase: 2000 });
 
   await prisma.sentEmail.createMany({
     data: emailOptions.map((options) => ({
       tenancyId: options.tenancyId,
       to: typeof options.to === 'string' ? [options.to] : options.to,
       subject: options.subject,
       html: options.html,
       text: options.text,
       senderConfig: omit(options.emailConfig, ['password']),
-      error: result.status === 'error' ? result.error.message : undefined,
+      error: result.status === 'error' ? result.error : undefined,
     })),
   });
   return result;
 }

apps/backend/src/app/api/latest/emails/send-email/route.tsx (4)

131-153: Don’t silently skip category pre-render failures; log the chunk and users

Silently continuing hides errors and defaults categories unexpectedly. Add logging.

-          if (rendered.status === "error") {
-            continue;
-          }
+          if (rendered.status === "error") {
+            console.warn("Category pre-render failed for chunk", {
+              error: rendered.error,
+              userIds: correspondingUsers.map(u => u.projectUserId),
+            });
+            continue;
+          }

---

203-211: Don’t silently skip final renders; log failures with affected users

Same concern as pre-render path—capture the error so failures are observable.

-        if (rendered.status === "error") {
-          continue;
-        }
+        if (rendered.status === "error") {
+          console.warn("Final render failed for chunk", {
+            error: rendered.error,
+            userIds: correspondingUsers.map(u => u.projectUserId),
+          });
+          continue;
+        }

---

225-229: Host check for Resend is brittle; also capture outcomes for both paths

Use a provider flag or a resilient host match, and log failures from both send paths.

-        if (emailConfig.host === "smtp.resend.com") {
-          await sendEmailResendBatched(emailConfig.password, emailOptions);
-        } else {
-          await Promise.allSettled(emailOptions.map(option => sendEmail(option)));
-        }
+        const isResend = /(^|\.)(resend\.com)$/i.test(emailConfig.host || "");
+        if (isResend) {
+          const batchResult = await sendEmailResendBatched(emailConfig.password, emailOptions);
+          if (batchResult.status === "error") {
+            console.warn("Resend batch send failed", { error: batchResult.error, size: emailOptions.length });
+          }
+        } else {
+          const outcomes = await Promise.allSettled(emailOptions.map((option) => sendEmail(option)));
+          const failures = outcomes.filter((o) => o.status === "rejected");
+          if (failures.length) {
+            console.warn("Some emails failed to send", { failures: failures.map((f) => (f as PromiseRejectedResult).reason) });
+          }
+        }

---

233-253: Wrap runAsynchronouslyAndWaitUntil body in try–catch

Uncaught errors will reject the background promise; capture them for visibility.

-    runAsynchronouslyAndWaitUntil((async () => {
+    runAsynchronouslyAndWaitUntil((async () => {
+      try {
         const usersArray = Array.from(userMap.values());
         // ...
         if ("draft_id" in body) {
           await prisma.emailDraft.update({
             // ...
           });
         }
-    })());
+      } catch (err) {
+        console.error("Batched email workflow failed", err);
+      }
+    })());

packages/stack-shared/src/utils/arrays.tsx (1)

205-213: Guard against non-integer, non-finite, or tiny chunk sizes

size can be non-integer/NaN/Infinity. Today fractional sizes "work" via slice coercion but are surprising. Clamp to a positive integer and early-return for invalid values.

Apply:

 export function getChunks<T>(arr: readonly T[], size: number): T[][] {
-  const result: T[][] = [];
-  if (size <= 0) return result;
-  for (let i = 0; i < arr.length; i += size) {
-    result.push(arr.slice(i, i + size));
-  }
-  return result;
+  const result: T[][] = [];
+  if (!Number.isFinite(size)) return result;
+  const chunkSize = Math.trunc(size);
+  if (chunkSize <= 0) return result;
+  for (let i = 0; i < arr.length; i += chunkSize) {
+    result.push(arr.slice(i, i + chunkSize));
+  }
+  return result;
 }

apps/backend/src/lib/email-rendering.tsx (1)

198-201: Version drift between sandboxed nodeModules and repo deps

Sandbox uses React 19.1.1 while the app depends on 19.0.0. Minor React deltas can affect JSX/runtime semantics. Recommend aligning to repo versions or centralizing these in one place.

apps/e2e/tests/backend/endpoints/api/v1/unsubscribe-link.test.ts (2)

51-55: Replace fixed sleep with polling to deflake mailbox checks.

A hard 2s sleep can still be flaky under load. Poll the mailbox with a short interval and a reasonable timeout.

-  await wait(2000);
-  const messages = await user.mailbox.fetchMessages();
-  const sentEmail = messages.find(msg => msg.subject === "Custom Test Email Subject");
+  let sentEmail: any | undefined;
+  for (let i = 0; i < 40; i++) {
+    const msgs = await user.mailbox.fetchMessages();
+    sentEmail = msgs.find(m => m.subject === "Custom Test Email Subject");
+    if (sentEmail) break;
+    await wait(250);
+  }

---

145-150: Same here: poll instead of sleeping.

-  await wait(2000);
-  const messages = await user.mailbox.fetchMessages();
-  const sentEmail = messages.find(msg => msg.subject === "Custom Test Email Subject");
+  let sentEmail: any | undefined;
+  for (let i = 0; i < 40; i++) {
+    const msgs = await user.mailbox.fetchMessages();
+    sentEmail = msgs.find(m => m.subject === "Custom Test Email Subject");
+    if (sentEmail) break;
+    await wait(250);
+  }

apps/e2e/tests/backend/endpoints/api/v1/send-email.test.ts (2)

297-301: Avoid fixed sleep; poll mailbox until the email arrives.

Prevents flakes and keeps tests fast locally.

-  await wait(2000);
-  const messages = await user.mailbox.fetchMessages();
-  const sentEmail = messages.find(msg => msg.subject === "Custom Test Email Subject");
+  let sentEmail: any | undefined;
+  for (let i = 0; i < 40; i++) {
+    const msgs = await user.mailbox.fetchMessages();
+    sentEmail = msgs.find(m => m.subject === "Custom Test Email Subject");
+    if (sentEmail) break;
+    await wait(250);
+  }

---

406-410: Same: replace 3s sleep with polling.

-  await wait(3000);
-  const messages = await user.mailbox.fetchMessages();
-  const sentEmail = messages.find(m => m.subject === "Overridden Subject");
+  let sentEmail: any | undefined;
+  for (let i = 0; i < 40; i++) {
+    const msgs = await user.mailbox.fetchMessages();
+    sentEmail = msgs.find(m => m.subject === "Overridden Subject");
+    if (sentEmail) break;
+    await wait(250);
+  }

apps/backend/src/app/api/latest/emails/send-email/route.tsx (3)

65-67: Avoid calling getEnvVariable for presence checks

getEnvVariable throws if the var is missing; this branch won’t run. Use process.env to ensure a consistent 500 with your message.

-    if (!getEnvVariable("STACK_FREESTYLE_API_KEY")) {
-      throw new StatusError(500, "STACK_FREESTYLE_API_KEY is not set");
-    }
+    if (!process.env.STACK_FREESTYLE_API_KEY) {
+      throw new StatusError(500, "STACK_FREESTYLE_API_KEY is not set");
+    }

---

162-168: N+1 preference checks

hasNotificationEnabled is called per user; consider batching preferences for large sends to cut DB roundtrips.

---

216-223: Subject fallback can be empty

When neither body.subject nor template Subject is present, subject becomes "". Consider enforcing a non-empty subject before sending.

Would you like me to update the schema so subject is required for the html variant and ensure a non-empty fallback for template/draft variants?

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

apps/backend/src/lib/email-rendering.tsx (1)

158-181: Don’t let a single render failure nuke the whole batch

As noted earlier, Promise.all will reject the entire batch on the first failure. Consider using Promise.allSettled and aggregating failures so you can decide upstream whether to continue sending partial successes.

Non-breaking internal change that preserves the current return type (throws on any failure but provides a clearer aggregated error), while paving the way for partial-success handling later:

-        return await Promise.all(inputs.map(renderOne));
+        const settled = await Promise.allSettled(inputs.map(renderOne));
+        const rejected = settled.filter((s: any) => s.status === "rejected");
+        if (rejected.length) {
+          const first = rejected[0] as any;
+          const reason = first?.reason?.message || String(first?.reason ?? "unknown error");
+          throw new Error(`Batched render failed for ${rejected.length}/${inputs.length} items. First error: ${reason}`);
+        }
+        return (settled as any[]).map((s: any) => s.value);

If you prefer partial success, introduce an optional flag (e.g., continueOnError) and return { successes, failures } instead—happy to draft that change if you want it in this PR.

To inspect call sites and decide which semantics you want (fail-fast vs partial success), run:

#!/bin/bash
# Locate all usages of the batched renderer to assess error-handling expectations.
rg -nP --type=ts --type=tsx -C2 '\brenderEmailsWithTemplateBatched\s*\('

Also applies to: 179-180

apps/backend/src/lib/email-rendering.tsx (2)

139-140: Avoid duplicating Freestyle API key wiring; pick one style consistently

Freestyle already reads STACK_FREESTYLE_API_KEY internally. Either keep the explicit retrieval here and also do it in the single-email path for consistency, or drop it here and rely on Freestyle’s default. Consistency reduces cognitive load.

Minimal change (drop explicit retrieval here):

-  const apiKey = getEnvVariable("STACK_FREESTYLE_API_KEY");
...
-  const freestyle = new Freestyle({ apiKey });
+  const freestyle = new Freestyle();

Additionally remove the now-unused import of getEnvVariable at Line 9.

Also applies to: 196-196

---

141-159: Guard against oversized embedded payloads to prevent huge sandbox scripts

Embedding the entire inputs array into the bundled script can balloon script size and exceed sandbox/request limits. Add a simple size backstop.

   const serializedInputs = JSON.stringify(inputs);
+  // Backstop to avoid shipping excessively large scripts to Freestyle.
+  // Rough char count ~ bytes for ASCII JSON.
+  const MAX_EMBEDDED_PAYLOAD_CHARS = 1_500_000; // ~1.5MB
+  if (serializedInputs.length > MAX_EMBEDDED_PAYLOAD_CHARS) {
+    return Result.error(
+      `Batched render payload too large (${serializedInputs.length} chars). Reduce batch size or chunk further.`
+    );
+  }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro