Intégration Email

[Application/API] → [Email Service] → [Queue Bull] → [SendGrid API] → [Destinataire]
                                           ↓
                                    [Webhooks] → [Event Handler] → [Base de données]

npm install @sendgrid/mail @sendgrid/client

import { Module } from '@nestjs/common';
import { BullModule } from '@nestjs/bull';
import { EmailService } from './email.service';
import { EmailProcessor } from './email.processor';

@Module({
  imports: [
    BullModule.registerQueue({
      name: 'email',
      defaultJobOptions: {
        attempts: 3,
        backoff: { type: 'exponential', delay: 5000 },
        removeOnComplete: 100,
        removeOnFail: 1000,
      },
    }),
  ],
  providers: [EmailService, EmailProcessor],
  exports: [EmailService],
})
export class EmailModule {}

npm install @getbrevo/brevo

import * as Brevo from '@getbrevo/brevo';

const apiInstance = new Brevo.TransactionalEmailsApi();
apiInstance.setApiKey(
  Brevo.TransactionalEmailsApiApiKeys.apiKey,
  process.env.BREVO_API_KEY
);

<!-- Header -->
<div style="background-color: #6366F1; padding: 20px; text-align: center;">
  <img src="{{logo_url}}" alt="REWAPP" height="40" />
</div>

<!-- Content -->
<div style="padding: 30px; font-family: 'Segoe UI', Arial, sans-serif;">
  <h1 style="color: #1F2937; font-size: 24px;">{{subject}}</h1>
  <p style="color: #4B5563; font-size: 16px; line-height: 1.6;">
    {{content}}
  </p>
  {{#if cta_url}}
  <a href="{{cta_url}}" style="display: inline-block; background-color: #6366F1; 
     color: white; padding: 12px 24px; border-radius: 8px; text-decoration: none;">
    {{cta_text}}
  </a>
  {{/if}}
</div>

<!-- Footer -->
<div style="background-color: #F3F4F6; padding: 20px; text-align: center; font-size: 12px;">
  <p>© 2025 REWAPP - La solution de cashback nouvelle génération</p>
  <p>
    <a href="{{unsubscribe_url}}">Se désinscrire</a> | 
    <a href="{{preferences_url}}">Préférences</a>
  </p>
</div>

Bonjour {{user_firstname}},

Bienvenue dans la communauté REWAPP ! Vous avez fait le bon choix 
en rejoignant la solution de cashback nouvelle génération.

Voici comment démarrer :
1. Liez votre carte bancaire (une seule fois)
2. Faites vos achats chez nos partenaires
3. Recevez automatiquement vos points
4. Convertissez-les en cashback bancaire ou dépensez-les en magasin

⚡ Rappel : 1 point = 0,10€

À très vite !
L'équipe REWAPP

Bonjour {{user_firstname}},

Attention ! {{points_expiring}} points (soit {{points_value}}€) 
vont expirer le {{expiration_date}}.

Ne laissez pas vos récompenses disparaître :
• Demandez un virement bancaire (minimum 100 points)
• Utilisez-les chez un partenaire via QR code

[Bouton : Utiliser mes points]

import { Injectable } from '@nestjs/common';
import { InjectQueue } from '@nestjs/bull';
import { Queue } from 'bull';
import * as sgMail from '@sendgrid/mail';

@Injectable()
export class EmailService {
  constructor(
    @InjectQueue('email') private emailQueue: Queue,
  ) {
    sgMail.setApiKey(process.env.SENDGRID_API_KEY);
  }

  async sendTransactional(
    to: string,
    templateId: string,
    dynamicData: Record<string, any>,
    options?: EmailOptions
  ): Promise<void> {
    await this.emailQueue.add('send', {
      type: 'transactional',
      to,
      templateId,
      dynamicData,
      ...options,
    }, {
      priority: options?.priority || 2,
    });
  }

  async sendBulk(
    recipients: BulkRecipient[],
    templateId: string,
    options?: EmailOptions
  ): Promise<void> {
    await this.emailQueue.add('send-bulk', {
      type: 'bulk',
      recipients,
      templateId,
      ...options,
    }, {
      priority: 3,
    });
  }
}

CREATE TABLE email_logs (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID REFERENCES users(id),
  recipient_email VARCHAR(255) NOT NULL,
  template_id VARCHAR(100) NOT NULL,
  subject VARCHAR(500),
  status VARCHAR(50) NOT NULL DEFAULT 'queued',
  sendgrid_message_id VARCHAR(255),
  sent_at TIMESTAMP,
  delivered_at TIMESTAMP,
  opened_at TIMESTAMP,
  clicked_at TIMESTAMP,
  bounced_at TIMESTAMP,
  error_message TEXT,
  metadata JSONB,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

CREATE INDEX idx_email_logs_user ON email_logs(user_id);
CREATE INDEX idx_email_logs_status ON email_logs(status);
CREATE INDEX idx_email_logs_template ON email_logs(template_id);

import * as sgMail from '@sendgrid/mail';

async function sendSimpleEmail(
  to: string,
  subject: string,
  htmlContent: string
): Promise<void> {
  const msg = {
    to,
    from: {
      email: 'noreply@rewapp.fr',
      name: 'REWAPP',
    },
    subject,
    html: htmlContent,
    trackingSettings: {
      clickTracking: { enable: true },
      openTracking: { enable: true },
    },
  };

  try {
    const [response] = await sgMail.send(msg);
    console.log('Email sent, status:', response.statusCode);
  } catch (error) {
    console.error('SendGrid error:', error.response?.body);
    throw error;
  }
}

async function sendTemplatedEmail(
  to: string,
  templateId: string,
  dynamicData: Record<string, any>
): Promise<string> {
  const msg = {
    to,
    from: {
      email: 'noreply@rewapp.fr',
      name: 'REWAPP',
    },
    templateId,
    dynamicTemplateData: {
      ...dynamicData,
      logo_url: 'https://cdn.rewapp.fr/logo.png',
      support_email: 'support@rewapp.fr',
      unsubscribe_url: 'https://rewapp.fr/unsubscribe?email=' + encodeURIComponent(to),
      current_year: new Date().getFullYear(),
    },
  };

  const [response] = await sgMail.send(msg);
  
  // Récupérer le Message-ID pour le tracking
  const messageId = response.headers['x-message-id'];
  return messageId;
}

async function sendBulkEmail(
  recipients: Array<{ email: string; data: Record<string, any> }>,
  templateId: string
): Promise<void> {
  const personalizations = recipients.map(r => ({
    to: [{ email: r.email }],
    dynamicTemplateData: {
      ...r.data,
      unsubscribe_url: 'https://rewapp.fr/unsubscribe?email=' + encodeURIComponent(r.email),
    },
  }));

  // SendGrid limite à 1000 destinataires par appel
  const chunks = chunkArray(personalizations, 1000);

  for (const chunk of chunks) {
    const msg = {
      from: { email: 'newsletter@rewapp.fr', name: 'REWAPP' },
      templateId,
      personalizations: chunk,
    };

    await sgMail.send(msg);
    
    // Rate limiting : 100 requêtes/seconde max
    await sleep(100);
  }
}

@Controller('webhooks')
export class SendGridWebhookController {
  @Post('sendgrid')
  @HttpCode(200)
  async handleWebhook(
    @Body() events: SendGridEvent[],
    @Headers('x-twilio-email-event-webhook-signature') signature: string,
    @Headers('x-twilio-email-event-webhook-timestamp') timestamp: string,
  ) {
    // Vérifier la signature
    if (!this.verifySignature(events, signature, timestamp)) {
      throw new UnauthorizedException('Invalid webhook signature');
    }

    for (const event of events) {
      await this.processEvent(event);
    }

    return { received: true };
  }

  private async processEvent(event: SendGridEvent) {
    const { email, event: eventType, sg_message_id, timestamp } = event;

    switch (eventType) {
      case 'delivered':
        await this.emailLogService.updateStatus(sg_message_id, 'delivered', {
          delivered_at: new Date(timestamp * 1000),
        });
        break;

      case 'bounce':
        await this.emailLogService.updateStatus(sg_message_id, 'bounced', {
          bounced_at: new Date(timestamp * 1000),
          error_message: event.reason,
        });
        await this.userService.markEmailInvalid(email, event.reason);
        break;

      case 'spam_report':
        await this.userService.unsubscribeFromAll(email);
        await this.alertService.notify('SPAM_REPORT', { email });
        break;
    }
  }
}

const retryConfig = {
  attempts: 5,
  backoff: {
    type: 'exponential',
    delay: 5000, // 5s, 10s, 20s, 40s, 80s
  },
};

async processEmailJob(job: Job<EmailJobData>) {
  try {
    await this.sendEmail(job.data);
  } catch (error) {
    if (this.isRetryableError(error)) {
      throw error; // Bull va automatiquement réessayer
    }
    
    // Erreur non récupérable → logger et abandonner
    await this.logFailedEmail(job.data, error);
    return; // Ne pas throw → job marqué comme complété
  }
}

private isRetryableError(error: any): boolean {
  const retryableCodes = [429, 500, 502, 503, 504];
  return retryableCodes.includes(error.code);
}

// Création des queues par priorité
const criticalQueue = new Bull('email-critical', { redis: redisConfig });
const transactionalQueue = new Bull('email-transactional', { redis: redisConfig });
const marketingQueue = new Bull('email-marketing', { redis: redisConfig });

// Workers avec concurrence adaptée
criticalQueue.process(10, processor); // 10 jobs simultanés
transactionalQueue.process(5, processor); // 5 jobs simultanés
marketingQueue.process(2, processor); // 2 jobs simultanés

SELECT 
  template_id,
  COUNT(*) as total_sent,
  COUNT(*) FILTER (WHERE status = 'delivered') as delivered,
  COUNT(*) FILTER (WHERE opened_at IS NOT NULL) as opened,
  COUNT(*) FILTER (WHERE clicked_at IS NOT NULL) as clicked,
  COUNT(*) FILTER (WHERE status = 'bounced') as bounced
FROM email_logs
WHERE created_at > NOW() - INTERVAL '7 days'
GROUP BY template_id;