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

packages/twenty-server/test/integration/imap/suites/imap-folder-discovery.integration-spec.ts

@@ -0,0 +1,75 @@
+import { randomUUID } from 'node:crypto';
+
+import { isNonEmptyString } from '@sniptt/guards';
+
+import { deleteConnectedAccount } from 'test/integration/metadata/suites/connected-account/utils/delete-connected-account.util';
+import { updateConfigVariable } from 'test/integration/twenty-config/utils/update-config-variable.util';
+import { connectDovecotImapAccount } from 'test/integration/utils/connect-dovecot-imap-account.util';
+import { queryMessageFolders } from 'test/integration/utils/query-messaging.util';
+import { runMessageChannelSync } from 'test/integration/utils/run-message-channel-sync.util';
+import { type DovecotServer } from 'test/integration/utils/start-dovecot-container.util';
+
+const PASSWORD = 'dovecot-password';
+const HANDLE = `imap-folder-discovery-${randomUUID()}@acme.test`;
+
+describe('IMAP folder discovery (integration)', () => {
+  let dovecot: DovecotServer;
+  let connectedAccountId: string;
+  let messageChannelId: string;
+
+  beforeAll(async () => {
+    ({ dovecot, connectedAccountId, messageChannelId } =
+      await connectDovecotImapAccount({
+        handle: HANDLE,
+        password: PASSWORD,
+      }));
+  }, 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 dovecot?.stop().catch(() => undefined);
+  });
+
+  it('discovers the mailboxes exposed by the IMAP server', async () => {
+    await runMessageChannelSync(messageChannelId);
+
+    const folderNames = (await queryMessageFolders(messageChannelId)).map(
+      (folder) => folder.name,
+    );
+
+    expect(folderNames).toEqual(
+      expect.arrayContaining(['INBOX', 'Sent', 'Drafts']),
+    );
+  }, 300000);
+
+  it('skips the mailboxes excluded from folder management', async () => {
+    await runMessageChannelSync(messageChannelId);
+
+    const folderNames = (await queryMessageFolders(messageChannelId)).map(
+      (folder) => folder.name,
+    );
+
+    expect(folderNames).not.toContain('Trash');
+    expect(folderNames).not.toContain('Junk');
+  }, 300000);
+
+  it('marks the special-use sent folder as the sent folder', async () => {
+    await runMessageChannelSync(messageChannelId);
+
+    const folders = await queryMessageFolders(messageChannelId);
+
+    expect(
+      folders.filter((folder) => folder.isSentFolder).map(({ name }) => name),
+    ).toEqual(['Sent']);
+  }, 300000);
+});

packages/twenty-server/test/integration/imap/suites/imap-folder-import-actions.integration-spec.ts

@@ -0,0 +1,124 @@
+import { randomUUID } from 'node:crypto';
+
+import { isNonEmptyString } from '@sniptt/guards';
+import { MessageFolderPendingSyncAction } from 'twenty-shared/types';
+
+import { deleteConnectedAccount } from 'test/integration/metadata/suites/connected-account/utils/delete-connected-account.util';
+import { updateConfigVariable } from 'test/integration/twenty-config/utils/update-config-variable.util';
+import { appendMessageOverImap } from 'test/integration/utils/append-message-over-imap.util';
+import { connectDovecotImapAccount } from 'test/integration/utils/connect-dovecot-imap-account.util';
+import { findImportedMessageSubjects } from 'test/integration/utils/find-imported-records.util';
+import {
+  type MessageFolderDto,
+  queryMessageFolders,
+} from 'test/integration/utils/query-messaging.util';
+import {
+  FOLDER_ACTION_NAMES,
+  MESSAGE_COUNT_ABOVE_V8_SPREAD_ARGUMENT_LIMIT,
+  runFolderActions,
+  runFolderActionsWithoutPendingActions,
+} from 'test/integration/utils/run-folder-actions.util';
+import { runMessageChannelSync } from 'test/integration/utils/run-message-channel-sync.util';
+import { type DovecotServer } from 'test/integration/utils/start-dovecot-container.util';
+
+const PASSWORD = 'dovecot-password';
+const HANDLE = `imap-folder-actions-${randomUUID()}@acme.test`;
+const DELETED_FOLDER_NAME = 'INBOX';
+const IMPORTED_SUBJECT = `IMAP inbox message ${randomUUID()}`;
+
+describe('IMAP folder actions (integration)', () => {
+  let dovecot: DovecotServer;
+  let connectedAccountId: string;
+  let messageExternalIdsToImport: string[];
+  let messageExternalIdsWithoutPendingActions: string[];
+  let folders: MessageFolderDto[];
+  let subjectsBeforeFolderDeletion: string[];
+  let subjectsAfterFolderDeletion: string[];
+
+  beforeAll(async () => {
+    const account = await connectDovecotImapAccount({
+      handle: HANDLE,
+      password: PASSWORD,
+    });
+
+    dovecot = account.dovecot;
+    connectedAccountId = account.connectedAccountId;
+
+    await appendMessageOverImap({
+      host: dovecot.host,
+      port: dovecot.imapPort,
+      username: HANDLE,
+      password: PASSWORD,
+      folder: 'INBOX',
+      from: `sender-${randomUUID()}@external.test`,
+      to: HANDLE,
+      subject: IMPORTED_SUBJECT,
+    });
+
+    await runMessageChannelSync(account.messageChannelId);
+
+    subjectsBeforeFolderDeletion = await findImportedMessageSubjects([
+      IMPORTED_SUBJECT,
+    ]);
+
+    messageExternalIdsToImport = await runFolderActions({
+      messageChannelId: account.messageChannelId,
+      folderNameToDelete: DELETED_FOLDER_NAME,
+    });
+
+    subjectsAfterFolderDeletion = await findImportedMessageSubjects([
+      IMPORTED_SUBJECT,
+    ]);
+    folders = await queryMessageFolders(account.messageChannelId);
+
+    messageExternalIdsWithoutPendingActions =
+      await runFolderActionsWithoutPendingActions(account.messageChannelId);
+  }, 300000);
+
+  afterAll(async () => {
+    jest.restoreAllMocks();
+
+    await updateConfigVariable({
+      input: { key: 'OUTBOUND_HTTP_ALLOWED_INTERNAL_HOSTS', value: [] },
+    }).catch(() => undefined);
+
+    if (isNonEmptyString(connectedAccountId)) {
+      await deleteConnectedAccount({
+        id: connectedAccountId,
+        expectToFail: false,
+      }).catch(() => undefined);
+    }
+
+    await dovecot?.stop().catch(() => undefined);
+  });
+
+  it('imports every message id of a folder larger than the spread-argument limit, deduplicated', () => {
+    expect(messageExternalIdsToImport).toHaveLength(
+      MESSAGE_COUNT_ABOVE_V8_SPREAD_ARGUMENT_LIMIT,
+    );
+  });
+
+  it('clears the pending action it processed, keeps the one it failed on, and drops the deleted folder', () => {
+    expect(
+      Object.fromEntries(
+        folders.map((folder) => [folder.name, folder.pendingSyncAction]),
+      ),
+    ).toEqual({
+      Sent: MessageFolderPendingSyncAction.NONE,
+      Drafts: MessageFolderPendingSyncAction.NONE,
+      [FOLDER_ACTION_NAMES.imported]: MessageFolderPendingSyncAction.NONE,
+      [FOLDER_ACTION_NAMES.failing]:
+        MessageFolderPendingSyncAction.FOLDER_IMPORT,
+      [FOLDER_ACTION_NAMES.untouched]: MessageFolderPendingSyncAction.NONE,
+    });
+  });
+
+  it('deletes the messages of the folder marked for deletion', () => {
+    expect(subjectsBeforeFolderDeletion).toEqual([IMPORTED_SUBJECT]);
+    expect(subjectsAfterFolderDeletion).toEqual([]);
+  });
+
+  it('imports nothing when no folder carries a pending action', () => {
+    expect(messageExternalIdsWithoutPendingActions).toEqual([]);
+  });
+});

packages/twenty-server/test/integration/imap/suites/imap-messages-import.integration-spec.ts

@@ -0,0 +1,192 @@
+import { randomUUID } from 'node:crypto';
+
+import { isNonEmptyString } from '@sniptt/guards';
+import { MessageChannelSyncStatus } from 'twenty-shared/types';
+
+import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+import { MessageFolderEntity } from 'src/engine/metadata-modules/message-folder/entities/message-folder.entity';
+import { ImapSyncService } from 'src/modules/messaging/message-import-manager/drivers/imap/services/imap-sync.service';
+
+import { deleteConnectedAccount } from 'test/integration/metadata/suites/connected-account/utils/delete-connected-account.util';
+import { updateConfigVariable } from 'test/integration/twenty-config/utils/update-config-variable.util';
+import { appendMessageOverImap } from 'test/integration/utils/append-message-over-imap.util';
+import { connectDovecotImapAccount } from 'test/integration/utils/connect-dovecot-imap-account.util';
+import { findImportedMessageSubjects } from 'test/integration/utils/find-imported-records.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import { runMessageChannelSync } from 'test/integration/utils/run-message-channel-sync.util';
+import { type DovecotServer } from 'test/integration/utils/start-dovecot-container.util';
+
+const PASSWORD = 'dovecot-password';
+const HANDLE = `imap-messages-import-${randomUUID()}@acme.test`;
+
+describe('IMAP messages import (integration)', () => {
+  let dovecot: DovecotServer;
+  let connectedAccountId: string;
+  let messageChannelId: string;
+
+  const readChannel = () =>
+    getCoreRepository<MessageChannelEntity>(
+      MessageChannelEntity,
+    ).findOneByOrFail({ id: messageChannelId });
+
+  const deliverMessage = ({
+    subject,
+    folder = 'INBOX',
+  }: {
+    subject: string;
+    folder?: string;
+  }) =>
+    appendMessageOverImap({
+      host: dovecot.host,
+      port: dovecot.imapPort,
+      username: HANDLE,
+      password: PASSWORD,
+      folder,
+      from: `sender-${randomUUID()}@external.test`,
+      to: HANDLE,
+      subject,
+    });
+
+  beforeAll(async () => {
+    ({ dovecot, connectedAccountId, messageChannelId } =
+      await connectDovecotImapAccount({
+        handle: HANDLE,
+        password: PASSWORD,
+      }));
+  }, 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 dovecot?.stop().catch(() => undefined);
+  });
+
+  it('imports a message delivered to the mailbox', async () => {
+    const subject = `IMAP message ${randomUUID()}`;
+
+    await deliverMessage({ subject });
+
+    await runMessageChannelSync(messageChannelId);
+
+    expect(await findImportedMessageSubjects([subject])).toEqual([subject]);
+  }, 300000);
+
+  it('keeps the channel active when the mailbox has not changed', async () => {
+    await runMessageChannelSync(messageChannelId);
+
+    expect((await readChannel()).syncStatus).toBe(
+      MessageChannelSyncStatus.ACTIVE,
+    );
+  }, 300000);
+
+  it('imports a message that arrives after a sync cursor was persisted', async () => {
+    const firstSubject = `IMAP incremental first ${randomUUID()}`;
+
+    await deliverMessage({ subject: firstSubject });
+    await runMessageChannelSync(messageChannelId);
+
+    expect(await findImportedMessageSubjects([firstSubject])).toEqual([
+      firstSubject,
+    ]);
+
+    const secondSubject = `IMAP incremental second ${randomUUID()}`;
+
+    await deliverMessage({ subject: secondSubject });
+    await runMessageChannelSync(messageChannelId);
+
+    expect(await findImportedMessageSubjects([secondSubject])).toEqual([
+      secondSubject,
+    ]);
+  }, 300000);
+
+  it('records the server MODSEQ in the folder sync cursor', async () => {
+    await runMessageChannelSync(messageChannelId);
+
+    const inbox = await getCoreRepository<MessageFolderEntity>(
+      MessageFolderEntity,
+    ).findOneByOrFail({ messageChannelId, name: 'INBOX' });
+
+    expect(JSON.parse(inbox.syncCursor ?? '{}')).toEqual(
+      expect.objectContaining({
+        modSeq: expect.any(String),
+        highestUid: expect.any(Number),
+        uidValidity: expect.any(Number),
+      }),
+    );
+  }, 300000);
+
+  it('skips opening a folder whose MODSEQ and UIDNEXT have not moved', async () => {
+    await runMessageChannelSync(messageChannelId);
+
+    const syncFolderSpy = jest.spyOn(
+      getAppProviderByClassName<ImapSyncService>('ImapSyncService'),
+      'syncFolder',
+    );
+
+    try {
+      await runMessageChannelSync(messageChannelId);
+
+      expect(syncFolderSpy).not.toHaveBeenCalled();
+
+      await deliverMessage({ subject: `IMAP skip path ${randomUUID()}` });
+      await runMessageChannelSync(messageChannelId);
+
+      expect(syncFolderSpy).toHaveBeenCalled();
+    } finally {
+      syncFolderSpy.mockRestore();
+    }
+  }, 300000);
+
+  it('imports a message that arrives after unrelated activity in another folder', async () => {
+    await deliverMessage({
+      subject: `IMAP sent activity ${randomUUID()}`,
+      folder: 'Sent',
+    });
+    await runMessageChannelSync(messageChannelId);
+
+    const subject = `IMAP inbox after sent activity ${randomUUID()}`;
+
+    await deliverMessage({ subject });
+    await runMessageChannelSync(messageChannelId);
+
+    expect(await findImportedMessageSubjects([subject])).toEqual([subject]);
+  }, 300000);
+
+  // Servers that scope HIGHESTMODSEQ to the account rather than the mailbox hand
+  // us a cursor MODSEQ higher than any message the folder will receive next.
+  // Dovecot is compliant and cannot produce that state, so it is written directly.
+  it('imports new mail when the stored MODSEQ is ahead of the mailbox', async () => {
+    await runMessageChannelSync(messageChannelId);
+
+    const messageFolderRepository =
+      getCoreRepository<MessageFolderEntity>(MessageFolderEntity);
+    const inbox = await messageFolderRepository.findOneByOrFail({
+      messageChannelId,
+      name: 'INBOX',
+    });
+
+    await messageFolderRepository.update(inbox.id, {
+      syncCursor: JSON.stringify({
+        ...JSON.parse(inbox.syncCursor ?? '{}'),
+        modSeq: '999999',
+      }),
+    });
+
+    const subject = `IMAP stale modseq ${randomUUID()}`;
+
+    await deliverMessage({ subject });
+    await runMessageChannelSync(messageChannelId);
+
+    expect(await findImportedMessageSubjects([subject])).toEqual([subject]);
+  }, 300000);
+});

packages/twenty-server/test/integration/imap/suites/imap-smtp-outbound.integration-spec.ts

@@ -0,0 +1,169 @@
+import { randomUUID } from 'node:crypto';
+
+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 { 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 { sendEmail } from 'test/integration/utils/send-email.util';
+import {
+  type GreenmailServer,
+  startGreenmailContainer,
+} from 'test/integration/utils/start-greenmail-container.util';
+
+const PASSWORD = 'greenmail-password';
+const HANDLE = `imap-smtp-outbound-${randomUUID()}@acme.test`;
+
+describe('IMAP/SMTP outbound messaging (integration)', () => {
+  let greenmail: GreenmailServer;
+  let connectedAccountId: string;
+  let messageChannelId: string;
+
+  beforeAll(async () => {
+    greenmail = await startGreenmailContainer({
+      username: HANDLE,
+      password: PASSWORD,
+    });
+
+    await updateConfigVariable({
+      input: {
+        key: 'OUTBOUND_HTTP_ALLOWED_INTERNAL_HOSTS',
+        value: [greenmail.host],
+      },
+    });
+
+    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 (connectedAccountId) {
+      await deleteConnectedAccount({
+        id: connectedAccountId,
+        expectToFail: false,
+      }).catch(() => undefined);
+    }
+
+    await greenmail?.stop().catch(() => undefined);
+  });
+
+  it('sends a threaded SMTP message through GraphQL and persists it', async () => {
+    const subject = `IMAP/SMTP outbound ${randomUUID()}`;
+
+    const result = await sendEmail({
+      connectedAccountId,
+      to: HANDLE,
+      cc: HANDLE,
+      bcc: HANDLE,
+      subject,
+      body: '<p>SMTP reply body</p>',
+      inReplyTo: '<smtp-parent@example.com>',
+    });
+
+    expect(result).toMatchObject({ success: true });
+
+    const [message] = await findRecordNodesByFilter<{
+      id: string;
+      isDraft: boolean;
+      messageThreadId: string | null;
+      text: string | null;
+    }>('message', 'messages', 'id isDraft messageThreadId text', {
+      subject: { eq: subject },
+    });
+
+    expect(message).toMatchObject({
+      isDraft: false,
+      messageThreadId: expect.any(String),
+      text: 'SMTP reply 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('refuses to send from an address the account has not verified', async () => {
+    const subject = `IMAP/SMTP rejected sender ${randomUUID()}`;
+
+    const result = await sendEmail({
+      connectedAccountId,
+      fromHandle: 'not-my-alias@acme.test',
+      to: HANDLE,
+      subject,
+      body: '<p>SMTP rejected body</p>',
+    });
+
+    expect(result).toMatchObject({
+      success: false,
+      error: 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);
+});