سرویس ایمیل بدون سرور با AWS Lambda، Node.js و SQS 📧

├── src
│   ├── services
│   │   ├── EmailService.ts   # Core email service using Nodemailer
│   ├── controllers
│   │   ├── emailController.ts   # Controls email operations
│   ├── handlers
│   │   ├── sendEmailHandler.ts   # Lambda handler for processing SQS
│   ├── utils
│   │   ├── logger.ts   # Logger for structured logging
│   │   ├── validate.ts # Environment validation helper
├── sls
│   ├── custom.yml    # Custom configuration
│   ├── functions.yml # Lambda function definitions
│   ├── resources.yml # AWS resource definitions
├── serverless.yml   # Main Serverless Framework configuration

import nodemailer from 'nodemailer';
import logger from '../utils/logger';
import { getEnvVariable } from '../utils/validate';

class EmailService {
  private transporter: nodemailer.Transporter;
  private smtpHost: string;
  private smtpPort: number;
  private smtpUser: string;
  private smtpPass: string;
  private smtpFrom: string;

  constructor() {
    this.smtpHost = getEnvVariable('SMTP_HOST');
    this.smtpPort = parseInt(getEnvVariable('SMTP_PORT', '587'));
    this.smtpUser = getEnvVariable('SMTP_USER');
    this.smtpPass = getEnvVariable('SMTP_PASS');
    this.smtpFrom = process.env['EMAIL_FROM'] || this.smtpUser;

    this.transporter = nodemailer.createTransport({
      host: this.smtpHost,
      port: this.smtpPort,
      secure: this.smtpPort === 465,
      auth: {
        user: this.smtpUser,
        pass: this.smtpPass,
      },
    });

    this.verifyConnection();
  }

  private async verifyConnection() {
    try {
      await this.transporter.verify();
      logger.info('SMTP server is ready to send emails');
    } catch (error) {
      logger.error('Failed to verify SMTP connection:', error);
      throw new Error('Unable to connect to SMTP server');
    }
  }

  async sendEmail(to: string, subject: string, htmlContent: string): Promise<void> {
    const mailOptions = {
      from: this.smtpFrom,
      to,
      subject,
      html: htmlContent,
    };

    try {
      const info = await this.transporter.sendMail(mailOptions);
      logger.info('Email sent successfully:', { messageId: info.messageId, to });
    } catch (error: any) {
      logger.error(`Error sending email: ${error.message}`, error);
      throw new Error('Email sending failed');
    }
  }
}

export default new EmailService();

import logger from '../utils/logger';
import EmailService from '../services/EmailService';

class EmailController {
  async sendCustomEmail(to: string, subject: string, templateContent: string) {
    try {
      logger.info(`Sending email to ${to} with subject "${subject}"`);
      await EmailService.sendEmail(to, subject, templateContent);
      logger.info(`Email sent successfully to ${to}`);
      return { success: true, message: 'Email sent successfully' };
    } catch (error: any) {
      logger.error(`Failed to send email to ${to} - ${error.message}`);
      throw new Error(`Failed to send custom email - ${error.message}`);
    }
  }
}

export default new EmailController();

import Joi from 'joi';
import EmailController from '../controllers/emailController';
import logger from '../utils/logger';
import { Handler } from 'aws-lambda';

const emailSchema = Joi.object({
  to: Joi.string().email().required(),
  subject: Joi.string().required(),
  templateContent: Joi.string().required(),
});

export const handler: Handler = async (event) => {
  for (const record of event.Records) {
    try {
      const message = JSON.parse(record.body);
      const { error, value } = emailSchema.validate(message);

      if (error) {
        logger.warn('Validation failed', {
          recordId: record.messageId,
          errors: error.details.map(e => e.message),
        });
        continue;
      }

      const { to, subject, templateContent } = value;
      await EmailController.sendCustomEmail(to, subject, templateContent);
      logger.info('Email sent successfully', { recordId: record.messageId, to });
    } catch (error: any) {
      logger.error('Failed to process SQS message', {
        recordId: record.messageId,
        error: error.message,
      });
    }
  }
};

npm install

npx serverless deploy --stage dev

npx serverless logs -f sendEmail -s dev

{
  "to": "recipient@example.com",
  "subject": "Welcome to Our Platform",
  "templateContent": ""
}