Skip to content

The open alternative to Salesforce, designed for AI.

Thread replies to email group and campaign emails (#25884)

neo773a5b97c592f11
diff --git a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/aws-ses/services/aws-ses-send-email.service.ts b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/aws-ses/services/aws-ses-send-email.service.ts
index 8fb3759f081..2d4a3e96800 100644
--- a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/aws-ses/services/aws-ses-send-email.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/aws-ses/services/aws-ses-send-email.service.ts
@@ -101,6 +101,7 @@ export class AwsSesSendEmailService {
return {
messageId: response.MessageId,
+ headerMessageId: null,
deliveredRecipients: {
to: input.to,
cc: input.cc ?? [],
@@ -183,6 +184,7 @@ export class AwsSesSendEmailService {
return {
recipientIndex: index,
messageId: null,
+ headerMessageId: null,
errorMessage: 'SES returned no result for this destination',
};
}
@@ -191,6 +193,7 @@ export class AwsSesSendEmailService {
return {
recipientIndex: index,
messageId: null,
+ headerMessageId: null,
errorMessage:
result.Error ??
`SES rejected the destination (${result.Status})`,
@@ -200,6 +203,7 @@ export class AwsSesSendEmailService {
return {
recipientIndex: index,
messageId: result.MessageId,
+ headerMessageId: null,
errorMessage: null,
};
}),
diff --git a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/log/services/log-emailing-domain-driver.service.ts b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/log/services/log-emailing-domain-driver.service.ts
index 248d7879922..d2cc92f4d1b 100644
--- a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/log/services/log-emailing-domain-driver.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/log/services/log-emailing-domain-driver.service.ts
@@ -161,6 +161,7 @@ export class LogEmailingDomainDriver implements EmailingDomainDriverInterface {
return {
messageId,
+ headerMessageId: null,
deliveredRecipients: {
to: emailToSend.to,
cc: emailToSend.cc ?? [],
@@ -205,7 +206,12 @@ export class LogEmailingDomainDriver implements EmailingDomainDriverInterface {
}`,
);
- return { recipientIndex: index, messageId, errorMessage: null };
+ return {
+ recipientIndex: index,
+ messageId,
+ headerMessageId: null,
+ errorMessage: null,
+ };
}),
};
}
diff --git a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/services/resend-api-client.service.ts b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/services/resend-api-client.service.ts
index cbeaa93c543..4c46922a568 100644
--- a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/services/resend-api-client.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/services/resend-api-client.service.ts
@@ -11,6 +11,7 @@ import { type ResendDomain } from 'src/engine/core-modules/emailing-domain/drive
import { type ResendErrorBody } from 'src/engine/core-modules/emailing-domain/drivers/resend/types/resend-error-body.type';
import { type ResendReceivedEmail } from 'src/engine/core-modules/emailing-domain/drivers/resend/types/resend-received-email.type';
import { type ResendSendEmailPayload } from 'src/engine/core-modules/emailing-domain/drivers/resend/types/resend-send-email-payload.type';
+import { type ResendSentEmail } from 'src/engine/core-modules/emailing-domain/drivers/resend/types/resend-sent-email.type';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
const RESEND_API_BASE_URL = 'https://api.resend.com';
@@ -56,6 +57,10 @@ export class ResendApiClientService {
await this.performRequest('DELETE', `/domains/${domainId}`);
}
+ async getSentEmail(emailId: string): Promise<ResendSentEmail> {
+ return this.requestJson<ResendSentEmail>('GET', `/emails/${emailId}`);
+ }
+
async getReceivedEmail(emailId: string): Promise<ResendReceivedEmail> {
return this.requestJson<ResendReceivedEmail>(
'GET',
diff --git a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/services/resend-driver.service.ts b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/services/resend-driver.service.ts
index ce99c17bcaa..7032811e169 100644
--- a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/services/resend-driver.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/services/resend-driver.service.ts
@@ -164,6 +164,7 @@ export class ResendDriver implements EmailingDomainDriverInterface {
return {
messageId: id,
+ headerMessageId: await this.findHeaderMessageId(id),
deliveredRecipients: {
to: emailToSend.to,
cc: emailToSend.cc ?? [],
@@ -232,16 +233,36 @@ export class ResendDriver implements EmailingDomainDriverInterface {
const id = data?.[index]?.id;
return isNonEmptyString(id)
- ? { recipientIndex: index, messageId: id, errorMessage: null }
+ ? {
+ recipientIndex: index,
+ messageId: id,
+ headerMessageId: null,
+ errorMessage: null,
+ }
: {
recipientIndex: index,
messageId: null,
+ headerMessageId: null,
errorMessage: 'Resend returned no id for this destination',
};
}),
};
}
+ private async findHeaderMessageId(emailId: string): Promise<string | null> {
+ const sentEmail = await this.resendApiClientService
+ .getSentEmail(emailId)
+ .catch(() => null);
+
+ const messageId = sentEmail?.message_id;
+
+ if (!isNonEmptyString(messageId)) {
+ return null;
+ }
+
+ return messageId.startsWith('<') ? messageId : `<${messageId}>`;
+ }
+
private async findOrCreateDomain(domainName: string): Promise<ResendDomain> {
const existingDomain = await this.findDomainByName(domainName);
diff --git a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/types/resend-sent-email.type.ts b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/types/resend-sent-email.type.ts
new file mode 100644
index 00000000000..df9de0b52e8
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/resend/types/resend-sent-email.type.ts
@@ -0,0 +1,4 @@
+export type ResendSentEmail = {
+ id: string;
+ message_id?: string;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-send-email-batch-result.type.ts b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-send-email-batch-result.type.ts
index 25cb89209ad..17affa209c9 100644
--- a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-send-email-batch-result.type.ts
+++ b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-send-email-batch-result.type.ts
@@ -6,6 +6,7 @@ export type EmailingDomainSendEmailBatchResult = {
entries: {
recipientIndex: number;
messageId: string | null;
+ headerMessageId: string | null;
errorMessage: string | null;
}[];
};
diff --git a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-send-email-result.type.ts b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-send-email-result.type.ts
index b1206b85fb8..d15ffb650d8 100644
--- a/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-send-email-result.type.ts
+++ b/packages/twenty-server/src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-send-email-result.type.ts
@@ -1,4 +1,5 @@
export type EmailingDomainSendEmailResult = {
messageId: string;
+ headerMessageId: string | null;
deliveredRecipients: { to: string[]; cc: string[]; bcc: string[] };
};
diff --git a/packages/twenty-server/src/modules/emailing/services/__tests__/message-campaign-batch-delivery.service.spec.ts b/packages/twenty-server/src/modules/emailing/services/__tests__/message-campaign-batch-delivery.service.spec.ts
index 824412df6c3..f47df7c4a35 100644
--- a/packages/twenty-server/src/modules/emailing/services/__tests__/message-campaign-batch-delivery.service.spec.ts
+++ b/packages/twenty-server/src/modules/emailing/services/__tests__/message-campaign-batch-delivery.service.spec.ts
@@ -372,7 +372,12 @@ describe('MessageCampaignBatchDeliveryService', () => {
harness.claimedIds.push('message-0');
harness.emailingDomainSenderService.sendEmailBatch.mockResolvedValue({
entries: [
- { recipientIndex: 0, messageId: 'provider-0', errorMessage: null },
+ {
+ recipientIndex: 0,
+ messageId: 'provider-0',
+ headerMessageId: '<[email protected]>',
+ errorMessage: null,
+ },
],
suppressedRecipientIndexes: [],
});
@@ -381,7 +386,9 @@ describe('MessageCampaignBatchDeliveryService', () => {
expect(harness.messageRepository.update).toHaveBeenCalledWith(
'message-0',
- expect.objectContaining({ headerMessageId: 'provider-0' }),
+ expect.objectContaining({
+ headerMessageId: '<[email protected]>',
+ }),
);
expect(harness.associationRepository.update).toHaveBeenCalledWith(
{ messageId: 'message-0' },
@@ -392,6 +399,41 @@ describe('MessageCampaignBatchDeliveryService', () => {
);
});
+ it('sends each recipient its own References token and falls back to the provider id when the header id is unknown', async () => {
+ const harness = buildHarness();
+
+ harness.claimedIds.push('message-0');
+ harness.emailingDomainSenderService.sendEmailBatch.mockResolvedValue({
+ entries: [
+ {
+ recipientIndex: 0,
+ messageId: 'provider-0',
+ headerMessageId: null,
+ errorMessage: null,
+ },
+ ],
+ suppressedRecipientIndexes: [],
+ });
+
+ await (await harness.buildService()).processSendBatchJob(buildJobData(1));
+
+ expect(
+ harness.emailingDomainSenderService.sendEmailBatch,
+ ).toHaveBeenCalledWith(
+ expect.objectContaining({
+ recipients: [
+ expect.objectContaining({
+ headers: [{ name: 'References', value: '<[email protected]>' }],
+ }),
+ ],
+ }),
+ );
+ expect(harness.messageRepository.update).toHaveBeenCalledWith(
+ 'message-0',
+ expect.objectContaining({ headerMessageId: 'provider-0' }),
+ );
+ });
+
it('asks for slots for the deliverable recipients only, not the suppressed ones', async () => {
const harness = buildHarness();
diff --git a/packages/twenty-server/src/modules/emailing/services/emailing-domain-sender.service.ts b/packages/twenty-server/src/modules/emailing/services/emailing-domain-sender.service.ts
index 77481692c8d..6d23006bfa1 100644
--- a/packages/twenty-server/src/modules/emailing/services/emailing-domain-sender.service.ts
+++ b/packages/twenty-server/src/modules/emailing/services/emailing-domain-sender.service.ts
@@ -167,6 +167,7 @@ export class EmailingDomainSenderService {
entries: entries.map((entry) => ({
recipientIndex: deliverableRecipientIndexes[entry.recipientIndex],
messageId: entry.messageId,
+ headerMessageId: entry.headerMessageId,
errorMessage: entry.errorMessage,
})),
suppressedRecipientIndexes,
diff --git a/packages/twenty-server/src/modules/emailing/services/message-campaign-batch-delivery.service.ts b/packages/twenty-server/src/modules/emailing/services/message-campaign-batch-delivery.service.ts
index 6e6546e57eb..7529326d638 100644
--- a/packages/twenty-server/src/modules/emailing/services/message-campaign-batch-delivery.service.ts
+++ b/packages/twenty-server/src/modules/emailing/services/message-campaign-batch-delivery.service.ts
@@ -37,6 +37,7 @@ import { type EmailingDomainEmailTemplate } from 'src/engine/core-modules/emaili
import { type CampaignDeliverySettlement } from 'src/modules/emailing/types/campaign-delivery-settlement.type';
import { type EmailCreditContext } from 'src/modules/emailing/types/email-credit-context.type';
import { buildCampaignBatchReplacements } from 'src/modules/emailing/utils/build-campaign-batch-replacements.util';
+import { buildCampaignThreadExternalId } from 'src/modules/emailing/utils/build-campaign-thread-external-id.util';
import { buildCampaignDeliverySettleQuery } from 'src/modules/emailing/utils/build-campaign-delivery-settle-query.util';
import { compileCampaignBatchTemplate } from 'src/modules/emailing/utils/compile-campaign-batch-template.util';
import { chunkRecipientsToAdmissibleSize } from 'src/modules/emailing/utils/chunk-recipients-to-admissible-size.util';
@@ -45,6 +46,7 @@ import { resolveCampaignBatchSettlements } from 'src/modules/emailing/utils/reso
import { resolveCampaignSendFailure } from 'src/modules/emailing/utils/resolve-campaign-send-failure.util';
import { MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
import { MessageWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message.workspace-entity';
+import { buildOutboundThreadingHeaders } from 'src/modules/messaging/message-outbound-manager/utils/build-outbound-threading-headers.util';
import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
type BatchRecipient = SendCampaignEmailBatchJobData['recipients'][number];
@@ -348,16 +350,24 @@ export class MessageCampaignBatchDeliveryService {
);
}
+ const fromAddress = campaign.fromAddress?.primaryEmail ?? '';
+
const providerOutcome = await this.emailingDomainSenderService
.sendEmailBatch({
workspaceId,
emailingDomainId,
sendKind: 'MARKETING',
- from: campaign.fromAddress?.primaryEmail ?? '',
+ from: fromAddress,
template,
recipients: claimedRecipients.map((recipient) => ({
email: recipient.email,
replacements: replacementsByDeliveryId.get(recipient.messageId) ?? {},
+ headers: buildOutboundThreadingHeaders({
+ threadExternalId: buildCampaignThreadExternalId({
+ messageId: recipient.messageId,
+ fromAddress,
+ }),
+ }),
})),
unsubscribeTopicId: campaign.unsubscribeTopicId ?? undefined,
})
@@ -386,6 +396,19 @@ export class MessageCampaignBatchDeliveryService {
outcome: providerOutcome,
});
+ const headerMessageIdByDeliveryId = new Map<string, string>();
+
+ for (const entry of providerOutcome.entries) {
+ const recipient = claimedRecipients[entry.recipientIndex];
+
+ if (isDefined(recipient) && isDefined(entry.headerMessageId)) {
+ headerMessageIdByDeliveryId.set(
+ recipient.messageId,
+ entry.headerMessageId,
+ );
+ }
+ }
+
try {
await this.settleDeliveredBatch({
data,
@@ -393,6 +416,7 @@ export class MessageCampaignBatchDeliveryService {
settlements,
template,
replacementsByDeliveryId,
+ headerMessageIdByDeliveryId,
});
} catch (error) {
await this.settleClaimsAlreadyHandedToProvider({
@@ -411,12 +435,14 @@ export class MessageCampaignBatchDeliveryService {
settlements,
template,
replacementsByDeliveryId,
+ headerMessageIdByDeliveryId,
}: {
data: SendCampaignEmailBatchJobData;
claimToken: string;
settlements: CampaignDeliverySettlement[];
template: EmailingDomainEmailTemplate;
replacementsByDeliveryId: Map<string, Record<string, string>>;
+ headerMessageIdByDeliveryId: Map<string, string>;
}): Promise<void> {
const { workspaceId, campaignId, userWorkspaceId } = data;
@@ -434,9 +460,14 @@ export class MessageCampaignBatchDeliveryService {
);
for (const settlement of sentSettlements) {
+ const providerMessageId = settlement.providerMessageId ?? '';
+
await this.recordSentMessage({
deliveryId: settlement.deliveryId,
- providerMessageId: settlement.providerMessageId ?? '',
+ providerMessageId,
+ headerMessageId:
+ headerMessageIdByDeliveryId.get(settlement.deliveryId) ??
+ providerMessageId,
template,
replacements: replacementsByDeliveryId.get(settlement.deliveryId) ?? {},
});
@@ -464,11 +495,13 @@ export class MessageCampaignBatchDeliveryService {
private async recordSentMessage({
deliveryId,
providerMessageId,
+ headerMessageId,
template,
replacements,
}: {
deliveryId: string;
providerMessageId: string;
+ headerMessageId: string;
template: EmailingDomainEmailTemplate;
replacements: Record<string, string>;
}): Promise<void> {
@@ -479,7 +512,7 @@ export class MessageCampaignBatchDeliveryService {
);
await messageRepository.update(deliveryId, {
- headerMessageId: providerMessageId,
+ headerMessageId,
subject: applyReplacementTags(template.subject, replacements),
text: applyReplacementTags(template.text, replacements),
});
@@ -492,10 +525,7 @@ export class MessageCampaignBatchDeliveryService {
await associationRepository.update(
{ messageId: deliveryId },
- {
- messageExternalId: providerMessageId,
- messageThreadExternalId: providerMessageId,
- },
+ { messageExternalId: providerMessageId },
);
}
diff --git a/packages/twenty-server/src/modules/emailing/services/message-campaign-delivery.service.ts b/packages/twenty-server/src/modules/emailing/services/message-campaign-delivery.service.ts
index 8a1d2ba0527..8e81923dadb 100644
--- a/packages/twenty-server/src/modules/emailing/services/message-campaign-delivery.service.ts
+++ b/packages/twenty-server/src/modules/emailing/services/message-campaign-delivery.service.ts
@@ -35,10 +35,12 @@ import { EmailingDomainSenderService } from 'src/modules/emailing/services/email
import { MessageCampaignLifecycleService } from 'src/modules/emailing/services/message-campaign-lifecycle.service';
import { MessageCampaignStatisticsService } from 'src/modules/emailing/services/message-campaign-statistics.service';
import { MessageCampaignWorkspaceEntity } from 'src/modules/emailing/standard-objects/message-campaign.workspace-entity';
+import { buildCampaignThreadExternalId } from 'src/modules/emailing/utils/build-campaign-thread-external-id.util';
import { resolveCampaignSendFailure } from 'src/modules/emailing/utils/resolve-campaign-send-failure.util';
import { renderCampaignEmail } from 'src/modules/emailing/utils/render-campaign-email.util';
import { MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
import { MessageWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message.workspace-entity';
+import { buildOutboundThreadingHeaders } from 'src/modules/messaging/message-outbound-manager/utils/build-outbound-threading-headers.util';
import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
import { MessageCampaignStatus } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
@@ -309,6 +311,12 @@ export class MessageCampaignDeliveryService {
variables,
});
+ const fromAddress = campaign.fromAddress?.primaryEmail ?? '';
+ const threadExternalId = buildCampaignThreadExternalId({
+ messageId,
+ fromAddress,
+ });
+
const result = await this.sendOrRecordFailure({
messageId,
claimToken,
@@ -316,13 +324,14 @@ export class MessageCampaignDeliveryService {
workspaceId,
emailingDomainId,
email: {
- from: campaign.fromAddress?.primaryEmail ?? '',
+ from: fromAddress,
to: [recipientEmail],
subject,
text: plainText,
html,
sendKind: 'MARKETING',
unsubscribeTopicId: campaign.unsubscribeTopicId ?? undefined,
+ headers: buildOutboundThreadingHeaders({ threadExternalId }),
},
});
@@ -352,7 +361,7 @@ export class MessageCampaignDeliveryService {
}
await messageRepository.update(messageId, {
- headerMessageId: result.messageId,
+ headerMessageId: result.headerMessageId ?? result.messageId,
subject,
text: plainText,
});
@@ -371,13 +380,13 @@ export class MessageCampaignDeliveryService {
);
});
- await this.linkMessageToProviderThread({
+ await this.linkMessageToProviderMessage({
messageId,
providerMessageId: result.messageId,
});
}
- private async linkMessageToProviderThread({
+ private async linkMessageToProviderMessage({
messageId,
providerMessageId,
}: {
@@ -392,10 +401,7 @@ export class MessageCampaignDeliveryService {
await associationRepository.update(
{ messageId },
- {
- messageExternalId: providerMessageId,
- messageThreadExternalId: providerMessageId,
- },
+ { messageExternalId: providerMessageId },
);
}
diff --git a/packages/twenty-server/src/modules/emailing/services/message-campaign-materialization.service.ts b/packages/twenty-server/src/modules/emailing/services/message-campaign-materialization.service.ts
index 636fc596cdb..e67e5a80ed1 100644
--- a/packages/twenty-server/src/modules/emailing/services/message-campaign-materialization.service.ts
+++ b/packages/twenty-server/src/modules/emailing/services/message-campaign-materialization.service.ts
@@ -29,6 +29,7 @@ import { MessageCampaignWorkspaceEntity } from 'src/modules/emailing/standard-ob
import { type CampaignRecipient } from 'src/engine/core-modules/emailing-domain/types/campaign-recipient.type';
import { type CampaignMessageRecipient } from 'src/modules/emailing/types/campaign-message-recipient.type';
import { buildCampaignMessageId } from 'src/modules/emailing/utils/build-campaign-message-id.util';
+import { buildCampaignThreadExternalId } from 'src/modules/emailing/utils/build-campaign-thread-external-id.util';
import { compileCampaignEmailContent } from 'src/modules/emailing/utils/compile-campaign-email-content.util';
import { MessageDirection } from 'src/modules/messaging/common/enums/message-direction.enum';
import { MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
@@ -478,7 +479,10 @@ export class MessageCampaignMaterializationService {
messageId: row.messageId,
messageChannelId,
messageExternalId: row.temporaryExternalId,
- messageThreadExternalId: row.temporaryExternalId,
+ messageThreadExternalId: buildCampaignThreadExternalId({
+ messageId: row.messageId,
+ fromAddress,
+ }),
direction: MessageDirection.OUTGOING,
})),
);
diff --git a/packages/twenty-server/src/modules/emailing/types/campaign-batch-send-outcome.type.ts b/packages/twenty-server/src/modules/emailing/types/campaign-batch-send-outcome.type.ts
index c576b1fe732..f975d7d2ffa 100644
--- a/packages/twenty-server/src/modules/emailing/types/campaign-batch-send-outcome.type.ts
+++ b/packages/twenty-server/src/modules/emailing/types/campaign-batch-send-outcome.type.ts
@@ -2,6 +2,7 @@ export type CampaignBatchSendOutcome = {
entries: {
recipientIndex: number;
messageId: string | null;
+ headerMessageId: string | null;
errorMessage: string | null;
}[];
suppressedRecipientIndexes: number[];
diff --git a/packages/twenty-server/src/modules/emailing/utils/build-campaign-thread-external-id.util.ts b/packages/twenty-server/src/modules/emailing/utils/build-campaign-thread-external-id.util.ts
new file mode 100644
index 00000000000..b1406199b66
--- /dev/null
+++ b/packages/twenty-server/src/modules/emailing/utils/build-campaign-thread-external-id.util.ts
@@ -0,0 +1,9 @@
+import { getDomainFromEmail } from 'src/utils/get-domain-from-email';
+
+export const buildCampaignThreadExternalId = ({
+ messageId,
+ fromAddress,
+}: {
+ messageId: string;
+ fromAddress: string;
+}): string => `<${messageId}@${getDomainFromEmail(fromAddress)}>`;
diff --git a/packages/twenty-server/src/modules/messaging/message-import-manager/drivers/inbound-email/services/inbound-email-import.service.ts b/packages/twenty-server/src/modules/messaging/message-import-manager/drivers/inbound-email/services/inbound-email-import.service.ts
index da24c3c2808..9940f5c4505 100644
--- a/packages/twenty-server/src/modules/messaging/message-import-manager/drivers/inbound-email/services/inbound-email-import.service.ts
+++ b/packages/twenty-server/src/modules/messaging/message-import-manager/drivers/inbound-email/services/inbound-email-import.service.ts
@@ -4,7 +4,7 @@ import { InjectRepository } from '@nestjs/typeorm';
import { isNonEmptyString } from '@sniptt/guards';
import { MessageChannelType } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
-import { Repository } from 'typeorm';
+import { In, Repository } from 'typeorm';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
@@ -14,6 +14,10 @@ import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system
import { InboundEmailMessageSourceResolverService } from 'src/modules/messaging/message-import-manager/drivers/inbound-email/sources/inbound-email-message-source-resolver.service';
import { type InboundEmailImportOutcome } from 'src/modules/messaging/message-import-manager/drivers/inbound-email/types/inbound-email-import-outcome.type';
import { type InboundEmailMessageReference } from 'src/modules/messaging/message-import-manager/drivers/inbound-email/types/inbound-email-message-reference.type';
+import { extractReferencedMessageIds } from 'src/modules/messaging/message-import-manager/drivers/inbound-email/utils/extract-referenced-message-ids.util';
+import { type MessageWithParticipants } from 'src/modules/messaging/message-import-manager/types/message';
+import { type MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
+import { type MessageWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message.workspace-entity';
import { MessagingSaveMessagesAndEnqueueContactCreationService } from 'src/modules/messaging/message-import-manager/services/messaging-save-messages-and-enqueue-contact-creation.service';
type ImportInboundMessageParams = {
@@ -108,6 +112,13 @@ export class InboundEmailImportService {
await this.workspaceOrmManager.executeInWorkspaceContext(
async () => {
+ const existingThreadExternalId =
+ await this.findExistingThreadExternalId(message, messageChannel.id);
+
+ if (isDefined(existingThreadExternalId)) {
+ message.messageThreadExternalId = existingThreadExternalId;
+ }
+
await this.messagingSaveMessagesAndEnqueueContactCreationService.saveMessagesAndEnqueueContactCreation(
[message],
messageChannel,
@@ -128,6 +139,80 @@ export class InboundEmailImportService {
};
}
+ private async findExistingThreadExternalId(
+ message: MessageWithParticipants,
+ messageChannelId: string,
+ ): Promise<string | undefined> {
+ const referencedMessageIds = extractReferencedMessageIds(
+ message.messageHeaders,
+ );
+
+ if (referencedMessageIds.length === 0) {
+ return undefined;
+ }
+
+ const storedHeaderMessageIdsByReferencedMessageId = new Map(
+ referencedMessageIds.map((referencedMessageId) => {
+ const atIndex = referencedMessageId.indexOf('@');
+
+ return [
+ referencedMessageId,
+ atIndex > 1
+ ? [referencedMessageId, referencedMessageId.slice(1, atIndex)]
+ : [referencedMessageId],
+ ];
+ }),
+ );
+
+ const referencedMessages = await this.workspaceOrmManager
+ .getRepository<MessageWorkspaceEntity>('message')
+ .find({
+ where: {
+ headerMessageId: In(
+ [...storedHeaderMessageIdsByReferencedMessageId.values()].flat(),
+ ),
+ },
+ select: { id: true, headerMessageId: true },
+ });
+
+ if (referencedMessages.length === 0) {
+ return undefined;
+ }
+
+ const channelAssociations = await this.workspaceOrmManager
+ .getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
+ 'messageChannelMessageAssociation',
+ )
+ .find({
+ where: {
+ messageChannelId,
+ messageId: In(
+ referencedMessages.map((referencedMessage) => referencedMessage.id),
+ ),
+ },
+ select: { messageId: true, messageThreadExternalId: true },
+ });
+
+ return referencedMessageIds
+ .map((referencedMessageId) => {
+ const storedHeaderMessageIds =
+ storedHeaderMessageIdsByReferencedMessageId.get(
+ referencedMessageId,
+ ) ?? [];
+
+ const referencedMessage = referencedMessages.find(
+ (candidate) =>
+ isNonEmptyString(candidate.headerMessageId) &&
+ storedHeaderMessageIds.includes(candidate.headerMessageId),
+ );
+
+ return channelAssociations.find(
+ (association) => association.messageId === referencedMessage?.id,
+ )?.messageThreadExternalId;
+ })
+ .find(isNonEmptyString);
+ }
+
private matchInboundRecipient(
envelopeRecipients: string[],
inboundEmailDomain: string,
diff --git a/packages/twenty-server/src/modules/messaging/message-import-manager/drivers/inbound-email/utils/__tests__/extract-referenced-message-ids.util.spec.ts b/packages/twenty-server/src/modules/messaging/message-import-manager/drivers/inbound-email/utils/__tests__/extract-referenced-message-ids.util.spec.ts
new file mode 100644
index 00000000000..a71db74195f
--- /dev/null
+++ b/packages/twenty-server/src/modules/messaging/message-import-manager/drivers/inbound-email/utils/__tests__/extract-referenced-message-ids.util.spec.ts
@@ -0,0 +1,51 @@
+import { extractReferencedMessageIds } from 'src/modules/messaging/message-import-manager/drivers/inbound-email/utils/extract-referenced-message-ids.util';
+
+describe('extractReferencedMessageIds', () => {
+ it('should list References ids in order followed by In-Reply-To, without duplicates', () => {
+ expect(
+ extractReferencedMessageIds([
+ { name: 'message-id', value: '<[email protected]>' },
+ {
+ name: 'in-reply-to',
+ value: '<[email protected]>',
+ },
+ {
+ name: 'references',
+ },
+ ]),
+ ).toEqual(['<[email protected]>', '<[email protected]>']);
+ });
+
+ it('should keep only the thread root and the most recent ids of a very long chain', () => {
+ const chainIds = Array.from(
+ { length: 500 },
+ (_, index) => `<chain-${index}@mail.example.com>`,
+ );
+
+ const referencedMessageIds = extractReferencedMessageIds([
+ { name: 'references', value: chainIds.join(' ') },
+ { name: 'in-reply-to', value: '<[email protected]>' },
+ ]);
+
+ expect(referencedMessageIds).toHaveLength(20);
+ expect(referencedMessageIds[0]).toBe('<[email protected]>');
+ expect(referencedMessageIds[19]).toBe('<[email protected]>');
+ });
+
+ it('should ignore an id longer than an email header line allows', () => {
+ expect(
+ extractReferencedMessageIds([
+ { name: 'references', value: `<${'a'.repeat(2000)}@mail.example.com>` },
+ ]),
+ ).toEqual([]);
+ });
+
+ it('should return nothing for a message that replies to nothing', () => {
+ expect(
+ extractReferencedMessageIds([
+ { name: 'message-id', value: '<[email protected]>' },
+ ]),
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/modules/messaging/message-import-manager/drivers/inbound-email/utils/extract-referenced-message-ids.util.ts b/packages/twenty-server/src/modules/messaging/message-import-manager/drivers/inbound-email/utils/extract-referenced-message-ids.util.ts
new file mode 100644
index 00000000000..db9a9fe897d
--- /dev/null
+++ b/packages/twenty-server/src/modules/messaging/message-import-manager/drivers/inbound-email/utils/extract-referenced-message-ids.util.ts
@@ -0,0 +1,41 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type MessageHeader } from 'src/modules/messaging/message-import-manager/types/message';
+
+const MESSAGE_ID_PATTERN = /<[^<>\s]{1,996}>/g;
+
+const MAX_REFERENCED_MESSAGE_IDS = 20;
+
+const extractMessageIdsFromHeader = (
+ messageHeaders: MessageHeader[],
+ headerName: string,
+): string[] =>
+ messageHeaders
+ .filter((header) => header.name.toLowerCase() === headerName)
+ .flatMap((header) => header.value.match(MESSAGE_ID_PATTERN) ?? []);
+
+export const extractReferencedMessageIds = (
+ messageHeaders: MessageHeader[] | undefined,
+): string[] => {
+ if (!isDefined(messageHeaders)) {
+ return [];
+ }
+
+ const referencedMessageIds = [
+ ...new Set([
+ ...extractMessageIdsFromHeader(messageHeaders, 'references'),
+ ...extractMessageIdsFromHeader(messageHeaders, 'in-reply-to'),
+ ]),
+ ];
+
+ if (referencedMessageIds.length <= MAX_REFERENCED_MESSAGE_IDS) {
+ return referencedMessageIds;
+ }
+
+ const [rootMessageId, ...laterMessageIds] = referencedMessageIds;
+
+ return [
+ rootMessageId,
+ ...laterMessageIds.slice(-(MAX_REFERENCED_MESSAGE_IDS - 1)),
+ ];
+};
diff --git a/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/services/email-group-message-outbound.service.ts b/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/services/email-group-message-outbound.service.ts
index a592cd926b3..aa4534f5e10 100644
--- a/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/services/email-group-message-outbound.service.ts
+++ b/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/services/email-group-message-outbound.service.ts
@@ -2,6 +2,7 @@ import { Injectable, Logger } from '@nestjs/common';
import { isNonEmptyString } from '@sniptt/guards';
import { isDefined } from 'twenty-shared/utils';
+import { v4 } from 'uuid';
import { EmailingDomainStatus } from 'src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-status.type';
import { EmailingDomainEntity } from 'src/engine/core-modules/emailing-domain/emailing-domain.entity';
@@ -17,6 +18,7 @@ import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scope
import { type MessageOutboundDriver } from 'src/modules/messaging/message-outbound-manager/interfaces/message-outbound-driver.interface';
import { type SendMessageInput } from 'src/modules/messaging/message-outbound-manager/types/send-message-input.type';
import { type SendMessageResult } from 'src/modules/messaging/message-outbound-manager/types/send-message-result.type';
+import { buildOutboundThreadingHeaders } from 'src/modules/messaging/message-outbound-manager/utils/build-outbound-threading-headers.util';
import { getDomainFromEmail } from 'src/utils/get-domain-from-email';
import { countDeliveredRecipients } from 'src/engine/core-modules/emailing-domain/utils/count-delivered-recipients.util';
@@ -48,6 +50,11 @@ export class EmailGroupMessageOutboundService implements MessageOutboundDriver {
connectedAccount.workspaceId,
);
+ const threadExternalId =
+ sendMessageInput.threadExternalId ??
+ sendMessageInput.inReplyTo ??
+ `<${v4()}@${emailingDomain.domain}>`;
+
const result = await this.emailingDomainSenderService.sendEmail(
connectedAccount.workspaceId,
emailingDomain.id,
@@ -64,6 +71,11 @@ export class EmailGroupMessageOutboundService implements MessageOutboundDriver {
from: connectedAccount.handle,
replyTo: [connectedAccount.handle],
attachments: sendMessageInput.attachments,
+ headers: buildOutboundThreadingHeaders({
+ threadExternalId,
+ inReplyTo: sendMessageInput.inReplyTo,
+ references: sendMessageInput.references,
+ }),
},
);
@@ -83,8 +95,9 @@ export class EmailGroupMessageOutboundService implements MessageOutboundDriver {
});
return {
- headerMessageId: result.messageId,
+ headerMessageId: result.headerMessageId ?? result.messageId,
messageExternalId: result.messageId,
+ threadExternalId,
deliveredRecipients: result.deliveredRecipients,
};
}
diff --git a/packages/twenty-server/src/modules/messaging/message-outbound-manager/utils/__tests__/build-outbound-threading-headers.util.spec.ts b/packages/twenty-server/src/modules/messaging/message-outbound-manager/utils/__tests__/build-outbound-threading-headers.util.spec.ts
new file mode 100644
index 00000000000..5bcacd7d1fc
--- /dev/null
+++ b/packages/twenty-server/src/modules/messaging/message-outbound-manager/utils/__tests__/build-outbound-threading-headers.util.spec.ts
@@ -0,0 +1,65 @@
+import { buildOutboundThreadingHeaders } from 'src/modules/messaging/message-outbound-manager/utils/build-outbound-threading-headers.util';
+
+describe('buildOutboundThreadingHeaders', () => {
+ it('should carry only the thread token in References for a new conversation', () => {
+ expect(
+ buildOutboundThreadingHeaders({
+ threadExternalId: '<[email protected]>',
+ }),
+ ).toEqual([{ name: 'References', value: '<[email protected]>' }]);
+ });
+
+ it('should keep the thread token first and end with the parent when replying', () => {
+ expect(
+ buildOutboundThreadingHeaders({
+ threadExternalId: '<[email protected]>',
+ inReplyTo: '<[email protected]>',
+ references: [
+ ],
+ }),
+ ).toEqual([
+ { name: 'In-Reply-To', value: '<[email protected]>' },
+ {
+ name: 'References',
+ value:
+ },
+ ]);
+ });
+
+ it('should leave out stored ids that are not valid message ids', () => {
+ expect(
+ buildOutboundThreadingHeaders({
+ threadExternalId: '010701a09b1e987b-03ce71c7-000000',
+ inReplyTo: '<[email protected]>',
+ }),
+ ).toEqual([
+ { name: 'In-Reply-To', value: '<[email protected]>' },
+ { name: 'References', value: '<[email protected]>' },
+ ]);
+ });
+
+ it('should drop the oldest middle ids but keep the thread token and the parent when the chain is too long', () => {
+ const middleIds = Array.from(
+ { length: 30 },
+ (_, index) => `<middle-${index}[email protected]>`,
+ );
+
+ const [, referencesHeader] = buildOutboundThreadingHeaders({
+ threadExternalId: '<[email protected]>',
+ inReplyTo: '<[email protected]>',
+ references: [...middleIds, '<[email protected]>'],
+ });
+
+ const keptIds = referencesHeader.value.split(' ');
+
+ expect(`References${referencesHeader.value}`.length).toBeLessThanOrEqual(
+ 996,
+ );
+ expect(keptIds[0]).toBe('<[email protected]>');
+ expect(keptIds[keptIds.length - 1]).toBe('<[email protected]>');
+ expect(keptIds).not.toContain(middleIds[0]);
+ });
+});
diff --git a/packages/twenty-server/src/modules/messaging/message-outbound-manager/utils/build-outbound-threading-headers.util.ts b/packages/twenty-server/src/modules/messaging/message-outbound-manager/utils/build-outbound-threading-headers.util.ts
new file mode 100644
index 00000000000..79aa14df517
--- /dev/null
+++ b/packages/twenty-server/src/modules/messaging/message-outbound-manager/utils/build-outbound-threading-headers.util.ts
@@ -0,0 +1,64 @@
+import { isNonEmptyString } from '@sniptt/guards';
+
+import { type EmailingDomainHeader } from 'src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-header.type';
+
+const MESSAGE_ID_PATTERN = /^<[^<>\s@]+@[^<>\s@]+>$/;
+
+const MAX_HEADER_NAME_AND_VALUE_LENGTH = 996;
+
+const REFERENCES_HEADER_NAME = 'References';
+
+const IN_REPLY_TO_HEADER_NAME = 'In-Reply-To';
+
+const isMessageId = (value: string | undefined): value is string =>
+ isNonEmptyString(value) && MESSAGE_ID_PATTERN.test(value);
+
+const fitReferencesToHeaderLength = (messageIds: string[]): string[] => {
+ const [rootMessageId, ...laterMessageIds] = messageIds;
+ const keptLaterMessageIds: string[] = [];
+ let headerLength = REFERENCES_HEADER_NAME.length + rootMessageId.length;
+
+ for (const messageId of [...laterMessageIds].reverse()) {
+ const nextHeaderLength = headerLength + 1 + messageId.length;
+
+ if (nextHeaderLength > MAX_HEADER_NAME_AND_VALUE_LENGTH) {
+ break;
+ }
+
+ keptLaterMessageIds.unshift(messageId);
+ headerLength = nextHeaderLength;
+ }
+
+ return [rootMessageId, ...keptLaterMessageIds];
+};
+
+export const buildOutboundThreadingHeaders = ({
+ threadExternalId,
+ inReplyTo,
+ references,
+}: {
+ threadExternalId: string;
+ inReplyTo?: string;
+ references?: string[];
+}): EmailingDomainHeader[] => {
+ const referencedMessageIds = [
+ ...new Set(
+ [threadExternalId, ...(references ?? []), inReplyTo].filter(isMessageId),
+ ),
+ ];
+
+ const headers: EmailingDomainHeader[] = [];
+
+ if (isMessageId(inReplyTo)) {
+ headers.push({ name: IN_REPLY_TO_HEADER_NAME, value: inReplyTo });
+ }
+
+ if (referencedMessageIds.length > 0) {
+ headers.push({
+ name: REFERENCES_HEADER_NAME,
+ value: fitReferencesToHeaderLength(referencedMessageIds).join(' '),
+ });
+ }
+
+ return headers;
+};
diff --git a/packages/twenty-server/test/integration/resend/suites/inbound-email-reply-threading.integration-spec.ts b/packages/twenty-server/test/integration/resend/suites/inbound-email-reply-threading.integration-spec.ts
new file mode 100644
index 00000000000..ccef10015d8
--- /dev/null
+++ b/packages/twenty-server/test/integration/resend/suites/inbound-email-reply-threading.integration-spec.ts
@@ -0,0 +1,269 @@
+import { randomUUID } from 'node:crypto';
+
+import { isNonEmptyString } from '@sniptt/guards';
+import { http, HttpResponse } from 'msw';
+
+import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { type WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+import { MESSAGE_CHANNEL_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/core/constants/message-channel-seed-ids.constant';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+import { MessageDirection } from 'src/modules/messaging/common/enums/message-direction.enum';
+import { type MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
+import { type MessageThreadWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-thread.workspace-entity';
+import { type MessageWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message.workspace-entity';
+import { type InboundEmailImportService } from 'src/modules/messaging/message-import-manager/drivers/inbound-email/services/inbound-email-import.service';
+
+import { updateConfigVariable } from 'test/integration/twenty-config/utils/update-config-variable.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 { setupHttpMock } from 'test/integration/utils/http-mock.util';
+
+const INBOUND_EMAIL_DOMAIN = 'inbound.threading.test';
+
+const RAW_EMAIL_DOWNLOAD_BASE_URL = 'https://resend-raw.threading.test';
+
+const buildRawReply = ({
+ groupHandle,
+ headerMessageId,
+ inReplyTo,
+ references,
+}: {
+ groupHandle: string;
+ headerMessageId: string;
+ inReplyTo?: string;
+ references?: string;
+}) => {
+ const headerLines = [
+ 'From: Customer <[email protected]>',
+ `To: ${groupHandle}`,
+ 'Subject: Re: Spring offer',
+ `Message-ID: ${headerMessageId}`,
+ 'Date: Mon, 14 Sep 2026 11:19:21 +0000',
+ 'MIME-Version: 1.0',
+ 'Content-Type: text/plain; charset=UTF-8',
+ ];
+
+ if (isNonEmptyString(inReplyTo)) {
+ headerLines.push(`In-Reply-To: ${inReplyTo}`);
+ }
+
+ if (isNonEmptyString(references)) {
+ headerLines.push(`References: ${references}`);
+ }
+
+ return [...headerLines, '', 'Thanks, sounds good.'].join('\r\n');
+};
+
+describe('Inbound email reply threading (integration)', () => {
+ const httpMock = setupHttpMock();
+
+ const messageChannelRepository =
+ getCoreRepository<MessageChannelEntity>(MessageChannelEntity);
+
+ let groupChannelId: string;
+ let groupHandle: string;
+
+ const inWorkspace = <TResult>(
+ work: (workspaceOrmManager: WorkspaceOrmManager) => Promise<TResult>,
+ ): Promise<TResult> => {
+ const workspaceOrmManager = getAppProviderByClassName<WorkspaceOrmManager>(
+ 'WorkspaceOrmManager',
+ );
+
+ return workspaceOrmManager.executeInWorkspaceContext(
+ () => work(workspaceOrmManager),
+ buildSystemAuthContext(SEED_APPLE_WORKSPACE_ID),
+ { lite: true },
+ );
+ };
+
+ const buildSesProviderMessageId = () =>
+ `010701a0${randomUUID().replace(/-/g, '').slice(0, 8)}-${randomUUID()}-000000`;
+
+ const seedSentMessage = ({
+ messageChannelId,
+ providerMessageId,
+ threadExternalId,
+ }: {
+ messageChannelId: string;
+ providerMessageId: string;
+ threadExternalId: string;
+ }) =>
+ inWorkspace(async (workspaceOrmManager) => {
+ const messageThreadId = randomUUID();
+ const messageId = randomUUID();
+
+ await workspaceOrmManager
+ .getRepository<MessageThreadWorkspaceEntity>('messageThread')
+ .insert({ id: messageThreadId });
+
+ await workspaceOrmManager
+ .getRepository<MessageWorkspaceEntity>('message')
+ .insert({
+ id: messageId,
+ headerMessageId: providerMessageId,
+ subject: 'Spring offer',
+ text: 'Our spring offer',
+ messageThreadId,
+ });
+
+ await workspaceOrmManager
+ .getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
+ 'messageChannelMessageAssociation',
+ )
+ .insert({
+ id: randomUUID(),
+ messageId,
+ messageChannelId,
+ messageExternalId: providerMessageId,
+ messageThreadExternalId: threadExternalId,
+ direction: MessageDirection.OUTGOING,
+ });
+
+ return messageThreadId;
+ });
+
+ const importReply = async (rawReply: string) => {
+ const receivedEmailId = randomUUID();
+ const downloadUrl = `${RAW_EMAIL_DOWNLOAD_BASE_URL}/${receivedEmailId}`;
+
+ httpMock.use(
+ http.get(
+ `https://api.resend.com/emails/receiving/${receivedEmailId}`,
+ () =>
+ HttpResponse.json({
+ id: receivedEmailId,
+ to: [groupHandle],
+ raw: { download_url: downloadUrl, expires_at: '2099-01-01' },
+ }),
+ ),
+ http.get(downloadUrl, () => HttpResponse.text(rawReply)),
+ );
+
+ const outcome = await getAppProviderByClassName<InboundEmailImportService>(
+ 'InboundEmailImportService',
+ ).importInboundMessage({
+ messageReference: { source: 'RESEND', reference: receivedEmailId },
+ envelopeRecipients: [groupHandle],
+ });
+
+ expect(outcome.kind).toBe('imported');
+ };
+
+ const findThreadIdOfMessage = (headerMessageId: string) =>
+ inWorkspace(async (workspaceOrmManager) => {
+ const message = await workspaceOrmManager
+ .getRepository<MessageWorkspaceEntity>('message')
+ .createQueryBuilder('message')
+ .where('message.headerMessageId = :headerMessageId', {
+ headerMessageId,
+ })
+ .getOne<MessageWorkspaceEntity>();
+
+ return message?.messageThreadId;
+ });
+
+ beforeAll(async () => {
+ await updateConfigVariable({
+ input: { key: 'INBOUND_EMAIL_DOMAIN', value: INBOUND_EMAIL_DOMAIN },
+ });
+ await updateConfigVariable({
+ input: { key: 'RESEND_API_KEY', value: 're_integration_test' },
+ });
+
+ const seededGroupChannel = await messageChannelRepository.findOneByOrFail({
+ id: MESSAGE_CHANNEL_DATA_SEED_IDS.SUPPORT_GROUP,
+ });
+
+ const { id: _id, ...groupChannelColumns } = seededGroupChannel;
+
+ groupHandle = `ch_${randomUUID().replace(/-/g, '')}@${INBOUND_EMAIL_DOMAIN}`;
+
+ const groupChannel = await messageChannelRepository.save({
+ ...groupChannelColumns,
+ handle: groupHandle,
+ });
+
+ groupChannelId = groupChannel.id;
+ }, 60000);
+
+ afterAll(async () => {
+ await messageChannelRepository
+ .delete({ id: groupChannelId })
+ .catch(() => undefined);
+ });
+
+ it('joins the sent thread when the reply carries the Twenty token in References', async () => {
+ const threadToken = `<${randomUUID()}@acme.com>`;
+ const providerMessageId = buildSesProviderMessageId();
+ const sentHeaderMessageId = `<${providerMessageId}@eu-central-1.amazonses.com>`;
+ const replyHeaderMessageId = `<${randomUUID()}@outlook.test>`;
+
+ const sentThreadId = await seedSentMessage({
+ messageChannelId: groupChannelId,
+ providerMessageId,
+ threadExternalId: threadToken,
+ });
+
+ await importReply(
+ buildRawReply({
+ groupHandle,
+ headerMessageId: replyHeaderMessageId,
+ inReplyTo: sentHeaderMessageId,
+ references: `${threadToken} ${sentHeaderMessageId}`,
+ }),
+ );
+
+ expect(await findThreadIdOfMessage(replyHeaderMessageId)).toBe(
+ sentThreadId,
+ );
+ }, 60000);
+
+ it('joins the sent thread when the mail app dropped References and only kept an In-Reply-To whose part before @ is the provider id', async () => {
+ const providerMessageId = buildSesProviderMessageId();
+ const replyHeaderMessageId = `<${randomUUID()}@icloud.test>`;
+
+ const sentThreadId = await seedSentMessage({
+ messageChannelId: groupChannelId,
+ providerMessageId,
+ threadExternalId: `<${randomUUID()}@acme.com>`,
+ });
+
+ await importReply(
+ buildRawReply({
+ groupHandle,
+ headerMessageId: replyHeaderMessageId,
+ inReplyTo: `<${providerMessageId}@email.amazonses.com>`,
+ }),
+ );
+
+ expect(await findThreadIdOfMessage(replyHeaderMessageId)).toBe(
+ sentThreadId,
+ );
+ }, 60000);
+
+ it('starts a new thread when the referenced thread belongs to another channel', async () => {
+ const threadToken = `<${randomUUID()}@acme.com>`;
+ const replyHeaderMessageId = `<${randomUUID()}@gmail.test>`;
+
+ const otherChannelThreadId = await seedSentMessage({
+ messageChannelId: MESSAGE_CHANNEL_DATA_SEED_IDS.SUPPORT_GROUP,
+ providerMessageId: buildSesProviderMessageId(),
+ threadExternalId: threadToken,
+ });
+
+ await importReply(
+ buildRawReply({
+ groupHandle,
+ headerMessageId: replyHeaderMessageId,
+ references: threadToken,
+ }),
+ );
+
+ expect(await findThreadIdOfMessage(replyHeaderMessageId)).not.toBe(
+ otherChannelThreadId,
+ );
+ }, 60000);
+});