refactor: apply relation optimistic effects on record update (#3556)

* refactor: apply relation optimistic effects on record update Related to #3509 * refactor: remove need to pass relation id field to create and update mutations * fix: fix tests * fix: fix SingleEntitySelect glitch * fix: fix usePersistField tests * fix: fix wrong import after rebase * fix: fix several tests * fix: fix test types
2024-01-29 08:00:00 -03:00
parent d66d8c9907
commit a58b4cf437
43 changed files with 970 additions and 1109 deletions
--- a/packages/twenty-front/src/modules/apollo/optimistic-effect/utils/triggerUpdateRelationFieldOptimisticEffect.ts
+++ b/packages/twenty-front/src/modules/apollo/optimistic-effect/utils/triggerUpdateRelationFieldOptimisticEffect.ts
@ -0,0 +1,86 @@
+import { ApolloCache, StoreObject } from '@apollo/client';
+
+import { isCachedObjectConnection } from '@/apollo/optimistic-effect/utils/isCachedObjectConnection';
+import { CachedObjectRecordEdge } from '@/apollo/types/CachedObjectRecordEdge';
+import { ObjectRecord } from '@/object-record/types/ObjectRecord';
+import { capitalize } from '~/utils/string/capitalize';
+
+export type TriggerUpdateRelationFieldOptimisticEffectParams = {
+  cache: ApolloCache<unknown>;
+  objectNameSingular: string;
+  record: ObjectRecord;
+  relationObjectMetadataNameSingular: string;
+  relationFieldName: string;
+  previousRelationRecord: ObjectRecord | null;
+  nextRelationRecord: ObjectRecord | null;
+};
+
+export const triggerUpdateRelationFieldOptimisticEffect = ({
+  cache,
+  objectNameSingular,
+  record,
+  relationObjectMetadataNameSingular,
+  relationFieldName,
+  previousRelationRecord,
+  nextRelationRecord,
+}: TriggerUpdateRelationFieldOptimisticEffectParams) => {
+  const recordTypeName = capitalize(objectNameSingular);
+  const relationRecordTypeName = capitalize(relationObjectMetadataNameSingular);
+
+  if (previousRelationRecord) {
+    cache.modify<StoreObject>({
+      id: cache.identify({
+        ...previousRelationRecord,
+        __typename: relationRecordTypeName,
+      }),
+      fields: {
+        [relationFieldName]: (cachedFieldValue, { isReference, readField }) => {
+          // To many objects => remove record from previous relation field list
+          if (isCachedObjectConnection(objectNameSingular, cachedFieldValue)) {
+            const nextEdges = cachedFieldValue.edges.filter(
+              ({ node }) => readField('id', node) !== record.id,
+            );
+            return { ...cachedFieldValue, edges: nextEdges };
+          }
+
+          // To one object => detach previous relation record
+          if (isReference(cachedFieldValue)) {
+            return null;
+          }
+        },
+      },
+    });
+  }
+
+  if (nextRelationRecord) {
+    cache.modify<StoreObject>({
+      id: cache.identify({
+        ...nextRelationRecord,
+        __typename: relationRecordTypeName,
+      }),
+      fields: {
+        [relationFieldName]: (cachedFieldValue, { toReference }) => {
+          const nodeReference = toReference(record);
+
+          if (!nodeReference) return cachedFieldValue;
+
+          if (isCachedObjectConnection(objectNameSingular, cachedFieldValue)) {
+            // To many objects => add record to next relation field list
+            const nextEdges: CachedObjectRecordEdge[] = [
+              ...cachedFieldValue.edges,
+              {
+                __typename: `${recordTypeName}Edge`,
+                node: nodeReference,
+                cursor: '',
+              },
+            ];
+            return { ...cachedFieldValue, edges: nextEdges };
+          }
+
+          // To one object => attach next relation record
+          return nodeReference;
+        },
+      },
+    });
+  }
+};