The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsindex 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/workspaceWorkspaceIteratorModule,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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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/timelinimport { 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.tsindex 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.tsindex 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.tsindex 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,+ );});});