feat: add draft email workflow action (#17793)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com> Co-authored-by: cubic-dev-ai[bot] <191113872+cubic-dev-ai[bot]@users.noreply.github.com>
2026-02-13 22:50:20 +05:30
parent ebfaff0a53
commit 84afbb4d2c
64 changed files with 1451 additions and 614 deletions
@@ -0,0 +1,134 @@
+import { Test, type TestingModule } from '@nestjs/testing';
+
+import { google } from 'googleapis';
+import { ConnectedAccountProvider } from 'twenty-shared/types';
+
+import { OAuth2ClientManagerService } from 'src/modules/connected-account/oauth2-client-manager/services/oauth2-client-manager.service';
+import { GmailMessageOutboundService } from 'src/modules/messaging/message-outbound-manager/drivers/gmail/services/gmail-message-outbound.service';
+
+jest.mock('nodemailer/lib/mail-composer', () => {
+  return jest.fn().mockImplementation(() => ({
+    compile: jest.fn().mockReturnValue({
+      build: jest.fn().mockResolvedValue(Buffer.from('mocked-email-content')),
+    }),
+  }));
+});
+
+describe('GmailMessageOutboundService', () => {
+  let service: GmailMessageOutboundService;
+
+  const mockSend = jest.fn().mockResolvedValue({ data: { id: 'message-id' } });
+
+  const mockGmailClient = {
+    users: {
+      messages: {
+        send: mockSend,
+      },
+      getProfile: jest
+        .fn()
+        .mockResolvedValue({ data: { emailAddress: 'test@example.com' } }),
+    },
+  };
+
+  const mockPeopleClient = {
+    people: {
+      get: jest.fn().mockResolvedValue({
+        data: {
+          names: [
+            {
+              displayName: 'Test User',
+            },
+          ],
+        },
+      }),
+    },
+  };
+
+  const mockOAuth2Client = {};
+
+  beforeEach(async () => {
+    jest.spyOn(google, 'gmail').mockReturnValue(mockGmailClient as never);
+    jest.spyOn(google, 'people').mockReturnValue(mockPeopleClient as never);
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        GmailMessageOutboundService,
+        {
+          provide: OAuth2ClientManagerService,
+          useValue: {
+            getGoogleOAuth2Client: jest
+              .fn()
+              .mockResolvedValue(mockOAuth2Client),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<GmailMessageOutboundService>(
+      GmailMessageOutboundService,
+    );
+  });
+
+  afterEach(() => {
+    mockSend.mockClear();
+    jest.restoreAllMocks();
+  });
+
+  it('should send multipart/alternative email with both text and HTML parts via Gmail', async () => {
+    const sendMessageInput = {
+      to: 'recipient@example.com',
+      subject: 'Test HTML Email',
+      body: 'This is plain text content',
+      html: '<p>This is <strong>HTML</strong> content</p>',
+      attachments: [],
+    };
+
+    const connectedAccount = {
+      provider: ConnectedAccountProvider.GOOGLE,
+      accessToken: 'access-token',
+      refreshToken: 'refresh-token',
+    } as any;
+
+    await service.sendMessage(sendMessageInput, connectedAccount);
+
+    expect(mockSend).toHaveBeenCalledTimes(1);
+    expect(mockSend).toHaveBeenCalledWith({
+      userId: 'me',
+      requestBody: {
+        raw: Buffer.from('mocked-email-content').toString('base64url'),
+      },
+    });
+  });
+
+  it('should send email with attachments via Gmail', async () => {
+    const sendMessageInput = {
+      to: 'recipient@example.com',
+      subject: 'Test Email with Attachments',
+      body: 'Plain text',
+      html: '<p>HTML content</p>',
+      attachments: [
+        {
+          filename: 'test.pdf',
+          content: Buffer.from('test-pdf-content'),
+          contentType: 'application/pdf',
+        },
+      ],
+    };
+
+    const connectedAccount = {
+      provider: ConnectedAccountProvider.GOOGLE,
+      accessToken: 'access-token',
+      refreshToken: 'refresh-token',
+    } as any;
+
+    await service.sendMessage(sendMessageInput, connectedAccount);
+
+    expect(mockSend).toHaveBeenCalledTimes(1);
+    expect(mockSend).toHaveBeenCalledWith({
+      userId: 'me',
+      requestBody: {
+        raw: Buffer.from('mocked-email-content').toString('base64url'),
+      },
+    });
+  });
+});
@@ -0,0 +1,109 @@
+import { Injectable } from '@nestjs/common';
+
+import { type gmail_v1, google } from 'googleapis';
+import MailComposer from 'nodemailer/lib/mail-composer';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type MessageOutboundDriver } from 'src/modules/messaging/message-outbound-manager/interfaces/message-outbound-driver.interface';
+
+import { OAuth2ClientManagerService } from 'src/modules/connected-account/oauth2-client-manager/services/oauth2-client-manager.service';
+import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+import { mimeEncode } from 'src/modules/messaging/message-import-manager/utils/mime-encode.util';
+import { type SendMessageInput } from 'src/modules/messaging/message-outbound-manager/types/send-message-input.type';
+import { toMailComposerOptions } from 'src/modules/messaging/message-outbound-manager/utils/to-mail-composer-options.util';
+
+@Injectable()
+export class GmailMessageOutboundService implements MessageOutboundDriver {
+  constructor(
+    private readonly oAuth2ClientManagerService: OAuth2ClientManagerService,
+  ) {}
+
+  async sendMessage(
+    sendMessageInput: SendMessageInput,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ): Promise<void> {
+    const { gmailClient, encodedMessage } = await this.composeGmailMessage(
+      connectedAccount,
+      sendMessageInput,
+    );
+
+    await gmailClient.users.messages.send({
+      userId: 'me',
+      requestBody: {
+        raw: encodedMessage,
+      },
+    });
+  }
+
+  async createDraft(
+    sendMessageInput: SendMessageInput,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ): Promise<void> {
+    const { gmailClient, encodedMessage } = await this.composeGmailMessage(
+      connectedAccount,
+      sendMessageInput,
+    );
+
+    await gmailClient.users.drafts.create({
+      userId: 'me',
+      requestBody: {
+        message: {
+          raw: encodedMessage,
+        },
+      },
+    });
+  }
+
+  private async composeGmailMessage(
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+    sendMessageInput: SendMessageInput,
+  ): Promise<{
+    gmailClient: gmail_v1.Gmail;
+    encodedMessage: string;
+  }> {
+    const oAuth2Client =
+      await this.oAuth2ClientManagerService.getGoogleOAuth2Client(
+        connectedAccount,
+      );
+
+    const gmailClient = google.gmail({
+      version: 'v1',
+      auth: oAuth2Client,
+    });
+
+    const peopleClient = google.people({
+      version: 'v1',
+      auth: oAuth2Client,
+    });
+
+    const { data: gmailData } = await gmailClient.users.getProfile({
+      userId: 'me',
+    });
+
+    const fromEmail = gmailData.emailAddress;
+
+    const { data: peopleData } = await peopleClient.people.get({
+      resourceName: 'people/me',
+      personFields: 'names',
+    });
+
+    const fromName = peopleData?.names?.[0]?.displayName;
+
+    const from = isDefined(fromName)
+      ? `"${mimeEncode(fromName)}" <${fromEmail}>`
+      : `${fromEmail}`;
+
+    const mail = new MailComposer(
+      toMailComposerOptions(from, sendMessageInput),
+    );
+
+    const compiledMessage = mail.compile();
+
+    compiledMessage.keepBcc = true;
+
+    const messageBuffer = await compiledMessage.build();
+    const encodedMessage = Buffer.from(messageBuffer).toString('base64url');
+
+    return { gmailClient, encodedMessage };
+  }
+}
@@ -0,0 +1,122 @@
+import { Injectable } from '@nestjs/common';
+
+import MailComposer from 'nodemailer/lib/mail-composer';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type MessageOutboundDriver } from 'src/modules/messaging/message-outbound-manager/interfaces/message-outbound-driver.interface';
+
+import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+import { ImapClientProvider } from 'src/modules/messaging/message-import-manager/drivers/imap/providers/imap-client.provider';
+import { ImapFindDraftsFolderService } from 'src/modules/messaging/message-import-manager/drivers/imap/services/imap-find-drafts-folder.service';
+import { SmtpClientProvider } from 'src/modules/messaging/message-import-manager/drivers/smtp/providers/smtp-client.provider';
+import { type SendMessageInput } from 'src/modules/messaging/message-outbound-manager/types/send-message-input.type';
+import { toMailComposerOptions } from 'src/modules/messaging/message-outbound-manager/utils/to-mail-composer-options.util';
+
+@Injectable()
+export class ImapSmtpMessageOutboundService implements MessageOutboundDriver {
+  constructor(
+    private readonly smtpClientProvider: SmtpClientProvider,
+    private readonly imapClientProvider: ImapClientProvider,
+    private readonly imapFindDraftsFolderService: ImapFindDraftsFolderService,
+  ) {}
+
+  async sendMessage(
+    sendMessageInput: SendMessageInput,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ): Promise<void> {
+    const { handle, connectionParameters, messageChannels } = connectedAccount;
+
+    const smtpClient =
+      await this.smtpClientProvider.getSmtpClient(connectedAccount);
+
+    this.assertHandleIsDefined(handle);
+
+    const messageBuffer = await this.compileRawMessage(
+      handle,
+      sendMessageInput,
+    );
+
+    await smtpClient.sendMail({
+      from: handle,
+      to: sendMessageInput.to,
+      cc: sendMessageInput.cc,
+      bcc: sendMessageInput.bcc,
+      raw: messageBuffer,
+    });
+
+    if (isDefined(connectionParameters?.IMAP)) {
+      const imapClient =
+        await this.imapClientProvider.getClient(connectedAccount);
+
+      const messageChannel = messageChannels.find(
+        (channel) => channel.handle === handle,
+      );
+
+      const sentFolder = messageChannel?.messageFolders.find(
+        (messageFolder) => messageFolder.isSentFolder,
+      );
+
+      if (isDefined(sentFolder) && isDefined(sentFolder.name)) {
+        await imapClient.append(sentFolder.name, messageBuffer);
+      }
+
+      await this.imapClientProvider.closeClient(imapClient);
+    }
+  }
+
+  async createDraft(
+    sendMessageInput: SendMessageInput,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ): Promise<void> {
+    const { handle, connectionParameters } = connectedAccount;
+
+    this.assertHandleIsDefined(handle);
+
+    if (!isDefined(connectionParameters?.IMAP)) {
+      throw new Error('IMAP connection is required to create drafts');
+    }
+
+    const messageBuffer = await this.compileRawMessage(
+      handle,
+      sendMessageInput,
+    );
+
+    const imapClient =
+      await this.imapClientProvider.getClient(connectedAccount);
+
+    try {
+      const draftsFolder =
+        await this.imapFindDraftsFolderService.findOrCreateDraftsFolder(
+          imapClient,
+        );
+
+      if (!isDefined(draftsFolder)) {
+        throw new Error('No drafts folder found and could not create one');
+      }
+      const DRAFT_FLAG = '\\Draft';
+
+      await imapClient.append(draftsFolder.path, messageBuffer, [DRAFT_FLAG]);
+    } finally {
+      await this.imapClientProvider.closeClient(imapClient);
+    }
+  }
+
+  private async compileRawMessage(
+    from: string,
+    sendMessageInput: SendMessageInput,
+  ): Promise<Buffer> {
+    const mail = new MailComposer(
+      toMailComposerOptions(from, sendMessageInput),
+    );
+
+    return mail.compile().build();
+  }
+
+  private assertHandleIsDefined(
+    handle: string | null,
+  ): asserts handle is string {
+    if (!isDefined(handle)) {
+      throw new Error('Handle is required');
+    }
+  }
+}
@@ -0,0 +1,75 @@
+import { Injectable } from '@nestjs/common';
+
+import { z } from 'zod';
+
+import { type MessageOutboundDriver } from 'src/modules/messaging/message-outbound-manager/interfaces/message-outbound-driver.interface';
+
+import { OAuth2ClientManagerService } from 'src/modules/connected-account/oauth2-client-manager/services/oauth2-client-manager.service';
+import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+import { toMicrosoftRecipients } from 'src/modules/messaging/message-import-manager/utils/to-microsoft-recipients.util';
+import { type SendMessageInput } from 'src/modules/messaging/message-outbound-manager/types/send-message-input.type';
+
+@Injectable()
+export class MicrosoftMessageOutboundService implements MessageOutboundDriver {
+  constructor(
+    private readonly oAuth2ClientManagerService: OAuth2ClientManagerService,
+  ) {}
+
+  async sendMessage(
+    sendMessageInput: SendMessageInput,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ): Promise<void> {
+    const microsoftClient =
+      await this.oAuth2ClientManagerService.getMicrosoftOAuth2Client(
+        connectedAccount,
+      );
+
+    const message = this.composeMicrosoftMessage(sendMessageInput);
+
+    const response = await microsoftClient.api(`/me/messages`).post(message);
+
+    z.string().parse(response.id);
+
+    await microsoftClient.api(`/me/messages/${response.id}/send`).post({});
+  }
+
+  async createDraft(
+    sendMessageInput: SendMessageInput,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ): Promise<void> {
+    const microsoftClient =
+      await this.oAuth2ClientManagerService.getMicrosoftOAuth2Client(
+        connectedAccount,
+      );
+
+    const message = this.composeMicrosoftMessage(sendMessageInput);
+
+    await microsoftClient.api(`/me/messages`).post(message);
+  }
+
+  private composeMicrosoftMessage(
+    sendMessageInput: SendMessageInput,
+  ): Record<string, unknown> {
+    return {
+      subject: sendMessageInput.subject,
+      body: {
+        contentType: 'HTML',
+        content: sendMessageInput.html,
+      },
+      toRecipients: toMicrosoftRecipients(sendMessageInput.to),
+      ccRecipients: toMicrosoftRecipients(sendMessageInput.cc),
+      bccRecipients: toMicrosoftRecipients(sendMessageInput.bcc),
+      ...(sendMessageInput.attachments &&
+      sendMessageInput.attachments.length > 0
+        ? {
+            attachments: sendMessageInput.attachments.map((attachment) => ({
+              '@odata.type': '#microsoft.graph.fileAttachment',
+              name: attachment.filename,
+              contentType: attachment.contentType,
+              contentBytes: attachment.content.toString('base64'),
+            })),
+          }
+        : {}),
+    };
+  }
+}
@@ -0,0 +1,14 @@
+import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+import { type SendMessageInput } from 'src/modules/messaging/message-outbound-manager/types/send-message-input.type';
+
+export type MessageOutboundDriver = {
+  sendMessage(
+    sendMessageInput: SendMessageInput,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ): Promise<void>;
+
+  createDraft(
+    sendMessageInput: SendMessageInput,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ): Promise<void>;
+};
@@ -0,0 +1,25 @@
+import { Module } from '@nestjs/common';
+
+import { OAuth2ClientManagerModule } from 'src/modules/connected-account/oauth2-client-manager/oauth2-client-manager.module';
+import { MessagingIMAPDriverModule } from 'src/modules/messaging/message-import-manager/drivers/imap/messaging-imap-driver.module';
+import { MessagingSmtpDriverModule } from 'src/modules/messaging/message-import-manager/drivers/smtp/messaging-smtp-driver.module';
+import { GmailMessageOutboundService } from 'src/modules/messaging/message-outbound-manager/drivers/gmail/services/gmail-message-outbound.service';
+import { ImapSmtpMessageOutboundService } from 'src/modules/messaging/message-outbound-manager/drivers/imap/services/imap-smtp-message-outbound.service';
+import { MicrosoftMessageOutboundService } from 'src/modules/messaging/message-outbound-manager/drivers/microsoft/services/microsoft-message-outbound.service';
+import { MessagingMessageOutboundService } from 'src/modules/messaging/message-outbound-manager/services/messaging-message-outbound.service';
+
+@Module({
+  imports: [
+    OAuth2ClientManagerModule,
+    MessagingIMAPDriverModule,
+    MessagingSmtpDriverModule,
+  ],
+  providers: [
+    GmailMessageOutboundService,
+    MicrosoftMessageOutboundService,
+    ImapSmtpMessageOutboundService,
+    MessagingMessageOutboundService,
+  ],
+  exports: [MessagingMessageOutboundService],
+})
+export class MessagingSendManagerModule {}
@@ -0,0 +1,75 @@
+import { Injectable } from '@nestjs/common';
+
+import { ConnectedAccountProvider } from 'twenty-shared/types';
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+import { GmailMessageOutboundService } from 'src/modules/messaging/message-outbound-manager/drivers/gmail/services/gmail-message-outbound.service';
+import { ImapSmtpMessageOutboundService } from 'src/modules/messaging/message-outbound-manager/drivers/imap/services/imap-smtp-message-outbound.service';
+import { MicrosoftMessageOutboundService } from 'src/modules/messaging/message-outbound-manager/drivers/microsoft/services/microsoft-message-outbound.service';
+import { SendMessageInput } from 'src/modules/messaging/message-outbound-manager/types/send-message-input.type';
+
+@Injectable()
+export class MessagingMessageOutboundService {
+  constructor(
+    private readonly gmailMessageOutboundService: GmailMessageOutboundService,
+    private readonly microsoftMessageOutboundService: MicrosoftMessageOutboundService,
+    private readonly imapSmtpMessageOutboundService: ImapSmtpMessageOutboundService,
+  ) {}
+
+  public async sendMessage(
+    sendMessageInput: SendMessageInput,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ): Promise<void> {
+    switch (connectedAccount.provider) {
+      case ConnectedAccountProvider.GOOGLE:
+        return this.gmailMessageOutboundService.sendMessage(
+          sendMessageInput,
+          connectedAccount,
+        );
+      case ConnectedAccountProvider.MICROSOFT:
+        return this.microsoftMessageOutboundService.sendMessage(
+          sendMessageInput,
+          connectedAccount,
+        );
+      case ConnectedAccountProvider.IMAP_SMTP_CALDAV:
+        return this.imapSmtpMessageOutboundService.sendMessage(
+          sendMessageInput,
+          connectedAccount,
+        );
+      default:
+        assertUnreachable(
+          connectedAccount.provider,
+          `Provider ${connectedAccount.provider} not supported for sending messages`,
+        );
+    }
+  }
+
+  public async createDraft(
+    sendMessageInput: SendMessageInput,
+    connectedAccount: ConnectedAccountWorkspaceEntity,
+  ): Promise<void> {
+    switch (connectedAccount.provider) {
+      case ConnectedAccountProvider.GOOGLE:
+        return this.gmailMessageOutboundService.createDraft(
+          sendMessageInput,
+          connectedAccount,
+        );
+      case ConnectedAccountProvider.MICROSOFT:
+        return this.microsoftMessageOutboundService.createDraft(
+          sendMessageInput,
+          connectedAccount,
+        );
+      case ConnectedAccountProvider.IMAP_SMTP_CALDAV:
+        return this.imapSmtpMessageOutboundService.createDraft(
+          sendMessageInput,
+          connectedAccount,
+        );
+      default:
+        assertUnreachable(
+          connectedAccount.provider,
+          `Provider ${connectedAccount.provider} not supported for creating drafts`,
+        );
+    }
+  }
+}
@@ -0,0 +1,15 @@
+type EmailAddress = string | string[];
+
+export type SendMessageInput = {
+  body: string;
+  subject: string;
+  to: EmailAddress;
+  cc?: EmailAddress;
+  bcc?: EmailAddress;
+  html: string;
+  attachments?: {
+    filename: string;
+    content: Buffer;
+    contentType: string;
+  }[];
+};
@@ -0,0 +1,25 @@
+import { type SendMessageInput } from 'src/modules/messaging/message-outbound-manager/types/send-message-input.type';
+
+export const toMailComposerOptions = (
+  from: string,
+  sendMessageInput: SendMessageInput,
+) => {
+  return {
+    from,
+    to: sendMessageInput.to,
+    cc: sendMessageInput.cc,
+    bcc: sendMessageInput.bcc,
+    subject: sendMessageInput.subject,
+    text: sendMessageInput.body,
+    html: sendMessageInput.html,
+    ...(sendMessageInput.attachments && sendMessageInput.attachments.length > 0
+      ? {
+          attachments: sendMessageInput.attachments.map((attachment) => ({
+            filename: attachment.filename,
+            content: attachment.content,
+            contentType: attachment.contentType,
+          })),
+        }
+      : {}),
+  };
+};