Skip to content

The open alternative to Salesforce, designed for AI.

Lock and read timeline merges per linked record (#28607)

Etiennebfc6a254d0ce
diff --git a/packages/twenty-server/src/modules/timeline/repositories/__tests__/timeline-activity.repository.spec.ts b/packages/twenty-server/src/modules/timeline/repositories/__tests__/timeline-activity.repository.spec.ts
index 12819b9f6c7..e74efb1b1d5 100644
--- a/packages/twenty-server/src/modules/timeline/repositories/__tests__/timeline-activity.repository.spec.ts
+++ b/packages/twenty-server/src/modules/timeline/repositories/__tests__/timeline-activity.repository.spec.ts
@@ -1,4 +1,5 @@
import { type TimelineActivityTypeSnapshot } from 'twenty-shared/timeline';
+import { In } from 'typeorm';
import { type WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { TimelineActivityRepository } from 'src/modules/timeline/repositories/timeline-activity.repository';
@@ -18,45 +19,52 @@ const TIMELINE_ACTIVITY_TYPE_SNAPSHOT: TimelineActivityTypeSnapshot = {
frontComponentUniversalIdentifier: null,
};
+const buildTimelineActivityRepository = (
+ recentTimelineActivities: Record<string, unknown>[] = [],
+) => {
+ const executeRawQuery = jest.fn().mockResolvedValue([]);
+ const workspaceRepository = {
+ find: jest.fn().mockResolvedValue(recentTimelineActivities),
+ update: jest.fn().mockResolvedValue(undefined),
+ insert: jest.fn().mockResolvedValue(undefined),
+ };
+ const workspaceOrmManager = {
+ executeInWorkspaceContext: async (callback: () => Promise<void>) =>
+ callback(),
+ runInWorkspaceTransaction: async (
+ callback: (transactionScope: {
+ getRepository: () => typeof workspaceRepository;
+ executeRawQuery: typeof executeRawQuery;
+ }) => Promise<void>,
+ ) =>
+ callback({ getRepository: () => workspaceRepository, executeRawQuery }),
+ } as unknown as WorkspaceOrmManager;
+
+ return {
+ repository: new TimelineActivityRepository(workspaceOrmManager),
+ workspaceRepository,
+ executeRawQuery,
+ };
+};
+
describe('TimelineActivityRepository', () => {
it('merges and stamps a recent row written without a snapshot', async () => {
- const update = jest.fn().mockResolvedValue(undefined);
- const insert = jest.fn().mockResolvedValue(undefined);
- const workspaceRepository = {
- find: jest.fn().mockResolvedValue([
- {
- id: '20202020-0000-4000-8000-000000000006',
- targetPersonId: RECORD_ID,
- workspaceMemberId: WORKSPACE_MEMBER_ID,
- timelineActivityTypeId: TIMELINE_ACTIVITY_TYPE_ID,
- timelineActivityTypeSnapshot: null,
- linkedRecordId: null,
- properties: {
- diff: { name: { before: 'Before', after: 'First' } },
- },
+ const {
+ repository,
+ workspaceRepository: { update, insert },
+ } = buildTimelineActivityRepository([
+ {
+ id: '20202020-0000-4000-8000-000000000006',
+ targetPersonId: RECORD_ID,
+ workspaceMemberId: WORKSPACE_MEMBER_ID,
+ timelineActivityTypeId: TIMELINE_ACTIVITY_TYPE_ID,
+ timelineActivityTypeSnapshot: null,
+ linkedRecordId: null,
+ properties: {
+ diff: { name: { before: 'Before', after: 'First' } },
},
- ]),
- update,
- insert,
- };
- const workspaceOrmManager = {
- executeInWorkspaceContext: jest.fn(
- async (callback: () => Promise<void>) => callback(),
- ),
- runInWorkspaceTransaction: jest.fn(
- async (
- callback: (transactionScope: {
- getRepository: () => typeof workspaceRepository;
- executeRawQuery: () => Promise<never[]>;
- }) => Promise<void>,
- ) =>
- callback({
- getRepository: () => workspaceRepository,
- executeRawQuery: jest.fn().mockResolvedValue([]),
- }),
- ),
- } as unknown as WorkspaceOrmManager;
- const repository = new TimelineActivityRepository(workspaceOrmManager);
+ },
+ ]);
await repository.upsertTimelineActivities({
objectSingularName: 'person',
@@ -89,30 +97,8 @@ describe('TimelineActivityRepository', () => {
});
it('locks merge identities in a stable order before reading recent rows', async () => {
- const executeRawQuery = jest.fn().mockResolvedValue([]);
- const workspaceRepository = {
- find: jest.fn().mockResolvedValue([]),
- update: jest.fn().mockResolvedValue(undefined),
- insert: jest.fn().mockResolvedValue(undefined),
- };
- const workspaceOrmManager = {
- executeInWorkspaceContext: jest.fn(
- async (callback: () => Promise<void>) => callback(),
- ),
- runInWorkspaceTransaction: jest.fn(
- async (
- callback: (transactionScope: {
- getRepository: () => typeof workspaceRepository;
- executeRawQuery: typeof executeRawQuery;
- }) => Promise<void>,
- ) =>
- callback({
- getRepository: () => workspaceRepository,
- executeRawQuery,
- }),
- ),
- } as unknown as WorkspaceOrmManager;
- const repository = new TimelineActivityRepository(workspaceOrmManager);
+ const { repository, workspaceRepository, executeRawQuery } =
+ buildTimelineActivityRepository();
await repository.upsertTimelineActivities({
objectSingularName: 'person',
@@ -151,6 +137,7 @@ describe('TimelineActivityRepository', () => {
'record-a',
WORKSPACE_MEMBER_ID,
TIMELINE_ACTIVITY_TYPE_ID,
+ null,
]),
JSON.stringify([
'timeline-activity-merge',
@@ -159,6 +146,7 @@ describe('TimelineActivityRepository', () => {
'record-z',
WORKSPACE_MEMBER_ID,
TIMELINE_ACTIVITY_TYPE_ID,
+ null,
]),
],
]);
@@ -166,4 +154,83 @@ describe('TimelineActivityRepository', () => {
workspaceRepository.find.mock.invocationCallOrder[0],
).toBeGreaterThan(executeRawQuery.mock.invocationCallOrder[0]);
});
+
+ it('locks and reads recent rows per linked record for linked payloads', async () => {
+ const { repository, workspaceRepository, executeRawQuery } =
+ buildTimelineActivityRepository();
+
+ await repository.upsertTimelineActivities({
+ objectSingularName: 'person',
+ workspaceId: WORKSPACE_ID,
+ payloads: ['message-b', 'message-a'].map((linkedRecordId) => ({
+ happensAt: new Date('2026-08-23T09:00:00.000Z'),
+ properties: {},
+ recordId: RECORD_ID,
+ workspaceMemberId: WORKSPACE_MEMBER_ID,
+ timelineActivityTypeId: TIMELINE_ACTIVITY_TYPE_ID,
+ timelineActivityTypeSnapshot: TIMELINE_ACTIVITY_TYPE_SNAPSHOT,
+ linkedRecordId,
+ })),
+ });
+
+ expect(executeRawQuery.mock.calls[0][1]).toEqual([
+ ['message-a', 'message-b'].map((linkedRecordId) =>
+ JSON.stringify([
+ 'timeline-activity-merge',
+ WORKSPACE_ID,
+ 'person',
+ RECORD_ID,
+ WORKSPACE_MEMBER_ID,
+ TIMELINE_ACTIVITY_TYPE_ID,
+ linkedRecordId,
+ ]),
+ ),
+ ]);
+ expect(workspaceRepository.find).toHaveBeenCalledWith(
+ expect.objectContaining({
+ where: expect.objectContaining({
+ linkedRecordId: In(['message-b', 'message-a']),
+ }),
+ }),
+ );
+ });
+
+ it('does not merge a payload without a linked record into a linked row', async () => {
+ const {
+ repository,
+ workspaceRepository: { update, insert },
+ } = buildTimelineActivityRepository([
+ {
+ id: '20202020-0000-4000-8000-000000000006',
+ targetPersonId: RECORD_ID,
+ workspaceMemberId: WORKSPACE_MEMBER_ID,
+ timelineActivityTypeId: TIMELINE_ACTIVITY_TYPE_ID,
+ timelineActivityTypeSnapshot: TIMELINE_ACTIVITY_TYPE_SNAPSHOT,
+ linkedRecordId: '20202020-0000-4000-8000-000000000007',
+ properties: {
+ diff: { name: { before: 'Before', after: 'First' } },
+ },
+ },
+ ]);
+
+ await repository.upsertTimelineActivities({
+ objectSingularName: 'person',
+ workspaceId: WORKSPACE_ID,
+ payloads: [
+ {
+ happensAt: new Date('2026-08-23T09:00:00.000Z'),
+ properties: {
+ diff: { name: { before: 'First', after: 'Second' } },
+ },
+ recordId: RECORD_ID,
+ workspaceMemberId: WORKSPACE_MEMBER_ID,
+ timelineActivityTypeId: TIMELINE_ACTIVITY_TYPE_ID,
+ timelineActivityTypeSnapshot: TIMELINE_ACTIVITY_TYPE_SNAPSHOT,
+ },
+ ],
+ });
+
+ expect(update).not.toHaveBeenCalled();
+ expect(insert).toHaveBeenCalledTimes(1);
+ });
});
diff --git a/packages/twenty-server/src/modules/timeline/repositories/timeline-activity.repository.ts b/packages/twenty-server/src/modules/timeline/repositories/timeline-activity.repository.ts
index 5c722800eaa..a8f17a06d21 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
@@ -237,8 +237,8 @@ export class TimelineActivityRepository {
)
.find(
(timelineActivity) =>
- !isDefined(payload.linkedRecordId) ||
- timelineActivity.linkedRecordId === payload.linkedRecordId,
+ (timelineActivity.linkedRecordId ?? null) ===
+ (payload.linkedRecordId ?? null),
);
if (isDefined(recentTimelineActivity)) {
@@ -339,6 +339,7 @@ export class TimelineActivityRepository {
payload.recordId,
payload.workspaceMemberId ?? null,
payload.timelineActivityTypeId,
+ payload.linkedRecordId ?? null,
]),
),
),
@@ -374,6 +375,12 @@ export class TimelineActivityRepository {
createdAt: MoreThan(tenMinutesAgo),
};
+ const linkedRecordIds = payloads.map((payload) => payload.linkedRecordId);
+
+ if (linkedRecordIds.every(isDefined)) {
+ whereConditions.linkedRecordId = In(linkedRecordIds);
+ }
+
// Every candidate is needed: a single row would let only one payload of a multi-record batch merge
return await timelineActivityRepository.find({
where: {