The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Follow reschedules on linked timeline activities (#24968)
Félix Malfaitfcde9ea94685
diff --git a/packages/twenty-server/src/modules/timeline/repositories/timeline-activity.repository.ts b/packages/twenty-server/src/modules/timeline/repositories/timeline-activity.repository.tsindex 4279ccdb439..6f1ba15a645 100644--- a/packages/twenty-server/src/modules/timeline/repositories/timeline-activity.repository.ts+++ b/packages/twenty-server/src/modules/timeline/repositories/timeline-activity.repository.ts@@ -1,5 +1,7 @@import { Injectable } from '@nestjs/common';+import chunk from 'lodash.chunk';+import { QUERY_MAX_RECORDS } from 'twenty-shared/constants';import { type ObjectRecord } from 'twenty-shared/types';import { isDefined } from 'twenty-shared/utils';import { In, MoreThan, type ObjectLiteral } from 'typeorm';@@ -11,10 +13,12 @@ import { type WorkspaceTransactionScope } from 'src/engine/twenty-orm/types/workimport { type WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace-repository';import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';import { type TimelineActivityPayload } from 'src/modules/timeline/types/timeline-activity-payload';+import { type LinkedTimelineActivityHappensAtSyncUpdate } from 'src/modules/timeline/utils/build-linked-timeline-activity-happens-at-sync-updates.util';import {buildTimelineActivityMergeKey,buildTimelineActivityMergeKeyCandidates,} from 'src/modules/timeline/utils/build-timeline-activity-merge-key.util';+import { parseLinkedTimelineActivityHappensAt } from 'src/modules/timeline/utils/resolve-timeline-activity-happens-at.util';import { buildTimelineActivityRelatedMorphFieldMetadataName } from 'src/modules/timeline/utils/timeline-activity-related-morph-field-metadata-name-builder.util';type TimelineActivityPayloadWorkspaceIdAndObjectSingularName = {@@ -57,6 +61,94 @@ export class TimelineActivityRepository {}}+ async updateLinkedTimelineActivitiesHappensAt({+ workspaceId,+ updates,+ }: {+ workspaceId: string;+ updates: LinkedTimelineActivityHappensAtSyncUpdate[];+ }) {+ if (updates.length === 0) {+ return;+ }++ const authContext = buildSystemAuthContext(workspaceId);++ await this.workspaceOrmManager.executeInWorkspaceContext(async () => {+ for (const update of updates) {+ await this.syncLinkedTimelineActivitiesHappensAtFromSourceRecords(+ update,+ );+ }+ }, authContext);+ }++ private async syncLinkedTimelineActivitiesHappensAtFromSourceRecords({+ sourceObjectNameSingular,+ happensAtFieldName,+ timelineActivityTypeIds,+ linkedRecordIds,+ }: LinkedTimelineActivityHappensAtSyncUpdate) {+ const sourceRepository =+ this.workspaceOrmManager.getRepository<ObjectLiteral>(+ sourceObjectNameSingular,+ { shouldBypassPermissionChecks: true },+ );++ // Queue retries can replay an older source event after a newer one, so the+ // value is read from the source row at write time instead of trusting the+ // event snapshot: a replay then rewrites the current value, not a stale one.+ const sourceRecords = await sourceRepository.find({+ select: ['id', happensAtFieldName],+ where: { id: In(linkedRecordIds) },+ });++ const happensAtByLinkedRecordId = new Map<string, Date>();++ for (const sourceRecord of sourceRecords) {+ const happensAt = parseLinkedTimelineActivityHappensAt(+ sourceRecord[happensAtFieldName],+ );++ // A cleared timestamp keeps the previously written happensAt+ if (isDefined(happensAt)) {+ happensAtByLinkedRecordId.set(sourceRecord.id, happensAt);+ }+ }++ if (happensAtByLinkedRecordId.size === 0) {+ return;+ }++ const timelineActivityRepository =+ this.workspaceOrmManager.getRepository<ObjectLiteral>(+ 'timelineActivity',+ { shouldBypassPermissionChecks: true },+ );++ const timelineActivities = await timelineActivityRepository.find({+ select: ['id', 'linkedRecordId'],+ where: {+ linkedRecordId: In([...happensAtByLinkedRecordId.keys()]),+ timelineActivityTypeId: In(timelineActivityTypeIds),+ },+ });++ const updateInputs = timelineActivities.flatMap((timelineActivity) => {+ const happensAt = happensAtByLinkedRecordId.get(+ timelineActivity.linkedRecordId,+ );++ return isDefined(happensAt)+ ? [{ criteria: timelineActivity.id, partialEntity: { happensAt } }]+ : [];+ });++ for (const updateInputsChunk of chunk(updateInputs, QUERY_MAX_RECORDS)) {+ await timelineActivityRepository.updateMany(updateInputsChunk);+ }+ }+private async upsertTimelineActivitiesOnce({objectSingularName,workspaceId,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 f1301d6705e..572c30ec39a 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@@ -26,14 +26,16 @@ import { type ResolvedTimelineActivityTarget } from 'src/modules/timeline/types/import { type TimelineActivityPayload } from 'src/modules/timeline/types/timeline-activity-payload';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 { buildLinkedTimelineActivityHappensAtSyncUpdates } from 'src/modules/timeline/utils/build-linked-timeline-activity-happens-at-sync-updates.util';import { resolveLinkedRecordCachedName } from 'src/modules/timeline/utils/resolve-linked-record-cached-name.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 { doesObjectRecordEventChangeFields } from 'src/modules/timeline/utils/does-object-record-event-change-fields.util';import { resolveTimelineActivityRuleAction } from 'src/modules/timeline/utils/resolve-timeline-activity-rule-action.util';+import { resolveTimelineActivityTypeForRule } from 'src/modules/timeline/utils/resolve-timeline-activity-type-for-rule.util';type BuildPayloadsForRuleArgs = {rule: TimelineActivityRule;@@ -171,6 +173,20 @@ export class TimelineActivityService {}, buildSystemAuthContext(workspaceId))).flat();+ if (action === 'updated') {+ await this.timelineActivityRepository.updateLinkedTimelineActivitiesHappensAt(+ {+ workspaceId,+ updates: buildLinkedTimelineActivityHappensAtSyncUpdates({+ rules: sourceRules,+ events: eventsWithoutPositionDiff,+ flatFieldMetadataMaps,+ resolveTimelineActivityType,+ }),+ },+ );+ }+if (payloads.length === 0) {return;}@@ -217,25 +233,6 @@ export class TimelineActivityService {);}- private resolveTimelineActivityTypeForRule({- rule,- ruleAction,- resolveTimelineActivityType,- }: {- rule: TimelineActivityRule;- ruleAction: TimelineActivityRuleAction;- resolveTimelineActivityType: TimelineActivityTypeResolver;- }): ResolvedTimelineActivityType | undefined {- return (- rule.timelineActivityType ??- resolveTimelineActivityType({- action: ruleAction,- objectUniversalIdentifier:- rule.sourceFlatObjectMetadata.universalIdentifier,- })- );- }-private async buildPayloadsForSourceRule({rule,events,@@ -254,7 +251,7 @@ export class TimelineActivityService {return [];}- const timelineActivityType = this.resolveTimelineActivityTypeForRule({+ const timelineActivityType = resolveTimelineActivityTypeForRule({rule,ruleAction,resolveTimelineActivityType,@@ -270,9 +267,9 @@ export class TimelineActivityService {rule.targetShape.kind !== 'DIRECT_RELATION' ||action !== 'updated' ||ruleAction === 'updated' ||- doesTimelineActivityLinkChange({+ doesObjectRecordEventChangeFields({event,- joinColumnNames: rule.targetShape.targetJoinColumns.map(+ fieldNames: rule.targetShape.targetJoinColumns.map(({ joinColumnName }) => joinColumnName,),}),@@ -403,7 +400,7 @@ export class TimelineActivityService {return [];}- const timelineActivityType = this.resolveTimelineActivityTypeForRule({+ const timelineActivityType = resolveTimelineActivityTypeForRule({rule,ruleAction,resolveTimelineActivityType,@@ -420,9 +417,9 @@ export class TimelineActivityService {.filter((event) =>action !== 'updated' ||- doesTimelineActivityLinkChange({+ doesObjectRecordEventChangeFields({event,- joinColumnNames: [+ fieldNames: [targetShape.junctionSourceJoinColumnName,...targetShape.targetJoinColumns.map(({ joinColumnName }) => joinColumnName,diff --git a/packages/twenty-server/src/modules/timeline/utils/__tests__/build-linked-timeline-activity-happens-at-sync-updates.util.spec.ts b/packages/twenty-server/src/modules/timeline/utils/__tests__/build-linked-timeline-activity-happens-at-sync-updates.util.spec.tsnew file mode 100644index 00000000000..75c183079cc--- /dev/null+++ b/packages/twenty-server/src/modules/timeline/utils/__tests__/build-linked-timeline-activity-happens-at-sync-updates.util.spec.ts@@ -0,0 +1,157 @@+import { type ObjectRecordBaseEvent } from 'twenty-shared/database-events';+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';++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 { type TimelineActivityRule } from 'src/modules/timeline/types/timeline-activity-rule.type';+import { buildLinkedTimelineActivityHappensAtSyncUpdates } from 'src/modules/timeline/utils/build-linked-timeline-activity-happens-at-sync-updates.util';++const CALENDAR_EVENT_ID = 'calendar-event-id';+const LINKED_TYPE_ID = 'calendar-event-linked-type-id';++const flatFieldMetadataMaps = {+ byUniversalIdentifier: {+ [STANDARD_OBJECTS.calendarEvent.fields.startsAt.universalIdentifier]: {+ universalIdentifier:+ STANDARD_OBJECTS.calendarEvent.fields.startsAt.universalIdentifier,+ name: 'startsAt',+ },+ },+ universalIdentifierById: {},+ universalIdentifiersByApplicationId: {},+} as unknown as FlatEntityMaps<FlatFieldMetadata>;++const buildCalendarEventRule = (+ overrides: Partial<TimelineActivityRule> = {},+): TimelineActivityRule =>+ ({+ sourceFlatObjectMetadata: {+ universalIdentifier: STANDARD_OBJECTS.calendarEvent.universalIdentifier,+ nameSingular: 'calendarEvent',+ },+ actions: ['linked'],+ timelineActivityType: {+ id: LINKED_TYPE_ID,+ applicationId: 'application-id',+ snapshot: {},+ },+ triggerFieldNames: null,+ targetShape: { kind: 'JUNCTION' },+ ...overrides,+ }) as TimelineActivityRule;++const buildStartsAtUpdatedEvent = (+ recordId = CALENDAR_EVENT_ID,+): ObjectRecordBaseEvent =>+ ({+ recordId,+ properties: {+ diff: {+ startsAt: {+ before: '2026-09-01T10:00:00.000Z',+ after: '2026-09-12T10:00:00.000Z',+ },+ },+ },+ }) as unknown as ObjectRecordBaseEvent;++const resolveTimelineActivityTypeToNothing = () => undefined;++describe('buildLinkedTimelineActivityHappensAtSyncUpdates', () => {+ it('collects the changed records when the semantic timestamp changes', () => {+ expect(+ buildLinkedTimelineActivityHappensAtSyncUpdates({+ rules: [buildCalendarEventRule()],+ events: [+ buildStartsAtUpdatedEvent(),+ buildStartsAtUpdatedEvent('other-calendar-event-id'),+ ],+ flatFieldMetadataMaps,+ resolveTimelineActivityType: resolveTimelineActivityTypeToNothing,+ }),+ ).toEqual([+ {+ sourceObjectNameSingular: 'calendarEvent',+ happensAtFieldName: 'startsAt',+ timelineActivityTypeIds: [LINKED_TYPE_ID],+ linkedRecordIds: [CALENDAR_EVENT_ID, 'other-calendar-event-id'],+ },+ ]);+ });++ it('ignores updates not touching the semantic timestamp', () => {+ const titleOnlyEvent = {+ recordId: CALENDAR_EVENT_ID,+ properties: {+ diff: { title: { before: 'Old', after: 'New' } },+ },+ } as unknown as ObjectRecordBaseEvent;++ expect(+ buildLinkedTimelineActivityHappensAtSyncUpdates({+ rules: [buildCalendarEventRule()],+ events: [titleOnlyEvent],+ flatFieldMetadataMaps,+ resolveTimelineActivityType: resolveTimelineActivityTypeToNothing,+ }),+ ).toEqual([]);+ });++ it('ignores source objects without a semantic timestamp', () => {+ expect(+ buildLinkedTimelineActivityHappensAtSyncUpdates({+ rules: [+ buildCalendarEventRule({+ sourceFlatObjectMetadata: {+ universalIdentifier: STANDARD_OBJECTS.note.universalIdentifier,+ nameSingular: 'note',+ } as TimelineActivityRule['sourceFlatObjectMetadata'],+ }),+ ],+ events: [buildStartsAtUpdatedEvent()],+ flatFieldMetadataMaps,+ resolveTimelineActivityType: resolveTimelineActivityTypeToNothing,+ }),+ ).toEqual([]);+ });++ it('ignores self rules and rules without a linked action', () => {+ expect(+ buildLinkedTimelineActivityHappensAtSyncUpdates({+ rules: [+ buildCalendarEventRule({+ targetShape: {+ kind: 'SELF',+ } as TimelineActivityRule['targetShape'],+ }),+ buildCalendarEventRule({ actions: ['unlinked'] }),+ ],+ events: [buildStartsAtUpdatedEvent()],+ flatFieldMetadataMaps,+ resolveTimelineActivityType: resolveTimelineActivityTypeToNothing,+ }),+ ).toEqual([]);+ });++ it('resolves the type through the resolver when the rule carries none', () => {+ expect(+ buildLinkedTimelineActivityHappensAtSyncUpdates({+ rules: [buildCalendarEventRule({ timelineActivityType: undefined })],+ events: [buildStartsAtUpdatedEvent()],+ flatFieldMetadataMaps,+ resolveTimelineActivityType: () => ({+ id: 'resolved-type-id',+ applicationId: 'application-id',+ snapshot: {} as never,+ }),+ }),+ ).toEqual([+ {+ sourceObjectNameSingular: 'calendarEvent',+ happensAtFieldName: 'startsAt',+ timelineActivityTypeIds: ['resolved-type-id'],+ linkedRecordIds: [CALENDAR_EVENT_ID],+ },+ ]);+ });+});diff --git a/packages/twenty-server/src/modules/timeline/utils/__tests__/does-timeline-activity-link-change.util.spec.ts b/packages/twenty-server/src/modules/timeline/utils/__tests__/does-object-record-event-change-fields.util.spec.tssimilarity index 59%rename from packages/twenty-server/src/modules/timeline/utils/__tests__/does-timeline-activity-link-change.util.spec.tsrename to packages/twenty-server/src/modules/timeline/utils/__tests__/does-object-record-event-change-fields.util.spec.tsindex 140ea0662d4..6c9b7535857 100644--- a/packages/twenty-server/src/modules/timeline/utils/__tests__/does-timeline-activity-link-change.util.spec.ts+++ b/packages/twenty-server/src/modules/timeline/utils/__tests__/does-object-record-event-change-fields.util.spec.ts@@ -1,8 +1,8 @@import { type ObjectRecordBaseEvent } from 'twenty-shared/database-events';-import { doesTimelineActivityLinkChange } from 'src/modules/timeline/utils/does-timeline-activity-link-change.util';+import { doesObjectRecordEventChangeFields } from 'src/modules/timeline/utils/does-object-record-event-change-fields.util';-const JOIN_COLUMN_NAMES = ['messageId', 'personId', 'workspaceMemberId'];+const FIELD_NAMES = ['messageId', 'personId', 'workspaceMemberId'];const buildEvent = ({updatedFields,@@ -16,41 +16,41 @@ const buildEvent = ({properties: { updatedFields, diff },}) as ObjectRecordBaseEvent<Record<string, unknown>>;-describe('doesTimelineActivityLinkChange', () => {- it('detects a join column in the ORM updated fields', () => {+describe('doesObjectRecordEventChangeFields', () => {+ it('detects a watched field in the ORM updated fields', () => {expect(- doesTimelineActivityLinkChange({+ doesObjectRecordEventChangeFields({event: buildEvent({ updatedFields: ['message', 'messageId'] }),- joinColumnNames: JOIN_COLUMN_NAMES,+ fieldNames: FIELD_NAMES,}),).toBe(true);});it('supports events carrying only a diff', () => {expect(- doesTimelineActivityLinkChange({+ doesObjectRecordEventChangeFields({event: buildEvent({diff: { personId: { before: null, after: 'id' } },}),- joinColumnNames: JOIN_COLUMN_NAMES,+ fieldNames: FIELD_NAMES,}),).toBe(true);});it('ignores unrelated field changes', () => {expect(- doesTimelineActivityLinkChange({+ doesObjectRecordEventChangeFields({event: buildEvent({ updatedFields: ['handle'] }),- joinColumnNames: JOIN_COLUMN_NAMES,+ fieldNames: FIELD_NAMES,}),).toBe(false);});it('returns false when change metadata is absent', () => {expect(- doesTimelineActivityLinkChange({+ doesObjectRecordEventChangeFields({event: buildEvent({}),- joinColumnNames: JOIN_COLUMN_NAMES,+ fieldNames: FIELD_NAMES,}),).toBe(false);});diff --git a/packages/twenty-server/src/modules/timeline/utils/build-linked-timeline-activity-happens-at-sync-updates.util.ts b/packages/twenty-server/src/modules/timeline/utils/build-linked-timeline-activity-happens-at-sync-updates.util.tsnew file mode 100644index 00000000000..c8b7a2eed98--- /dev/null+++ b/packages/twenty-server/src/modules/timeline/utils/build-linked-timeline-activity-happens-at-sync-updates.util.ts@@ -0,0 +1,88 @@+import { type ObjectRecordBaseEvent } from 'twenty-shared/database-events';+import { isDefined } from 'twenty-shared/utils';++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 { type TimelineActivityRule } from 'src/modules/timeline/types/timeline-activity-rule.type';+import { doesObjectRecordEventChangeFields } from 'src/modules/timeline/utils/does-object-record-event-change-fields.util';+import { resolveLinkedTimelineActivityHappensAtFieldName } from 'src/modules/timeline/utils/resolve-timeline-activity-happens-at.util';+import { resolveTimelineActivityTypeForRule } from 'src/modules/timeline/utils/resolve-timeline-activity-type-for-rule.util';+import { type TimelineActivityTypeResolver } from 'src/modules/timeline/utils/resolve-timeline-activity-type.util';++export type LinkedTimelineActivityHappensAtSyncUpdate = {+ sourceObjectNameSingular: string;+ happensAtFieldName: string;+ timelineActivityTypeIds: string[];+ linkedRecordIds: string[];+};++// A linked activity is anchored at its source record's own moment (an email's+// receivedAt, a calendar event's startsAt), so when that moment moves, e.g. a+// meeting gets rescheduled, the already written activities must follow. Only+// the changed record ids are collected here: the new value is read from the+// source row at write time, not from the event snapshot.+export const buildLinkedTimelineActivityHappensAtSyncUpdates = ({+ rules,+ events,+ flatFieldMetadataMaps,+ resolveTimelineActivityType,+}: {+ rules: TimelineActivityRule[];+ events: ObjectRecordBaseEvent[];+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;+ resolveTimelineActivityType: TimelineActivityTypeResolver;+}): LinkedTimelineActivityHappensAtSyncUpdate[] => {+ const linkedRules = rules.filter(+ (rule) =>+ rule.targetShape.kind !== 'SELF' && rule.actions.includes('linked'),+ );++ if (linkedRules.length === 0) {+ return [];+ }++ const updates: LinkedTimelineActivityHappensAtSyncUpdate[] = [];++ for (const rule of linkedRules) {+ const happensAtFieldName = resolveLinkedTimelineActivityHappensAtFieldName({+ sourceFlatObjectMetadata: rule.sourceFlatObjectMetadata,+ flatFieldMetadataMaps,+ });++ const timelineActivityTypeId = resolveTimelineActivityTypeForRule({+ rule,+ ruleAction: 'linked',+ resolveTimelineActivityType,+ })?.id;++ if (!isDefined(happensAtFieldName) || !isDefined(timelineActivityTypeId)) {+ continue;+ }++ const linkedRecordIds = [+ ...new Set(+ events+ .filter((event) =>+ doesObjectRecordEventChangeFields({+ event,+ fieldNames: [happensAtFieldName],+ }),+ )+ .map((event) => event.recordId),+ ),+ ];++ if (linkedRecordIds.length === 0) {+ continue;+ }++ updates.push({+ sourceObjectNameSingular: rule.sourceFlatObjectMetadata.nameSingular,+ happensAtFieldName,+ timelineActivityTypeIds: [timelineActivityTypeId],+ linkedRecordIds,+ });+ }++ return updates;+};diff --git a/packages/twenty-server/src/modules/timeline/utils/does-timeline-activity-link-change.util.ts b/packages/twenty-server/src/modules/timeline/utils/does-object-record-event-change-fields.util.tssimilarity index 51%rename from packages/twenty-server/src/modules/timeline/utils/does-timeline-activity-link-change.util.tsrename to packages/twenty-server/src/modules/timeline/utils/does-object-record-event-change-fields.util.tsindex 6495db47e8b..b12dec6ca17 100644--- a/packages/twenty-server/src/modules/timeline/utils/does-timeline-activity-link-change.util.ts+++ b/packages/twenty-server/src/modules/timeline/utils/does-object-record-event-change-fields.util.ts@@ -1,25 +1,23 @@import { type ObjectRecordBaseEvent } from 'twenty-shared/database-events';import { isDefined } from 'twenty-shared/utils';-export const doesTimelineActivityLinkChange = ({+export const doesObjectRecordEventChangeFields = ({event,- joinColumnNames,+ fieldNames,}: {event: ObjectRecordBaseEvent;- joinColumnNames: string[];+ fieldNames: string[];}): boolean => {const { updatedFields, diff } = event.properties;if (isDefined(updatedFields)) {- return joinColumnNames.some((joinColumnName) =>- updatedFields.includes(joinColumnName),- );+ return fieldNames.some((fieldName) => updatedFields.includes(fieldName));}return (isDefined(diff) &&- joinColumnNames.some((joinColumnName) =>- Object.prototype.hasOwnProperty.call(diff, joinColumnName),+ fieldNames.some((fieldName) =>+ Object.prototype.hasOwnProperty.call(diff, fieldName),));};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 69a2b7949f3..0e28cb3a53a 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@@ -54,6 +54,32 @@ const LINKED_HAPPENS_AT_FIELD_UNIVERSAL_IDENTIFIER_BY_OBJECT_UNIVERSAL_IDENTIFIESTANDARD_OBJECTS.calendarEvent.fields.startsAt.universalIdentifier,};+export const resolveLinkedTimelineActivityHappensAtFieldName = ({+ sourceFlatObjectMetadata,+ flatFieldMetadataMaps,+}: {+ sourceFlatObjectMetadata: Pick<FlatObjectMetadata, 'universalIdentifier'>;+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;+}): string | undefined => {+ const happensAtFieldUniversalIdentifier =+ LINKED_HAPPENS_AT_FIELD_UNIVERSAL_IDENTIFIER_BY_OBJECT_UNIVERSAL_IDENTIFIER[+ sourceFlatObjectMetadata.universalIdentifier+ ];++ if (!isDefined(happensAtFieldUniversalIdentifier)) {+ return undefined;+ }++ return findFlatEntityByUniversalIdentifier({+ flatEntityMaps: flatFieldMetadataMaps,+ universalIdentifier: happensAtFieldUniversalIdentifier,+ })?.name;+};++export const parseLinkedTimelineActivityHappensAt = (+ value: unknown,+): Date | undefined => parseTimestamp(value);+export const resolveLinkedTimelineActivityHappensAt = ({event,ruleAction,@@ -67,22 +93,14 @@ export const resolveLinkedTimelineActivityHappensAt = ({sourceRecord: Record<string, unknown> | undefined;flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;}): Date => {- const happensAtFieldUniversalIdentifier =+ const happensAtFieldName =ruleAction === 'linked'- ? LINKED_HAPPENS_AT_FIELD_UNIVERSAL_IDENTIFIER_BY_OBJECT_UNIVERSAL_IDENTIFIER[- sourceFlatObjectMetadata.universalIdentifier- ]+ ? resolveLinkedTimelineActivityHappensAtFieldName({+ sourceFlatObjectMetadata,+ flatFieldMetadataMaps,+ }): undefined;- if (!isDefined(happensAtFieldUniversalIdentifier)) {- return resolveTimelineActivityHappensAt(event);- }-- const happensAtFieldName = findFlatEntityByUniversalIdentifier({- flatEntityMaps: flatFieldMetadataMaps,- universalIdentifier: happensAtFieldUniversalIdentifier,- })?.name;-const sourceRecordHappensAt = isDefined(happensAtFieldName)? parseTimestamp(sourceRecord?.[happensAtFieldName]): undefined;diff --git a/packages/twenty-server/src/modules/timeline/utils/resolve-timeline-activity-type-for-rule.util.ts b/packages/twenty-server/src/modules/timeline/utils/resolve-timeline-activity-type-for-rule.util.tsnew file mode 100644index 00000000000..1f7b892e9e6--- /dev/null+++ b/packages/twenty-server/src/modules/timeline/utils/resolve-timeline-activity-type-for-rule.util.ts@@ -0,0 +1,22 @@+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 {+ type ResolvedTimelineActivityType,+ type TimelineActivityTypeResolver,+} from 'src/modules/timeline/utils/resolve-timeline-activity-type.util';++export const resolveTimelineActivityTypeForRule = ({+ rule,+ ruleAction,+ resolveTimelineActivityType,+}: {+ rule: TimelineActivityRule;+ ruleAction: TimelineActivityRuleAction;+ resolveTimelineActivityType: TimelineActivityTypeResolver;+}): ResolvedTimelineActivityType | undefined =>+ rule.timelineActivityType ??+ resolveTimelineActivityType({+ action: ruleAction,+ objectUniversalIdentifier:+ rule.sourceFlatObjectMetadata.universalIdentifier,+ });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 f43635588ec..4827ff1c757 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@@ -179,6 +179,7 @@ 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 ROUTED_CALENDAR_EVENT_RESCHEDULED_STARTS_AT = '2024-04-09T16: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 = [@@ -708,6 +709,71 @@ describe('timeline activity write path (integration)', () => {ROUTED_CALENDAR_EVENT_STARTS_AT,);});++ it('should move linked activities when a calendar event is rescheduled', async () => {+ await updateRecord({+ objectMetadataSingularName: 'calendarEvent',+ recordId: ROUTED_CALENDAR_EVENT_ID,+ data: { title: 'Generic calendar routing renamed' },+ });++ const activitiesAfterRename = await findTimelineActivities({+ targetPersonId: { eq: ROUTED_PERSON_ID },+ timelineActivityTypeId: {+ eq: timelineActivityTypeIdForOrThrow(+ 'linked',+ CALENDAR_EVENT_UNIVERSAL_IDENTIFIER,+ ),+ },+ });++ expect(activitiesAfterRename).toHaveLength(1);+ expect(new Date(activitiesAfterRename[0].happensAt).toISOString()).toBe(+ ROUTED_CALENDAR_EVENT_STARTS_AT,+ );++ await updateRecord({+ objectMetadataSingularName: 'calendarEvent',+ recordId: ROUTED_CALENDAR_EVENT_ID,+ data: { startsAt: ROUTED_CALENDAR_EVENT_RESCHEDULED_STARTS_AT },+ });++ const activitiesAfterReschedule = await findTimelineActivities({+ targetPersonId: { eq: ROUTED_PERSON_ID },+ timelineActivityTypeId: {+ eq: timelineActivityTypeIdForOrThrow(+ 'linked',+ CALENDAR_EVENT_UNIVERSAL_IDENTIFIER,+ ),+ },+ });++ expect(activitiesAfterReschedule).toHaveLength(1);+ expect(+ new Date(activitiesAfterReschedule[0].happensAt).toISOString(),+ ).toBe(ROUTED_CALENDAR_EVENT_RESCHEDULED_STARTS_AT);++ await updateRecord({+ objectMetadataSingularName: 'calendarEvent',+ recordId: ROUTED_CALENDAR_EVENT_ID,+ data: { startsAt: null },+ });++ const activitiesAfterClearing = await findTimelineActivities({+ targetPersonId: { eq: ROUTED_PERSON_ID },+ timelineActivityTypeId: {+ eq: timelineActivityTypeIdForOrThrow(+ 'linked',+ CALENDAR_EVENT_UNIVERSAL_IDENTIFIER,+ ),+ },+ });++ expect(activitiesAfterClearing).toHaveLength(1);+ expect(new Date(activitiesAfterClearing[0].happensAt).toISOString()).toBe(+ ROUTED_CALENDAR_EVENT_RESCHEDULED_STARTS_AT,+ );+ });});describe('metadata-declared direct relation routing', () => {