The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Cover timeline activity routing branches (#24655)
Félix Malfaitf535ca426f3d
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.tsnew file mode 100644index 00000000000..76046b347ab--- /dev/null+++ b/packages/twenty-server/src/modules/timeline/services/__tests__/timeline-activity.service.spec.ts@@ -0,0 +1,444 @@+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();+ });+});