snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-server/test/integration/workflow-actions/draft-email/drivers/gmail.integration-spec.ts

@@ -0,0 +1,115 @@
+import { randomUUID } from 'node:crypto';
+
+import { ConnectedAccountProvider } from 'twenty-shared/types';
+
+import { setupGoogleMock } from 'test/integration/google/mocks/setup-google-mock.util';
+import { runWorkflowActionStep } from 'test/integration/graphql/suites/workflow/utils/run-workflow-action-step.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { findRecordNodesByFilter } from 'test/integration/utils/find-records-by-filter.util';
+import { setTestConnectedAccountHandleAliases } from 'test/integration/utils/set-test-connected-account-handle-aliases.util';
+
+const HANDLE = 'gmail-draft-email-action@apple.dev';
+const ALIAS = 'gmail-draft-email-action-alias@apple.dev';
+const RECIPIENTS = {
+  to: 'to-recipient@example.com',
+  cc: 'cc-recipient@example.com',
+  bcc: 'bcc-recipient@example.com',
+};
+
+describe('DRAFT_EMAIL workflow action on Gmail (integration)', () => {
+  const google = setupGoogleMock({ handle: HANDLE });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.GOOGLE,
+      handle: HANDLE,
+    });
+    await setTestConnectedAccountHandleAliases({
+      connectedAccountId: channel.connectedAccountId,
+      handleAliases: [ALIAS],
+    });
+  }, 60000);
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('creates a draft without sending or persisting it', async () => {
+    const subject = `Gmail workflow draft ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Gmail draft email workflow',
+      stepType: 'DRAFT_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        recipients: {
+          to: '{{trigger.to}}',
+          cc: '{{trigger.cc}}',
+          bcc: '{{trigger.bcc}}',
+        },
+        subject: '{{trigger.subject}}',
+        body: '<p>Gmail workflow draft body</p>',
+      },
+      payload: { ...RECIPIENTS, subject },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      recipients: [RECIPIENTS.to],
+      ccRecipients: [RECIPIENTS.cc],
+      bccRecipients: [RECIPIENTS.bcc],
+      subject,
+      connectedAccountId: channel.connectedAccountId,
+    });
+    expect(google.draftMessages).toHaveLength(1);
+
+    const [{ raw }] = google.draftMessages;
+
+    expect(raw).toContain(`To: ${RECIPIENTS.to}`);
+    expect(raw).toContain(`Cc: ${RECIPIENTS.cc}`);
+    expect(raw).toContain(`Bcc: ${RECIPIENTS.bcc}`);
+    expect(raw).toContain(`Subject: ${subject}`);
+    expect(google.sentMessages).toEqual([]);
+    expect(
+      await findRecordNodesByFilter<{ id: string }>(
+        'message',
+        'messages',
+        'id',
+        {
+          subject: { eq: subject },
+        },
+      ),
+    ).toEqual([]);
+  }, 60000);
+
+  it('drafts from a verified alias configured on the step', async () => {
+    const subject = `Gmail workflow alias draft ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Gmail alias draft email workflow',
+      stepType: 'DRAFT_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        fromHandle: ALIAS,
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject,
+        body: '<p>Gmail workflow alias draft body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+
+    const [{ raw }] = google.draftMessages.slice(-1);
+
+    expect(raw).toContain(`<${ALIAS}>`);
+    expect(google.sentMessages).toEqual([]);
+  }, 60000);
+});

packages/twenty-server/test/integration/workflow-actions/draft-email/drivers/imap-smtp.integration-spec.ts

@@ -0,0 +1,193 @@
+import { randomUUID } from 'node:crypto';
+
+import { isNonEmptyString } from '@sniptt/guards';
+import { ImapFlow } from 'imapflow';
+
+import { EmailConnectionSecurity } from 'src/engine/core-modules/imap-smtp-caldav-connection/enums/email-connection-security.enum';
+import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+
+import { runWorkflowActionStep } from 'test/integration/graphql/suites/workflow/utils/run-workflow-action-step.util';
+import { deleteConnectedAccount } from 'test/integration/metadata/suites/connected-account/utils/delete-connected-account.util';
+import { saveImapSmtpCaldavAccount } from 'test/integration/metadata/suites/connected-account/utils/save-imap-smtp-caldav-account.util';
+import { updateConfigVariable } from 'test/integration/twenty-config/utils/update-config-variable.util';
+import { findRecordNodesByFilter } from 'test/integration/utils/find-records-by-filter.util';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import { runMessageChannelSync } from 'test/integration/utils/run-message-channel-sync.util';
+import {
+  type GreenmailServer,
+  startGreenmailContainer,
+} from 'test/integration/utils/start-greenmail-container.util';
+
+const PASSWORD = 'greenmail-password';
+const HANDLE = `imap-draft-email-action-${randomUUID()}@acme.test`;
+
+describe('DRAFT_EMAIL workflow action on IMAP (integration)', () => {
+  let greenmail: GreenmailServer;
+  let connectedAccountId: string;
+  let messageChannelId: string;
+
+  const findDrafts = async (): Promise<
+    { subject: string; source: string }[]
+  > => {
+    const client = new ImapFlow({
+      host: greenmail.host,
+      port: greenmail.imapPort,
+      secure: false,
+      auth: { user: HANDLE.split('@')[0], pass: PASSWORD },
+      logger: false,
+    });
+
+    await client.connect();
+
+    try {
+      const { exists } = await client.mailboxOpen('Drafts');
+
+      if (exists === 0) {
+        return [];
+      }
+
+      const drafts: { subject: string; source: string }[] = [];
+
+      for await (const message of client.fetch('1:*', {
+        envelope: true,
+        source: true,
+      })) {
+        const subject = message.envelope?.subject;
+
+        if (isNonEmptyString(subject)) {
+          drafts.push({
+            subject,
+            source: message.source?.toString('latin1') ?? '',
+          });
+        }
+      }
+
+      return drafts;
+    } finally {
+      await client.logout();
+    }
+  };
+
+  beforeAll(async () => {
+    await updateConfigVariable({
+      input: { key: 'OUTBOUND_HTTP_ALLOWED_INTERNAL_HOSTS', value: ['*'] },
+    });
+
+    greenmail = await startGreenmailContainer({
+      username: HANDLE,
+      password: PASSWORD,
+    });
+
+    const { data } = await saveImapSmtpCaldavAccount({
+      input: {
+        handle: HANDLE,
+        connectionParameters: {
+          IMAP: {
+            host: greenmail.host,
+            port: greenmail.imapPort,
+            username: HANDLE.split('@')[0],
+            password: PASSWORD,
+            connectionSecurity: EmailConnectionSecurity.NONE,
+          },
+          SMTP: {
+            host: greenmail.host,
+            port: greenmail.smtpPort,
+            username: HANDLE.split('@')[0],
+            password: PASSWORD,
+            connectionSecurity: EmailConnectionSecurity.NONE,
+          },
+        },
+      },
+      expectToFail: false,
+    });
+
+    connectedAccountId = data.connectedAccountId;
+    messageChannelId = (
+      await getCoreRepository<MessageChannelEntity>(
+        MessageChannelEntity,
+      ).findOneByOrFail({ connectedAccountId })
+    ).id;
+
+    await runMessageChannelSync(messageChannelId);
+  }, 300000);
+
+  afterAll(async () => {
+    await updateConfigVariable({
+      input: { key: 'OUTBOUND_HTTP_ALLOWED_INTERNAL_HOSTS', value: [] },
+    }).catch(() => undefined);
+
+    if (isNonEmptyString(connectedAccountId)) {
+      await deleteConnectedAccount({
+        id: connectedAccountId,
+        expectToFail: false,
+      }).catch(() => undefined);
+    }
+
+    await greenmail?.stop().catch(() => undefined);
+  });
+
+  it('appends a draft to the drafts folder without persisting it', async () => {
+    const subject = `IMAP/SMTP workflow draft ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'IMAP/SMTP draft email workflow',
+      stepType: 'DRAFT_EMAIL',
+      input: {
+        connectedAccountId,
+        recipients: { to: '{{trigger.to}}' },
+        subject: '{{trigger.subject}}',
+        body: '<p>SMTP workflow draft body</p>',
+      },
+      payload: { to: HANDLE, subject },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      recipients: [HANDLE],
+      subject,
+      connectedAccountId,
+    });
+    expect(await findDrafts()).toContainEqual(
+      expect.objectContaining({ subject }),
+    );
+    expect(
+      await findRecordNodesByFilter<{ id: string }>(
+        'message',
+        'messages',
+        'id',
+        { subject: { eq: subject } },
+      ),
+    ).toEqual([]);
+  }, 300000);
+
+  it('appends a multi-paragraph draft with CRLF line endings only', async () => {
+    const subject = `IMAP/SMTP multi-paragraph draft ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'IMAP/SMTP multi-paragraph draft email workflow',
+      stepType: 'DRAFT_EMAIL',
+      input: {
+        connectedAccountId,
+        recipients: { to: '{{trigger.to}}' },
+        subject: '{{trigger.subject}}',
+        body: '<p>First paragraph</p><p>Second paragraph</p>',
+      },
+      payload: { to: HANDLE, subject },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+
+    const draft = (await findDrafts()).find(
+      (candidate) => candidate.subject === subject,
+    );
+
+    expect(draft?.source).toContain('First paragraph\r\n\r\nSecond paragraph');
+    expect(draft?.source).not.toMatch(/[^\r]\n/);
+  }, 300000);
+});

packages/twenty-server/test/integration/workflow-actions/draft-email/drivers/microsoft.integration-spec.ts

@@ -0,0 +1,208 @@
+import { randomUUID } from 'node:crypto';
+
+import { ConnectedAccountProvider } from 'twenty-shared/types';
+
+import { runWorkflowActionStep } from 'test/integration/graphql/suites/workflow/utils/run-workflow-action-step.util';
+import { uploadFileWithDirectUpload } from 'test/integration/graphql/utils/upload-file-with-direct-upload.util';
+import { setupMicrosoftMock } from 'test/integration/microsoft/mocks/setup-microsoft-mock.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { findRecordNodesByFilter } from 'test/integration/utils/find-records-by-filter.util';
+import { setTestConnectedAccountHandleAliases } from 'test/integration/utils/set-test-connected-account-handle-aliases.util';
+
+const HANDLE = 'microsoft-draft-email-action@apple.dev';
+const ALIAS = 'microsoft-draft-email-action-alias@apple.dev';
+const RECIPIENTS = {
+  to: 'to-recipient@example.com',
+  cc: 'cc-recipient@example.com',
+  bcc: 'bcc-recipient@example.com',
+};
+const ATTACHMENT_CONTENT = Buffer.from('draft attachment content');
+const PARENT_INTERNET_MESSAGE_ID = '<microsoft-parent@example.com>';
+
+const uploadAttachmentFile = async (filename: string) => {
+  const uploadedFile = await uploadFileWithDirectUpload({
+    filename,
+    content: ATTACHMENT_CONTENT,
+    fileFolder: 'Workflow',
+  });
+
+  return {
+    id: uploadedFile.id,
+    name: filename,
+    size: uploadedFile.size,
+    type: 'text/plain',
+    createdAt: uploadedFile.createdAt,
+  };
+};
+
+describe('DRAFT_EMAIL workflow action on Microsoft (integration)', () => {
+  const microsoft = setupMicrosoftMock({ handle: HANDLE });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.MICROSOFT,
+      handle: HANDLE,
+    });
+    await setTestConnectedAccountHandleAliases({
+      connectedAccountId: channel.connectedAccountId,
+      handleAliases: [ALIAS],
+    });
+  }, 60000);
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('creates a draft without sending or persisting it', async () => {
+    const subject = `Microsoft workflow draft ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft draft email workflow',
+      stepType: 'DRAFT_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        recipients: {
+          to: '{{trigger.to}}',
+          cc: '{{trigger.cc}}',
+          bcc: '{{trigger.bcc}}',
+        },
+        subject: '{{trigger.subject}}',
+        body: '<p>Microsoft workflow draft body</p>',
+      },
+      payload: { ...RECIPIENTS, subject },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      recipients: [RECIPIENTS.to],
+      ccRecipients: [RECIPIENTS.cc],
+      bccRecipients: [RECIPIENTS.bcc],
+      subject,
+      connectedAccountId: channel.connectedAccountId,
+    });
+    expect(microsoft.createdMessages).toEqual([
+      expect.objectContaining({
+        subject,
+        toRecipients: [{ emailAddress: { address: RECIPIENTS.to } }],
+        ccRecipients: [{ emailAddress: { address: RECIPIENTS.cc } }],
+        bccRecipients: [{ emailAddress: { address: RECIPIENTS.bcc } }],
+      }),
+    ]);
+    expect(microsoft.sentMessageIds).toEqual([]);
+    expect(
+      await findRecordNodesByFilter<{ id: string }>(
+        'message',
+        'messages',
+        'id',
+        {
+          subject: { eq: subject },
+        },
+      ),
+    ).toEqual([]);
+  }, 60000);
+
+  it('drafts from a verified alias configured on the step', async () => {
+    const subject = `Microsoft workflow alias draft ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft alias draft email workflow',
+      stepType: 'DRAFT_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        fromHandle: ALIAS,
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject,
+        body: '<p>Microsoft workflow alias draft body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    const [lastCreatedMessage] = microsoft.createdMessages.slice(-1);
+
+    expect(lastCreatedMessage).toMatchObject({
+      subject,
+      from: { emailAddress: { address: ALIAS } },
+    });
+    expect(microsoft.sentMessageIds).toEqual([]);
+  }, 60000);
+
+  it('attaches files to the drafted message', async () => {
+    const subject = `Microsoft workflow draft with attachment ${randomUUID()}`;
+    const file = await uploadAttachmentFile('draft-attachment.txt');
+    const attachmentsBefore = microsoft.createdAttachments.length;
+    const messagesBefore = microsoft.createdMessages.length;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft draft email with attachment workflow',
+      stepType: 'DRAFT_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject,
+        body: '<p>Microsoft workflow draft body</p>',
+        files: [file],
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+
+    expect(microsoft.createdAttachments.slice(attachmentsBefore)).toMatchObject(
+      [
+        {
+          messageId: `microsoft-message-${messagesBefore + 1}`,
+          '@odata.type': '#microsoft.graph.fileAttachment',
+          name: 'draft-attachment.txt',
+          contentBytes: ATTACHMENT_CONTENT.toString('base64'),
+        },
+      ],
+    );
+    expect(microsoft.sentMessageIds).toEqual([]);
+  }, 60000);
+
+  it('attaches files to a drafted reply', async () => {
+    const subject = `Microsoft workflow reply draft with attachment ${randomUUID()}`;
+    const file = await uploadAttachmentFile('reply-attachment.txt');
+    const attachmentsBefore = microsoft.createdAttachments.length;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft draft reply with attachment workflow',
+      stepType: 'DRAFT_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject,
+        body: '<p>Microsoft workflow reply draft body</p>',
+        files: [file],
+        inReplyTo: PARENT_INTERNET_MESSAGE_ID,
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+
+    expect(microsoft.createdAttachments.slice(attachmentsBefore)).toMatchObject(
+      [
+        {
+          messageId: 'microsoft-reply-message',
+          '@odata.type': '#microsoft.graph.fileAttachment',
+          name: 'reply-attachment.txt',
+          contentBytes: ATTACHMENT_CONTENT.toString('base64'),
+        },
+      ],
+    );
+    expect(microsoft.sentMessageIds).toEqual([]);
+  }, 60000);
+});