Feat/put target object identifier on use activities (#4682)

When writing to the normalized cache (record), it's crucial to use _refs
for relationships to avoid many problems. Essentially, we only deal with
level 0 and generate all fields to be comfortable with their defaults.

When writing in queries (which should be very rare, the only cases are
prefetch and the case of activities due to the nested query; I've
reduced this to a single file for activities
usePrepareFindManyActivitiesQuery 🙂), it's important to use queryFields
to avoid bugs. I've implemented them on the side of query generation and
record generation.

When doing an updateOne / createOne, etc., it's necessary to distinguish
between optimistic writing (which we actually want to do with _refs) and
the server response without refs. This allows for a clean write in the
optimistic cache without worrying about nesting (as the first point).

To simplify the whole activities part, write to the normalized cache
first. Then, base queries on it in an idempotent manner. This way,
there's no need to worry about the current page or action. The
normalized cache is up-to-date, so I update the queries. Same idea as
for optimisticEffects, actually.

Finally, I've triggered optimisticEffects rather than the manual update
of many queries.

---------

Co-authored-by: Lucas Bordeau <bordeau.lucas@gmail.com>

packages/twenty-front/src/modules/activities/hooks/useCreateActivityInCache.ts

@@ -1,20 +1,24 @@
+import { Reference, useApolloClient } from '@apollo/client';
 import { useRecoilCallback, useRecoilValue } from 'recoil';
 import { v4 } from 'uuid';
 
-import { useAttachRelationInBothDirections } from '@/activities/hooks/useAttachRelationInBothDirections';
-import { useInjectIntoActivityTargetInlineCellCache } from '@/activities/inline-cell/hooks/useInjectIntoActivityTargetInlineCellCache';
 import { Activity, ActivityType } from '@/activities/types/Activity';
 import { ActivityTarget } from '@/activities/types/ActivityTarget';
 import { ActivityTargetableObject } from '@/activities/types/ActivityTargetableEntity';
 import { makeActivityTargetsToCreateFromTargetableObjects } from '@/activities/utils/getActivityTargetsToCreateFromTargetableObjects';
 import { currentWorkspaceMemberState } from '@/auth/states/currentWorkspaceMemberState';
+import { useObjectMetadataItemOnly } from '@/object-metadata/hooks/useObjectMetadataItemOnly';
+import { objectMetadataItemsState } from '@/object-metadata/states/objectMetadataItemsState';
 import { CoreObjectNameSingular } from '@/object-metadata/types/CoreObjectNameSingular';
-import { useCreateManyRecordsInCache } from '@/object-record/hooks/useCreateManyRecordsInCache';
-import { useCreateOneRecordInCache } from '@/object-record/hooks/useCreateOneRecordInCache';
+import { useCreateManyRecordsInCache } from '@/object-record/cache/hooks/useCreateManyRecordsInCache';
+import { useCreateOneRecordInCache } from '@/object-record/cache/hooks/useCreateOneRecordInCache';
+import { getRecordConnectionFromRecords } from '@/object-record/cache/utils/getRecordConnectionFromRecords';
+import { modifyRecordFromCache } from '@/object-record/cache/utils/modifyRecordFromCache';
 import { useFindOneRecord } from '@/object-record/hooks/useFindOneRecord';
 import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
 import { WorkspaceMember } from '@/workspace-member/types/WorkspaceMember';
 import { isDefined } from '~/utils/isDefined';
+import { isUndefinedOrNull } from '~/utils/isUndefinedOrNull';
 
 export const useCreateActivityInCache = () => {
   const { createManyRecordsInCache: createManyActivityTargetsInCache } =
@@ -22,11 +26,9 @@ export const useCreateActivityInCache = () => {
       objectNameSingular: CoreObjectNameSingular.ActivityTarget,
     });
 
-  const { createOneRecordInCache: createOneActivityInCache } =
-    useCreateOneRecordInCache<Activity>({
-      objectNameSingular: CoreObjectNameSingular.Activity,
-    });
+  const cache = useApolloClient().cache;
 
+  const objectMetadataItems = useRecoilValue(objectMetadataItemsState);
   const currentWorkspaceMember = useRecoilValue(currentWorkspaceMemberState);
 
   const { record: currentWorkspaceMemberRecord } = useFindOneRecord({
@@ -35,27 +37,37 @@ export const useCreateActivityInCache = () => {
     depth: 0,
   });
 
-  const { injectIntoActivityTargetInlineCellCache } =
-    useInjectIntoActivityTargetInlineCellCache();
+  const { objectMetadataItem: objectMetadataItemActivity } =
+    useObjectMetadataItemOnly({
+      objectNameSingular: CoreObjectNameSingular.Activity,
+    });
 
-  const { attachRelationInBothDirections } =
-    useAttachRelationInBothDirections();
+  const { objectMetadataItem: objectMetadataItemActivityTarget } =
+    useObjectMetadataItemOnly({
+      objectNameSingular: CoreObjectNameSingular.ActivityTarget,
+    });
+
+  const createOneActivityInCache = useCreateOneRecordInCache<Activity>({
+    objectMetadataItem: objectMetadataItemActivity,
+  });
 
   const createActivityInCache = useRecoilCallback(
     ({ snapshot, set }) =>
       ({
         type,
-        targetableObjects,
+        targetObject,
         customAssignee,
       }: {
         type: ActivityType;
-        targetableObjects: ActivityTargetableObject[];
+        targetObject?: ActivityTargetableObject;
         customAssignee?: WorkspaceMember;
       }) => {
         const activityId = v4();
 
         const createdActivityInCache = createOneActivityInCache({
           id: activityId,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
           author: currentWorkspaceMemberRecord,
           authorId: currentWorkspaceMemberRecord?.id,
           assignee: customAssignee ?? currentWorkspaceMemberRecord,
@@ -63,42 +75,89 @@ export const useCreateActivityInCache = () => {
           type,
         });
 
-        const targetObjectRecords = targetableObjects
-          .map((targetableObject) => {
-            const targetObject = snapshot
-              .getLoadable(recordStoreFamilyState(targetableObject.id))
-              .getValue();
+        if (isUndefinedOrNull(createdActivityInCache)) {
+          throw new Error('Failed to create activity in cache');
+        }
 
-            return targetObject;
-          })
-          .filter(isDefined);
+        if (isUndefinedOrNull(targetObject)) {
+          set(recordStoreFamilyState(activityId), {
+            ...createdActivityInCache,
+            activityTargets: [],
+            comments: [],
+          });
+
+          return {
+            createdActivityInCache: {
+              ...createdActivityInCache,
+              activityTargets: [],
+            },
+          };
+        }
+
+        const targetObjectRecord = snapshot
+          .getLoadable(recordStoreFamilyState(targetObject.id))
+          .getValue();
+
+        if (isUndefinedOrNull(targetObjectRecord)) {
+          throw new Error('Failed to find target object record');
+        }
 
         const activityTargetsToCreate =
           makeActivityTargetsToCreateFromTargetableObjects({
-            activityId,
-            targetableObjects,
-            targetObjectRecords,
+            activity: createdActivityInCache,
+            targetableObjects: [targetObject],
+            targetObjectRecords: [targetObjectRecord],
           });
 
         const createdActivityTargetsInCache = createManyActivityTargetsInCache(
           activityTargetsToCreate,
         );
 
-        injectIntoActivityTargetInlineCellCache({
-          activityId,
-          activityTargetsToInject: createdActivityTargetsInCache,
+        const activityTargetsConnection = getRecordConnectionFromRecords({
+          objectMetadataItems: objectMetadataItems,
+          objectMetadataItem: objectMetadataItemActivityTarget,
+          records: createdActivityTargetsInCache,
+          withPageInfo: false,
+          computeReferences: true,
+          isRootLevel: false,
         });
 
-        attachRelationInBothDirections({
-          sourceRecord: createdActivityInCache,
-          fieldNameOnSourceRecord: 'activityTargets',
-          sourceObjectNameSingular: CoreObjectNameSingular.Activity,
-          fieldNameOnTargetRecord: 'activity',
-          targetObjectNameSingular: CoreObjectNameSingular.ActivityTarget,
-          targetRecords: createdActivityTargetsInCache,
+        modifyRecordFromCache({
+          recordId: createdActivityInCache.id,
+          cache,
+          fieldModifiers: {
+            activityTargets: () => activityTargetsConnection,
+          },
+          objectMetadataItem: objectMetadataItemActivity,
         });
 
-        // TODO: should refactor when refactoring make activity connection utils
+        const targetObjectMetadataItem = objectMetadataItems.find(
+          (item) => item.nameSingular === targetObject.targetObjectNameSingular,
+        );
+
+        if (isDefined(targetObjectMetadataItem)) {
+          modifyRecordFromCache({
+            cache,
+            objectMetadataItem: targetObjectMetadataItem,
+            recordId: targetObject.id,
+            fieldModifiers: {
+              activityTargets: (activityTargetsRef, { readField }) => {
+                const edges = readField<{ node: Reference }[]>(
+                  'edges',
+                  activityTargetsRef,
+                );
+
+                if (!edges) return activityTargetsRef;
+
+                return {
+                  ...activityTargetsRef,
+                  edges: [...edges, ...activityTargetsConnection.edges],
+                };
+              },
+            },
+          });
+        }
+
         set(recordStoreFamilyState(activityId), {
           ...createdActivityInCache,
           activityTargets: createdActivityTargetsInCache,
@@ -110,15 +169,16 @@ export const useCreateActivityInCache = () => {
             ...createdActivityInCache,
             activityTargets: createdActivityTargetsInCache,
           },
-          createdActivityTargetsInCache,
         };
       },
     [
-      attachRelationInBothDirections,
-      createManyActivityTargetsInCache,
       createOneActivityInCache,
       currentWorkspaceMemberRecord,
-      injectIntoActivityTargetInlineCellCache,
+      createManyActivityTargetsInCache,
+      objectMetadataItems,
+      objectMetadataItemActivityTarget,
+      cache,
+      objectMetadataItemActivity,
     ],
   );