WIP

Author: andresgutgon

packages/core/src/events/handlers/sendIssueEscalatingHandler.test.ts

@@ -188,17 +188,21 @@ describe('sendIssueEscalatingHandler', () => {
       // Verify first batch has 2 users
       const firstBatch = mockSend.mock.calls[0][0]
       expect(firstBatch.to).toHaveLength(2)
+      expect(firstBatch.recipientVariables).toBeDefined()
+      expect(Object.keys(firstBatch.recipientVariables)).toHaveLength(2)
 
       // Verify second batch has 1 user
       const secondBatch = mockSend.mock.calls[1][0]
       expect(secondBatch.to).toHaveLength(1)
+      expect(secondBatch.recipientVariables).toBeDefined()
+      expect(Object.keys(secondBatch.recipientVariables)).toHaveLength(1)
 
       // Verify all 3 users were sent emails
       const allRecipients = [...firstBatch.to, ...secondBatch.to]
       expect(allRecipients).toHaveLength(3)
-      expect(
-        allRecipients.map((r: { address: string; name: string }) => r.address),
-      ).toEqual(expect.arrayContaining([user.email, user2.email, user3.email]))
+      expect(allRecipients).toEqual(
+        expect.arrayContaining([user.email, user2.email, user3.email]),
+      )
     })
   })
 
@@ -397,14 +401,15 @@ describe('sendIssueEscalatingHandler', () => {
       const mailerInstance = vi.mocked(IssueEscalatingMailer).mock.results[0]
         ?.value
 
-      // Verify send was called with Address objects
+      // Verify send was called with proper format
       expect(mailerInstance?.send).toHaveBeenCalledWith({
-        to: expect.arrayContaining([
-          expect.objectContaining({
-            address: expect.any(String),
+        to: expect.arrayContaining([expect.any(String)]),
+        recipientVariables: expect.objectContaining({
+          [user.email]: expect.objectContaining({
             name: expect.any(String),
+            id: expect.any(String),
           }),
-        ]),
+        }),
       })
     })
   })

packages/core/src/events/handlers/sendIssueEscalatingHandler.ts

@@ -3,15 +3,19 @@ import { env } from '@latitude-data/env'
 import { findAllUsersInWorkspace } from '../../data-access/users'
 import { unsafelyFindWorkspace } from '../../data-access/workspaces'
 import { NotFoundError } from '../../lib/errors'
-import { IssueEscalatingMailer } from '../../mailers'
+import {
+  IssueEscalatingMailer,
+  SendIssueEscalatingMailOptions,
+} from '../../mailers'
 import { IssuesRepository } from '../../repositories'
 import { updateEscalatingIssue } from '../../services/issues/updateEscalating'
 import { captureException } from '../../utils/datadogCapture'
 import { IssueIncrementedEvent } from '../events'
 import { Workspace } from '../../schema/models/types/Workspace'
 
-const BATCH_SIZE = 100
+const BATCH_SIZE = 100 // Batch size can be up to 1000 in mailgun
 
+// TODO: Refactor common batching logic with other mailers
 async function sendEmail({
   workspace,
   issue,
@@ -36,28 +40,43 @@ async function sendEmail({
   )
 
   const addresses = users.map((u) => ({
+    id: u.id,
     address: u.email,
     name: u.name || u.email,
   }))
 
-  const batches: (typeof addresses)[] = []
+  const batches: SendIssueEscalatingMailOptions[] = []
 
   for (let i = 0; i < addresses.length; i += batchSize) {
-    batches.push(addresses.slice(i, i + batchSize))
+    const batchAddresses = addresses.slice(i, i + batchSize)
+    const recipientVariables: Record<string, Record<string, unknown>> = {}
+
+    batchAddresses.forEach((user) => {
+      recipientVariables[user.address] = {
+        name: user.name,
+        id: user.id,
+      }
+    })
+
+    batches.push({
+      to: batchAddresses.map((u) => u.address),
+      recipientVariables,
+    })
   }
 
   // Send all batches in parallel and capture any errors
   await Promise.all(
     batches.map(async (batch, index) => {
-      const result = await mailer.send({ to: batch })
+      const result = await mailer.send(batch)
 
       if (result.error) {
+        const batchSize = Array.isArray(batch.to) ? batch.to.length : 1
         captureException(result.error, {
           issueId: issue.id,
           issueTitle: issue.title,
           workspaceId: workspace.id,
           batchIndex: index,
-          batchSize: batch.length,
+          batchSize: batchSize,
           context: 'issue_escalation_email',
         })
       }
@@ -115,9 +134,7 @@ export async function sendIssueEscalatingHandler({
   const wasEscalatingButExpired =
     previousEscalatingAt && previousEscalatingAt <= expirationDate
 
-  // Early return if still in same escalation period
   if (!wasNotEscalating && !wasEscalatingButExpired) return
 
-  // Send email for new escalation
   await sendEmail({ workspace, issue: updatedIssue, batchSize })
 }

packages/core/src/mailers/emails/issues/IssueEscalatingMail.tsx

@@ -15,7 +15,7 @@ export default function IssueEscalatingMail({
       title='Issue Escalating'
       previewText={`Issue "${issueTitle}" is escalating.`}
     >
-      <Text>Hello</Text>
+      <Text>Hello team</Text>
       <Text>
         We have detected that the issue <strong>"{issueTitle}"</strong> is
         escalating. This means the error frequency has increased significantly

packages/core/src/mailers/mailers/Mailer.ts

@@ -6,6 +6,14 @@ import SMTPTransport from 'nodemailer/lib/smtp-transport'
 import { Result, TypedResult } from '../../lib/Result'
 import { createAdapter } from './adapters'
 
+/**
+ * Batch sending options for Mailgun.
+ * https://documentation.mailgun.com/docs/mailgun/user-manual/sending-messages/batch-sending
+ */
+export type ExtendedMailOptions = Mail.Options & {
+  'recipient-variables'?: Record<string, Record<string, unknown>>
+}
+
 export default abstract class Mailer {
   protected options: Mail.Options
 
@@ -21,12 +29,12 @@ export default abstract class Mailer {
   }
 
   abstract send(
-    _options: Mail.Options,
+    _options: ExtendedMailOptions,
     _attrs: unknown,
   ): Promise<TypedResult<SMTPTransport.SentMessageInfo, Error>>
 
   protected async sendMail(
-    options: Mail.Options,
+    options: ExtendedMailOptions,
   ): Promise<TypedResult<SMTPTransport.SentMessageInfo, Error>> {
     let result
     try {

packages/core/src/mailers/mailers/mailers/issues/IssueEscalatingMailer.ts

@@ -23,6 +23,10 @@ function convertTo(to: Mail.Options['to']): Address[] {
   })
 }
 
+export type SendIssueEscalatingMailOptions = {
+  to: Mail.Options['to']
+  recipientVariables?: Record<string, Record<string, unknown>>
+}
 export class IssueEscalatingMailer extends Mailer {
   issueTitle: string
   link: string
@@ -39,14 +43,16 @@ export class IssueEscalatingMailer extends Mailer {
 
   async send({
     to,
-  }: Pick<Mail.Options, 'to'>): Promise<
+    recipientVariables,
+  }: SendIssueEscalatingMailOptions): Promise<
     TypedResult<SMTPTransport.SentMessageInfo, Error>
   > {
     const emails = convertTo(to ?? this.options.to)
     return this.sendMail({
       to: emails,
       from: this.options.from,
       subject: `📈 Latitude issue Escalating: ${this.issueTitle}`,
+      'recipient-variables': recipientVariables,
       html: await render(
         IssueEscalatingMail({
           issueTitle: this.issueTitle,