Skip to content

The open alternative to Salesforce, designed for AI.

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.ts
index 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/work
import { 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.ts
index 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.ts
new file mode 100644
index 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.ts
similarity index 59%
rename from packages/twenty-server/src/modules/timeline/utils/__tests__/does-timeline-activity-link-change.util.spec.ts
rename to packages/twenty-server/src/modules/timeline/utils/__tests__/does-object-record-event-change-fields.util.spec.ts
index 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.ts
new file mode 100644
index 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.ts
similarity index 51%
rename from packages/twenty-server/src/modules/timeline/utils/does-timeline-activity-link-change.util.ts
rename to packages/twenty-server/src/modules/timeline/utils/does-object-record-event-change-fields.util.ts
index 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.ts
index 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_IDENTIFIE
STANDARD_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.ts
new file mode 100644
index 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.ts
index 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', () => {