Merge pull request #68 from internxt/feature/draft-emails

[PB-1974]: Feature/draft emails

Author: xabg2

src/modules/email/email.controller.ts

@@ -232,11 +232,13 @@ export class EmailController {
   @ApiOperation({
     summary: 'Save a draft',
     description:
-      'Creates a new draft email. All fields are optional so partial drafts can be saved.',
+      'Creates a new draft email. All fields are optional so partial drafts can be saved. ' +
+      "Pass `encryption` to store the body encrypted only with the sender's key — the sender " +
+      'is the only reader and can decrypt it on retrieval.',
   })
   @ApiBody({ type: DraftEmailRequestDto })
   @ApiOkResponse({
-    type: EmailCreatedResponseDto,
+    type: EmailResponseDto,
     description: 'Draft saved successfully',
   })
   saveDraft(
@@ -246,6 +248,55 @@ export class EmailController {
     return this.emailService.saveDraft(email, dto);
   }
 
+  @Patch('drafts/:id')
+  @ApiOperation({
+    summary: 'Update a draft',
+    description:
+      'Updates a draft email. All fields are optional so partial drafts can be saved. ' +
+      'Pass `encryption` with a fresh envelope to replace the stored body — the previous ' +
+      'envelope is dropped together with the destroyed draft.',
+  })
+  @ApiBody({ type: DraftEmailRequestDto })
+  @ApiOkResponse({
+    type: EmailResponseDto,
+    description: 'Draft updated successfully',
+  })
+  @ApiNotFoundResponse({ description: 'Draft not found' })
+  updateDraft(
+    @MailAddress('address') email: string,
+    @Param('id') draftId: string,
+    @Body() dto: DraftEmailRequestDto,
+  ) {
+    return this.emailService.updateDraft(email, draftId, dto);
+  }
+
+  @Get('drafts/:id')
+  @ApiOperation({
+    summary: 'Get a draft',
+    description: 'Returns a draft',
+  })
+  @ApiParam({ name: 'id', description: 'Draft ID' })
+  @ApiOkResponse({ type: EmailResponseDto })
+  @ApiNotFoundResponse({ description: 'Draft not found' })
+  getDraft(@MailAddress('address') email: string, @Param('id') id: string) {
+    return this.emailService.getDraft(email, id);
+  }
+
+  @Delete('drafts/:id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({
+    summary: 'Discard a draft',
+    description:
+      'Permanently discards a draft by ID. Returns 404 if the email exists ' +
+      'but is not a draft.',
+  })
+  @ApiParam({ name: 'id', description: 'Draft ID' })
+  @ApiNoContentResponse({ description: 'Draft discarded successfully' })
+  @ApiNotFoundResponse({ description: 'Draft not found' })
+  discardDraft(@MailAddress('address') email: string, @Param('id') id: string) {
+    return this.emailService.discardDraft(email, id);
+  }
+
   @Post('attachment')
   @ApiOperation({
     summary: 'Upload an attachment',

src/modules/email/email.dto.ts

@@ -123,6 +123,14 @@ export class SendEmailRequestDto {
     description: 'JMAP id of the email being replied to (for threading)',
   })
   inReplyToEmailId?: string;
+
+  @ApiPropertyOptional({
+    example: 'Ma1f09b…',
+    description:
+      'JMAP id of the draft being sent. When present, the draft is destroyed ' +
+      'after the email is sent so it no longer appears in the Drafts folder.',
+  })
+  draftId?: string;
 }
 
 export class LookupRecipientKeysRequestDto {
@@ -174,6 +182,15 @@ export class DraftEmailRequestDto {
   @ApiPropertyOptional({ example: '<p>Still working on this…</p>' })
   htmlBody?: string;
 
+  @ApiPropertyOptional({
+    type: EncryptionBlockDto,
+    description:
+      'When present, the draft body is stored encrypted. Only the sender can ' +
+      'decrypt it later, so wrappedKeys / attachmentWrappedKeys should contain ' +
+      "a single entry built from the sender's own public key.",
+  })
+  encryption?: EncryptionBlockDto;
+
   @ApiPropertyOptional({ type: [AttachmentRefDto] })
   attachments?: AttachmentRefDto[];
 }
@@ -274,6 +291,9 @@ export class EmailSummaryResponseDto {
   @ApiProperty({ example: false })
   isFlagged!: boolean;
 
+  @ApiProperty({ example: false })
+  isDraft!: boolean;
+
   @ApiProperty({ example: false })
   hasAttachment!: boolean;
 

src/modules/email/email.service.spec.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { describe, it, test, expect, beforeEach, vi } from 'vitest';
 import { Test } from '@nestjs/testing';
 import { NotFoundException, BadRequestException } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
@@ -254,9 +254,9 @@ describe('EmailService', () => {
     it('when opening a conversation by an id that does not exist, then the user is told it was not found', async () => {
       provider.getThread.mockResolvedValue([]);
 
-      await expect(
-        service.getThread(userEmail, 'nonexistent'),
-      ).rejects.toThrow(NotFoundException);
+      await expect(service.getThread(userEmail, 'nonexistent')).rejects.toThrow(
+        NotFoundException,
+      );
     });
 
     it('when a conversation contains end-to-end encrypted messages, then the encrypted previews and wrapped keys are attached for the client to decrypt', async () => {
@@ -349,7 +349,11 @@ describe('EmailService', () => {
 
       await service.sendEmail(userEmail, dto);
 
-      expect(provider.sendEmail).toHaveBeenCalledWith(userEmail, dto, undefined);
+      expect(provider.sendEmail).toHaveBeenCalledWith(
+        userEmail,
+        dto,
+        undefined,
+      );
     });
 
     it('when replying to an existing email, then the reply is delivered into the same conversation', async () => {
@@ -367,7 +371,11 @@ describe('EmailService', () => {
         userEmail,
         'parent-id',
       );
-      expect(provider.sendEmail).toHaveBeenCalledWith(userEmail, dto, threading);
+      expect(provider.sendEmail).toHaveBeenCalledWith(
+        userEmail,
+        dto,
+        threading,
+      );
     });
 
     it('when replying to an email that no longer exists, then the user is told the original was not found', async () => {
@@ -521,10 +529,7 @@ describe('EmailService', () => {
       expect(smtp.sendRaw).toHaveBeenCalledWith(
         expect.objectContaining({
           inReplyTo: '<parent@example.com>',
-          references: [
-            '<grandparent@example.com>',
-            '<parent@example.com>',
-          ],
+          references: ['<grandparent@example.com>', '<parent@example.com>'],
         }),
       );
       expect(provider.saveToSent).toHaveBeenCalledWith(
@@ -570,12 +575,104 @@ describe('EmailService', () => {
   describe('saveDraft', () => {
     it('when called, then delegates to provider', async () => {
       const dto = newDraftEmailDto();
-      provider.saveDraft.mockResolvedValue({ id: 'draft-id' });
+      const savedDraft = newEmail({ isDraft: true });
+      provider.saveDraft.mockResolvedValue(savedDraft);
 
       const result = await service.saveDraft(userEmail, dto);
 
       expect(provider.saveDraft).toHaveBeenCalledWith(userEmail, dto);
-      expect(result).toEqual({ id: 'draft-id' });
+      expect(result).toBe(savedDraft);
+    });
+
+    it('when DTO has encryption block, then serializes it into textBody and clears htmlBody', async () => {
+      const encryption = newEncryptionBlock();
+      const dto = newDraftEmailDto({
+        encryption,
+        htmlBody: '<p>original</p>',
+      });
+      provider.saveDraft.mockResolvedValue(newEmail({ isDraft: true }));
+
+      await service.saveDraft(userEmail, dto);
+
+      const expectedBundle = Buffer.from(JSON.stringify(encryption)).toString(
+        'base64',
+      );
+      expect(provider.saveDraft).toHaveBeenCalledWith(
+        userEmail,
+        expect.objectContaining({
+          textBody: `INTERNXT-ENCRYPTED-EMAIL-v1\n${expectedBundle}`,
+          htmlBody: undefined,
+        }),
+      );
+    });
+  });
+
+  describe('updateDraft', () => {
+    it('when called, then delegates to provider', async () => {
+      const dto = newDraftEmailDto();
+      const updatedDraft = newEmail({ isDraft: true });
+      provider.updateDraft.mockResolvedValue(updatedDraft);
+
+      const result = await service.updateDraft(userEmail, 'draft-id', dto);
+
+      expect(provider.updateDraft).toHaveBeenCalledWith(
+        userEmail,
+        'draft-id',
+        dto,
+      );
+      expect(result).toBe(updatedDraft);
+    });
+
+    it('when DTO has encryption block, then serializes it into textBody and clears htmlBody', async () => {
+      const encryption = newEncryptionBlock();
+      const dto = newDraftEmailDto({
+        encryption,
+        htmlBody: '<p>original</p>',
+      });
+      provider.updateDraft.mockResolvedValue(newEmail({ isDraft: true }));
+
+      await service.updateDraft(userEmail, 'draft-id', dto);
+
+      const expectedBundle = Buffer.from(JSON.stringify(encryption)).toString(
+        'base64',
+      );
+      expect(provider.updateDraft).toHaveBeenCalledWith(
+        userEmail,
+        'draft-id',
+        expect.objectContaining({
+          textBody: `INTERNXT-ENCRYPTED-EMAIL-v1\n${expectedBundle}`,
+          htmlBody: undefined,
+        }),
+      );
+    });
+
+    test('When the user tries to update a draft that does not exist, then they are told it was not found', async () => {
+      provider.updateDraft.mockResolvedValue(null);
+
+      await expect(
+        service.updateDraft(userEmail, 'missing-draft', newDraftEmailDto()),
+      ).rejects.toThrow(NotFoundException);
+    });
+  });
+
+  describe('Discard Draft', () => {
+    test('When the user discards an existing draft, then it is removed from their mailbox', async () => {
+      const draft = newEmail({ isDraft: true });
+      provider.getDraft.mockResolvedValue(draft);
+      provider.discardDraft.mockResolvedValue(undefined);
+
+      await service.discardDraft(userEmail, draft.id);
+
+      expect(provider.discardDraft).toHaveBeenCalledWith(userEmail, draft.id);
+    });
+
+    test('When the user tries to discard a draft that does not exist, then they are told it was not found', async () => {
+      provider.getDraft.mockResolvedValue(null);
+
+      await expect(
+        service.discardDraft(userEmail, 'missing-draft'),
+      ).rejects.toThrow(NotFoundException);
+      expect(provider.discardDraft).not.toHaveBeenCalled();
     });
   });
 

src/modules/email/email.service.ts

@@ -278,8 +278,45 @@ export class EmailService {
     );
   }
 
-  saveDraft(userEmail: string, dto: DraftEmailDto): Promise<{ id: string }> {
-    return this.mail.saveDraft(userEmail, dto);
+  saveDraft(userEmail: string, dto: DraftEmailDto): Promise<Email> {
+    return this.mail.saveDraft(userEmail, this.packDraftEnvelope(dto));
+  }
+
+  async updateDraft(
+    userEmail: string,
+    draftId: string,
+    dto: DraftEmailDto,
+  ): Promise<Email> {
+    const result = await this.mail.updateDraft(
+      userEmail,
+      draftId,
+      this.packDraftEnvelope(dto),
+    );
+    if (!result) {
+      throw new NotFoundException(`Draft ${draftId} not found`);
+    }
+    return result;
+  }
+
+  private packDraftEnvelope(dto: DraftEmailDto): DraftEmailDto {
+    if (!dto.encryption) return dto;
+    return {
+      ...dto,
+      textBody: packEnvelope(dto.encryption),
+      htmlBody: undefined,
+    };
+  }
+
+  getDraft(userEmail: string, id: string): Promise<Email | null> {
+    return this.mail.getDraft(userEmail, id);
+  }
+
+  async discardDraft(userEmail: string, id: string): Promise<void> {
+    const draft = await this.mail.getDraft(userEmail, id);
+    if (!draft) {
+      throw new NotFoundException(`Draft ${id} not found`);
+    }
+    await this.mail.discardDraft(userEmail, id);
   }
 
   moveEmail(userEmail: string, id: string, target: MailboxType): Promise<void> {

src/modules/email/email.types.ts

@@ -39,6 +39,7 @@ export interface EmailSummary {
   preview: string;
   isRead: boolean;
   isFlagged: boolean;
+  isDraft: boolean;
   hasAttachment: boolean;
   size: number;
   encryption?: EncryptedSummaryFields | null;
@@ -93,6 +94,7 @@ export interface SendEmailDto {
   encryption?: EncryptionBlock;
   attachments?: EmailAttachment[];
   inReplyToEmailId?: string;
+  draftId?: string;
 }
 
 export interface ThreadingHeaders {
@@ -101,12 +103,14 @@ export interface ThreadingHeaders {
 }
 
 export interface DraftEmailDto {
+  draftId?: string;
   to?: EmailAddress[];
   cc?: EmailAddress[];
   bcc?: EmailAddress[];
   subject?: string;
   textBody?: string;
   htmlBody?: string;
+  encryption?: EncryptionBlock;
   attachments?: EmailAttachment[];
 }
 

src/modules/email/mail-provider.port.ts

@@ -41,10 +41,14 @@ export abstract class MailProvider {
     parentId: string,
   ): Promise<ThreadingHeaders | null>;
   abstract getThread(userEmail: string, emailId: string): Promise<Email[]>;
-  abstract saveDraft(
+  abstract saveDraft(userEmail: string, dto: DraftEmailDto): Promise<Email>;
+  abstract updateDraft(
     userEmail: string,
+    draftId: string,
     dto: DraftEmailDto,
-  ): Promise<{ id: string }>;
+  ): Promise<Email | null>;
+  abstract getDraft(userEmail: string, id: string): Promise<Email | null>;
+  abstract discardDraft(userEmail: string, id: string): Promise<void>;
   abstract moveEmail(
     userEmail: string,
     id: string,

src/modules/infrastructure/jmap/jmap-mail.mapper.ts

@@ -70,6 +70,7 @@ export function mapJmapEmailToSummary(e: JmapEmail): EmailSummary {
     preview: e.preview ?? '',
     isRead: !!e.keywords?.['$seen'],
     isFlagged: !!e.keywords?.['$flagged'],
+    isDraft: !!e.keywords?.['$draft'],
     hasAttachment: !!e.hasAttachment,
     size: e.size,
   };