The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsdeleted file mode 100644index 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.tsindex 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-queuimport { 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.tsindex 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-systemimport { 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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-oTimelineActivityWorkspaceEntity,]),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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsdeleted file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsdeleted file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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 () => {