Skip to content

The open alternative to Salesforce, designed for AI.

Anchor email and calendar timeline activities at their semantic time (#24967)

Félix Malfaita9123f07ac66
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-upgrade-version-command.module.ts
index 2f8bd80e785..fa660808028 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-upgrade-version-command.module.ts
@@ -2,6 +2,7 @@ import { Module } from '@nestjs/common';
import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';
import { EnableEditLayoutAcrossAppCommand } from 'src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1787906715270-enable-edit-layout-across-app.command';
+import { BackfillLinkedTimelineActivityHappensAtCommand } from 'src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1787914663665-backfill-linked-timeline-activity-happens-at.command';
import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
@@ -11,6 +12,9 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
WorkspaceIteratorModule,
WorkspaceMigrationModule,
],
- providers: [EnableEditLayoutAcrossAppCommand],
+ providers: [
+ EnableEditLayoutAcrossAppCommand,
+ BackfillLinkedTimelineActivityHappensAtCommand,
+ ],
})
export class V2_38_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1787914663665-backfill-linked-timeline-activity-happens-at.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1787914663665-backfill-linked-timeline-activity-happens-at.command.ts
new file mode 100644
index 00000000000..8b43fe74e81
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1787914663665-backfill-linked-timeline-activity-happens-at.command.ts
@@ -0,0 +1,121 @@
+import { Command } from 'nest-commander';
+import { isDefined } from 'twenty-shared/utils';
+
+import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';
+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';
+import { buildLinkedTimelineActivityHappensAtBackfillQueries } from 'src/database/commands/upgrade-version-command/2-38/utils/build-linked-timeline-activity-happens-at-backfill-queries.util';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+const BACKFILL_BATCH_SIZE = 5_000;
+
+@RegisteredWorkspaceCommand('2.38.0', 1787914663665)
+@Command({
+ name: 'upgrade:2-38:backfill-linked-timeline-activity-happens-at',
+ description:
+ 'Backfill timelineActivity.happensAt for message and calendar event linked activities from message.receivedAt and calendarEvent.startsAt',
+})
+export class BackfillLinkedTimelineActivityHappensAtCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ options,
+ dataSource,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ if (!isDefined(dataSource)) {
+ this.logger.warn(
+ `Skipping linked timeline activity happensAt backfill for workspace ${workspaceId}: no workspace data source`,
+ );
+
+ return;
+ }
+
+ const schemaName = getWorkspaceSchemaName(workspaceId);
+ const [workspaceTables] = await dataSource.query<
+ Array<{
+ timelineActivity: string | null;
+ message: string | null;
+ calendarEvent: string | null;
+ }>
+ >(
+ `SELECT
+ to_regclass($1) AS "timelineActivity",
+ to_regclass($2) AS "message",
+ to_regclass($3) AS "calendarEvent"`,
+ [
+ `"${schemaName}"."timelineActivity"`,
+ `"${schemaName}"."message"`,
+ `"${schemaName}"."calendarEvent"`,
+ ],
+ );
+
+ if (
+ !isDefined(workspaceTables?.timelineActivity) ||
+ !isDefined(workspaceTables.message) ||
+ !isDefined(workspaceTables.calendarEvent)
+ ) {
+ this.logger.warn(
+ `Skipping linked timeline activity happensAt backfill for workspace ${workspaceId}: tables are not provisioned`,
+ );
+
+ return;
+ }
+
+ const { flatTimelineActivityTypeMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatTimelineActivityTypeMaps',
+ ]);
+
+ const queries = buildLinkedTimelineActivityHappensAtBackfillQueries({
+ schemaName,
+ batchSize: BACKFILL_BATCH_SIZE,
+ flatTimelineActivityTypes: Object.values(
+ flatTimelineActivityTypeMaps.byUniversalIdentifier,
+ ).filter(isDefined),
+ });
+
+ if (options.dryRun) {
+ for (const query of queries) {
+ const [result] = await dataSource.query<Array<{ count: number }>>(
+ query.countSql,
+ query.parameters,
+ );
+
+ this.logger.log(
+ `[DRY RUN] Would rewrite happensAt on ${result?.count ?? 0} ${query.label} for workspace ${workspaceId}`,
+ );
+ }
+
+ return;
+ }
+
+ for (const query of queries) {
+ let backfilledRowCount = 0;
+ let lastBatchRowCount = 0;
+
+ // Each batch commits on its own and only ever picks rows still diverging
+ // from their source timestamp, so an interrupted run resumes cleanly.
+ do {
+ const result = await dataSource.query(
+ query.updateSql,
+ query.parameters,
+ );
+
+ lastBatchRowCount = result?.[1] ?? 0;
+ backfilledRowCount += lastBatchRowCount;
+ } while (lastBatchRowCount === BACKFILL_BATCH_SIZE);
+
+ this.logger.log(
+ `Rewrote happensAt on ${backfilledRowCount} ${query.label} for workspace ${workspaceId}`,
+ );
+ }
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/__tests__/2-38-workspace-command-1787914663665-backfill-linked-timeline-activity-happens-at.command.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/__tests__/2-38-workspace-command-1787914663665-backfill-linked-timeline-activity-happens-at.command.spec.ts
new file mode 100644
index 00000000000..00e2cc5f8c7
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/__tests__/2-38-workspace-command-1787914663665-backfill-linked-timeline-activity-happens-at.command.spec.ts
@@ -0,0 +1,151 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+
+import { type WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { BackfillLinkedTimelineActivityHappensAtCommand } from 'src/database/commands/upgrade-version-command/2-38/2-38-workspace-command-1787914663665-backfill-linked-timeline-activity-happens-at.command';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+const WORKSPACE_ID = '20202020-0000-0000-0000-000000000001';
+
+const buildWorkspaceCacheService = () =>
+ ({
+ getOrRecompute: jest.fn().mockResolvedValue({
+ flatTimelineActivityTypeMaps: {
+ byUniversalIdentifier: {
+ 'message-linked-type-uid': {
+ id: 'message-linked-type-id',
+ action: 'linked',
+ objectUniversalIdentifier:
+ STANDARD_OBJECTS.message.universalIdentifier,
+ },
+ 'calendar-event-linked-type-uid': {
+ id: 'calendar-event-linked-type-id',
+ action: 'linked',
+ objectUniversalIdentifier:
+ STANDARD_OBJECTS.calendarEvent.universalIdentifier,
+ },
+ },
+ },
+ }),
+ }) as unknown as WorkspaceCacheService;
+
+const PROVISIONED_TABLES = [
+ {
+ timelineActivity: 'workspace.timelineActivity',
+ message: 'workspace.message',
+ calendarEvent: 'workspace.calendarEvent',
+ },
+];
+
+describe('BackfillLinkedTimelineActivityHappensAtCommand', () => {
+ it('skips workspaces without a data source', async () => {
+ const command = new BackfillLinkedTimelineActivityHappensAtCommand(
+ {} as WorkspaceIteratorService,
+ buildWorkspaceCacheService(),
+ );
+
+ jest.spyOn(command['logger'], 'warn').mockImplementation();
+
+ await expect(
+ command.runOnWorkspace({
+ workspaceId: WORKSPACE_ID,
+ options: {},
+ dataSource: undefined,
+ index: 0,
+ total: 1,
+ }),
+ ).resolves.toBeUndefined();
+ expect(command['logger'].warn).toHaveBeenCalledWith(
+ `Skipping linked timeline activity happensAt backfill for workspace ${WORKSPACE_ID}: no workspace data source`,
+ );
+ });
+
+ it('skips workspaces whose tables were not provisioned', async () => {
+ const query = jest.fn().mockResolvedValue([
+ {
+ timelineActivity: null,
+ message: null,
+ calendarEvent: null,
+ },
+ ]);
+ const command = new BackfillLinkedTimelineActivityHappensAtCommand(
+ {} as WorkspaceIteratorService,
+ buildWorkspaceCacheService(),
+ );
+
+ jest.spyOn(command['logger'], 'warn').mockImplementation();
+
+ await command.runOnWorkspace({
+ workspaceId: WORKSPACE_ID,
+ options: {},
+ dataSource: { query } as never,
+ index: 0,
+ total: 1,
+ });
+
+ expect(query).toHaveBeenCalledTimes(1);
+ expect(command['logger'].warn).toHaveBeenCalledWith(
+ `Skipping linked timeline activity happensAt backfill for workspace ${WORKSPACE_ID}: tables are not provisioned`,
+ );
+ });
+
+ it('only counts candidates on a dry run', async () => {
+ const query = jest
+ .fn()
+ .mockResolvedValueOnce(PROVISIONED_TABLES)
+ .mockResolvedValueOnce([{ count: 12 }])
+ .mockResolvedValueOnce([{ count: 3 }]);
+ const command = new BackfillLinkedTimelineActivityHappensAtCommand(
+ {} as WorkspaceIteratorService,
+ buildWorkspaceCacheService(),
+ );
+
+ jest.spyOn(command['logger'], 'log').mockImplementation();
+
+ await command.runOnWorkspace({
+ workspaceId: WORKSPACE_ID,
+ options: { dryRun: true },
+ dataSource: { query } as never,
+ index: 0,
+ total: 1,
+ });
+
+ expect(query).toHaveBeenCalledTimes(3);
+ expect(command['logger'].log).toHaveBeenCalledWith(
+ `[DRY RUN] Would rewrite happensAt on 12 message timeline activities for workspace ${WORKSPACE_ID}`,
+ );
+ expect(command['logger'].log).toHaveBeenCalledWith(
+ `[DRY RUN] Would rewrite happensAt on 3 calendar event timeline activities for workspace ${WORKSPACE_ID}`,
+ );
+ });
+
+ it('keeps rewriting batches until one comes back partial', async () => {
+ const query = jest
+ .fn()
+ .mockResolvedValueOnce(PROVISIONED_TABLES)
+ .mockResolvedValueOnce([[], 5_000])
+ .mockResolvedValueOnce([[], 42])
+ .mockResolvedValueOnce([[], 0]);
+ const command = new BackfillLinkedTimelineActivityHappensAtCommand(
+ {} as WorkspaceIteratorService,
+ buildWorkspaceCacheService(),
+ );
+
+ jest.spyOn(command['logger'], 'log').mockImplementation();
+
+ await command.runOnWorkspace({
+ workspaceId: WORKSPACE_ID,
+ options: {},
+ dataSource: { query } as never,
+ index: 0,
+ total: 1,
+ });
+
+ expect(query).toHaveBeenCalledTimes(4);
+ expect(command['logger'].log).toHaveBeenCalledWith(
+ `Rewrote happensAt on 5042 message timeline activities for workspace ${WORKSPACE_ID}`,
+ );
+ expect(command['logger'].log).toHaveBeenCalledWith(
+ `Rewrote happensAt on 0 calendar event timeline activities for workspace ${WORKSPACE_ID}`,
+ );
+ });
+});
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/__tests__/build-linked-timeline-activity-happens-at-backfill-queries.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/__tests__/build-linked-timeline-activity-happens-at-backfill-queries.util.spec.ts
new file mode 100644
index 00000000000..91e0eaaef06
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/__tests__/build-linked-timeline-activity-happens-at-backfill-queries.util.spec.ts
@@ -0,0 +1,89 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+
+import { buildLinkedTimelineActivityHappensAtBackfillQueries } from 'src/database/commands/upgrade-version-command/2-38/utils/build-linked-timeline-activity-happens-at-backfill-queries.util';
+
+const MESSAGE_LINKED_TYPE = {
+ id: 'message-linked-type-id',
+ action: 'linked' as const,
+ objectUniversalIdentifier: STANDARD_OBJECTS.message.universalIdentifier,
+};
+
+const CALENDAR_EVENT_LINKED_TYPE = {
+ id: 'calendar-event-linked-type-id',
+ action: 'linked' as const,
+ objectUniversalIdentifier:
+ STANDARD_OBJECTS.calendarEvent.universalIdentifier,
+};
+
+describe('buildLinkedTimelineActivityHappensAtBackfillQueries', () => {
+ const queries = buildLinkedTimelineActivityHappensAtBackfillQueries({
+ schemaName: 'workspace_test',
+ batchSize: 5_000,
+ flatTimelineActivityTypes: [MESSAGE_LINKED_TYPE, CALENDAR_EVENT_LINKED_TYPE],
+ });
+
+ it('builds one bounded update per linked source object', () => {
+ expect(queries.map(({ label }) => label)).toEqual([
+ 'message timeline activities',
+ 'calendar event timeline activities',
+ ]);
+
+ for (const { updateSql } of queries) {
+ expect(updateSql).toContain('LIMIT 5000');
+ expect(updateSql).toContain('"workspace_test"');
+ expect(updateSql).toContain(
+ `"timelineActivityTypeId" = ANY($1::uuid[])`,
+ );
+ }
+ });
+
+ it('rewrites happensAt from the source semantic timestamp column', () => {
+ const [messageQuery, calendarEventQuery] = queries;
+
+ expect(messageQuery.updateSql).toContain(
+ 'SET "happensAt" = source."receivedAt"',
+ );
+ expect(messageQuery.updateSql).toContain('"workspace_test"."message"');
+ expect(messageQuery.parameters).toEqual([[MESSAGE_LINKED_TYPE.id]]);
+
+ expect(calendarEventQuery.updateSql).toContain(
+ 'SET "happensAt" = source."startsAt"',
+ );
+ expect(calendarEventQuery.updateSql).toContain(
+ '"workspace_test"."calendarEvent"',
+ );
+ expect(calendarEventQuery.parameters).toEqual([
+ [CALENDAR_EVENT_LINKED_TYPE.id],
+ ]);
+ });
+
+ it('only ever picks rows still diverging from their source timestamp', () => {
+ for (const { updateSql, countSql } of queries) {
+ expect(updateSql).toContain('IS DISTINCT FROM');
+ expect(updateSql).toContain('IS NOT NULL');
+ expect(countSql).toContain('IS DISTINCT FROM');
+ }
+ });
+
+ it('ignores types with another action or object', () => {
+ expect(
+ buildLinkedTimelineActivityHappensAtBackfillQueries({
+ schemaName: 'workspace_test',
+ batchSize: 5_000,
+ flatTimelineActivityTypes: [
+ {
+ id: 'message-unlinked-type-id',
+ action: 'unlinked',
+ objectUniversalIdentifier:
+ STANDARD_OBJECTS.message.universalIdentifier,
+ },
+ {
+ id: 'note-linked-type-id',
+ action: 'linked',
+ objectUniversalIdentifier: STANDARD_OBJECTS.note.universalIdentifier,
+ },
+ ],
+ }),
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/build-linked-timeline-activity-happens-at-backfill-queries.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/build-linked-timeline-activity-happens-at-backfill-queries.util.ts
new file mode 100644
index 00000000000..56097d0e0f2
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-38/utils/build-linked-timeline-activity-happens-at-backfill-queries.util.ts
@@ -0,0 +1,108 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+
+import { type FlatTimelineActivityType } from 'src/engine/metadata-modules/flat-timeline-activity-type/types/flat-timeline-activity-type.type';
+
+type LinkedTimelineActivityHappensAtBackfillQuery = {
+ label: string;
+ countSql: string;
+ updateSql: string;
+ parameters: [string[]];
+};
+
+type LinkedSourceObject = {
+ label: string;
+ objectUniversalIdentifier: string;
+ sourceTableName: 'message' | 'calendarEvent';
+ happensAtColumnName: 'receivedAt' | 'startsAt';
+};
+
+// Linked activities were historically stamped with the participant row's own
+// timestamps, so synced emails and meetings sat at import time instead of when
+// they happened. The write path now uses these same source columns.
+const LINKED_SOURCE_OBJECTS: LinkedSourceObject[] = [
+ {
+ label: 'message timeline activities',
+ objectUniversalIdentifier: STANDARD_OBJECTS.message.universalIdentifier,
+ sourceTableName: 'message',
+ happensAtColumnName: 'receivedAt',
+ },
+ {
+ label: 'calendar event timeline activities',
+ objectUniversalIdentifier:
+ STANDARD_OBJECTS.calendarEvent.universalIdentifier,
+ sourceTableName: 'calendarEvent',
+ happensAtColumnName: 'startsAt',
+ },
+];
+
+const buildQueryForSourceObject = ({
+ schemaName,
+ batchSize,
+ sourceObject,
+ timelineActivityTypeIds,
+}: {
+ schemaName: string;
+ batchSize: number;
+ sourceObject: LinkedSourceObject;
+ timelineActivityTypeIds: string[];
+}): LinkedTimelineActivityHappensAtBackfillQuery => {
+ const { label, sourceTableName, happensAtColumnName } = sourceObject;
+
+ const candidateSql = `SELECT candidate_timeline_activity."id"
+FROM "${schemaName}"."timelineActivity" candidate_timeline_activity
+INNER JOIN "${schemaName}"."${sourceTableName}" candidate_source
+ ON candidate_source."id" = candidate_timeline_activity."linkedRecordId"
+WHERE candidate_timeline_activity."timelineActivityTypeId" = ANY($1::uuid[])
+ AND candidate_source."${happensAtColumnName}" IS NOT NULL
+ AND candidate_timeline_activity."happensAt" IS DISTINCT FROM candidate_source."${happensAtColumnName}"`;
+
+ return {
+ label,
+ countSql: `SELECT COUNT(*)::int AS "count" FROM (${candidateSql}) candidates`,
+ updateSql: `UPDATE "${schemaName}"."timelineActivity" timeline_activity
+SET "happensAt" = source."${happensAtColumnName}"
+FROM "${schemaName}"."${sourceTableName}" source
+WHERE timeline_activity."id" IN (${candidateSql}
+ LIMIT ${batchSize})
+ AND source."id" = timeline_activity."linkedRecordId"`,
+ parameters: [timelineActivityTypeIds],
+ };
+};
+
+export const buildLinkedTimelineActivityHappensAtBackfillQueries = ({
+ schemaName,
+ batchSize,
+ flatTimelineActivityTypes,
+}: {
+ schemaName: string;
+ batchSize: number;
+ flatTimelineActivityTypes: Pick<
+ FlatTimelineActivityType,
+ 'id' | 'action' | 'objectUniversalIdentifier'
+ >[];
+}): LinkedTimelineActivityHappensAtBackfillQuery[] =>
+ LINKED_SOURCE_OBJECTS.flatMap((sourceObject) => {
+ // Inactive types still label rows written while they were active, so they
+ // stay in scope; the filter mirrors how the write path picks the type.
+ const timelineActivityTypeIds = flatTimelineActivityTypes
+ .filter(
+ (flatTimelineActivityType) =>
+ flatTimelineActivityType.action === 'linked' &&
+ flatTimelineActivityType.objectUniversalIdentifier ===
+ sourceObject.objectUniversalIdentifier,
+ )
+ .map((flatTimelineActivityType) => flatTimelineActivityType.id);
+
+ if (timelineActivityTypeIds.length === 0) {
+ return [];
+ }
+
+ return [
+ buildQueryForSourceObject({
+ schemaName,
+ batchSize,
+ sourceObject,
+ timelineActivityTypeIds,
+ }),
+ ];
+ });
diff --git a/packages/twenty-server/src/modules/timeline/services/timeline-activity.service.ts b/packages/twenty-server/src/modules/timeline/services/timeline-activity.service.ts
index 5a966fd10be..f1301d6705e 100644
--- a/packages/twenty-server/src/modules/timeline/services/timeline-activity.service.ts
+++ b/packages/twenty-server/src/modules/timeline/services/timeline-activity.service.ts
@@ -27,7 +27,10 @@ import { type TimelineActivityPayload } from 'src/modules/timeline/types/timelin
import { type TimelineActivityRuleAction } from 'src/modules/timeline/types/timeline-activity-rule-action.type';
import { type TimelineActivityRule } from 'src/modules/timeline/types/timeline-activity-rule.type';
import { resolveLinkedRecordCachedName } from 'src/modules/timeline/utils/resolve-linked-record-cached-name.util';
-import { resolveTimelineActivityHappensAt } from 'src/modules/timeline/utils/resolve-timeline-activity-happens-at.util';
+import {
+ resolveLinkedTimelineActivityHappensAt,
+ resolveTimelineActivityHappensAt,
+} from 'src/modules/timeline/utils/resolve-timeline-activity-happens-at.util';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
import { doesTimelineActivityLinkChange } from 'src/modules/timeline/utils/does-timeline-activity-link-change.util';
import { resolveTimelineActivityRuleAction } from 'src/modules/timeline/utils/resolve-timeline-activity-rule-action.util';
@@ -335,7 +338,13 @@ export class TimelineActivityService {
record,
flatFieldMetadataMaps,
}),
- happensAt: resolveTimelineActivityHappensAt(event),
+ happensAt: resolveLinkedTimelineActivityHappensAt({
+ event,
+ ruleAction,
+ sourceFlatObjectMetadata: rule.sourceFlatObjectMetadata,
+ sourceRecord: record,
+ flatFieldMetadataMaps,
+ }),
properties: event.properties,
}),
];
@@ -363,7 +372,13 @@ export class TimelineActivityService {
record: event.properties.after as ObjectRecord | undefined,
flatFieldMetadataMaps,
}),
- happensAt: resolveTimelineActivityHappensAt(event),
+ happensAt: resolveLinkedTimelineActivityHappensAt({
+ event,
+ ruleAction,
+ sourceFlatObjectMetadata: rule.sourceFlatObjectMetadata,
+ sourceRecord: event.properties.after as ObjectRecord | undefined,
+ flatFieldMetadataMaps,
+ }),
properties: event.properties,
}),
),
@@ -455,8 +470,10 @@ export class TimelineActivityService {
// The junction event is the semantic fact; this enrichment read can race
// the transaction that created the linked record.
- return eventsWithJunctionRecord.map(({ event, target, sourceRecordId }) =>
- buildLinkedPayload({
+ return eventsWithJunctionRecord.map(({ event, target, sourceRecordId }) => {
+ const sourceRecord = sourceRecordsByRecordId.get(sourceRecordId);
+
+ return buildLinkedPayload({
rule,
timelineActivityType,
target,
@@ -464,13 +481,19 @@ export class TimelineActivityService {
linkedRecordId: sourceRecordId,
linkedRecordCachedName: resolveLinkedRecordCachedName({
rule,
- record: sourceRecordsByRecordId.get(sourceRecordId),
+ record: sourceRecord,
+ flatFieldMetadataMaps,
+ }),
+ happensAt: resolveLinkedTimelineActivityHappensAt({
+ event,
+ ruleAction,
+ sourceFlatObjectMetadata: rule.sourceFlatObjectMetadata,
+ sourceRecord,
flatFieldMetadataMaps,
}),
- happensAt: resolveTimelineActivityHappensAt(event),
properties: {},
- }),
- );
+ });
+ });
}
private async enrichEventsWithWorkspaceMemberId({
diff --git a/packages/twenty-server/src/modules/timeline/utils/__tests__/resolve-timeline-activity-happens-at.util.spec.ts b/packages/twenty-server/src/modules/timeline/utils/__tests__/resolve-timeline-activity-happens-at.util.spec.ts
index 32f4d2e2828..ba2e603179c 100644
--- a/packages/twenty-server/src/modules/timeline/utils/__tests__/resolve-timeline-activity-happens-at.util.spec.ts
+++ b/packages/twenty-server/src/modules/timeline/utils/__tests__/resolve-timeline-activity-happens-at.util.spec.ts
@@ -1,8 +1,15 @@
import { type ObjectRecordBaseEvent } from 'twenty-shared/database-events';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
-import { resolveTimelineActivityHappensAt } from 'src/modules/timeline/utils/resolve-timeline-activity-happens-at.util';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import {
+ resolveLinkedTimelineActivityHappensAt,
+ resolveTimelineActivityHappensAt,
+} from 'src/modules/timeline/utils/resolve-timeline-activity-happens-at.util';
const EVENT_TIME = new Date('2026-08-22T12:00:00.000Z');
+const SOURCE_TIME = new Date('2024-03-15T09:30:00.000Z');
describe('resolveTimelineActivityHappensAt', () => {
it('uses the mutation timestamp from the record after the event', () => {
@@ -31,3 +38,115 @@ describe('resolveTimelineActivityHappensAt', () => {
jest.useRealTimers();
});
});
+
+describe('resolveLinkedTimelineActivityHappensAt', () => {
+ const event = {
+ properties: { after: { updatedAt: EVENT_TIME.toISOString() } },
+ } as ObjectRecordBaseEvent;
+
+ const buildFlatFieldMetadataMaps = (
+ fields: { universalIdentifier: string; name: string }[],
+ ): FlatEntityMaps<FlatFieldMetadata> =>
+ ({
+ byUniversalIdentifier: Object.fromEntries(
+ fields.map((field) => [field.universalIdentifier, field]),
+ ),
+ universalIdentifierById: {},
+ universalIdentifiersByApplicationId: {},
+ }) as unknown as FlatEntityMaps<FlatFieldMetadata>;
+
+ const messageFlatObjectMetadata = {
+ universalIdentifier: STANDARD_OBJECTS.message.universalIdentifier,
+ };
+
+ const calendarEventFlatObjectMetadata = {
+ universalIdentifier: STANDARD_OBJECTS.calendarEvent.universalIdentifier,
+ };
+
+ const flatFieldMetadataMaps = buildFlatFieldMetadataMaps([
+ {
+ universalIdentifier:
+ STANDARD_OBJECTS.message.fields.receivedAt.universalIdentifier,
+ name: 'receivedAt',
+ },
+ {
+ universalIdentifier:
+ STANDARD_OBJECTS.calendarEvent.fields.startsAt.universalIdentifier,
+ name: 'startsAt',
+ },
+ ]);
+
+ it('anchors a linked message at its receivedAt instead of the sync time', () => {
+ expect(
+ resolveLinkedTimelineActivityHappensAt({
+ event,
+ ruleAction: 'linked',
+ sourceFlatObjectMetadata: messageFlatObjectMetadata,
+ sourceRecord: { receivedAt: SOURCE_TIME.toISOString() },
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual(SOURCE_TIME);
+ });
+
+ it('anchors a linked calendar event at its startsAt instead of the sync time', () => {
+ expect(
+ resolveLinkedTimelineActivityHappensAt({
+ event,
+ ruleAction: 'linked',
+ sourceFlatObjectMetadata: calendarEventFlatObjectMetadata,
+ sourceRecord: { startsAt: SOURCE_TIME.toISOString() },
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual(SOURCE_TIME);
+ });
+
+ it('keeps the event timestamp for rule actions other than linked', () => {
+ expect(
+ resolveLinkedTimelineActivityHappensAt({
+ event,
+ ruleAction: 'unlinked',
+ sourceFlatObjectMetadata: messageFlatObjectMetadata,
+ sourceRecord: { receivedAt: SOURCE_TIME.toISOString() },
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual(EVENT_TIME);
+ });
+
+ it('keeps the event timestamp for objects without a semantic timestamp', () => {
+ expect(
+ resolveLinkedTimelineActivityHappensAt({
+ event,
+ ruleAction: 'linked',
+ sourceFlatObjectMetadata: {
+ universalIdentifier: STANDARD_OBJECTS.note.universalIdentifier,
+ },
+ sourceRecord: { receivedAt: SOURCE_TIME.toISOString() },
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual(EVENT_TIME);
+ });
+
+ it('keeps the event timestamp when the source record read raced the write', () => {
+ expect(
+ resolveLinkedTimelineActivityHappensAt({
+ event,
+ ruleAction: 'linked',
+ sourceFlatObjectMetadata: messageFlatObjectMetadata,
+ sourceRecord: undefined,
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual(EVENT_TIME);
+ });
+
+ it('keeps the event timestamp when the semantic timestamp is null', () => {
+ expect(
+ resolveLinkedTimelineActivityHappensAt({
+ event,
+ ruleAction: 'linked',
+ sourceFlatObjectMetadata: messageFlatObjectMetadata,
+ sourceRecord: { receivedAt: null },
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual(EVENT_TIME);
+ });
+});
diff --git a/packages/twenty-server/src/modules/timeline/utils/resolve-timeline-activity-happens-at.util.ts b/packages/twenty-server/src/modules/timeline/utils/resolve-timeline-activity-happens-at.util.ts
index 8a627c75e2c..69a2b7949f3 100644
--- a/packages/twenty-server/src/modules/timeline/utils/resolve-timeline-activity-happens-at.util.ts
+++ b/packages/twenty-server/src/modules/timeline/utils/resolve-timeline-activity-happens-at.util.ts
@@ -1,7 +1,14 @@
import { type ObjectRecordBaseEvent } from 'twenty-shared/database-events';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
import { isNonEmptyString } from '@sniptt/guards';
import { isDefined } from 'twenty-shared/utils';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { type TimelineActivityRuleAction } from 'src/modules/timeline/types/timeline-activity-rule-action.type';
+
const parseTimestamp = (value: unknown): Date | undefined => {
if (value instanceof Date) {
return Number.isNaN(value.getTime()) ? undefined : value;
@@ -34,3 +41,51 @@ export const resolveTimelineActivityHappensAt = (
return isDefined(recordTimestamp) ? recordTimestamp : new Date();
};
+
+// Synced records carry their own moment in time: an email happened when it was
+// received and a calendar event when it starts, not when a sync or a late
+// participant match wrote the row.
+const LINKED_HAPPENS_AT_FIELD_UNIVERSAL_IDENTIFIER_BY_OBJECT_UNIVERSAL_IDENTIFIER: Partial<
+ Record<string, string>
+> = {
+ [STANDARD_OBJECTS.message.universalIdentifier]:
+ STANDARD_OBJECTS.message.fields.receivedAt.universalIdentifier,
+ [STANDARD_OBJECTS.calendarEvent.universalIdentifier]:
+ STANDARD_OBJECTS.calendarEvent.fields.startsAt.universalIdentifier,
+};
+
+export const resolveLinkedTimelineActivityHappensAt = ({
+ event,
+ ruleAction,
+ sourceFlatObjectMetadata,
+ sourceRecord,
+ flatFieldMetadataMaps,
+}: {
+ event: ObjectRecordBaseEvent;
+ ruleAction: TimelineActivityRuleAction;
+ sourceFlatObjectMetadata: Pick<FlatObjectMetadata, 'universalIdentifier'>;
+ sourceRecord: Record<string, unknown> | undefined;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): Date => {
+ const happensAtFieldUniversalIdentifier =
+ ruleAction === 'linked'
+ ? LINKED_HAPPENS_AT_FIELD_UNIVERSAL_IDENTIFIER_BY_OBJECT_UNIVERSAL_IDENTIFIER[
+ sourceFlatObjectMetadata.universalIdentifier
+ ]
+ : undefined;
+
+ if (!isDefined(happensAtFieldUniversalIdentifier)) {
+ return resolveTimelineActivityHappensAt(event);
+ }
+
+ const happensAtFieldName = findFlatEntityByUniversalIdentifier({
+ flatEntityMaps: flatFieldMetadataMaps,
+ universalIdentifier: happensAtFieldUniversalIdentifier,
+ })?.name;
+
+ const sourceRecordHappensAt = isDefined(happensAtFieldName)
+ ? parseTimestamp(sourceRecord?.[happensAtFieldName])
+ : undefined;
+
+ return sourceRecordHappensAt ?? resolveTimelineActivityHappensAt(event);
+};
diff --git a/packages/twenty-server/test/integration/graphql/suites/timeline/timeline-activity-write-path.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/timeline/timeline-activity-write-path.integration-spec.ts
index 98b923e7f87..f43635588ec 100644
--- a/packages/twenty-server/test/integration/graphql/suites/timeline/timeline-activity-write-path.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/timeline/timeline-activity-write-path.integration-spec.ts
@@ -177,6 +177,8 @@ const ROUTED_MESSAGE_PARTICIPANT_ID = '20202020-7171-4000-8000-000000000013';
const ROUTED_CALENDAR_EVENT_ID = '20202020-7171-4000-8000-000000000014';
const ROUTED_CALENDAR_EVENT_PARTICIPANT_ID =
'20202020-7171-4000-8000-000000000015';
+const ROUTED_MESSAGE_RECEIVED_AT = '2024-03-15T09:30:00.000Z';
+const ROUTED_CALENDAR_EVENT_STARTS_AT = '2024-04-02T14:00:00.000Z';
const ATTACHMENT_ID = '20202020-7171-4000-8000-000000000016';
const ORM_V2_COMPOSITE_COMPANY_ID = '20202020-7171-4000-8000-000000000017';
const BATCH_COMPANY_IDS = [
@@ -604,7 +606,7 @@ describe('timeline activity write path (integration)', () => {
messageThreadId: ROUTED_MESSAGE_THREAD_ID,
subject: 'Generic message routing',
text: 'No specialized listener required',
- receivedAt: new Date().toISOString(),
+ receivedAt: ROUTED_MESSAGE_RECEIVED_AT,
},
});
await createRecord({
@@ -638,6 +640,9 @@ describe('timeline activity write path (integration)', () => {
linkedRecordId: ROUTED_MESSAGE_ID,
linkedRecordCachedName: 'Generic message routing',
});
+ expect(new Date(messageActivities[0].happensAt).toISOString()).toBe(
+ ROUTED_MESSAGE_RECEIVED_AT,
+ );
await updateRecord({
objectMetadataSingularName: 'messageParticipant',
@@ -663,8 +668,8 @@ describe('timeline activity write path (integration)', () => {
id: ROUTED_CALENDAR_EVENT_ID,
title: 'Generic calendar routing',
isFullDay: false,
- startsAt: new Date().toISOString(),
- endsAt: new Date().toISOString(),
+ startsAt: ROUTED_CALENDAR_EVENT_STARTS_AT,
+ endsAt: ROUTED_CALENDAR_EVENT_STARTS_AT,
},
});
await createRecord({
@@ -699,6 +704,9 @@ describe('timeline activity write path (integration)', () => {
linkedRecordId: ROUTED_CALENDAR_EVENT_ID,
linkedRecordCachedName: 'Generic calendar routing',
});
+ expect(new Date(calendarActivities[0].happensAt).toISOString()).toBe(
+ ROUTED_CALENDAR_EVENT_STARTS_AT,
+ );
});
});