Send email with NestJS

npm install @poststack.dev/sdk @nestjs/config

// src/mail/mail.constants.ts
export const POSTSTACK = Symbol('POSTSTACK');

// src/mail/mail.module.ts
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { PostStack } from '@poststack.dev/sdk';
import { POSTSTACK } from './mail.constants';
import { MailService } from './mail.service';

@Module({
  imports: [ConfigModule],
  providers: [
    {
      provide: POSTSTACK,
      inject: [ConfigService],
      useFactory: (config: ConfigService) =>
        new PostStack(config.getOrThrow<string>('POSTSTACK_API_KEY')),
    },
    MailService,
  ],
  exports: [MailService],
})
export class MailModule {}

// src/mail/mail.service.ts
import { Inject, Injectable } from '@nestjs/common';
import { PostStack } from '@poststack.dev/sdk';
import { POSTSTACK } from './mail.constants';

@Injectable()
export class MailService {
  constructor(@Inject(POSTSTACK) private readonly poststack: PostStack) {}

  async sendWelcome(to: string, name: string) {
    const { id } = await this.poststack.emails.send({
      from: 'Acme <hello@yourdomain.com>',   // must be on a verified domain
      to: [to],                              // always an array
      subject: `Welcome, ${name}`,
      html: `<h1>Welcome, ${name}!</h1>`,
      text: `Welcome, ${name}!`,
      tags: ['welcome'],
    });
    return id;                               // "em_..."
  }
}

// src/users/users.service.ts — inject it anywhere MailModule is imported
@Injectable()
export class UsersService {
  constructor(private readonly mail: MailService) {}

  async register(email: string, name: string) {
    // ...create the user
    await this.mail.sendWelcome(email, name);
  }
}

// src/mail/poststack-exception.filter.ts
import { ArgumentsHost, Catch, ExceptionFilter, HttpStatus, Logger } from '@nestjs/common';
import { PostStackError } from '@poststack.dev/sdk';
import type { Response } from 'express';

@Catch(PostStackError)
export class PostStackExceptionFilter implements ExceptionFilter {
  private readonly logger = new Logger('PostStack');

  catch(err: PostStackError, host: ArgumentsHost) {
    this.logger.error(`${err.statusCode} ${err.message} (request ${err.requestId})`);

    // 400/422 are caused by the input (bad payload, unverified domain,
    // suppressed recipient); everything else is our problem, not the caller's.
    const status =
      err.statusCode === 400 || err.statusCode === 422
        ? err.statusCode
        : HttpStatus.BAD_GATEWAY;

    host.switchToHttp().getResponse<Response>().status(status).json({
      statusCode: status,
      message: status === HttpStatus.BAD_GATEWAY ? 'Email could not be sent' : err.message,
    });
  }
}

// main.ts
app.useGlobalFilters(new PostStackExceptionFilter());

// npm install @nestjs/bullmq bullmq
// mail.module.ts: imports: [BullModule.registerQueue({ name: 'mail' })]

// src/mail/mail.processor.ts
import { Processor, WorkerHost } from '@nestjs/bullmq';
import { Inject } from '@nestjs/common';
import { Job } from 'bullmq';
import { PostStack, PostStackError } from '@poststack.dev/sdk';
import { POSTSTACK } from './mail.constants';

@Processor('mail')
export class MailProcessor extends WorkerHost {
  constructor(@Inject(POSTSTACK) private readonly poststack: PostStack) {
    super();
  }

  async process(job: Job<{ to: string; name: string }>) {
    try {
      const { id } = await this.poststack.emails.send({
        from: 'Acme <hello@yourdomain.com>',
        to: [job.data.to],
        subject: `Welcome, ${job.data.name}`,
        html: `<h1>Welcome, ${job.data.name}!</h1>`,
        idempotency_key: `welcome-${job.id}`,
      });
      return { id };
    } catch (err) {
      // 400/422 will fail the same way on every attempt — don't retry them
      if (err instanceof PostStackError && [400, 422].includes(err.statusCode)) {
        await job.discard();
      }
      throw err;
    }
  }
}

// enqueue: await this.mailQueue.add('welcome', { to, name }, { attempts: 5, backoff: { type: 'exponential', delay: 30_000 } });

@Post('report')
@UseInterceptors(FileInterceptor('file'))
async sendReport(@UploadedFile() file: Express.Multer.File) {
  const { id } = await this.poststack.emails.send({
    from: 'reports@yourdomain.com',
    to: ['team@yourdomain.com'],
    subject: `Report: ${file.originalname}`,
    text: 'Report attached.',
    attachments: [
      {
        filename: file.originalname,
        content: file.buffer.toString('base64'),
        content_type: file.mimetype,
      },
    ],
  });
  return { id };
}

const send = jest.fn().mockResolvedValue({ id: 'em_test' });

const moduleRef = await Test.createTestingModule({ imports: [MailModule] })
  .overrideProvider(POSTSTACK)
  .useValue({ emails: { send } })
  .compile();

await moduleRef.get(MailService).sendWelcome('ada@example.com', 'Ada');
expect(send).toHaveBeenCalledWith(expect.objectContaining({ to: ['ada@example.com'] }));