Skip to content

The open alternative to Salesforce, designed for AI.

Drive timeline activities from rules instead of hardcoded branches (#24341)

Félix Malfaita48607172782
diff --git a/packages/twenty-server/src/engine/core-modules/event-emitter/utils/object-record-changed-values.ts b/packages/twenty-server/src/engine/core-modules/event-emitter/utils/object-record-changed-values.ts
index a9a9d796674..75919b66719 100644
--- a/packages/twenty-server/src/engine/core-modules/event-emitter/utils/object-record-changed-values.ts
+++ b/packages/twenty-server/src/engine/core-modules/event-emitter/utils/object-record-changed-values.ts
@@ -7,6 +7,7 @@ import { fastDeepEqual, isDefined } from 'twenty-shared/utils';
import { getFlatFieldsFromFlatObjectMetadata } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-flat-fields-for-flat-object-metadata.util';
import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';
+import { getJoinColumnNameForRelationField } from 'src/engine/metadata-modules/field-metadata/utils/get-join-column-name-for-relation-field.util';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
@@ -33,17 +34,6 @@ const isManyToOneRelationField = (
);
};
-const getJoinColumnNameForRelationField = (
- field: FlatFieldMetadata<FieldMetadataType.RELATION>,
-) => {
- return (
- field.settings?.joinColumnName ??
- computeMorphOrRelationFieldJoinColumnName({
- name: field.name,
- })
- );
-};
-
export const computeUpdatedFieldsFromDiff = (
diff: Record<string, unknown>,
objectMetadataItem: FlatObjectMetadata,
diff --git a/packages/twenty-server/src/engine/metadata-modules/field-metadata/utils/get-join-column-name-for-relation-field.util.ts b/packages/twenty-server/src/engine/metadata-modules/field-metadata/utils/get-join-column-name-for-relation-field.util.ts
new file mode 100644
index 00000000000..7c378363b02
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/field-metadata/utils/get-join-column-name-for-relation-field.util.ts
@@ -0,0 +1,25 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';
+import { isFieldMetadataSettingsOfType } from 'src/engine/metadata-modules/field-metadata/utils/is-field-metadata-settings-of-type.util';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+
+// The ORM derives relation columns from the field name, so fall back to it
+// when settings carry no explicit join column.
+export const getJoinColumnNameForRelationField = (
+ flatFieldMetadata: FlatFieldMetadata,
+): string => {
+ const { settings } = flatFieldMetadata;
+
+ if (
+ isFieldMetadataSettingsOfType(settings, FieldMetadataType.RELATION) &&
+ isDefined(settings.joinColumnName)
+ ) {
+ return settings.joinColumnName;
+ }
+
+ return computeMorphOrRelationFieldJoinColumnName({
+ name: flatFieldMetadata.name,
+ });
+};
diff --git a/packages/twenty-server/src/modules/timeline/constants/standard-timeline-activity-rules.constant.ts b/packages/twenty-server/src/modules/timeline/constants/standard-timeline-activity-rules.constant.ts
new file mode 100644
index 00000000000..24e99d5edea
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/constants/standard-timeline-activity-rules.constant.ts
@@ -0,0 +1,35 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+
+import { type TimelineActivityRuleAction } from 'src/modules/timeline/types/timeline-activity-rule-action.type';
+
+type StandardTimelineActivityRule = {
+ objectUniversalIdentifier: string;
+ relationFieldUniversalIdentifier: string;
+ actions: TimelineActivityRuleAction[];
+ triggerFieldUniversalIdentifiers: string[] | null;
+};
+
+// Activity fan-out is not derived from metadata: deriving one rule per junction
+// relation would silently switch on every junction, messageList.members
+// included. Notes and tasks are declared instead.
+export const STANDARD_TIMELINE_ACTIVITY_RULES: StandardTimelineActivityRule[] =
+ [
+ {
+ objectUniversalIdentifier: STANDARD_OBJECTS.note.universalIdentifier,
+ relationFieldUniversalIdentifier:
+ STANDARD_OBJECTS.note.fields.noteTargets.universalIdentifier,
+ actions: ['updated', 'linked', 'unlinked'],
+ triggerFieldUniversalIdentifiers: [
+ STANDARD_OBJECTS.note.fields.title.universalIdentifier,
+ ],
+ },
+ {
+ objectUniversalIdentifier: STANDARD_OBJECTS.task.universalIdentifier,
+ relationFieldUniversalIdentifier:
+ STANDARD_OBJECTS.task.fields.taskTargets.universalIdentifier,
+ actions: ['updated', 'linked', 'unlinked'],
+ triggerFieldUniversalIdentifiers: [
+ STANDARD_OBJECTS.task.fields.title.universalIdentifier,
+ ],
+ },
+ ];
diff --git a/packages/twenty-server/src/modules/timeline/constants/system-objects-with-timeline-activities.constant.ts b/packages/twenty-server/src/modules/timeline/constants/system-objects-with-timeline-activities.constant.ts
deleted file mode 100644
index 6f5a6fbddb6..00000000000
--- a/packages/twenty-server/src/modules/timeline/constants/system-objects-with-timeline-activities.constant.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export const SYSTEM_OBJECTS_WITH_TIMELINE_ACTIVITIES = [
- 'noteTarget',
- 'taskTarget',
-];
diff --git a/packages/twenty-server/src/modules/timeline/jobs/upsert-timeline-activity-from-internal-event.job.ts b/packages/twenty-server/src/modules/timeline/jobs/upsert-timeline-activity-from-internal-event.job.ts
index fdaf722e90b..97f345523a8 100644
--- a/packages/twenty-server/src/modules/timeline/jobs/upsert-timeline-activity-from-internal-event.job.ts
+++ b/packages/twenty-server/src/modules/timeline/jobs/upsert-timeline-activity-from-internal-event.job.ts
@@ -1,5 +1,3 @@
-import { isDefined } from 'twenty-shared/utils';
-import { In } from 'typeorm';
import { type ObjectRecordNonDestructiveEvent } from 'twenty-shared/database-events';
import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
@@ -8,9 +6,7 @@ import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queu
import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
-import { SYSTEM_OBJECTS_WITH_TIMELINE_ACTIVITIES } from 'src/modules/timeline/constants/system-objects-with-timeline-activities.constant';
import { TimelineActivityService } from 'src/modules/timeline/services/timeline-activity.service';
-import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@Processor(MessageQueue.entityEventsToDbQueue)
export class UpsertTimelineActivityFromInternalEvent {
@@ -27,46 +23,10 @@ export class UpsertTimelineActivityFromInternalEvent {
return;
}
- if (
- workspaceEventBatch.objectMetadata.isSystem &&
- !SYSTEM_OBJECTS_WITH_TIMELINE_ACTIVITIES.includes(
- workspaceEventBatch.objectMetadata.nameSingular,
- )
- ) {
- return;
- }
-
- const authContext = buildSystemAuthContext(workspaceEventBatch.workspaceId);
-
- await this.globalWorkspaceOrmManager.executeInWorkspaceContext(async () => {
- const workspaceMemberRepository =
- await this.globalWorkspaceOrmManager.getRepository(
- workspaceEventBatch.workspaceId,
- WorkspaceMemberWorkspaceEntity,
- {
- shouldBypassPermissionChecks: true,
- },
- );
-
- const userIds = workspaceEventBatch.events
- .map((event) => event.userId)
- .filter(isDefined);
-
- const workspaceMembers = await workspaceMemberRepository.findBy({
- userId: In(userIds),
- });
-
- for (const eventData of workspaceEventBatch.events) {
- const workspaceMember = workspaceMembers.find(
- (workspaceMember) => workspaceMember.userId === eventData.userId,
- );
-
- if (eventData.userId && workspaceMember) {
- eventData.workspaceMemberId = workspaceMember.id;
- }
- }
-
- await this.timelineActivityService.upsertEvents(workspaceEventBatch);
- }, authContext);
+ await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+ async () =>
+ await this.timelineActivityService.upsertEvents(workspaceEventBatch),
+ buildSystemAuthContext(workspaceEventBatch.workspaceId),
+ );
}
}
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 4637db82406..1224582e4d2 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
@@ -10,6 +10,18 @@ import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system
import { type TimelineActivityPayload } from 'src/modules/timeline/types/timeline-activity-payload';
import { buildTimelineActivityRelatedMorphFieldMetadataName } from 'src/modules/timeline/utils/timeline-activity-related-morph-field-metadata-name-builder.util';
+// An unset author is null on a stored row and undefined on a payload, so both
+// are normalized before they can decide whether two events are the same.
+const buildMergeKey = ({
+ recordId,
+ workspaceMemberId,
+ name,
+}: {
+ recordId: string;
+ workspaceMemberId: string | null | undefined;
+ name: string;
+}): string => `${recordId}|${workspaceMemberId ?? null}|${name}`;
+
type TimelineActivityPayloadWorkspaceIdAndObjectSingularName = {
payloads: (Omit<TimelineActivityPayload, 'properties'> & {
properties: Pick<TimelineActivityPayload['properties'], 'diff'>;
@@ -58,43 +70,75 @@ export class TimelineActivityRepository {
const payloadsToInsert: TimelineActivityPayloadWorkspaceIdAndObjectSingularName['payloads'] =
[];
+ const mergesToApply: {
+ id: string;
+ properties: Partial<ObjectRecord>;
+ workspaceMemberId: string | undefined;
+ }[] = [];
const timelineActivityPropertyName =
await this.getTimelineActivityPropertyName(objectSingularName);
+ // Bucketed once so matching a payload stays constant time: the recent
+ // window is scoped to this batch but is not capped in size.
+ const recentTimelineActivitiesByMergeKey = new Map<
+ string,
+ (typeof recentTimelineActivities)[number][]
+ >();
+
+ for (const timelineActivity of recentTimelineActivities) {
+ const mergeKey = buildMergeKey({
+ recordId: timelineActivity[timelineActivityPropertyName],
+ workspaceMemberId: timelineActivity.workspaceMemberId,
+ name: timelineActivity.name,
+ });
+
+ const bucket = recentTimelineActivitiesByMergeKey.get(mergeKey);
+
+ if (isDefined(bucket)) {
+ bucket.push(timelineActivity);
+ } else {
+ recentTimelineActivitiesByMergeKey.set(mergeKey, [timelineActivity]);
+ }
+ }
+
for (const payload of payloadsToUpsert) {
- const recentTimelineActivity = recentTimelineActivities.find(
- (timelineActivity) =>
- timelineActivity[timelineActivityPropertyName] ===
- payload.recordId &&
- timelineActivity.workspaceMemberId === payload.workspaceMemberId &&
- (!isDefined(payload.linkedRecordId) ||
- timelineActivity.linkedRecordId === payload.linkedRecordId) &&
- timelineActivity.name === payload.name,
- );
-
- if (recentTimelineActivity) {
- const mergedProperties = objectRecordDiffMerge(
- recentTimelineActivity.properties,
- payload.properties,
+ const recentTimelineActivity = recentTimelineActivitiesByMergeKey
+ .get(
+ buildMergeKey({
+ recordId: payload.recordId,
+ workspaceMemberId: payload.workspaceMemberId,
+ name: payload.name,
+ }),
+ )
+ ?.find(
+ (timelineActivity) =>
+ !isDefined(payload.linkedRecordId) ||
+ timelineActivity.linkedRecordId === payload.linkedRecordId,
);
- await this.updateTimelineActivity({
+ if (isDefined(recentTimelineActivity)) {
+ mergesToApply.push({
id: recentTimelineActivity.id,
- properties: mergedProperties,
+ properties: objectRecordDiffMerge(
+ recentTimelineActivity.properties,
+ payload.properties,
+ ),
workspaceMemberId: payload.workspaceMemberId,
- workspaceId,
});
} else {
payloadsToInsert.push(payload);
}
}
- await this.insertTimelineActivities({
- objectSingularName,
- payloads: payloadsToInsert,
- workspaceId,
- });
+ await Promise.all([
+ this.updateTimelineActivities({ merges: mergesToApply, workspaceId }),
+ this.insertTimelineActivities({
+ objectSingularName,
+ payloads: payloadsToInsert,
+ workspaceId,
+ }),
+ ]);
}, authContext);
}
@@ -128,10 +172,12 @@ export class TimelineActivityRepository {
createdAt: MoreThan(tenMinutesAgo),
};
+ // The where clause is already scoped to this batch payloads and to the merge
+ // window, so every candidate is fetched: taking a single row would let only
+ // one payload of a multi record batch merge.
return await timelineActivityTypeORMRepository.find({
where: whereConditions,
order: { createdAt: 'DESC' },
- take: 1,
});
}
@@ -169,17 +215,21 @@ export class TimelineActivityRepository {
);
}
- private async updateTimelineActivity({
- id,
- properties,
- workspaceMemberId,
+ private async updateTimelineActivities({
+ merges,
workspaceId,
}: {
- id: string;
- properties: Partial<ObjectRecord>;
- workspaceMemberId: string | undefined;
+ merges: {
+ id: string;
+ properties: Partial<ObjectRecord>;
+ workspaceMemberId: string | undefined;
+ }[];
workspaceId: string;
}) {
+ if (merges.length === 0) {
+ return;
+ }
+
const timelineActivityTypeORMRepository =
await this.globalWorkspaceOrmManager.getRepository(
workspaceId,
@@ -189,10 +239,14 @@ export class TimelineActivityRepository {
},
);
- return timelineActivityTypeORMRepository.update(id, {
- properties: properties,
- workspaceMemberId: workspaceMemberId,
- });
+ await Promise.all(
+ merges.map(({ id, properties, workspaceMemberId }) =>
+ timelineActivityTypeORMRepository.update(id, {
+ properties,
+ workspaceMemberId,
+ }),
+ ),
+ );
}
private async getTimelineActivityPropertyName(objectSingularName: string) {
diff --git a/packages/twenty-server/src/modules/timeline/services/timeline-activity-rule-builder.service.ts b/packages/twenty-server/src/modules/timeline/services/timeline-activity-rule-builder.service.ts
new file mode 100644
index 00000000000..82279cce360
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/services/timeline-activity-rule-builder.service.ts
@@ -0,0 +1,124 @@
+import { Injectable } from '@nestjs/common';
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+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 { STANDARD_TIMELINE_ACTIVITY_RULES } from 'src/modules/timeline/constants/standard-timeline-activity-rules.constant';
+import { type TimelineActivityRule } from 'src/modules/timeline/types/timeline-activity-rule.type';
+import { buildJunctionTargetShape } from 'src/modules/timeline/utils/build-junction-target-shape.util';
+import { deriveDefaultTimelineActivityRule } from 'src/modules/timeline/utils/derive-default-timeline-activity-rule.util';
+
+type TimelineActivityRulesForEventBatch = {
+ // Rules triggered by events on the batch object itself
+ sourceRules: TimelineActivityRule[];
+ // Rules whose junction object is the batch object, so events on it are link
+ // or unlink events for the rule
+ junctionRules: TimelineActivityRule[];
+ // Returned so callers reading field metadata do not fetch the cache again
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+};
+
+@Injectable()
+export class TimelineActivityRuleBuilderService {
+ constructor(
+ private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+ ) {}
+
+ async getRulesForEventBatch({
+ workspaceId,
+ flatObjectMetadata,
+ }: {
+ workspaceId: string;
+ flatObjectMetadata: FlatObjectMetadata;
+ }): Promise<TimelineActivityRulesForEventBatch> {
+ const { flatObjectMetadataMaps, flatFieldMetadataMaps } =
+ await this.workspaceManyOrAllFlatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ {
+ workspaceId,
+ flatMapsKeys: ['flatObjectMetadataMaps', 'flatFieldMetadataMaps'],
+ },
+ );
+
+ const standardRules = this.buildStandardRules({
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ });
+
+ const derivedSelfRule =
+ deriveDefaultTimelineActivityRule(flatObjectMetadata);
+
+ const sourceRules = [
+ ...(isDefined(derivedSelfRule) ? [derivedSelfRule] : []),
+ ...standardRules.filter(
+ (rule) => rule.sourceFlatObjectMetadata.id === flatObjectMetadata.id,
+ ),
+ ];
+
+ const junctionRules = standardRules.filter(
+ (rule) =>
+ rule.targetShape.kind === 'JUNCTION' &&
+ rule.targetShape.junctionObjectMetadataId === flatObjectMetadata.id,
+ );
+
+ return { sourceRules, junctionRules, flatFieldMetadataMaps };
+ }
+
+ private buildStandardRules({
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ }: {
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ }): TimelineActivityRule[] {
+ return STANDARD_TIMELINE_ACTIVITY_RULES.map(
+ (standardRule): TimelineActivityRule | undefined => {
+ const sourceFlatObjectMetadata = findFlatEntityByUniversalIdentifier({
+ flatEntityMaps: flatObjectMetadataMaps,
+ universalIdentifier: standardRule.objectUniversalIdentifier,
+ });
+
+ const relationFlatFieldMetadata = findFlatEntityByUniversalIdentifier({
+ flatEntityMaps: flatFieldMetadataMaps,
+ universalIdentifier: standardRule.relationFieldUniversalIdentifier,
+ });
+
+ if (
+ !isDefined(sourceFlatObjectMetadata) ||
+ !isDefined(relationFlatFieldMetadata)
+ ) {
+ return undefined;
+ }
+
+ const targetShape = buildJunctionTargetShape({
+ relationFlatFieldMetadata,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ });
+
+ if (!isDefined(targetShape)) {
+ return undefined;
+ }
+
+ return {
+ sourceFlatObjectMetadata,
+ actions: standardRule.actions,
+ triggerFieldNames:
+ standardRule.triggerFieldUniversalIdentifiers
+ ?.map(
+ (universalIdentifier) =>
+ findFlatEntityByUniversalIdentifier({
+ flatEntityMaps: flatFieldMetadataMaps,
+ universalIdentifier,
+ })?.name,
+ )
+ .filter(isDefined) ?? null,
+ targetShape,
+ };
+ },
+ ).filter(isDefined);
+ }
+}
diff --git a/packages/twenty-server/src/modules/timeline/services/timeline-activity-target-query.service.ts b/packages/twenty-server/src/modules/timeline/services/timeline-activity-target-query.service.ts
new file mode 100644
index 00000000000..f41592b9e0b
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/services/timeline-activity-target-query.service.ts
@@ -0,0 +1,135 @@
+import { Injectable } from '@nestjs/common';
+
+import { isNonEmptyString } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
+import { In } from 'typeorm';
+
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { type ResolvedTimelineActivityTarget } from 'src/modules/timeline/types/resolved-timeline-activity-target.type';
+import { type TimelineActivityRule } from 'src/modules/timeline/types/timeline-activity-rule.type';
+
+const readTargetFromJunctionRow = (
+ junctionRow: Record<string, unknown>,
+ rule: TimelineActivityRule,
+): ResolvedTimelineActivityTarget | undefined => {
+ if (rule.targetShape.kind !== 'JUNCTION') {
+ return undefined;
+ }
+
+ for (const { joinColumnName, targetObjectNameSingular } of rule.targetShape
+ .junctionTargetJoinColumns) {
+ const targetRecordId = junctionRow[joinColumnName];
+
+ if (isNonEmptyString(targetRecordId)) {
+ return { targetObjectNameSingular, targetRecordId };
+ }
+ }
+
+ return undefined;
+};
+
+@Injectable()
+export class TimelineActivityTargetQueryService {
+ constructor(
+ private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
+ ) {}
+
+ // Source events: walk the junction in one batched query and return, per source
+ // record, every record whose timeline receives an entry.
+ async resolveTargetsBySourceRecordId({
+ rule,
+ sourceRecordIds,
+ workspaceId,
+ }: {
+ rule: TimelineActivityRule;
+ sourceRecordIds: string[];
+ workspaceId: string;
+ }): Promise<Map<string, ResolvedTimelineActivityTarget[]>> {
+ const targetsBySourceRecordId = new Map<
+ string,
+ ResolvedTimelineActivityTarget[]
+ >();
+
+ if (rule.targetShape.kind !== 'JUNCTION' || sourceRecordIds.length === 0) {
+ return targetsBySourceRecordId;
+ }
+
+ const { junctionObjectNameSingular, junctionSourceJoinColumnName } =
+ rule.targetShape;
+
+ const junctionRepository =
+ await this.globalWorkspaceOrmManager.getRepository(
+ workspaceId,
+ junctionObjectNameSingular,
+ { shouldBypassPermissionChecks: true },
+ );
+
+ const junctionRows = await junctionRepository.find({
+ where: { [junctionSourceJoinColumnName]: In(sourceRecordIds) },
+ });
+
+ for (const junctionRow of junctionRows) {
+ const sourceRecordId = junctionRow[junctionSourceJoinColumnName];
+ const target = readTargetFromJunctionRow(junctionRow, rule);
+
+ if (!isNonEmptyString(sourceRecordId) || !isDefined(target)) {
+ continue;
+ }
+
+ const targets = targetsBySourceRecordId.get(sourceRecordId);
+
+ if (isDefined(targets)) {
+ targets.push(target);
+ } else {
+ targetsBySourceRecordId.set(sourceRecordId, [target]);
+ }
+ }
+
+ return targetsBySourceRecordId;
+ }
+
+ // Link events: the junction row is the event payload, no query needed.
+ resolveTargetFromJunctionRecord({
+ rule,
+ junctionRecord,
+ }: {
+ rule: TimelineActivityRule;
+ junctionRecord: Record<string, unknown> | undefined;
+ }): ResolvedTimelineActivityTarget | undefined {
+ if (!isDefined(junctionRecord)) {
+ return undefined;
+ }
+
+ return readTargetFromJunctionRow(junctionRecord, rule);
+ }
+
+ async findSourceRecordsByRecordId({
+ rule,
+ recordIds,
+ workspaceId,
+ }: {
+ rule: TimelineActivityRule;
+ recordIds: string[];
+ workspaceId: string;
+ }): Promise<Map<string, Record<string, unknown>>> {
+ const sourceRecordsByRecordId = new Map<string, Record<string, unknown>>();
+
+ if (recordIds.length === 0) {
+ return sourceRecordsByRecordId;
+ }
+
+ const repository = await this.globalWorkspaceOrmManager.getRepository(
+ workspaceId,
+ rule.sourceFlatObjectMetadata.nameSingular,
+ { shouldBypassPermissionChecks: true },
+ );
+
+ const records = await repository.find({ where: { id: In(recordIds) } });
+
+ for (const record of records) {
+ sourceRecordsByRecordId.set(record.id, record);
+ }
+
+ return sourceRecordsByRecordId;
+ }
+}
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 39ba204439f..7f13be5fa32 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
@@ -2,42 +2,90 @@ import { Injectable } from '@nestjs/common';
import { type ObjectRecordBaseEvent } from 'twenty-shared/database-events';
import { FieldMetadataType, type ObjectRecord } from 'twenty-shared/types';
-import { isDefined } from 'twenty-shared/utils';
+import { isNonEmptyString } from '@sniptt/guards';
+import { fromArrayToValuesByKeyRecord, isDefined } from 'twenty-shared/utils';
import { In } from 'typeorm';
import { getFlatFieldsFromFlatObjectMetadata } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-flat-fields-for-flat-object-metadata.util';
-import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
-import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { type DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
+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 FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
import { parseEventNameOrThrow } from 'src/engine/workspace-event-emitter/utils/parse-event-name';
-import { NoteWorkspaceEntity } from 'src/modules/note/standard-objects/note.workspace-entity';
-import { TaskWorkspaceEntity } from 'src/modules/task/standard-objects/task.workspace-entity';
import { TimelineActivityRepository } from 'src/modules/timeline/repositories/timeline-activity.repository';
+import { TimelineActivityRuleBuilderService } from 'src/modules/timeline/services/timeline-activity-rule-builder.service';
+import { TimelineActivityTargetQueryService } from 'src/modules/timeline/services/timeline-activity-target-query.service';
import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-objects/timeline-activity.workspace-entity';
+import { type ResolvedTimelineActivityTarget } from 'src/modules/timeline/types/resolved-timeline-activity-target.type';
import { type TimelineActivityPayload } from 'src/modules/timeline/types/timeline-activity-payload';
-import { extractObjectSingularNameFromTargetColumnName } from 'src/modules/timeline/utils/extract-object-singular-name-from-target-column-name.util';
-
-type ActivityType = 'note' | 'task';
+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 { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
+
+// An event on the junction object is a change to the link, not to the linked
+// record. `updated` covers a junction row being repointed at another target.
+const JUNCTION_EVENT_ACTIONS: Partial<
+ Record<DatabaseEventAction, TimelineActivityRuleAction>
+> = {
+ created: 'linked',
+ restored: 'linked',
+ updated: 'linked',
+ deleted: 'unlinked',
+};
+
+const SOURCE_EVENT_ACTIONS: Partial<
+ Record<DatabaseEventAction, TimelineActivityRuleAction>
+> = {
+ created: 'created',
+ updated: 'updated',
+ deleted: 'deleted',
+ restored: 'restored',
+};
+
+// Both event streams write the same row shape; only the linked record, its
+// cached name and the persisted properties differ.
+const buildLinkedPayload = ({
+ rule,
+ action,
+ target,
+ workspaceMemberId,
+ linkedRecordId,
+ linkedRecordCachedName,
+ properties,
+}: {
+ rule: TimelineActivityRule;
+ action: DatabaseEventAction;
+ target: ResolvedTimelineActivityTarget;
+ workspaceMemberId: string | undefined;
+ linkedRecordId: string;
+ linkedRecordCachedName: string | undefined;
+ properties: ObjectRecordBaseEvent['properties'];
+}): TimelineActivityPayload => ({
+ name: `linked-${rule.sourceFlatObjectMetadata.nameSingular}.${action}`,
+ objectSingularName: target.targetObjectNameSingular,
+ recordId: target.targetRecordId,
+ workspaceMemberId,
+ linkedRecordId,
+ linkedObjectMetadataId: rule.sourceFlatObjectMetadata.id,
+ linkedRecordCachedName,
+ properties,
+});
@Injectable()
export class TimelineActivityService {
constructor(
@InjectObjectMetadataRepository(TimelineActivityWorkspaceEntity)
private readonly timelineActivityRepository: TimelineActivityRepository,
- private readonly featureFlagService: FeatureFlagService,
private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
- private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+ private readonly timelineActivityRuleResolverService: TimelineActivityRuleBuilderService,
+ private readonly timelineActivityTargetResolverService: TimelineActivityTargetQueryService,
) {}
- private targetObjects: Record<ActivityType, string> = {
- note: 'noteTarget',
- task: 'taskTarget',
- };
-
async upsertEvents({
events,
name,
@@ -48,44 +96,67 @@ export class TimelineActivityService {
return;
}
- const { objectSingularName } = parseEventNameOrThrow(name);
-
- const eventsWithoutPositionDiff =
- await this.excludePositionFieldsFromEventsDiff({
- events,
- objectMetadata,
- workspaceId,
- });
+ const { action } = parseEventNameOrThrow(name);
- const timelineActivitiesPayloads =
- await this.transformEventsToTimelineActivityPayloads({
- events: eventsWithoutPositionDiff,
- objectMetadata,
+ const { sourceRules, junctionRules, flatFieldMetadataMaps } =
+ await this.timelineActivityRuleResolverService.getRulesForEventBatch({
workspaceId,
- name,
+ flatObjectMetadata: objectMetadata,
});
- if (
- !timelineActivitiesPayloads ||
- timelineActivitiesPayloads.length === 0
- ) {
+ if (sourceRules.length === 0 && junctionRules.length === 0) {
return;
}
- const payloadsByObjectSingularName = timelineActivitiesPayloads.reduce(
- (acc, payload) => {
- const computedObjectSingularName =
- payload.objectSingularName ?? objectSingularName;
+ const eventsWithoutPositionDiff = this.excludePositionFieldsFromEventsDiff({
+ events,
+ objectMetadata,
+ flatFieldMetadataMaps,
+ });
- acc[computedObjectSingularName] = [
- ...(acc[computedObjectSingularName] || []),
- payload,
- ];
+ const payloads = (
+ await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+ async () => {
+ // Resolved after the rule check so batches without rules, system
+ // objects mostly, never pay the workspace member query.
+ const enrichedEvents = await this.enrichEventsWithWorkspaceMemberId({
+ events: eventsWithoutPositionDiff,
+ workspaceId,
+ });
- return acc;
- },
- {} as Record<string, TimelineActivityPayload[]>,
- );
+ return Promise.all([
+ ...sourceRules.map((rule) =>
+ this.buildPayloadsForSourceRule({
+ rule,
+ events: enrichedEvents,
+ action,
+ workspaceId,
+ flatFieldMetadataMaps,
+ }),
+ ),
+ ...junctionRules.map((rule) =>
+ this.buildPayloadsForJunctionRule({
+ rule,
+ events: enrichedEvents,
+ action,
+ workspaceId,
+ flatFieldMetadataMaps,
+ }),
+ ),
+ ]);
+ },
+ buildSystemAuthContext(workspaceId),
+ )
+ ).flat();
+
+ if (payloads.length === 0) {
+ return;
+ }
+
+ const payloadsByObjectSingularName = fromArrayToValuesByKeyRecord({
+ array: payloads,
+ key: 'objectSingularName',
+ });
for (const objectSingularName in payloadsByObjectSingularName) {
await this.timelineActivityRepository.upsertTimelineActivities({
@@ -96,354 +167,263 @@ export class TimelineActivityService {
}
}
- // Position changes reach other consumers (SSE, webhooks, workflows) but render
- // blank in the timeline, so exclude them to avoid empty activity rows.
- private async excludePositionFieldsFromEventsDiff({
+ private ruleMatchesEvent({
+ rule,
+ ruleAction,
+ event,
+ }: {
+ rule: TimelineActivityRule;
+ ruleAction: TimelineActivityRuleAction;
+ event: ObjectRecordBaseEvent;
+ }): boolean {
+ if (!rule.actions.includes(ruleAction)) {
+ return false;
+ }
+
+ if (ruleAction !== 'updated' || !isDefined(rule.triggerFieldNames)) {
+ return true;
+ }
+
+ const diff = event.properties.diff;
+
+ if (!isDefined(diff)) {
+ return false;
+ }
+
+ return rule.triggerFieldNames.some((fieldName) =>
+ isDefined((diff as Record<string, unknown>)[fieldName]),
+ );
+ }
+
+ private async buildPayloadsForSourceRule({
+ rule,
events,
- objectMetadata,
+ action,
workspaceId,
+ flatFieldMetadataMaps,
}: {
+ rule: TimelineActivityRule;
events: ObjectRecordBaseEvent[];
- objectMetadata: FlatObjectMetadata;
+ action: DatabaseEventAction;
workspaceId: string;
- }): Promise<ObjectRecordBaseEvent[]> {
- const someEventHasDiff = events.some((event) =>
- isDefined(event.properties.diff),
- );
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ }): Promise<TimelineActivityPayload[]> {
+ const ruleAction = SOURCE_EVENT_ACTIONS[action];
- if (!someEventHasDiff) {
- return events;
+ if (!isDefined(ruleAction)) {
+ return [];
}
- const { flatFieldMetadataMaps } =
- await this.workspaceManyOrAllFlatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
- {
- workspaceId,
- flatMapsKeys: ['flatFieldMetadataMaps'],
- },
- );
-
- const positionFieldNames = new Set(
- getFlatFieldsFromFlatObjectMetadata(objectMetadata, flatFieldMetadataMaps)
- .filter((field) => field.type === FieldMetadataType.POSITION)
- .map((field) => field.name),
+ const matchingEvents = events.filter((event) =>
+ this.ruleMatchesEvent({ rule, ruleAction, event }),
);
- if (positionFieldNames.size === 0) {
- return events;
+ if (matchingEvents.length === 0) {
+ return [];
}
- return events.map((event) => {
- const diff = event.properties.diff;
-
- if (!isDefined(diff)) {
- return event;
- }
-
- const diffWithoutPositionFields = Object.fromEntries(
- Object.entries(diff).filter(
- ([fieldName]) => !positionFieldNames.has(fieldName),
- ),
- );
-
- return {
- ...event,
- properties: { ...event.properties, diff: diffWithoutPositionFields },
- };
- });
- }
+ const { nameSingular } = rule.sourceFlatObjectMetadata;
- private async transformEventsToTimelineActivityPayloads({
- events,
- workspaceId,
- objectMetadata,
- name,
- }: WorkspaceEventBatch<ObjectRecordBaseEvent>): Promise<
- TimelineActivityPayload[] | undefined
- > {
- const { objectSingularName } = parseEventNameOrThrow(name);
-
- if (objectSingularName === 'note') {
- const noteEventsTimelineActivities =
- await this.computeTimelineActivityPayloadsForActivities({
- events: events as ObjectRecordBaseEvent<NoteWorkspaceEntity>[],
- activityType: 'note',
- workspaceId,
- objectMetadata,
- name,
- });
-
- return [
- ...noteEventsTimelineActivities,
- ...(events.map((event) => ({
- name,
- objectSingularName,
- recordId: event.recordId,
- workspaceMemberId: event.workspaceMemberId,
- properties: event.properties,
- })) satisfies TimelineActivityPayload[]),
- ];
+ if (rule.targetShape.kind === 'SELF') {
+ return matchingEvents.map((event) => ({
+ name: `${nameSingular}.${action}`,
+ objectSingularName: nameSingular,
+ recordId: event.recordId,
+ workspaceMemberId: event.workspaceMemberId,
+ properties: event.properties,
+ }));
}
- if (objectSingularName === 'task') {
- const taskEventsTimelineActivities =
- await this.computeTimelineActivityPayloadsForActivities({
- events: events as ObjectRecordBaseEvent<TaskWorkspaceEntity>[],
- activityType: 'task',
+ const targetsBySourceRecordId =
+ await this.timelineActivityTargetResolverService.resolveTargetsBySourceRecordId(
+ {
+ rule,
+ sourceRecordIds: matchingEvents.map((event) => event.recordId),
workspaceId,
- objectMetadata,
- name,
- });
-
- return [
- ...taskEventsTimelineActivities,
- ...(events.map((event) => ({
- name,
- objectSingularName,
- recordId: event.recordId,
+ },
+ );
+
+ return matchingEvents.flatMap((event) =>
+ (targetsBySourceRecordId.get(event.recordId) ?? []).map((target) =>
+ buildLinkedPayload({
+ rule,
+ action,
+ target,
workspaceMemberId: event.workspaceMemberId,
+ linkedRecordId: event.recordId,
+ linkedRecordCachedName: resolveLinkedRecordCachedName({
+ rule,
+ record: event.properties.after as ObjectRecord | undefined,
+ flatFieldMetadataMaps,
+ }),
properties: event.properties,
- })) satisfies TimelineActivityPayload[]),
- ];
- }
-
- if (
- objectSingularName === 'noteTarget' ||
- objectSingularName === 'taskTarget'
- ) {
- return await this.computeTimelineActivityPayloadsForActivityTargets({
- events,
- activityType: objectSingularName === 'noteTarget' ? 'note' : 'task',
- workspaceId,
- objectMetadata,
- name,
- });
- }
-
- return events.map((event) => ({
- name,
- objectSingularName,
- recordId: event.recordId,
- workspaceMemberId: event.workspaceMemberId,
- properties: event.properties,
- })) satisfies TimelineActivityPayload[];
+ }),
+ ),
+ );
}
- private async computeTimelineActivityPayloadsForActivities({
+ private async buildPayloadsForJunctionRule({
+ rule,
events,
- activityType,
- name,
+ action,
workspaceId,
- objectMetadata,
- }: WorkspaceEventBatch<
- ObjectRecordBaseEvent<NoteWorkspaceEntity | TaskWorkspaceEntity>
- > & {
- activityType: ActivityType;
+ flatFieldMetadataMaps,
+ }: {
+ rule: TimelineActivityRule;
+ events: ObjectRecordBaseEvent[];
+ action: DatabaseEventAction;
+ workspaceId: string;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
}): Promise<TimelineActivityPayload[]> {
- if (!isDefined(workspaceId)) {
+ const ruleAction = JUNCTION_EVENT_ACTIONS[action];
+
+ if (!isDefined(ruleAction) || rule.targetShape.kind !== 'JUNCTION') {
return [];
}
- const { action } = parseEventNameOrThrow(name);
-
- const authContext = buildSystemAuthContext(workspaceId);
+ const { junctionSourceJoinColumnName } = rule.targetShape;
- const activityTargets =
- await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
- async () => {
- const activityTargetRepository =
- await this.globalWorkspaceOrmManager.getRepository(
- workspaceId,
- this.targetObjects[activityType],
- {
- shouldBypassPermissionChecks: true,
- },
- );
-
- return activityTargetRepository.find({
- where: {
- [`${activityType}Id`]: In(events.map((event) => event.recordId)),
- },
- });
- },
- authContext,
- );
+ const eventsWithJunctionRecord = events
+ .filter((event) => this.ruleMatchesEvent({ rule, ruleAction, event }))
+ .map((event) => {
+ const junctionRecord = event.properties.after as
+ | ObjectRecord
+ | undefined;
- if (activityTargets.length === 0) {
- return [];
- }
+ const target =
+ this.timelineActivityTargetResolverService.resolveTargetFromJunctionRecord(
+ { rule, junctionRecord },
+ );
- return events
- .flatMap((event) => {
- const correspondingActivityTargets = activityTargets.filter(
- (activityTarget) =>
- activityTarget[`${activityType}Id`] === event.recordId,
- );
+ const sourceRecordId = junctionRecord?.[junctionSourceJoinColumnName];
- if (correspondingActivityTargets.length === 0) {
- return;
+ if (!isDefined(target) || !isNonEmptyString(sourceRecordId)) {
+ return undefined;
}
- return correspondingActivityTargets.map((activityTarget) => {
- const targetColumn: string | undefined = Object.entries(
- activityTarget,
- ).find(
- ([columnName, columnValue]: [string, string]) =>
- columnName !== activityType + 'Id' &&
- columnName.endsWith('Id') &&
- columnValue !== null,
- )?.[0];
-
- if (!isDefined(targetColumn)) {
- return;
- }
-
- const activityTitle = event.properties.diff?.title?.after;
- const activityId = event.recordId;
-
- if (!isDefined(activityTitle)) {
- return;
- }
-
- return {
- name: `linked-${activityType}.${action}`,
- workspaceMemberId: event.workspaceMemberId,
- recordId: activityTarget[targetColumn.replace(/Id$/, '')],
- linkedRecordCachedName: activityTitle,
- linkedRecordId: activityId,
- linkedObjectMetadataId: objectMetadata.id,
- properties: event.properties,
- objectSingularName: objectMetadata.nameSingular,
- } satisfies TimelineActivityPayload;
- });
+ return { event, target, sourceRecordId };
})
.filter(isDefined);
- }
- private async computeTimelineActivityPayloadsForActivityTargets({
- events,
- activityType,
- name,
- objectMetadata,
- workspaceId,
- }: WorkspaceEventBatch<ObjectRecordBaseEvent> & {
- activityType: ActivityType;
- }): Promise<TimelineActivityPayload[]> {
- const { action } = parseEventNameOrThrow(name);
-
- const authContext = buildSystemAuthContext(workspaceId);
+ if (eventsWithJunctionRecord.length === 0) {
+ return [];
+ }
- const activities =
- await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
- async () => {
- const activityRepository =
- await this.globalWorkspaceOrmManager.getRepository(
- workspaceId,
- activityType,
- {
- shouldBypassPermissionChecks: true,
- },
- );
-
- return activityRepository.find({
- where: {
- id: In(
- events
- .map((event) =>
- this.extractActivityIdFromActivityTargetEvent(
- event,
- activityType,
- ),
- )
- .filter(isDefined),
- ),
- },
- });
+ const sourceRecordsByRecordId =
+ await this.timelineActivityTargetResolverService.findSourceRecordsByRecordId(
+ {
+ rule,
+ recordIds: eventsWithJunctionRecord.map(
+ ({ sourceRecordId }) => sourceRecordId,
+ ),
+ workspaceId,
},
- authContext,
);
- if (activities.length === 0) {
- return [];
+ return eventsWithJunctionRecord
+ .filter(({ sourceRecordId }) =>
+ sourceRecordsByRecordId.has(sourceRecordId),
+ )
+ .map(({ event, target, sourceRecordId }) =>
+ buildLinkedPayload({
+ rule,
+ action,
+ target,
+ workspaceMemberId: event.workspaceMemberId,
+ linkedRecordId: sourceRecordId,
+ linkedRecordCachedName: resolveLinkedRecordCachedName({
+ rule,
+ record: sourceRecordsByRecordId.get(sourceRecordId),
+ flatFieldMetadataMaps,
+ }),
+ properties: {},
+ }),
+ );
+ }
+
+ private async enrichEventsWithWorkspaceMemberId({
+ events,
+ workspaceId,
+ }: {
+ events: ObjectRecordBaseEvent[];
+ workspaceId: string;
+ }): Promise<ObjectRecordBaseEvent[]> {
+ const userIds = events.map((event) => event.userId).filter(isDefined);
+
+ if (userIds.length === 0) {
+ return events;
}
- const { flatFieldMetadataMaps } =
- await this.workspaceManyOrAllFlatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ const workspaceMemberRepository =
+ await this.globalWorkspaceOrmManager.getRepository(
+ workspaceId,
+ WorkspaceMemberWorkspaceEntity,
{
- workspaceId,
- flatMapsKeys: ['flatFieldMetadataMaps'],
+ shouldBypassPermissionChecks: true,
},
);
- const fields = getFlatFieldsFromFlatObjectMetadata(
- objectMetadata,
- flatFieldMetadataMaps,
- );
-
- const activityObjectMetadataId = fields.find(
- (field) => field.name === activityType,
- )?.relationTargetObjectMetadataId;
+ const workspaceMembers = await workspaceMemberRepository.findBy({
+ userId: In(userIds),
+ });
- return events
- .map((event) => {
- const activity = activities.find(
- (activity) =>
- activity.id ===
- this.extractActivityIdFromActivityTargetEvent(event, activityType),
- );
-
- if (!isDefined(activity)) {
- return;
- }
+ return events.map((event) => {
+ const workspaceMember = workspaceMembers.find(
+ (member) => member.userId === event.userId,
+ );
- if (!isDefined(activityObjectMetadataId)) {
- return;
- }
+ return isDefined(event.userId) && isDefined(workspaceMember)
+ ? { ...event, workspaceMemberId: workspaceMember.id }
+ : event;
+ });
+ }
- if (!isDefined(event.properties.after)) {
- return;
- }
+ // Position changes reach other consumers (SSE, webhooks, workflows) but render
+ // blank in the timeline, so exclude them to avoid empty activity rows.
+ private excludePositionFieldsFromEventsDiff({
+ events,
+ objectMetadata,
+ flatFieldMetadataMaps,
+ }: {
+ events: ObjectRecordBaseEvent[];
+ objectMetadata: FlatObjectMetadata;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ }): ObjectRecordBaseEvent[] {
+ const someEventHasDiff = events.some((event) =>
+ isDefined(event.properties.diff),
+ );
- const targetColumnName = Object.entries(event.properties.after).find(
- ([columnName, columnValue]: [string, string]) =>
- columnName !== activityType + 'Id' &&
- columnName.endsWith('Id') &&
- columnValue !== null,
- )?.[0];
+ if (!someEventHasDiff) {
+ return events;
+ }
- if (!isDefined(targetColumnName)) {
- return;
- }
+ const positionFieldNames = new Set(
+ getFlatFieldsFromFlatObjectMetadata(objectMetadata, flatFieldMetadataMaps)
+ .filter((field) => field.type === FieldMetadataType.POSITION)
+ .map((field) => field.name),
+ );
- const recordId = (event.properties.after as ObjectRecord)[
- targetColumnName
- ];
+ if (positionFieldNames.size === 0) {
+ return events;
+ }
- const objectSingularName =
- extractObjectSingularNameFromTargetColumnName(targetColumnName);
+ return events.map((event) => {
+ const diff = event.properties.diff;
- return {
- name: `linked-${activityType}.${action}`,
- objectSingularName,
- recordId,
- linkedRecordCachedName: activity.title,
- linkedRecordId: activity.id,
- linkedObjectMetadataId: activityObjectMetadataId,
- workspaceMemberId: event.workspaceMemberId,
- properties: {},
- } satisfies TimelineActivityPayload;
- })
- .filter(isDefined);
- }
+ if (!isDefined(diff)) {
+ return event;
+ }
- private extractActivityIdFromActivityTargetEvent(
- event: ObjectRecordBaseEvent,
- activityType: ActivityType,
- ): string | undefined {
- const activityId = (event.properties.after as ObjectRecord)?.[
- `${activityType}Id`
- ];
+ const diffWithoutPositionFields = Object.fromEntries(
+ Object.entries(diff).filter(
+ ([fieldName]) => !positionFieldNames.has(fieldName),
+ ),
+ );
- return activityId;
+ return {
+ ...event,
+ properties: { ...event.properties, diff: diffWithoutPositionFields },
+ };
+ });
}
}
diff --git a/packages/twenty-server/src/modules/timeline/timeline-activity.module.ts b/packages/twenty-server/src/modules/timeline/timeline-activity.module.ts
index bc35c9d4339..27a3966ac9b 100644
--- a/packages/twenty-server/src/modules/timeline/timeline-activity.module.ts
+++ b/packages/twenty-server/src/modules/timeline/timeline-activity.module.ts
@@ -1,9 +1,10 @@
import { Module } from '@nestjs/common';
-import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';
+import { TimelineActivityRuleBuilderService } from 'src/modules/timeline/services/timeline-activity-rule-builder.service';
+import { TimelineActivityTargetQueryService } from 'src/modules/timeline/services/timeline-activity-target-query.service';
import { TimelineActivityService } from 'src/modules/timeline/services/timeline-activity.service';
import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-objects/timeline-activity.workspace-entity';
@@ -13,10 +14,13 @@ import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-o
TimelineActivityWorkspaceEntity,
]),
TwentyORMModule,
- FeatureFlagModule,
WorkspaceManyOrAllFlatEntityMapsCacheModule,
],
- providers: [TimelineActivityService],
+ providers: [
+ TimelineActivityService,
+ TimelineActivityRuleBuilderService,
+ TimelineActivityTargetQueryService,
+ ],
exports: [TimelineActivityService],
})
export class TimelineActivityModule {}
diff --git a/packages/twenty-server/src/modules/timeline/types/resolved-timeline-activity-target.type.ts b/packages/twenty-server/src/modules/timeline/types/resolved-timeline-activity-target.type.ts
new file mode 100644
index 00000000000..dcfa7731e50
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/types/resolved-timeline-activity-target.type.ts
@@ -0,0 +1,4 @@
+export type ResolvedTimelineActivityTarget = {
+ targetObjectNameSingular: string;
+ targetRecordId: string;
+};
diff --git a/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule-action.type.ts b/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule-action.type.ts
new file mode 100644
index 00000000000..3e5af16bbf4
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule-action.type.ts
@@ -0,0 +1,7 @@
+export type TimelineActivityRuleAction =
+ | 'created'
+ | 'updated'
+ | 'deleted'
+ | 'restored'
+ | 'linked'
+ | 'unlinked';
diff --git a/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule-target-join-column.type.ts b/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule-target-join-column.type.ts
new file mode 100644
index 00000000000..9d6215ac88b
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule-target-join-column.type.ts
@@ -0,0 +1,4 @@
+export type TimelineActivityRuleTargetJoinColumn = {
+ joinColumnName: string;
+ targetObjectNameSingular: string;
+};
diff --git a/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule-target-shape.type.ts b/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule-target-shape.type.ts
new file mode 100644
index 00000000000..170bcd5f0ed
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule-target-shape.type.ts
@@ -0,0 +1,14 @@
+import { type TimelineActivityRuleTargetJoinColumn } from 'src/modules/timeline/types/timeline-activity-rule-target-join-column.type';
+
+export type TimelineActivityRuleTargetShape =
+ | { kind: 'SELF' }
+ | {
+ kind: 'JUNCTION';
+ junctionObjectMetadataId: string;
+ junctionObjectNameSingular: string;
+ // Column on the junction object pointing back at the rule object, e.g. noteId
+ junctionSourceJoinColumnName: string;
+ // Columns on the junction object pointing at the records receiving the
+ // entry. More than one when the junction target is a morph relation
+ junctionTargetJoinColumns: TimelineActivityRuleTargetJoinColumn[];
+ };
diff --git a/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule.type.ts b/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule.type.ts
new file mode 100644
index 00000000000..a372cdac3da
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/types/timeline-activity-rule.type.ts
@@ -0,0 +1,13 @@
+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';
+import { type TimelineActivityRuleTargetShape } from 'src/modules/timeline/types/timeline-activity-rule-target-shape.type';
+
+export type TimelineActivityRule = {
+ // Object whose events trigger this rule. Carried whole so the label of a
+ // linked record resolves through the shared display-name logic
+ sourceFlatObjectMetadata: FlatObjectMetadata;
+ actions: TimelineActivityRuleAction[];
+ // Diff keys gating the `updated` action. null = any field
+ triggerFieldNames: string[] | null;
+ targetShape: TimelineActivityRuleTargetShape;
+};
diff --git a/packages/twenty-server/src/modules/timeline/utils/__tests__/build-junction-target-shape.util.spec.ts b/packages/twenty-server/src/modules/timeline/utils/__tests__/build-junction-target-shape.util.spec.ts
new file mode 100644
index 00000000000..e0ebaa6b3f1
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/utils/__tests__/build-junction-target-shape.util.spec.ts
@@ -0,0 +1,221 @@
+import { FieldMetadataType, RelationType } from 'twenty-shared/types';
+
+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 FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { buildJunctionTargetShape } from 'src/modules/timeline/utils/build-junction-target-shape.util';
+
+type FlatEntityFixture = { id: string; universalIdentifier: string };
+
+const buildFlatEntityMaps = <T extends FlatEntityFixture>(
+ flatEntities: T[],
+): FlatEntityMaps<never> =>
+ ({
+ byUniversalIdentifier: Object.fromEntries(
+ flatEntities.map((flatEntity) => [
+ flatEntity.universalIdentifier,
+ flatEntity,
+ ]),
+ ),
+ universalIdentifierById: Object.fromEntries(
+ flatEntities.map((flatEntity) => [
+ flatEntity.id,
+ flatEntity.universalIdentifier,
+ ]),
+ ),
+ universalIdentifiersByApplicationId: {},
+ }) as unknown as FlatEntityMaps<never>;
+
+const NOTE_OBJECT = {
+ id: 'note-object',
+ universalIdentifier: 'note-object-uid',
+ nameSingular: 'note',
+ fieldIds: ['note-targets-field'],
+};
+
+const NOTE_TARGET_OBJECT = {
+ id: 'note-target-object',
+ universalIdentifier: 'note-target-object-uid',
+ nameSingular: 'noteTarget',
+ fieldIds: [
+ 'note-target-note-field',
+ 'note-target-person-field',
+ 'note-target-company-field',
+ ],
+};
+
+const PERSON_OBJECT = {
+ id: 'person-object',
+ universalIdentifier: 'person-object-uid',
+ nameSingular: 'person',
+ fieldIds: [],
+};
+
+const COMPANY_OBJECT = {
+ id: 'company-object',
+ universalIdentifier: 'company-object-uid',
+ nameSingular: 'company',
+ fieldIds: [],
+};
+
+const NOTE_TARGETS_FIELD = {
+ id: 'note-targets-field',
+ universalIdentifier: 'note-targets-field-uid',
+ name: 'noteTargets',
+ type: FieldMetadataType.RELATION,
+ objectMetadataId: NOTE_OBJECT.id,
+ morphId: null,
+ relationTargetObjectMetadataId: NOTE_TARGET_OBJECT.id,
+ relationTargetFieldMetadataId: 'note-target-note-field',
+ settings: {
+ relationType: RelationType.ONE_TO_MANY,
+ junctionTargetFieldId: 'note-target-person-field',
+ },
+};
+
+const NOTE_TARGET_NOTE_FIELD = {
+ id: 'note-target-note-field',
+ universalIdentifier: 'note-target-note-field-uid',
+ name: 'note',
+ type: FieldMetadataType.RELATION,
+ objectMetadataId: NOTE_TARGET_OBJECT.id,
+ morphId: null,
+ relationTargetObjectMetadataId: NOTE_OBJECT.id,
+ relationTargetFieldMetadataId: NOTE_TARGETS_FIELD.id,
+ settings: {
+ relationType: RelationType.MANY_TO_ONE,
+ joinColumnName: 'noteId',
+ },
+};
+
+const NOTE_TARGET_PERSON_FIELD = {
+ id: 'note-target-person-field',
+ universalIdentifier: 'note-target-person-field-uid',
+ name: 'targetPerson',
+ type: FieldMetadataType.MORPH_RELATION,
+ objectMetadataId: NOTE_TARGET_OBJECT.id,
+ morphId: 'target-morph-id',
+ relationTargetObjectMetadataId: PERSON_OBJECT.id,
+ relationTargetFieldMetadataId: 'person-note-targets-field',
+ settings: {
+ relationType: RelationType.MANY_TO_ONE,
+ joinColumnName: 'targetPersonId',
+ },
+};
+
+const NOTE_TARGET_COMPANY_FIELD = {
+ id: 'note-target-company-field',
+ universalIdentifier: 'note-target-company-field-uid',
+ name: 'targetCompany',
+ type: FieldMetadataType.MORPH_RELATION,
+ objectMetadataId: NOTE_TARGET_OBJECT.id,
+ morphId: 'target-morph-id',
+ relationTargetObjectMetadataId: COMPANY_OBJECT.id,
+ relationTargetFieldMetadataId: 'company-note-targets-field',
+ settings: {
+ relationType: RelationType.MANY_TO_ONE,
+ joinColumnName: 'targetCompanyId',
+ },
+};
+
+const NON_MORPH_JUNCTION_TARGET_FIELD = {
+ id: 'junction-person-field',
+ universalIdentifier: 'junction-person-field-uid',
+ name: 'person',
+ type: FieldMetadataType.RELATION,
+ objectMetadataId: NOTE_TARGET_OBJECT.id,
+ morphId: null,
+ relationTargetObjectMetadataId: PERSON_OBJECT.id,
+ relationTargetFieldMetadataId: 'person-junctions-field',
+ settings: {
+ relationType: RelationType.MANY_TO_ONE,
+ joinColumnName: 'personId',
+ },
+};
+
+const flatObjectMetadataMaps = buildFlatEntityMaps([
+ NOTE_OBJECT,
+ NOTE_TARGET_OBJECT,
+ PERSON_OBJECT,
+ COMPANY_OBJECT,
+]) as unknown as FlatEntityMaps<FlatObjectMetadata>;
+
+const flatFieldMetadataMaps = buildFlatEntityMaps([
+ NOTE_TARGETS_FIELD,
+ NOTE_TARGET_NOTE_FIELD,
+ NOTE_TARGET_PERSON_FIELD,
+ NOTE_TARGET_COMPANY_FIELD,
+]) as unknown as FlatEntityMaps<FlatFieldMetadata>;
+
+const buildShape = (relationFlatFieldMetadata: object) =>
+ buildJunctionTargetShape({
+ relationFlatFieldMetadata:
+ relationFlatFieldMetadata as unknown as FlatFieldMetadata,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ });
+
+describe('buildJunctionTargetShape', () => {
+ it('should expand a morph junction target into every morph member', () => {
+ expect(buildShape(NOTE_TARGETS_FIELD)).toEqual({
+ kind: 'JUNCTION',
+ junctionObjectMetadataId: NOTE_TARGET_OBJECT.id,
+ junctionObjectNameSingular: 'noteTarget',
+ junctionSourceJoinColumnName: 'noteId',
+ junctionTargetJoinColumns: [
+ {
+ joinColumnName: 'targetPersonId',
+ targetObjectNameSingular: 'person',
+ },
+ {
+ joinColumnName: 'targetCompanyId',
+ targetObjectNameSingular: 'company',
+ },
+ ],
+ });
+ });
+
+ it('should return undefined when the relation declares no junction target', () => {
+ expect(
+ buildShape({
+ ...NOTE_TARGETS_FIELD,
+ settings: { relationType: RelationType.ONE_TO_MANY },
+ }),
+ ).toBeUndefined();
+ });
+
+ it('should return undefined for a many to one relation', () => {
+ expect(buildShape(NOTE_TARGET_NOTE_FIELD)).toBeUndefined();
+ });
+
+ it('should build a single join column for a non morph junction target', () => {
+ const shape = buildJunctionTargetShape({
+ relationFlatFieldMetadata: {
+ ...NOTE_TARGETS_FIELD,
+ settings: {
+ relationType: RelationType.ONE_TO_MANY,
+ junctionTargetFieldId: NON_MORPH_JUNCTION_TARGET_FIELD.id,
+ },
+ } as unknown as FlatFieldMetadata,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps: buildFlatEntityMaps([
+ NOTE_TARGETS_FIELD,
+ NOTE_TARGET_NOTE_FIELD,
+ NON_MORPH_JUNCTION_TARGET_FIELD,
+ ]) as unknown as FlatEntityMaps<FlatFieldMetadata>,
+ });
+
+ expect(shape).toEqual({
+ kind: 'JUNCTION',
+ junctionObjectMetadataId: NOTE_TARGET_OBJECT.id,
+ junctionObjectNameSingular: 'noteTarget',
+ junctionSourceJoinColumnName: 'noteId',
+ junctionTargetJoinColumns: [
+ {
+ joinColumnName: 'personId',
+ targetObjectNameSingular: 'person',
+ },
+ ],
+ });
+ });
+});
diff --git a/packages/twenty-server/src/modules/timeline/utils/__tests__/derive-default-timeline-activity-rule.util.spec.ts b/packages/twenty-server/src/modules/timeline/utils/__tests__/derive-default-timeline-activity-rule.util.spec.ts
new file mode 100644
index 00000000000..12b9523c927
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/utils/__tests__/derive-default-timeline-activity-rule.util.spec.ts
@@ -0,0 +1,44 @@
+import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { deriveDefaultTimelineActivityRule } from 'src/modules/timeline/utils/derive-default-timeline-activity-rule.util';
+
+const COMPANY_FLAT_OBJECT_METADATA = getFlatObjectMetadataMock({
+ universalIdentifier: 'company-universal-identifier',
+ id: 'company-object-id',
+ nameSingular: 'company',
+ isAuditLogged: true,
+ isSystem: false,
+});
+
+const withOverrides = (
+ overrides: Partial<FlatObjectMetadata>,
+): FlatObjectMetadata => ({ ...COMPANY_FLAT_OBJECT_METADATA, ...overrides });
+
+describe('deriveDefaultTimelineActivityRule', () => {
+ it('should derive a self rule for an audit logged non system object', () => {
+ expect(
+ deriveDefaultTimelineActivityRule(COMPANY_FLAT_OBJECT_METADATA),
+ ).toEqual({
+ sourceFlatObjectMetadata: COMPANY_FLAT_OBJECT_METADATA,
+ actions: ['created', 'updated', 'deleted', 'restored'],
+ triggerFieldNames: null,
+ targetShape: { kind: 'SELF' },
+ });
+ });
+
+ it('should not derive a rule when the object is not audit logged', () => {
+ expect(
+ deriveDefaultTimelineActivityRule(
+ withOverrides({ isAuditLogged: false }),
+ ),
+ ).toBeUndefined();
+ });
+
+ it('should not derive a rule for a system object', () => {
+ expect(
+ deriveDefaultTimelineActivityRule(
+ withOverrides({ isSystem: true, nameSingular: 'noteTarget' }),
+ ),
+ ).toBeUndefined();
+ });
+});
diff --git a/packages/twenty-server/src/modules/timeline/utils/__tests__/extract-object-singular-name-from-target-column-name.util.spec.ts b/packages/twenty-server/src/modules/timeline/utils/__tests__/extract-object-singular-name-from-target-column-name.util.spec.ts
deleted file mode 100644
index cebe316cba6..00000000000
--- a/packages/twenty-server/src/modules/timeline/utils/__tests__/extract-object-singular-name-from-target-column-name.util.spec.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { extractObjectSingularNameFromTargetColumnName } from 'src/modules/timeline/utils/extract-object-singular-name-from-target-column-name.util';
-
-describe('extractObjectSingularNameFromTargetColumnName', () => {
- it('should extract "person" from "targetPersonId"', () => {
- expect(
- extractObjectSingularNameFromTargetColumnName('targetPersonId'),
- ).toBe('person');
- });
-
- it('should extract "arrowTarget" from "targetArrowTargetId"', () => {
- expect(
- extractObjectSingularNameFromTargetColumnName('targetArrowTargetId'),
- ).toBe('arrowTarget');
- });
-
- it('should extract "idCard" from "targetIdCardId"', () => {
- expect(
- extractObjectSingularNameFromTargetColumnName('targetIdCardId'),
- ).toBe('idCard');
- });
-
- it('should extract "cardId" from "targetCardIdId"', () => {
- expect(
- extractObjectSingularNameFromTargetColumnName('targetCardIdId'),
- ).toBe('cardId');
- });
-});
diff --git a/packages/twenty-server/src/modules/timeline/utils/build-junction-target-shape.util.ts b/packages/twenty-server/src/modules/timeline/utils/build-junction-target-shape.util.ts
new file mode 100644
index 00000000000..349ddc0c8dd
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/utils/build-junction-target-shape.util.ts
@@ -0,0 +1,141 @@
+import { FieldMetadataType, RelationType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { getJoinColumnNameForRelationField } from 'src/engine/metadata-modules/field-metadata/utils/get-join-column-name-for-relation-field.util';
+import { isFieldMetadataSettingsOfType } from 'src/engine/metadata-modules/field-metadata/utils/is-field-metadata-settings-of-type.util';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { findAllOthersMorphRelationFlatFieldMetadatasOrThrow } from 'src/engine/metadata-modules/flat-field-metadata/utils/find-all-others-morph-relation-flat-field-metadatas-or-throw.util';
+import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { type TimelineActivityRuleTargetJoinColumn } from 'src/modules/timeline/types/timeline-activity-rule-target-join-column.type';
+import { type TimelineActivityRuleTargetShape } from 'src/modules/timeline/types/timeline-activity-rule-target-shape.type';
+
+type BuildJunctionTargetShapeArgs = {
+ relationFlatFieldMetadata: FlatFieldMetadata;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+};
+
+// A junction relation is a ONE_TO_MANY field declaring, through
+// settings.junctionTargetFieldId, which field of the junction object leads to
+// the far side. When that field is a morph relation the whole morph group is
+// expanded, so one rule reaches every target type.
+export const buildJunctionTargetShape = ({
+ relationFlatFieldMetadata,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+}: BuildJunctionTargetShapeArgs):
+ | TimelineActivityRuleTargetShape
+ | undefined => {
+ const { settings } = relationFlatFieldMetadata;
+
+ if (!isFieldMetadataSettingsOfType(settings, FieldMetadataType.RELATION)) {
+ return undefined;
+ }
+
+ if (settings.relationType !== RelationType.ONE_TO_MANY) {
+ return undefined;
+ }
+
+ const junctionTargetFieldId = settings.junctionTargetFieldId;
+
+ if (!isDefined(junctionTargetFieldId)) {
+ return undefined;
+ }
+
+ const { relationTargetObjectMetadataId, relationTargetFieldMetadataId } =
+ relationFlatFieldMetadata;
+
+ if (
+ !isDefined(relationTargetObjectMetadataId) ||
+ !isDefined(relationTargetFieldMetadataId)
+ ) {
+ return undefined;
+ }
+
+ const junctionFlatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: relationTargetObjectMetadataId,
+ flatEntityMaps: flatObjectMetadataMaps,
+ });
+
+ if (!isDefined(junctionFlatObjectMetadata)) {
+ return undefined;
+ }
+
+ const junctionSourceFlatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: relationTargetFieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (!isDefined(junctionSourceFlatFieldMetadata)) {
+ return undefined;
+ }
+
+ const junctionSourceJoinColumnName = getJoinColumnNameForRelationField(
+ junctionSourceFlatFieldMetadata,
+ );
+
+ const junctionTargetFlatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: junctionTargetFieldId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (!isDefined(junctionTargetFlatFieldMetadata)) {
+ return undefined;
+ }
+
+ const junctionTargetFlatFieldMetadatas = isFlatFieldMetadataOfType(
+ junctionTargetFlatFieldMetadata,
+ FieldMetadataType.MORPH_RELATION,
+ )
+ ? [
+ junctionTargetFlatFieldMetadata,
+ ...findAllOthersMorphRelationFlatFieldMetadatasOrThrow({
+ flatFieldMetadata: junctionTargetFlatFieldMetadata,
+ flatFieldMetadataMaps,
+ flatObjectMetadata: junctionFlatObjectMetadata,
+ }),
+ ]
+ : [junctionTargetFlatFieldMetadata];
+
+ const junctionTargetJoinColumns = junctionTargetFlatFieldMetadatas
+ .map(
+ (flatFieldMetadata): TimelineActivityRuleTargetJoinColumn | undefined => {
+ const targetObjectMetadataId =
+ flatFieldMetadata.relationTargetObjectMetadataId;
+
+ if (!isDefined(targetObjectMetadataId)) {
+ return undefined;
+ }
+
+ const targetFlatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: targetObjectMetadataId,
+ flatEntityMaps: flatObjectMetadataMaps,
+ });
+
+ if (!isDefined(targetFlatObjectMetadata)) {
+ return undefined;
+ }
+
+ return {
+ joinColumnName: getJoinColumnNameForRelationField(flatFieldMetadata),
+ targetObjectNameSingular: targetFlatObjectMetadata.nameSingular,
+ };
+ },
+ )
+ .filter(isDefined);
+
+ if (junctionTargetJoinColumns.length === 0) {
+ return undefined;
+ }
+
+ return {
+ kind: 'JUNCTION',
+ junctionObjectMetadataId: junctionFlatObjectMetadata.id,
+ junctionObjectNameSingular: junctionFlatObjectMetadata.nameSingular,
+ junctionSourceJoinColumnName,
+ junctionTargetJoinColumns,
+ };
+};
diff --git a/packages/twenty-server/src/modules/timeline/utils/derive-default-timeline-activity-rule.util.ts b/packages/twenty-server/src/modules/timeline/utils/derive-default-timeline-activity-rule.util.ts
new file mode 100644
index 00000000000..23bdf88c8e8
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/utils/derive-default-timeline-activity-rule.util.ts
@@ -0,0 +1,27 @@
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { type TimelineActivityRule } from 'src/modules/timeline/types/timeline-activity-rule.type';
+
+const SELF_RULE_ACTIONS = [
+ 'created',
+ 'updated',
+ 'deleted',
+ 'restored',
+] as const;
+
+// Every audit logged non system object records its own changes. Materialising
+// this as a row per object would mean backfilling every object of every
+// workspace, so it is derived and only overrides are persisted.
+export const deriveDefaultTimelineActivityRule = (
+ flatObjectMetadata: FlatObjectMetadata,
+): TimelineActivityRule | undefined => {
+ if (!flatObjectMetadata.isAuditLogged || flatObjectMetadata.isSystem) {
+ return undefined;
+ }
+
+ return {
+ sourceFlatObjectMetadata: flatObjectMetadata,
+ actions: [...SELF_RULE_ACTIONS],
+ triggerFieldNames: null,
+ targetShape: { kind: 'SELF' },
+ };
+};
diff --git a/packages/twenty-server/src/modules/timeline/utils/extract-object-singular-name-from-target-column-name.util.ts b/packages/twenty-server/src/modules/timeline/utils/extract-object-singular-name-from-target-column-name.util.ts
deleted file mode 100644
index 1a74c8f7803..00000000000
--- a/packages/twenty-server/src/modules/timeline/utils/extract-object-singular-name-from-target-column-name.util.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-const ID_SUFFIX = 'Id';
-const TARGET_PREFIX = 'target';
-
-export const extractObjectSingularNameFromTargetColumnName = (
- targetColumnName: string,
-): string => {
- let result = targetColumnName;
-
- if (result.endsWith(ID_SUFFIX)) {
- result = result.slice(0, -ID_SUFFIX.length);
- }
-
- if (
- result.startsWith(TARGET_PREFIX) &&
- result.length > TARGET_PREFIX.length
- ) {
- result =
- result.charAt(TARGET_PREFIX.length).toLowerCase() +
- result.slice(TARGET_PREFIX.length + 1);
- }
-
- return result;
-};
diff --git a/packages/twenty-server/src/modules/timeline/utils/resolve-linked-record-cached-name.util.ts b/packages/twenty-server/src/modules/timeline/utils/resolve-linked-record-cached-name.util.ts
new file mode 100644
index 00000000000..2e047905f16
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/utils/resolve-linked-record-cached-name.util.ts
@@ -0,0 +1,25 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { getRecordDisplayName } from 'src/engine/core-modules/record-crud/utils/get-record-display-name.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 { type TimelineActivityRule } from 'src/modules/timeline/types/timeline-activity-rule.type';
+
+// Shared so both event streams label a linked record the same way, including
+// composite label identifiers such as a person full name.
+export const resolveLinkedRecordCachedName = ({
+ rule,
+ record,
+ flatFieldMetadataMaps,
+}: {
+ rule: TimelineActivityRule;
+ record: Record<string, unknown> | undefined;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): string | undefined =>
+ isDefined(record)
+ ? getRecordDisplayName(
+ record,
+ rule.sourceFlatObjectMetadata,
+ flatFieldMetadataMaps,
+ )
+ : undefined;
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 5cf5f57aca3..5d2d314f889 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
@@ -1,6 +1,7 @@
import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
import { destroyOneOperationFactory } from 'test/integration/graphql/utils/destroy-one-operation-factory.util';
import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
+import { updateManyOperationFactory } from 'test/integration/graphql/utils/update-many-operation-factory.util';
import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
import { updateOneOperationFactory } from 'test/integration/graphql/utils/update-one-operation-factory.util';
import { deleteOneOperationFactory } from 'test/integration/graphql/utils/delete-one-operation-factory.util';
@@ -115,12 +116,20 @@ const NOTE_COMPANY_ID = '20202020-7171-4000-8000-000000000004';
const NOTE_ID = '20202020-7171-4000-8000-000000000005';
const NOTE_TARGET_ID = '20202020-7171-4000-8000-000000000006';
const MESSAGE_LIST_ID = '20202020-7171-4000-8000-000000000007';
+const BATCH_COMPANY_IDS = [
+ '20202020-7171-4000-8000-000000000008',
+ '20202020-7171-4000-8000-000000000009',
+];
const CREATED_RECORD_IDS: { objectMetadataSingularName: string; id: string }[] =
[
{ objectMetadataSingularName: 'noteTarget', id: NOTE_TARGET_ID },
{ objectMetadataSingularName: 'note', id: NOTE_ID },
{ objectMetadataSingularName: 'messageList', id: MESSAGE_LIST_ID },
+ ...BATCH_COMPANY_IDS.map((id) => ({
+ objectMetadataSingularName: 'company',
+ id,
+ })),
{ objectMetadataSingularName: 'company', id: NOTE_COMPANY_ID },
{ objectMetadataSingularName: 'company', id: MERGE_COMPANY_ID },
{ objectMetadataSingularName: 'company', id: POSITION_COMPANY_ID },
@@ -227,6 +236,48 @@ describe('timeline activity write path (integration)', () => {
});
});
+ it('should merge every record of a multi record batch', async () => {
+ for (const [index, id] of BATCH_COMPANY_IDS.entries()) {
+ await createRecord({
+ objectMetadataSingularName: 'company',
+ data: { id, name: `Batch ${index}` },
+ });
+ }
+
+ const updateBatchTo = async (name: string) => {
+ const response = await makeGraphqlAPIRequest(
+ updateManyOperationFactory({
+ objectMetadataSingularName: 'company',
+ objectMetadataPluralName: 'companies',
+ gqlFields: 'id',
+ data: { name },
+ filter: { id: { in: BATCH_COMPANY_IDS } },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ };
+
+ await updateBatchTo('Batch renamed once');
+ await waitForAllJobsToFinish();
+
+ await updateBatchTo('Batch renamed twice');
+
+ for (const [index, id] of BATCH_COMPANY_IDS.entries()) {
+ const timelineActivities = await findTimelineActivities({
+ targetCompanyId: { eq: id },
+ name: { eq: 'company.updated' },
+ });
+
+ expect(timelineActivities).toHaveLength(1);
+ expect(timelineActivities[0].properties).toEqual({
+ diff: {
+ name: { before: `Batch ${index}`, after: 'Batch renamed twice' },
+ },
+ });
+ }
+ });
+
it('should not write an entry for a position only change', async () => {
await createRecord({
objectMetadataSingularName: 'company',
@@ -293,45 +344,59 @@ describe('timeline activity write path (integration)', () => {
expect(timelineActivities).toHaveLength(1);
});
- // Known defect: computeTimelineActivityPayloadsForActivities reads the
- // relation property instead of its join column, so the entry lands with no
- // target at all rather than on the linked company.
- it('should write an orphan linked entry when the note title changes', async () => {
- // Orphan rows carry no target, so nothing cascades them away when the
- // company is destroyed and they accumulate across runs: count the
- // difference rather than the total, which a previous run would satisfy.
- const orphanRowCountBefore = (
+ it('should write a linked entry on the company when the note title changes', async () => {
+ await updateRecord({
+ objectMetadataSingularName: 'note',
+ recordId: NOTE_ID,
+ data: { title: 'Linked note renamed' },
+ });
+
+ const onCompany = await findTimelineActivities({
+ targetCompanyId: { eq: NOTE_COMPANY_ID },
+ name: { eq: 'linked-note.updated' },
+ });
+
+ expect(onCompany).toHaveLength(1);
+ expect(onCompany[0].linkedRecordId).toBe(NOTE_ID);
+ expect(onCompany[0].linkedRecordCachedName).toBe('Linked note renamed');
+ expect(onCompany[0].properties).toEqual({
+ diff: {
+ title: { before: 'Linked note', after: 'Linked note renamed' },
+ },
+ });
+
+ const rowsWithoutTarget = (
await findTimelineActivityRowsByLinkedRecordId({
name: 'linked-note.updated',
linkedRecordId: NOTE_ID,
})
- ).length;
+ ).filter((row) => row.targetCompanyId === null);
+
+ expect(rowsWithoutTarget).toHaveLength(0);
+ });
+ // The note rule only fans out on its trigger field, so editing the body
+ // leaves the linked timelines alone.
+ it('should not write a linked entry when a non trigger field changes', async () => {
await updateRecord({
objectMetadataSingularName: 'note',
recordId: NOTE_ID,
- data: { title: 'Linked note renamed' },
+ data: {
+ bodyV2: { blocknote: null, markdown: 'Body only change' },
+ },
});
- await waitForAllJobsToFinish();
const onCompany = await findTimelineActivities({
targetCompanyId: { eq: NOTE_COMPANY_ID },
name: { eq: 'linked-note.updated' },
});
- expect(onCompany).toHaveLength(0);
-
- const orphanRows = await findTimelineActivityRowsByLinkedRecordId({
- name: 'linked-note.updated',
- linkedRecordId: NOTE_ID,
+ expect(onCompany).toHaveLength(1);
+ expect(onCompany[0].properties).toEqual({
+ diff: {
+ title: { before: 'Linked note', after: 'Linked note renamed' },
+ },
});
-
- expect(orphanRows).toHaveLength(orphanRowCountBefore + 1);
- expect(
- orphanRows.every(
- (row) => row.targetCompanyId === null && row.targetNoteId === null,
- ),
- ).toBe(true);
});
it('should write a linked entry on the company when the note target is deleted', async () => {