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

packages/twenty-server/test/integration/workflow-actions/caller-connected-account.integration-spec.ts

@@ -0,0 +1,268 @@
+import { randomUUID } from 'node:crypto';
+
+import { ConnectedAccountProvider } from 'twenty-shared/types';
+import { IsNull } from 'typeorm';
+
+import { setupGoogleMock } from 'test/integration/google/mocks/setup-google-mock.util';
+import { runWebhookTriggeredActionStep } from 'test/integration/graphql/suites/workflow/utils/run-webhook-triggered-action-step.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 { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+
+import {
+  ConnectedAccountEntity,
+  type ConnectedAccountVisibility,
+} from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+import { USER_WORKSPACE_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/core/utils/seed-user-workspaces.util';
+
+const OLDEST_HANDLE = 'workspace-oldest-account@apple.dev';
+const CALLER_HANDLE = 'run-caller-account@apple.dev';
+const RECIPIENT = 'sender-fallback-recipient@example.com';
+
+const CALLER_USER_WORKSPACE_ID = USER_WORKSPACE_DATA_SEED_IDS.JANE;
+const OTHER_MEMBER_USER_WORKSPACE_ID = USER_WORKSPACE_DATA_SEED_IDS.JONY;
+const THIRD_MEMBER_USER_WORKSPACE_ID = USER_WORKSPACE_DATA_SEED_IDS.PHIL;
+
+describe('Email workflow actions with no sender configured (integration)', () => {
+  const google = setupGoogleMock({ handle: OLDEST_HANDLE });
+
+  const connectedAccounts = () =>
+    getCoreRepository<ConnectedAccountEntity>(ConnectedAccountEntity);
+
+  const setAccountOwnership = async ({
+    connectedAccountId,
+    userWorkspaceId,
+    visibility,
+  }: {
+    connectedAccountId: string;
+    userWorkspaceId: string;
+    visibility: ConnectedAccountVisibility;
+  }) =>
+    connectedAccounts().update(
+      { id: connectedAccountId },
+      { userWorkspaceId, visibility },
+    );
+
+  let oldestAccount: Awaited<ReturnType<typeof connectMessagingAccount>>;
+  let callerAccount: Awaited<ReturnType<typeof connectMessagingAccount>>;
+  let preexistingAccountIds: string[] = [];
+
+  beforeAll(async () => {
+    const preexistingAccounts = await connectedAccounts().find({
+      where: { workspaceId: SEED_APPLE_WORKSPACE_ID, archivedAt: IsNull() },
+      select: { id: true },
+    });
+
+    preexistingAccountIds = preexistingAccounts.map(({ id }) => id);
+
+    if (preexistingAccountIds.length > 0) {
+      await connectedAccounts().update(preexistingAccountIds, {
+        archivedAt: new Date(),
+      });
+    }
+
+    oldestAccount = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.GOOGLE,
+      handle: OLDEST_HANDLE,
+    });
+
+    google.actAsAccount(CALLER_HANDLE);
+
+    callerAccount = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.GOOGLE,
+      handle: CALLER_HANDLE,
+    });
+  }, 120000);
+
+  beforeEach(async () => {
+    await setAccountOwnership({
+      connectedAccountId: oldestAccount.connectedAccountId,
+      userWorkspaceId: OTHER_MEMBER_USER_WORKSPACE_ID,
+      visibility: 'user',
+    });
+    await setAccountOwnership({
+      connectedAccountId: callerAccount.connectedAccountId,
+      userWorkspaceId: CALLER_USER_WORKSPACE_ID,
+      visibility: 'user',
+    });
+  });
+
+  afterAll(async () => {
+    await setAccountOwnership({
+      connectedAccountId: oldestAccount.connectedAccountId,
+      userWorkspaceId: CALLER_USER_WORKSPACE_ID,
+      visibility: 'user',
+    }).catch(() => undefined);
+
+    await callerAccount?.cleanup().catch(() => undefined);
+    await oldestAccount?.cleanup().catch(() => undefined);
+
+    if (preexistingAccountIds.length > 0) {
+      await connectedAccounts().update(preexistingAccountIds, {
+        archivedAt: null,
+      });
+    }
+  });
+
+  it('sends from the run caller own account rather than the oldest account of the workspace', async () => {
+    const subject = `Caller scoped send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Caller scoped send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: '',
+        recipients: { to: RECIPIENT, cc: '', bcc: '' },
+        subject,
+        body: '<p>Caller scoped send body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      subject,
+      connectedAccountId: callerAccount.connectedAccountId,
+    });
+  }, 60000);
+
+  it('drafts from the run caller own account rather than the oldest account of the workspace', async () => {
+    const subject = `Caller scoped draft ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Caller scoped draft email workflow',
+      stepType: 'DRAFT_EMAIL',
+      input: {
+        connectedAccountId: '',
+        recipients: { to: RECIPIENT, cc: '', bcc: '' },
+        subject,
+        body: '<p>Caller scoped draft body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      subject,
+      connectedAccountId: callerAccount.connectedAccountId,
+    });
+  }, 60000);
+
+  it('keeps the account pinned on the step even when another member owns it', async () => {
+    const subject = `Pinned sender send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Pinned sender send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: oldestAccount.connectedAccountId,
+        recipients: { to: RECIPIENT, cc: '', bcc: '' },
+        subject,
+        body: '<p>Pinned sender send body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      subject,
+      connectedAccountId: oldestAccount.connectedAccountId,
+    });
+  }, 60000);
+
+  it('falls back to a workspace visible account when the run caller owns none', async () => {
+    await setAccountOwnership({
+      connectedAccountId: callerAccount.connectedAccountId,
+      userWorkspaceId: THIRD_MEMBER_USER_WORKSPACE_ID,
+      visibility: 'user',
+    });
+    await setAccountOwnership({
+      connectedAccountId: oldestAccount.connectedAccountId,
+      userWorkspaceId: OTHER_MEMBER_USER_WORKSPACE_ID,
+      visibility: 'workspace',
+    });
+
+    const subject = `Workspace visible fallback ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Workspace visible fallback send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: '',
+        recipients: { to: RECIPIENT, cc: '', bcc: '' },
+        subject,
+        body: '<p>Workspace visible fallback body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      subject,
+      connectedAccountId: oldestAccount.connectedAccountId,
+    });
+  }, 60000);
+
+  it('fails the step rather than sending from a private account of another member', async () => {
+    await setAccountOwnership({
+      connectedAccountId: callerAccount.connectedAccountId,
+      userWorkspaceId: THIRD_MEMBER_USER_WORKSPACE_ID,
+      visibility: 'user',
+    });
+
+    const sentMessageCount = google.sentMessages.length;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'No usable account send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: '',
+        recipients: { to: RECIPIENT, cc: '', bcc: '' },
+        subject: `No usable account ${randomUUID()}`,
+        body: '<p>No usable account body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'FAILED',
+      stepStatus: 'FAILED',
+      stepError: expect.stringContaining(
+        `No connected account available for user workspace '${CALLER_USER_WORKSPACE_ID}'`,
+      ),
+    });
+    expect(google.sentMessages).toHaveLength(sentMessageCount);
+  }, 60000);
+
+  it('keeps the workspace wide fallback for runs that no user started', async () => {
+    const subject = `Webhook triggered send ${randomUUID()}`;
+
+    const workflowRun = await runWebhookTriggeredActionStep({
+      name: 'Webhook triggered send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: '',
+        recipients: { to: RECIPIENT, cc: '', bcc: '' },
+        subject,
+        body: '<p>Webhook triggered send body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      subject,
+      connectedAccountId: oldestAccount.connectedAccountId,
+    });
+  }, 60000);
+});

packages/twenty-server/test/integration/workflow-actions/create-calendar-event/drivers/caldav.integration-spec.ts

@@ -0,0 +1,132 @@
+import { randomUUID } from 'node:crypto';
+
+import { isNonEmptyString } from '@sniptt/guards';
+
+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 { findImportedCalendarEventTitles } from 'test/integration/utils/find-imported-records.util';
+import {
+  type RadicaleServer,
+  startRadicaleContainer,
+} from 'test/integration/utils/start-radicale-container.util';
+
+const HANDLE = `caldav-create-event-action-${randomUUID()}@acme.test`;
+const COLLECTION = 'personal';
+const PASSWORD = 'radicale-password';
+const ATTENDEE = 'attendee@example.com';
+
+const authorizationHeader = `Basic ${Buffer.from(`${HANDLE}:${PASSWORD}`).toString('base64')}`;
+
+describe('CREATE_CALENDAR_EVENT workflow action on CalDAV (integration)', () => {
+  let radicale: RadicaleServer;
+  let connectedAccountId: string;
+
+  const collectionUrl = () =>
+    `http://${radicale.host}:${radicale.port}/${HANDLE}/${COLLECTION}/`;
+
+  beforeAll(async () => {
+    // The CalDAV driver wraps its fetch in the SSRF guard, which rejects the
+    // container's private address before the request is made.
+    await updateConfigVariable({
+      input: { key: 'OUTBOUND_HTTP_ALLOWED_INTERNAL_HOSTS', value: ['*'] },
+    });
+
+    radicale = await startRadicaleContainer({
+      username: HANDLE,
+      password: PASSWORD,
+    });
+
+    await fetch(collectionUrl(), {
+      method: 'MKCOL',
+      headers: {
+        'Content-Type': 'application/xml; charset=utf-8',
+        Authorization: authorizationHeader,
+      },
+      body: `<?xml version="1.0" encoding="utf-8"?>
+        <mkcol xmlns="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav">
+          <set><prop>
+            <resourcetype><collection/><c:calendar/></resourcetype>
+            <displayname>Personal</displayname>
+            <c:supported-calendar-component-set><c:comp name="VEVENT"/></c:supported-calendar-component-set>
+          </prop></set>
+        </mkcol>`,
+    });
+
+    const { data } = await saveImapSmtpCaldavAccount({
+      input: {
+        handle: HANDLE,
+        connectionParameters: {
+          CALDAV: {
+            host: `http://${radicale.host}:${radicale.port}`,
+            port: radicale.port,
+            username: HANDLE,
+            password: PASSWORD,
+          },
+        },
+      },
+      expectToFail: false,
+    });
+
+    connectedAccountId = data.connectedAccountId;
+  }, 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 radicale?.stop().catch(() => undefined);
+  });
+
+  it('creates an event in the CalDAV collection with a title resolved from the trigger payload', async () => {
+    const title = `CalDAV workflow calendar ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'CalDAV create calendar event workflow',
+      stepType: 'CREATE_CALENDAR_EVENT',
+      input: {
+        connectedAccountId,
+        title: '{{trigger.title}}',
+        description: 'Planning meeting',
+        location: 'Room 101',
+        startsAt: '2026-08-13T09:00:00Z',
+        endsAt: '2026-08-13T10:00:00Z',
+        isFullDay: false,
+        timeZone: 'UTC',
+        attendees: ATTENDEE,
+        sendInvitations: true,
+        addConferencing: false,
+      },
+      payload: { title },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      title,
+      iCalUid: expect.any(String),
+      attendeeCount: 1,
+      connectedAccountId,
+    });
+    expect(await findImportedCalendarEventTitles([title])).toEqual([title]);
+
+    const response = await fetch(
+      `${collectionUrl()}${workflowRun.stepResult?.iCalUid}.ics`,
+      { headers: { Authorization: authorizationHeader } },
+    );
+
+    expect(response.status).toBe(200);
+    expect(await response.text()).toContain(`SUMMARY:${title}`);
+  }, 300000);
+});

packages/twenty-server/test/integration/workflow-actions/create-calendar-event/drivers/google-calendar.integration-spec.ts

@@ -0,0 +1,74 @@
+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 { findImportedCalendarEventTitles } from 'test/integration/utils/find-imported-records.util';
+
+const HANDLE = 'google-calendar-create-event-action@apple.dev';
+const ATTENDEE = 'to-recipient@example.com';
+
+describe('CREATE_CALENDAR_EVENT workflow action on Google Calendar (integration)', () => {
+  const google = setupGoogleMock({ handle: HANDLE });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.GOOGLE,
+      handle: HANDLE,
+    });
+  }, 60000);
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('creates an event with a title resolved from the trigger payload', async () => {
+    const title = `Gmail workflow calendar ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Gmail create calendar event workflow',
+      stepType: 'CREATE_CALENDAR_EVENT',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        title: '{{trigger.title}}',
+        description: 'Planning meeting',
+        location: 'Room 101',
+        startsAt: '2026-08-13T09:00:00Z',
+        endsAt: '2026-08-13T10:00:00Z',
+        isFullDay: false,
+        timeZone: 'UTC',
+        attendees: ATTENDEE,
+        sendInvitations: true,
+        addConferencing: true,
+      },
+      payload: { title },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      title,
+      iCalUid: expect.stringContaining('@google.com'),
+      attendeeCount: 1,
+      connectedAccountId: channel.connectedAccountId,
+    });
+    expect(google.createdCalendarEvents).toEqual([
+      expect.objectContaining({
+        summary: title,
+        description: 'Planning meeting',
+        location: 'Room 101',
+        attendees: [expect.objectContaining({ email: ATTENDEE })],
+        conferenceData: expect.objectContaining({
+          createRequest: expect.any(Object),
+        }),
+      }),
+    ]);
+    expect(await findImportedCalendarEventTitles([title])).toEqual([title]);
+  }, 60000);
+});

packages/twenty-server/test/integration/workflow-actions/create-calendar-event/drivers/microsoft-calendar.integration-spec.ts

@@ -0,0 +1,72 @@
+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 { setupMicrosoftMock } from 'test/integration/microsoft/mocks/setup-microsoft-mock.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { findImportedCalendarEventTitles } from 'test/integration/utils/find-imported-records.util';
+
+const HANDLE = 'microsoft-calendar-create-event-action@apple.dev';
+const ATTENDEE = 'to-recipient@example.com';
+
+describe('CREATE_CALENDAR_EVENT workflow action on Microsoft Calendar (integration)', () => {
+  const microsoft = setupMicrosoftMock({ handle: HANDLE });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.MICROSOFT,
+      handle: HANDLE,
+    });
+  }, 60000);
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('creates an event with a title resolved from the trigger payload', async () => {
+    const title = `Microsoft workflow calendar ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft create calendar event workflow',
+      stepType: 'CREATE_CALENDAR_EVENT',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        title: '{{trigger.title}}',
+        description: 'Planning meeting',
+        location: 'Room 101',
+        startsAt: '2026-08-13T09:00:00Z',
+        endsAt: '2026-08-13T10:00:00Z',
+        isFullDay: false,
+        timeZone: 'UTC',
+        attendees: ATTENDEE,
+        sendInvitations: true,
+        addConferencing: true,
+      },
+      payload: { title },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      title,
+      iCalUid: expect.stringContaining('@microsoft.com'),
+      attendeeCount: 1,
+      connectedAccountId: channel.connectedAccountId,
+    });
+    expect(microsoft.createdCalendarEvents).toEqual([
+      expect.objectContaining({
+        subject: title,
+        location: { displayName: 'Room 101' },
+        attendees: [{ emailAddress: { address: ATTENDEE }, type: 'required' }],
+        isOnlineMeeting: true,
+        onlineMeetingProvider: 'teamsForBusiness',
+      }),
+    ]);
+    expect(await findImportedCalendarEventTitles([title])).toEqual([title]);
+  }, 60000);
+});

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);
+});

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

@@ -0,0 +1,167 @@
+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-send-email-action@apple.dev';
+const ALIAS = 'gmail-send-email-action-alias@apple.dev';
+const RECIPIENTS = {
+  to: 'to-recipient@example.com',
+  cc: 'cc-recipient@example.com',
+  bcc: 'bcc-recipient@example.com',
+};
+
+describe('SEND_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('sends an email with recipients resolved from the trigger payload', async () => {
+    const subject = `Gmail workflow send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Gmail send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        recipients: {
+          to: '{{trigger.to}}',
+          cc: '{{trigger.cc}}',
+          bcc: '{{trigger.bcc}}',
+        },
+        subject: '{{trigger.subject}}',
+        body: '<p>Gmail workflow 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,
+      messageId: expect.any(String),
+      messageThreadId: expect.any(String),
+    });
+    expect(google.sentMessages).toHaveLength(1);
+
+    const [{ raw }] = google.sentMessages;
+
+    expect(raw).toContain(`To: ${RECIPIENTS.to}`);
+    expect(raw).toContain(`Cc: ${RECIPIENTS.cc}`);
+    expect(raw).toContain(`Bcc: ${RECIPIENTS.bcc}`);
+    expect(raw).toContain(`Subject: ${subject}`);
+
+    const [message] = await findRecordNodesByFilter<{
+      id: string;
+      isDraft: boolean;
+      text: string | null;
+    }>('message', 'messages', 'id isDraft text', {
+      subject: { eq: subject },
+    });
+
+    expect(message).toMatchObject({
+      isDraft: false,
+      text: 'Gmail workflow body',
+    });
+    expect(
+      await findRecordNodesByFilter<{ messageChannelId: string }>(
+        'messageChannelMessageAssociation',
+        'messageChannelMessageAssociations',
+        'messageChannelId',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual([
+      expect.objectContaining({ messageChannelId: channel.channelId }),
+    ]);
+    expect(
+      await findRecordNodesByFilter<{ handle: string; role: string }>(
+        'messageParticipant',
+        'messageParticipants',
+        'handle role',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ handle: RECIPIENTS.to, role: 'TO' }),
+        expect.objectContaining({ handle: RECIPIENTS.cc, role: 'CC' }),
+        expect.objectContaining({ handle: RECIPIENTS.bcc, role: 'BCC' }),
+      ]),
+    );
+  }, 60000);
+
+  it('sends from a verified alias configured on the step', async () => {
+    const subject = `Gmail workflow alias send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Gmail alias send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        fromHandle: ALIAS,
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject,
+        body: '<p>Gmail workflow alias body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+
+    const [{ raw }] = google.sentMessages.slice(-1);
+
+    expect(raw).toContain(`<${ALIAS}>`);
+  }, 60000);
+
+  it('fails the step when the from handle is not a verified alias', async () => {
+    const sentMessageCount = google.sentMessages.length;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Gmail rejected sender send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        fromHandle: 'not-my-alias@apple.dev',
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject: `Gmail workflow rejected sender ${randomUUID()}`,
+        body: '<p>Gmail workflow rejected body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'FAILED',
+      stepStatus: 'FAILED',
+      stepError: expect.stringContaining(
+        'is not the connected account handle nor one of its verified aliases',
+      ),
+    });
+    expect(google.sentMessages).toHaveLength(sentMessageCount);
+  }, 60000);
+});

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

@@ -0,0 +1,186 @@
+import { randomUUID } from 'node:crypto';
+
+import { isNonEmptyString } from '@sniptt/guards';
+
+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 = `smtp-send-email-action-${randomUUID()}@acme.test`;
+
+describe('SEND_EMAIL workflow action on SMTP (integration)', () => {
+  let greenmail: GreenmailServer;
+  let connectedAccountId: string;
+  let messageChannelId: string;
+
+  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('sends an email over SMTP and persists it', async () => {
+    const subject = `IMAP/SMTP workflow send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'IMAP/SMTP send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId,
+        recipients: {
+          to: '{{trigger.to}}',
+          cc: '{{trigger.cc}}',
+          bcc: '{{trigger.bcc}}',
+        },
+        subject: '{{trigger.subject}}',
+        body: '<p>SMTP workflow body</p>',
+      },
+      payload: { to: HANDLE, cc: HANDLE, bcc: HANDLE, subject },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      recipients: [HANDLE],
+      ccRecipients: [HANDLE],
+      bccRecipients: [HANDLE],
+      subject,
+      connectedAccountId,
+      messageId: expect.any(String),
+      messageThreadId: expect.any(String),
+    });
+
+    const [message] = await findRecordNodesByFilter<{
+      id: string;
+      isDraft: boolean;
+      text: string | null;
+    }>('message', 'messages', 'id isDraft text', {
+      subject: { eq: subject },
+    });
+
+    expect(message).toMatchObject({
+      isDraft: false,
+      text: 'SMTP workflow body',
+    });
+    expect(
+      await findRecordNodesByFilter<{ messageChannelId: string }>(
+        'messageChannelMessageAssociation',
+        'messageChannelMessageAssociations',
+        'messageChannelId',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual([expect.objectContaining({ messageChannelId })]);
+    expect(
+      await findRecordNodesByFilter<{ handle: string; role: string }>(
+        'messageParticipant',
+        'messageParticipants',
+        'handle role',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ handle: HANDLE, role: 'TO' }),
+        expect.objectContaining({ handle: HANDLE, role: 'CC' }),
+        expect.objectContaining({ handle: HANDLE, role: 'BCC' }),
+      ]),
+    );
+  }, 300000);
+
+  it('fails the step when the from handle is not a verified alias', async () => {
+    const subject = `IMAP/SMTP workflow rejected sender ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'IMAP/SMTP rejected sender send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId,
+        fromHandle: 'not-my-alias@acme.test',
+        recipients: { to: HANDLE, cc: '', bcc: '' },
+        subject,
+        body: '<p>SMTP workflow rejected body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'FAILED',
+      stepStatus: 'FAILED',
+      stepError: expect.stringContaining(
+        'is not the connected account handle nor one of its verified aliases',
+      ),
+    });
+    expect(
+      await findRecordNodesByFilter<{ id: string }>(
+        'message',
+        'messages',
+        'id',
+        { subject: { eq: subject } },
+      ),
+    ).toEqual([]);
+  }, 300000);
+});

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

@@ -0,0 +1,176 @@
+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 { 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-send-email-action@apple.dev';
+const ALIAS = 'microsoft-send-email-action-alias@apple.dev';
+const RECIPIENTS = {
+  to: 'to-recipient@example.com',
+  cc: 'cc-recipient@example.com',
+  bcc: 'bcc-recipient@example.com',
+};
+
+describe('SEND_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('sends an email with recipients resolved from the trigger payload', async () => {
+    const subject = `Microsoft workflow send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        recipients: {
+          to: '{{trigger.to}}',
+          cc: '{{trigger.cc}}',
+          bcc: '{{trigger.bcc}}',
+        },
+        subject: '{{trigger.subject}}',
+        body: '<p>Microsoft workflow 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,
+      messageId: expect.any(String),
+      messageThreadId: expect.any(String),
+    });
+    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(['microsoft-message-1']);
+
+    const [message] = await findRecordNodesByFilter<{
+      id: string;
+      isDraft: boolean;
+      text: string | null;
+    }>('message', 'messages', 'id isDraft text', {
+      subject: { eq: subject },
+    });
+
+    expect(message).toMatchObject({
+      isDraft: false,
+      text: 'Microsoft workflow body',
+    });
+    expect(
+      await findRecordNodesByFilter<{
+        messageChannelId: string;
+        messageExternalId: string;
+      }>(
+        'messageChannelMessageAssociation',
+        'messageChannelMessageAssociations',
+        'messageChannelId messageExternalId',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual([
+      expect.objectContaining({
+        messageChannelId: channel.channelId,
+        messageExternalId: 'microsoft-message-1',
+      }),
+    ]);
+    expect(
+      await findRecordNodesByFilter<{ handle: string; role: string }>(
+        'messageParticipant',
+        'messageParticipants',
+        'handle role',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ handle: RECIPIENTS.to, role: 'TO' }),
+        expect.objectContaining({ handle: RECIPIENTS.cc, role: 'CC' }),
+        expect.objectContaining({ handle: RECIPIENTS.bcc, role: 'BCC' }),
+      ]),
+    );
+  }, 60000);
+
+  it('sends from a verified alias configured on the step', async () => {
+    const subject = `Microsoft workflow alias send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft alias send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        fromHandle: ALIAS,
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject,
+        body: '<p>Microsoft workflow alias body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    const [lastCreatedMessage] = microsoft.createdMessages.slice(-1);
+
+    expect(lastCreatedMessage).toMatchObject({
+      subject,
+      from: { emailAddress: { address: ALIAS } },
+    });
+  }, 60000);
+
+  it('fails the step when the from handle is not a verified alias', async () => {
+    const createdMessageCount = microsoft.createdMessages.length;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft rejected sender send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        fromHandle: 'not-my-alias@apple.dev',
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject: `Microsoft workflow rejected sender ${randomUUID()}`,
+        body: '<p>Microsoft workflow rejected body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'FAILED',
+      stepStatus: 'FAILED',
+      stepError: expect.stringContaining(
+        'is not the connected account handle nor one of its verified aliases',
+      ),
+    });
+    expect(microsoft.createdMessages).toHaveLength(createdMessageCount);
+  }, 60000);
+});