Emit restore events for revived upsert records

Author: FelixMalfait

packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts

@@ -86,7 +86,11 @@ const MUTATION_EVENT_ACTIONS_BY_KIND: Record<
   delete: [DatabaseEventAction.DESTROYED],
   restore: [DatabaseEventAction.RESTORED],
   'soft-delete': [DatabaseEventAction.DELETED],
-  update: [DatabaseEventAction.UPDATED, DatabaseEventAction.UPSERTED],
+  update: [
+    DatabaseEventAction.UPDATED,
+    DatabaseEventAction.RESTORED,
+    DatabaseEventAction.UPSERTED,
+  ],
 };
 
 type WorkspaceRepositoryOptions<TEntity extends ObjectLiteral> = {
@@ -1439,16 +1443,40 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
     const formattedAfter = isDefined(recordsAfter)
       ? this.formatResult<ObjectRecord[]>(recordsAfter)
       : undefined;
+    const recordBeforeById = new Map(
+      formattedBefore.map((record) => [record.id, record]),
+    );
+
+    const restoredRecordIds = new Set(
+      formattedAfter
+        ?.filter((recordAfter) => {
+          const recordBefore = recordBeforeById.get(recordAfter.id);
+
+          return (
+            isDefined(recordBefore?.deletedAt) && recordAfter.deletedAt === null
+          );
+        })
+        .map(({ id }) => id),
+    );
 
     for (const action of actions) {
+      const recordsAfterForAction =
+        kind !== 'update' || action === DatabaseEventAction.UPSERTED
+          ? formattedAfter
+          : formattedAfter?.filter(({ id }) =>
+              action === DatabaseEventAction.RESTORED
+                ? restoredRecordIds.has(id)
+                : !restoredRecordIds.has(id),
+            );
+
       const event = formatTwentyOrmEventToDatabaseBatchEvent({
         action,
         objectMetadataItem: this.options.flatObjectMetadata,
         flatFieldMetadataMaps:
           this.options.internalContext.flatFieldMetadataMaps,
         workspaceId: this.options.internalContext.workspaceId,
         recordsBefore: formattedBefore,
-        recordsAfter: formattedAfter,
+        recordsAfter: recordsAfterForAction,
         authContext: this.options.authContext,
       });
 

packages/twenty-server/test/integration/graphql/suites/timeline/timeline-activity-write-path.integration-spec.ts

@@ -1,4 +1,5 @@
 import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
+import { createManyOperationFactory } from 'test/integration/graphql/utils/create-many-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';
@@ -563,7 +564,7 @@ describe('timeline activity write path (integration)', () => {
       });
     });
 
-    it('should write a linked entry on the company when the note target is deleted', async () => {
+    it('should write the unlink and re-link entries when a note target is deleted and upserted', async () => {
       await makeGraphqlAPIRequest(
         deleteOneOperationFactory({
           objectMetadataSingularName: 'noteTarget',
@@ -584,6 +585,36 @@ describe('timeline activity write path (integration)', () => {
 
       expect(timelineActivities).toHaveLength(1);
       expect(timelineActivities[0].linkedRecordId).toBe(NOTE_ID);
+
+      const restoreResponse = await makeGraphqlAPIRequest(
+        createManyOperationFactory({
+          objectMetadataSingularName: 'noteTarget',
+          objectMetadataPluralName: 'noteTargets',
+          gqlFields: 'id',
+          data: [
+            {
+              noteId: NOTE_ID,
+              targetCompanyId: NOTE_COMPANY_ID,
+            },
+          ],
+          upsert: true,
+        }),
+      );
+
+      expect(restoreResponse.body.errors).toBeUndefined();
+
+      const linkedTimelineActivities = await findTimelineActivities({
+        targetCompanyId: { eq: NOTE_COMPANY_ID },
+        timelineActivityTypeId: {
+          eq: timelineActivityTypeIdForOrThrow(
+            'linked',
+            NOTE_UNIVERSAL_IDENTIFIER,
+          ),
+        },
+      });
+
+      expect(linkedTimelineActivities).toHaveLength(2);
+      expect(linkedTimelineActivities[1].linkedRecordId).toBe(NOTE_ID);
     });
   });