Refacto views (#10272)

In this huge (sorry!) PR:
- introducing objectMetadataItem in contextStore instead of
objectMetadataId which is more convenient
- splitting some big hooks into smaller parts to avoid re-renders
- removing Effects to avoid re-renders (especially onViewChange)
- making the view prefetch separate from favorites to avoid re-renders
- making the view prefetch load a state and add selectors on top of it
to avoir re-renders

As a result, the performance is WAY better (I suspect the favorite
implementation to trigger a lot of re-renders unfortunately).
However, we are still facing a random app freeze on view creation. I
could not investigate the root cause. As this seems to be already there
in the precedent release, we can move forward but this seems a urgent
follow up to me ==> EDIT: I've found the root cause after a few ours of
deep dive... an infinite loop in RecordTableNoRecordGroupBodyEffect...

prastoin edit: close https://github.com/twentyhq/twenty/issues/10253

---------

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

packages/twenty-front/src/modules/object-metadata/hooks/useColumnDefinitionsFromFieldMetadata.ts

@@ -1,5 +1,3 @@
-import { useMemo } from 'react';
-
 import { ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
 import { FieldMetadata } from '@/object-record/record-field/types/FieldMetadata';
 import { ColumnDefinition } from '@/object-record/record-table/types/ColumnDefinition';
@@ -13,14 +11,8 @@ import { formatFieldMetadataItemsAsSortDefinitions } from '../utils/formatFieldM
 export const useColumnDefinitionsFromFieldMetadata = (
   objectMetadataItem: ObjectMetadataItem,
 ) => {
-  const activeFieldMetadataItems = useMemo(
-    () =>
-      objectMetadataItem
-        ? objectMetadataItem.fields.filter(
-            ({ isActive, isSystem }) => isActive && !isSystem,
-          )
-        : [],
-    [objectMetadataItem],
+  const activeFieldMetadataItems = objectMetadataItem.fields.filter(
+    ({ isActive, isSystem }) => isActive && !isSystem,
   );
 
   const filterableFieldMetadataItems = useRecoilValue(
@@ -33,43 +25,30 @@ export const useColumnDefinitionsFromFieldMetadata = (
     fields: activeFieldMetadataItems,
   });
 
-  const columnDefinitions: ColumnDefinition<FieldMetadata>[] = useMemo(
-    () =>
-      objectMetadataItem
-        ? activeFieldMetadataItems
-            .map((field, index) =>
-              formatFieldMetadataItemAsColumnDefinition({
-                position: index,
-                field,
-                objectMetadataItem,
-              }),
-            )
-            .filter(filterAvailableTableColumns)
-            .map((column) => {
-              const existsInFilterDefinitions =
-                filterableFieldMetadataItems.some(
-                  (fieldMetadataItem) =>
-                    fieldMetadataItem.id === column.fieldMetadataId,
-                );
-
-              const existsInSortDefinitions = sortDefinitions.some(
-                (sort) => sort.fieldMetadataId === column.fieldMetadataId,
-              );
-
-              return {
-                ...column,
-                isFilterable: existsInFilterDefinitions,
-                isSortable: existsInSortDefinitions,
-              };
-            })
-        : [],
-    [
-      filterableFieldMetadataItems,
-      activeFieldMetadataItems,
-      objectMetadataItem,
-      sortDefinitions,
-    ],
-  );
+  const columnDefinitions: ColumnDefinition<FieldMetadata>[] =
+    activeFieldMetadataItems
+      .map((field, index) =>
+        formatFieldMetadataItemAsColumnDefinition({
+          position: index,
+          field,
+          objectMetadataItem,
+        }),
+      )
+      .filter(filterAvailableTableColumns)
+      .map((column) => {
+        const existsInFilterDefinitions = filterableFieldMetadataItems.some(
+          (fieldMetadataItem) =>
+            fieldMetadataItem.id === column.fieldMetadataId,
+        );
+        const existsInSortDefinitions = sortDefinitions.some(
+          (sort) => sort.fieldMetadataId === column.fieldMetadataId,
+        );
+        return {
+          ...column,
+          isFilterable: existsInFilterDefinitions,
+          isSortable: existsInSortDefinitions,
+        };
+      });
 
   return {
     columnDefinitions,