Skip to content

The open alternative to Salesforce, designed for AI.

Share timeline activity routing plans (#24656)

Félix Malfaita1e593865e8d
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/listeners/entity-events-to-db.listener.ts b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/listeners/entity-events-to-db.listener.ts
index 5225b8ddd67..bdc75658d32 100644
--- a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/listeners/entity-events-to-db.listener.ts
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/listeners/entity-events-to-db.listener.ts
@@ -23,7 +23,7 @@ import { CallDatabaseEventTriggerJobsJob } from 'src/engine/core-modules/logic-f
import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
import { ObjectRecordEventPublisher } from 'src/engine/subscriptions/object-record-event/object-record-event-publisher';
import { UpsertTimelineActivityFromInternalEvent } from 'src/modules/timeline/jobs/upsert-timeline-activity-from-internal-event.job';
-import { TimelineActivityEventEligibilityService } from 'src/modules/timeline/services/timeline-activity-event-eligibility.service';
+import { TimelineActivityRoutingPlanService } from 'src/modules/timeline/services/timeline-activity-routing-plan.service';
@Injectable()
export class EntityEventsToDbListener {
@@ -35,7 +35,7 @@ export class EntityEventsToDbListener {
@InjectMessageQueue(MessageQueue.triggerQueue)
private readonly triggerQueueService: MessageQueueService,
private readonly objectRecordEventPublisher: ObjectRecordEventPublisher,
- private readonly timelineActivityEventEligibilityService: TimelineActivityEventEligibilityService,
+ private readonly timelineActivityRoutingPlanService: TimelineActivityRoutingPlanService,
) {}
@OnDatabaseBatchEvent('*', DatabaseEventAction.CREATED)
@@ -83,7 +83,7 @@ export class EntityEventsToDbListener {
const isAuditLogBatchEvent = batchEvent.objectMetadata?.isAuditLogged;
const shouldCreateTimelineActivity =
action !== DatabaseEventAction.DESTROYED &&
- (await this.timelineActivityEventEligibilityService.shouldProcessEvent({
+ (await this.timelineActivityRoutingPlanService.shouldProcessEvent({
flatObjectMetadata: batchEvent.objectMetadata,
workspaceId: batchEvent.workspaceId,
}));
diff --git a/packages/twenty-server/src/modules/timeline/services/__tests__/timeline-activity-event-eligibility.service.spec.ts b/packages/twenty-server/src/modules/timeline/services/__tests__/timeline-activity-event-eligibility.service.spec.ts
deleted file mode 100644
index a6a50c6e0bc..00000000000
--- a/packages/twenty-server/src/modules/timeline/services/__tests__/timeline-activity-event-eligibility.service.spec.ts
+++ /dev/null
@@ -1,128 +0,0 @@
-import { TimelineActivityEventEligibilityService } from 'src/modules/timeline/services/timeline-activity-event-eligibility.service';
-
-const SOURCE_OBJECT_UNIVERSAL_IDENTIFIER =
- '00000000-0000-4000-8000-000000000001';
-const JUNCTION_OBJECT_ID = '00000000-0000-4000-8000-000000000002';
-const RELATION_FIELD_UNIVERSAL_IDENTIFIER =
- '00000000-0000-4000-8000-000000000003';
-
-const buildService = ({
- objectUniversalIdentifier,
- relationTargetObjectMetadataId,
-}: {
- objectUniversalIdentifier: string;
- relationTargetObjectMetadataId?: string;
-}) => {
- const getOrRecomputeManyOrAllFlatEntityMapsWithHashes = jest
- .fn()
- .mockResolvedValue({
- data: {
- flatFieldMetadataMaps: {
- byUniversalIdentifier: {
- [RELATION_FIELD_UNIVERSAL_IDENTIFIER]: {
- relationTargetObjectMetadataId,
- },
- },
- },
- flatObjectMetadataMaps: {
- byUniversalIdentifier: {
- [SOURCE_OBJECT_UNIVERSAL_IDENTIFIER]: {
- id: 'source-object-id',
- },
- },
- },
- flatTimelineActivityTypeMaps: {
- byUniversalIdentifier: {
- type: {
- action: 'linked',
- applicationUniversalIdentifier:
- '00000000-0000-4000-8000-000000000004',
- isActive: true,
- objectUniversalIdentifier,
- targetRelationFieldUniversalIdentifier:
- RELATION_FIELD_UNIVERSAL_IDENTIFIER,
- triggerFieldUniversalIdentifiers: null,
- universalIdentifier: '00000000-0000-4000-8000-000000000005',
- },
- },
- },
- },
- hashes: {
- flatFieldMetadataMaps: 'field-hash',
- flatObjectMetadataMaps: 'object-hash',
- flatTimelineActivityTypeMaps: 'type-hash',
- },
- });
-
- return {
- getOrRecomputeManyOrAllFlatEntityMapsWithHashes,
- service: new TimelineActivityEventEligibilityService({
- getOrRecomputeManyOrAllFlatEntityMapsWithHashes,
- } as never),
- };
-};
-
-describe('TimelineActivityEventEligibilityService', () => {
- it('keeps audit-logged objects on the timeline write path', async () => {
- const { getOrRecomputeManyOrAllFlatEntityMapsWithHashes, service } =
- buildService({
- objectUniversalIdentifier: SOURCE_OBJECT_UNIVERSAL_IDENTIFIER,
- });
-
- await expect(
- service.shouldProcessEvent({
- flatObjectMetadata: { isAuditLogged: true } as never,
- workspaceId: 'workspace-id',
- }),
- ).resolves.toBe(true);
- expect(
- getOrRecomputeManyOrAllFlatEntityMapsWithHashes,
- ).not.toHaveBeenCalled();
- });
-
- it('keeps non-audited declared source and junction objects', async () => {
- const { service } = buildService({
- objectUniversalIdentifier: SOURCE_OBJECT_UNIVERSAL_IDENTIFIER,
- relationTargetObjectMetadataId: JUNCTION_OBJECT_ID,
- });
-
- await expect(
- service.shouldProcessEvent({
- flatObjectMetadata: {
- id: 'source-object-id',
- isAuditLogged: false,
- universalIdentifier: SOURCE_OBJECT_UNIVERSAL_IDENTIFIER,
- } as never,
- workspaceId: 'workspace-id',
- }),
- ).resolves.toBe(true);
- await expect(
- service.shouldProcessEvent({
- flatObjectMetadata: {
- id: JUNCTION_OBJECT_ID,
- isAuditLogged: false,
- universalIdentifier: 'junction-object-universal-identifier',
- } as never,
- workspaceId: 'workspace-id',
- }),
- ).resolves.toBe(true);
- });
-
- it('drops unrelated non-audited hot-path objects before enqueueing', async () => {
- const { service } = buildService({
- objectUniversalIdentifier: SOURCE_OBJECT_UNIVERSAL_IDENTIFIER,
- relationTargetObjectMetadataId: JUNCTION_OBJECT_ID,
- });
-
- await expect(
- service.shouldProcessEvent({
- flatObjectMetadata: {
- id: 'unrelated-object-id',
- isAuditLogged: false,
- universalIdentifier: 'unrelated-object-universal-identifier',
- } as never,
- workspaceId: 'workspace-id',
- }),
- ).resolves.toBe(false);
- });
-});
diff --git a/packages/twenty-server/src/modules/timeline/services/__tests__/timeline-activity.service.spec.ts b/packages/twenty-server/src/modules/timeline/services/__tests__/timeline-activity.service.spec.ts
deleted file mode 100644
index 76046b347ab..00000000000
--- a/packages/twenty-server/src/modules/timeline/services/__tests__/timeline-activity.service.spec.ts
+++ /dev/null
@@ -1,444 +0,0 @@
-import { ObjectRecordBaseEvent } from 'twenty-shared/database-events';
-import { type TimelineActivityTypeSnapshot } from 'twenty-shared/timeline';
-
-import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';
-import { type TimelineActivityPayload } from 'src/modules/timeline/types/timeline-activity-payload';
-import { type TimelineActivityRule } from 'src/modules/timeline/types/timeline-activity-rule.type';
-import { type ResolvedTimelineActivityType } from 'src/modules/timeline/utils/resolve-timeline-activity-type.util';
-import { TimelineActivityService } from 'src/modules/timeline/services/timeline-activity.service';
-
-const WORKSPACE_ID = '20202020-0000-4000-8000-000000000001';
-const SOURCE_RECORD_ID = '20202020-0000-4000-8000-000000000002';
-const OLD_TARGET_RECORD_ID = '20202020-0000-4000-8000-000000000003';
-const NEW_TARGET_RECORD_ID = '20202020-0000-4000-8000-000000000004';
-const WORKSPACE_MEMBER_ID = '20202020-0000-4000-8000-000000000005';
-const EVENT_DATE = '2026-08-23T09:00:00.000Z';
-
-const SOURCE_OBJECT = getFlatObjectMetadataMock({
- id: 'source-object-id',
- universalIdentifier: 'source-object-universal-identifier',
- nameSingular: 'attachment',
-});
-
-const EMPTY_FLAT_FIELD_METADATA_MAPS = {
- byUniversalIdentifier: {},
- universalIdentifierById: {},
- universalIdentifiersByApplicationId: {},
-};
-
-const buildTimelineActivityType = (
- action: TimelineActivityTypeSnapshot['action'],
-): ResolvedTimelineActivityType => {
- const id = `timeline-activity-type-${action}`;
-
- return {
- id,
- applicationId: 'application-id',
- snapshot: {
- id,
- universalIdentifier: `${id}-universal-identifier`,
- name: `${action}Attachment`,
- label: `${action} an attachment`,
- action,
- icon: 'IconPaperclip',
- objectUniversalIdentifier: SOURCE_OBJECT.universalIdentifier,
- frontComponentUniversalIdentifier: null,
- },
- };
-};
-
-const buildEvent = ({
- before,
- after,
- diff,
- updatedFields,
-}: {
- before?: Record<string, unknown>;
- after?: Record<string, unknown>;
- diff?: ObjectRecordBaseEvent<Record<string, unknown>>['properties']['diff'];
- updatedFields?: string[];
-}): ObjectRecordBaseEvent<Record<string, unknown>> => {
- const event = new ObjectRecordBaseEvent<Record<string, unknown>>();
-
- event.recordId = SOURCE_RECORD_ID;
- event.workspaceMemberId = WORKSPACE_MEMBER_ID;
- event.properties = { before, after, diff, updatedFields };
-
- return event;
-};
-
-const buildRule = ({
- action,
- targetShape,
-}: Pick<TimelineActivityRule, 'targetShape'> & {
- action: TimelineActivityTypeSnapshot['action'];
-}): TimelineActivityRule => ({
- sourceFlatObjectMetadata: SOURCE_OBJECT,
- actions: action === null ? [] : [action],
- timelineActivityType: buildTimelineActivityType(action),
- triggerFieldNames: null,
- targetShape,
-});
-
-const buildService = ({
- sourceRules = [],
- junctionRules = [],
-}: {
- sourceRules?: TimelineActivityRule[];
- junctionRules?: TimelineActivityRule[];
-}) => {
- const upsertTimelineActivities = jest.fn().mockResolvedValue(undefined);
- const resolveTimelineActivityType = jest.fn();
- const getRulesForEventBatch = jest.fn().mockResolvedValue({
- sourceRules,
- junctionRules,
- flatFieldMetadataMaps: EMPTY_FLAT_FIELD_METADATA_MAPS,
- resolveTimelineActivityType,
- });
- const resolveTargetsBySourceRecordId = jest.fn().mockResolvedValue(new Map());
- const resolveTargetFromDirectRelationRecord = jest.fn(
- ({ record }: { record?: Record<string, unknown> }) =>
- typeof record?.targetPersonId === 'string'
- ? {
- targetObjectNameSingular: 'person',
- targetRecordId: record.targetPersonId,
- }
- : undefined,
- );
- const resolveTargetFromJunctionRecord = jest.fn(
- ({ junctionRecord }: { junctionRecord?: Record<string, unknown> }) =>
- typeof junctionRecord?.targetPersonId === 'string'
- ? {
- targetObjectNameSingular: 'person',
- targetRecordId: junctionRecord.targetPersonId,
- }
- : undefined,
- );
- const findSourceRecordsByRecordId = jest
- .fn()
- .mockResolvedValue(
- new Map([
- [
- SOURCE_RECORD_ID,
- { id: SOURCE_RECORD_ID, name: 'Quarterly report.pdf' },
- ],
- ]),
- );
- const report = jest.fn();
-
- const service = new TimelineActivityService(
- { upsertTimelineActivities } as never,
- {
- executeInWorkspaceContext: jest.fn(
- async (callback: () => Promise<TimelineActivityPayload[][]>) =>
- callback(),
- ),
- } as never,
- { getRulesForEventBatch } as never,
- {
- resolveTargetsBySourceRecordId,
- resolveTargetFromDirectRelationRecord,
- resolveTargetFromJunctionRecord,
- findSourceRecordsByRecordId,
- } as never,
- { report } as never,
- );
-
- return {
- service,
- upsertTimelineActivities,
- resolveTimelineActivityType,
- resolveTargetsBySourceRecordId,
- findSourceRecordsByRecordId,
- report,
- };
-};
-
-const upsertEvent = async ({
- service,
- action,
- event,
-}: {
- service: TimelineActivityService;
- action: 'created' | 'updated' | 'deleted';
- event: ObjectRecordBaseEvent;
-}) =>
- service.upsertEvents({
- name: `attachment.${action}`,
- workspaceId: WORKSPACE_ID,
- objectMetadata: SOURCE_OBJECT,
- events: [event],
- });
-
-describe('TimelineActivityService', () => {
- it('writes a self activity with only the displayable update diff', async () => {
- const timelineActivityType = buildTimelineActivityType('updated');
- const rule: TimelineActivityRule = {
- sourceFlatObjectMetadata: SOURCE_OBJECT,
- actions: ['updated'],
- triggerFieldNames: null,
- targetShape: { kind: 'SELF' },
- };
- const { service, upsertTimelineActivities, resolveTimelineActivityType } =
- buildService({ sourceRules: [rule] });
-
- resolveTimelineActivityType.mockReturnValue(timelineActivityType);
-
- await upsertEvent({
- service,
- action: 'updated',
- event: buildEvent({
- after: { id: SOURCE_RECORD_ID, updatedAt: EVENT_DATE },
- diff: { name: { before: 'Before', after: 'After' } },
- }),
- });
-
- expect(upsertTimelineActivities).toHaveBeenCalledTimes(1);
- expect(upsertTimelineActivities).toHaveBeenCalledWith({
- objectSingularName: 'attachment',
- workspaceId: WORKSPACE_ID,
- payloads: [
- {
- timelineActivityTypeId: timelineActivityType.id,
- timelineActivityTypeSnapshot: timelineActivityType.snapshot,
- happensAt: new Date(EVENT_DATE),
- objectSingularName: 'attachment',
- recordId: SOURCE_RECORD_ID,
- workspaceMemberId: WORKSPACE_MEMBER_ID,
- properties: {
- diff: { name: { before: 'Before', after: 'After' } },
- },
- },
- ],
- });
- });
-
- it('fans a source update out through every junction target', async () => {
- const rule = buildRule({
- action: 'updated',
- targetShape: {
- kind: 'JUNCTION',
- junctionObjectMetadataId: 'junction-object-id',
- junctionObjectNameSingular: 'attachmentTarget',
- junctionSourceJoinColumnName: 'attachmentId',
- targetJoinColumns: [
- {
- joinColumnName: 'targetPersonId',
- targetObjectNameSingular: 'person',
- },
- ],
- },
- });
- const {
- service,
- upsertTimelineActivities,
- resolveTargetsBySourceRecordId,
- } = buildService({ sourceRules: [rule] });
-
- resolveTargetsBySourceRecordId.mockResolvedValue(
- new Map([
- [
- SOURCE_RECORD_ID,
- [
- {
- targetObjectNameSingular: 'person',
- targetRecordId: OLD_TARGET_RECORD_ID,
- },
- {
- targetObjectNameSingular: 'person',
- targetRecordId: NEW_TARGET_RECORD_ID,
- },
- ],
- ],
- ]),
- );
-
- await upsertEvent({
- service,
- action: 'updated',
- event: buildEvent({
- after: {
- id: SOURCE_RECORD_ID,
- name: 'Quarterly report.pdf',
- updatedAt: EVENT_DATE,
- },
- diff: { name: { before: 'Old.pdf', after: 'Quarterly report.pdf' } },
- }),
- });
-
- expect(upsertTimelineActivities).toHaveBeenCalledTimes(1);
- expect(upsertTimelineActivities).toHaveBeenCalledWith(
- expect.objectContaining({
- objectSingularName: 'person',
- workspaceId: WORKSPACE_ID,
- payloads: expect.arrayContaining([
- expect.objectContaining({
- recordId: OLD_TARGET_RECORD_ID,
- linkedRecordId: SOURCE_RECORD_ID,
- }),
- expect.objectContaining({
- recordId: NEW_TARGET_RECORD_ID,
- linkedRecordId: SOURCE_RECORD_ID,
- }),
- ]),
- }),
- );
- });
-
- it('emits unlinked and linked activities when a direct relation is repointed', async () => {
- const targetShape = {
- kind: 'DIRECT_RELATION' as const,
- targetJoinColumns: [
- {
- joinColumnName: 'targetPersonId',
- targetObjectNameSingular: 'person',
- },
- ],
- };
- const unlinkedRule = buildRule({ action: 'unlinked', targetShape });
- const linkedRule = buildRule({ action: 'linked', targetShape });
- const { service, upsertTimelineActivities } = buildService({
- sourceRules: [unlinkedRule, linkedRule],
- });
-
- await upsertEvent({
- service,
- action: 'updated',
- event: buildEvent({
- before: {
- id: SOURCE_RECORD_ID,
- targetPersonId: OLD_TARGET_RECORD_ID,
- updatedAt: EVENT_DATE,
- },
- after: {
- id: SOURCE_RECORD_ID,
- targetPersonId: NEW_TARGET_RECORD_ID,
- updatedAt: EVENT_DATE,
- },
- diff: {
- targetPersonId: {
- before: OLD_TARGET_RECORD_ID,
- after: NEW_TARGET_RECORD_ID,
- },
- },
- updatedFields: ['targetPersonId'],
- }),
- });
-
- expect(upsertTimelineActivities).toHaveBeenCalledTimes(1);
- expect(upsertTimelineActivities).toHaveBeenCalledWith(
- expect.objectContaining({
- objectSingularName: 'person',
- payloads: [
- expect.objectContaining({
- timelineActivityTypeId: unlinkedRule.timelineActivityType?.id,
- recordId: OLD_TARGET_RECORD_ID,
- }),
- expect.objectContaining({
- timelineActivityTypeId: linkedRule.timelineActivityType?.id,
- recordId: NEW_TARGET_RECORD_ID,
- }),
- ],
- }),
- );
- });
-
- it.each([
- { eventAction: 'created' as const, ruleAction: 'linked' as const },
- { eventAction: 'deleted' as const, ruleAction: 'unlinked' as const },
- ])(
- 'turns a $eventAction junction row into a $ruleAction activity',
- async ({ eventAction, ruleAction }) => {
- const rule = buildRule({
- action: ruleAction,
- targetShape: {
- kind: 'JUNCTION',
- junctionObjectMetadataId: 'junction-object-id',
- junctionObjectNameSingular: 'attachmentTarget',
- junctionSourceJoinColumnName: 'attachmentId',
- targetJoinColumns: [
- {
- joinColumnName: 'targetPersonId',
- targetObjectNameSingular: 'person',
- },
- ],
- },
- });
- const { service, upsertTimelineActivities, findSourceRecordsByRecordId } =
- buildService({ junctionRules: [rule] });
- const junctionRecord = {
- id: 'junction-record-id',
- attachmentId: SOURCE_RECORD_ID,
- targetPersonId: NEW_TARGET_RECORD_ID,
- updatedAt: EVENT_DATE,
- };
-
- await upsertEvent({
- service,
- action: eventAction,
- event: buildEvent({
- before: junctionRecord,
- after: junctionRecord,
- }),
- });
-
- expect(findSourceRecordsByRecordId).toHaveBeenCalledWith({
- rule,
- recordIds: [SOURCE_RECORD_ID],
- workspaceId: WORKSPACE_ID,
- });
- expect(findSourceRecordsByRecordId).toHaveBeenCalledTimes(1);
- expect(upsertTimelineActivities).toHaveBeenCalledTimes(1);
- expect(upsertTimelineActivities).toHaveBeenCalledWith(
- expect.objectContaining({
- objectSingularName: 'person',
- payloads: [
- expect.objectContaining({
- timelineActivityTypeId: rule.timelineActivityType?.id,
- recordId: NEW_TARGET_RECORD_ID,
- linkedRecordId: SOURCE_RECORD_ID,
- properties: {},
- }),
- ],
- }),
- );
- },
- );
-
- it('does not treat an unrelated junction update as a new link', async () => {
- const rule = buildRule({
- action: 'linked',
- targetShape: {
- kind: 'JUNCTION',
- junctionObjectMetadataId: 'junction-object-id',
- junctionObjectNameSingular: 'attachmentTarget',
- junctionSourceJoinColumnName: 'attachmentId',
- targetJoinColumns: [
- {
- joinColumnName: 'targetPersonId',
- targetObjectNameSingular: 'person',
- },
- ],
- },
- });
- const { service, upsertTimelineActivities } = buildService({
- junctionRules: [rule],
- });
-
- await upsertEvent({
- service,
- action: 'updated',
- event: buildEvent({
- after: {
- attachmentId: SOURCE_RECORD_ID,
- targetPersonId: NEW_TARGET_RECORD_ID,
- updatedAt: EVENT_DATE,
- },
- diff: { position: { before: 1, after: 2 } },
- updatedFields: ['position'],
- }),
- });
-
- expect(upsertTimelineActivities).not.toHaveBeenCalled();
- });
-});
diff --git a/packages/twenty-server/src/modules/timeline/services/timeline-activity-event-eligibility.service.ts b/packages/twenty-server/src/modules/timeline/services/timeline-activity-event-eligibility.service.ts
deleted file mode 100644
index 10bf3e39c40..00000000000
--- a/packages/twenty-server/src/modules/timeline/services/timeline-activity-event-eligibility.service.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-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 { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
-import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
-import { resolveTimelineActivityTypeRouting } from 'src/modules/timeline/utils/resolve-timeline-activity-type-routing.util';
-
-@Injectable()
-export class TimelineActivityEventEligibilityService {
- private readonly eligibleNonAuditedObjectIdsByWorkspaceId = new Map<
- string,
- { cacheKey: string; objectIds: Set<string> }
- >();
-
- constructor(
- private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
- ) {}
-
- async shouldProcessEvent({
- flatObjectMetadata,
- workspaceId,
- }: {
- flatObjectMetadata: FlatObjectMetadata;
- workspaceId: string;
- }): Promise<boolean> {
- if (flatObjectMetadata.isAuditLogged) {
- return true;
- }
-
- const { data, hashes } =
- await this.workspaceManyOrAllFlatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMapsWithHashes(
- {
- workspaceId,
- flatMapsKeys: [
- 'flatFieldMetadataMaps',
- 'flatObjectMetadataMaps',
- 'flatTimelineActivityTypeMaps',
- ],
- },
- );
- const cacheKey = [
- hashes.flatFieldMetadataMaps,
- hashes.flatObjectMetadataMaps,
- hashes.flatTimelineActivityTypeMaps,
- ].join('|');
- const cachedEligibility =
- this.eligibleNonAuditedObjectIdsByWorkspaceId.get(workspaceId);
-
- if (cachedEligibility?.cacheKey === cacheKey) {
- return cachedEligibility.objectIds.has(flatObjectMetadata.id);
- }
-
- const eligibleObjectIds = new Set<string>();
- const {
- flatFieldMetadataMaps,
- flatObjectMetadataMaps,
- flatTimelineActivityTypeMaps,
- } = data;
-
- for (const timelineActivityType of Object.values(
- flatTimelineActivityTypeMaps.byUniversalIdentifier,
- )
- .filter(isDefined)
- .filter(
- (timelineActivityType) =>
- timelineActivityType.isActive &&
- isDefined(timelineActivityType.action),
- )) {
- if (isDefined(timelineActivityType.objectUniversalIdentifier)) {
- const sourceObjectMetadata = findFlatEntityByUniversalIdentifier({
- flatEntityMaps: flatObjectMetadataMaps,
- universalIdentifier: timelineActivityType.objectUniversalIdentifier,
- });
-
- if (isDefined(sourceObjectMetadata)) {
- eligibleObjectIds.add(sourceObjectMetadata.id);
- }
- }
-
- const routing = resolveTimelineActivityTypeRouting(timelineActivityType);
-
- if (!isDefined(routing)) {
- continue;
- }
-
- const relationFieldMetadata = findFlatEntityByUniversalIdentifier({
- flatEntityMaps: flatFieldMetadataMaps,
- universalIdentifier: routing.targetRelationFieldUniversalIdentifier,
- });
-
- if (isDefined(relationFieldMetadata?.relationTargetObjectMetadataId)) {
- eligibleObjectIds.add(
- relationFieldMetadata.relationTargetObjectMetadataId,
- );
- }
- }
-
- this.eligibleNonAuditedObjectIdsByWorkspaceId.set(workspaceId, {
- cacheKey,
- objectIds: eligibleObjectIds,
- });
-
- return eligibleObjectIds.has(flatObjectMetadata.id);
- }
-}
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-routing-plan.service.ts
similarity index 62%
rename from packages/twenty-server/src/modules/timeline/services/timeline-activity-rule-builder.service.ts
rename to packages/twenty-server/src/modules/timeline/services/timeline-activity-routing-plan.service.ts
index be744c68e15..ab01a6bf1ee 100644
--- a/packages/twenty-server/src/modules/timeline/services/timeline-activity-rule-builder.service.ts
+++ b/packages/twenty-server/src/modules/timeline/services/timeline-activity-routing-plan.service.ts
@@ -7,17 +7,19 @@ import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/typ
import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { type FlatTimelineActivityTypeMaps } from 'src/engine/metadata-modules/flat-timeline-activity-type/types/flat-timeline-activity-type-maps.type';
import { TimelineActivityMetadataDiagnosticsService } from 'src/modules/timeline/services/timeline-activity-metadata-diagnostics.service';
-import {
- buildTimelineActivityTypeResolution,
- toResolvedTimelineActivityType,
- type TimelineActivityTypeResolver,
-} from 'src/modules/timeline/utils/resolve-timeline-activity-type.util';
import { type TimelineActivityRule } from 'src/modules/timeline/types/timeline-activity-rule.type';
import { buildDirectRelationTargetShape } from 'src/modules/timeline/utils/build-direct-relation-target-shape.util';
import { buildJunctionTargetShape } from 'src/modules/timeline/utils/build-junction-target-shape.util';
import { buildTimelineActivitySelfRule } from 'src/modules/timeline/utils/build-timeline-activity-self-rule.util';
import { resolveTimelineActivityTypeRouting } from 'src/modules/timeline/utils/resolve-timeline-activity-type-routing.util';
+import {
+ buildTimelineActivityTypeResolution,
+ toResolvedTimelineActivityType,
+ type ResolvableTimelineActivityType,
+ type TimelineActivityTypeResolver,
+} from 'src/modules/timeline/utils/resolve-timeline-activity-type.util';
type TimelineActivityRulesForEventBatch = {
sourceRules: TimelineActivityRule[];
@@ -26,13 +28,44 @@ type TimelineActivityRulesForEventBatch = {
resolveTimelineActivityType: TimelineActivityTypeResolver;
};
+type TimelineActivityRoutingPlan = {
+ activeTimelineActivityTypes: ResolvableTimelineActivityType[];
+ throughRules: TimelineActivityRule[];
+ eligibleNonAuditedObjectMetadataIds: Set<string>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ resolveTimelineActivityType: TimelineActivityTypeResolver;
+};
+
@Injectable()
-export class TimelineActivityRuleBuilderService {
+export class TimelineActivityRoutingPlanService {
+ private readonly routingPlanByWorkspaceId = new Map<
+ string,
+ { cacheKey: string; routingPlan: TimelineActivityRoutingPlan }
+ >();
+
constructor(
private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
private readonly timelineActivityMetadataDiagnosticsService: TimelineActivityMetadataDiagnosticsService,
) {}
+ async shouldProcessEvent({
+ flatObjectMetadata,
+ workspaceId,
+ }: {
+ flatObjectMetadata: FlatObjectMetadata;
+ workspaceId: string;
+ }): Promise<boolean> {
+ if (flatObjectMetadata.isAuditLogged) {
+ return true;
+ }
+
+ const routingPlan = await this.getRoutingPlan(workspaceId);
+
+ return routingPlan.eligibleNonAuditedObjectMetadataIds.has(
+ flatObjectMetadata.id,
+ );
+ }
+
async getRulesForEventBatch({
workspaceId,
flatObjectMetadata,
@@ -40,12 +73,34 @@ export class TimelineActivityRuleBuilderService {
workspaceId: string;
flatObjectMetadata: FlatObjectMetadata;
}): Promise<TimelineActivityRulesForEventBatch> {
- const {
- flatObjectMetadataMaps,
- flatFieldMetadataMaps,
- flatTimelineActivityTypeMaps,
- } =
- await this.workspaceManyOrAllFlatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ const routingPlan = await this.getRoutingPlan(workspaceId);
+ const selfRule = buildTimelineActivitySelfRule({
+ flatObjectMetadata,
+ timelineActivityTypes: routingPlan.activeTimelineActivityTypes,
+ });
+
+ return {
+ sourceRules: [
+ ...(isDefined(selfRule) ? [selfRule] : []),
+ ...routingPlan.throughRules.filter(
+ (rule) => rule.sourceFlatObjectMetadata.id === flatObjectMetadata.id,
+ ),
+ ],
+ junctionRules: routingPlan.throughRules.filter(
+ (rule) =>
+ rule.targetShape.kind === 'JUNCTION' &&
+ rule.targetShape.junctionObjectMetadataId === flatObjectMetadata.id,
+ ),
+ flatFieldMetadataMaps: routingPlan.flatFieldMetadataMaps,
+ resolveTimelineActivityType: routingPlan.resolveTimelineActivityType,
+ };
+ }
+
+ private async getRoutingPlan(
+ workspaceId: string,
+ ): Promise<TimelineActivityRoutingPlan> {
+ const { data, hashes } =
+ await this.workspaceManyOrAllFlatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMapsWithHashes(
{
workspaceId,
flatMapsKeys: [
@@ -55,7 +110,38 @@ export class TimelineActivityRuleBuilderService {
],
},
);
+ const cacheKey = [
+ hashes.flatObjectMetadataMaps,
+ hashes.flatFieldMetadataMaps,
+ hashes.flatTimelineActivityTypeMaps,
+ ].join('|');
+ const cachedRoutingPlan = this.routingPlanByWorkspaceId.get(workspaceId);
+
+ if (cachedRoutingPlan?.cacheKey === cacheKey) {
+ return cachedRoutingPlan.routingPlan;
+ }
+
+ const routingPlan = this.buildRoutingPlan({ workspaceId, ...data });
+
+ this.routingPlanByWorkspaceId.set(workspaceId, {
+ cacheKey,
+ routingPlan,
+ });
+
+ return routingPlan;
+ }
+ private buildRoutingPlan({
+ workspaceId,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ flatTimelineActivityTypeMaps,
+ }: {
+ workspaceId: string;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ flatTimelineActivityTypeMaps: FlatTimelineActivityTypeMaps;
+ }): TimelineActivityRoutingPlan {
const {
effectiveTimelineActivityTypes,
routingConflicts,
@@ -87,12 +173,11 @@ export class TimelineActivityRuleBuilderService {
const activeTimelineActivityTypes = effectiveTimelineActivityTypes.filter(
(timelineActivityType) => timelineActivityType.isActive,
);
-
const invalidThroughRules: {
action: string;
objectUniversalIdentifier: string | null;
}[] = [];
- const declaredThroughRules = activeTimelineActivityTypes
+ const throughRules = activeTimelineActivityTypes
.map((timelineActivityType): TimelineActivityRule | undefined => {
const routing =
resolveTimelineActivityTypeRouting(timelineActivityType);
@@ -123,6 +208,7 @@ export class TimelineActivityRuleBuilderService {
objectUniversalIdentifier:
timelineActivityType.objectUniversalIdentifier,
});
+
return undefined;
}
@@ -144,6 +230,7 @@ export class TimelineActivityRuleBuilderService {
objectUniversalIdentifier:
timelineActivityType.objectUniversalIdentifier,
});
+
return undefined;
}
@@ -173,27 +260,38 @@ export class TimelineActivityRuleBuilderService {
issues: invalidThroughRules,
});
- const selfRule = buildTimelineActivitySelfRule({
- flatObjectMetadata,
- timelineActivityTypes: activeTimelineActivityTypes,
- });
+ const eligibleNonAuditedObjectMetadataIds = new Set(
+ throughRules.flatMap((rule) => [
+ rule.sourceFlatObjectMetadata.id,
+ ...(rule.targetShape.kind === 'JUNCTION'
+ ? [rule.targetShape.junctionObjectMetadataId]
+ : []),
+ ]),
+ );
- const sourceRules = [
- ...(isDefined(selfRule) ? [selfRule] : []),
- ...declaredThroughRules.filter(
- (rule) => rule.sourceFlatObjectMetadata.id === flatObjectMetadata.id,
- ),
- ];
+ for (const timelineActivityType of activeTimelineActivityTypes) {
+ if (
+ !isDefined(timelineActivityType.action) ||
+ !isDefined(timelineActivityType.objectUniversalIdentifier) ||
+ isDefined(resolveTimelineActivityTypeRouting(timelineActivityType))
+ ) {
+ continue;
+ }
- const junctionRules = declaredThroughRules.filter(
- (rule) =>
- rule.targetShape.kind === 'JUNCTION' &&
- rule.targetShape.junctionObjectMetadataId === flatObjectMetadata.id,
- );
+ const flatObjectMetadata = findFlatEntityByUniversalIdentifier({
+ flatEntityMaps: flatObjectMetadataMaps,
+ universalIdentifier: timelineActivityType.objectUniversalIdentifier,
+ });
+
+ if (isDefined(flatObjectMetadata)) {
+ eligibleNonAuditedObjectMetadataIds.add(flatObjectMetadata.id);
+ }
+ }
return {
- sourceRules,
- junctionRules,
+ activeTimelineActivityTypes,
+ throughRules,
+ eligibleNonAuditedObjectMetadataIds,
flatFieldMetadataMaps,
resolveTimelineActivityType,
};
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 4043752abed..d4e64a994a3 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
@@ -17,7 +17,7 @@ import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system
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 { TimelineActivityRepository } from 'src/modules/timeline/repositories/timeline-activity.repository';
-import { TimelineActivityRuleBuilderService } from 'src/modules/timeline/services/timeline-activity-rule-builder.service';
+import { TimelineActivityRoutingPlanService } from 'src/modules/timeline/services/timeline-activity-routing-plan.service';
import {
type ResolvedTimelineActivityType,
type TimelineActivityTypeResolver,
@@ -102,7 +102,7 @@ export class TimelineActivityService {
@InjectObjectMetadataRepository(TimelineActivityWorkspaceEntity)
private readonly timelineActivityRepository: TimelineActivityRepository,
private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
- private readonly timelineActivityRuleBuilderService: TimelineActivityRuleBuilderService,
+ private readonly timelineActivityRoutingPlanService: TimelineActivityRoutingPlanService,
private readonly timelineActivityTargetQueryService: TimelineActivityTargetQueryService,
private readonly timelineActivityMetadataDiagnosticsService: TimelineActivityMetadataDiagnosticsService,
) {}
@@ -124,7 +124,7 @@ export class TimelineActivityService {
junctionRules,
flatFieldMetadataMaps,
resolveTimelineActivityType,
- } = await this.timelineActivityRuleBuilderService.getRulesForEventBatch({
+ } = await this.timelineActivityRoutingPlanService.getRulesForEventBatch({
workspaceId,
flatObjectMetadata: objectMetadata,
});
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 02010365734..1ac620f4fa3 100644
--- a/packages/twenty-server/src/modules/timeline/timeline-activity.module.ts
+++ b/packages/twenty-server/src/modules/timeline/timeline-activity.module.ts
@@ -3,14 +3,13 @@ import { Module } from '@nestjs/common';
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 { TimelineActivityRoutingPlanService } from 'src/modules/timeline/services/timeline-activity-routing-plan.service';
import { TimelineActivityTargetQueryService } from 'src/modules/timeline/services/timeline-activity-target-query.service';
import { TimelineActivityTypeCacheService } from 'src/modules/timeline/services/timeline-activity-type-cache.service';
import { TimelineActivityService } from 'src/modules/timeline/services/timeline-activity.service';
import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-objects/timeline-activity.workspace-entity';
import { MetricsModule } from 'src/engine/core-modules/metrics/metrics.module';
import { TimelineActivityMetadataDiagnosticsService } from 'src/modules/timeline/services/timeline-activity-metadata-diagnostics.service';
-import { TimelineActivityEventEligibilityService } from 'src/modules/timeline/services/timeline-activity-event-eligibility.service';
@Module({
imports: [
@@ -23,16 +22,15 @@ import { TimelineActivityEventEligibilityService } from 'src/modules/timeline/se
],
providers: [
TimelineActivityService,
- TimelineActivityRuleBuilderService,
+ TimelineActivityRoutingPlanService,
TimelineActivityTargetQueryService,
TimelineActivityTypeCacheService,
TimelineActivityMetadataDiagnosticsService,
- TimelineActivityEventEligibilityService,
],
exports: [
TimelineActivityService,
TimelineActivityTypeCacheService,
- TimelineActivityEventEligibilityService,
+ TimelineActivityRoutingPlanService,
],
})
export class TimelineActivityModule {}