perf: apply record optimistic effects with cache.modify on mutation (#3540)

* perf: apply record optimistic effects with cache.modify on mutation

Closes #3509

* refactor: return early when created records do not match filter

* fix: fix id generation on record creation

* fix: comment filtering behavior on record creation

* Fixed typing error

* refactor: review - use ??

* refactor: review - add variables in readFieldValueToSort

* docs: review - add comments for variables.first in triggerUpdateRecordOptimisticEffect

* refactor: review - add intermediary variable for 'not' filter in useMultiObjectSearchMatchesSearchFilterAndToSelectQuery

* refactor: review - add filter utils

* fix: fix tests

---------

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

packages/twenty-front/src/modules/object-record/select/hooks/useRecordsForSelect.ts

@@ -5,7 +5,8 @@ import { OrderBy } from '@/object-metadata/types/OrderBy';
 import { useFindManyRecords } from '@/object-record/hooks/useFindManyRecords';
 import { SelectableRecord } from '@/object-record/select/types/SelectableRecord';
 import { getObjectFilterFields } from '@/object-record/select/utils/getObjectFilterFields';
-import { isDefined } from '~/utils/isDefined';
+import { andFilterVariables } from '@/object-record/utils/andFilterVariables';
+import { orFilterVariables } from '@/object-record/utils/orFilterVariables';
 
 export const DEFAULT_SEARCH_REQUEST_LIMIT = 60;
 
@@ -37,85 +38,62 @@ export const useRecordsForSelect = ({
   ];
 
   const orderByField = getObjectOrderByField(sortOrder);
+  const selectedIdsFilter = { id: { in: selectedIds } };
 
   const { loading: selectedRecordsLoading, records: selectedRecordsData } =
     useFindManyRecords({
-      filter: {
-        id: {
-          in: selectedIds,
-        },
-      },
+      filter: selectedIdsFilter,
       orderBy: orderByField,
       objectNameSingular,
+      skip: !selectedIds.length,
     });
 
-  const searchFilter = filters
-    .map(({ fieldNames, filter }) => {
-      if (!isNonEmptyString(filter)) {
-        return undefined;
-      }
+  const searchFilters = filters.map(({ fieldNames, filter }) => {
+    if (!isNonEmptyString(filter)) {
+      return undefined;
+    }
 
-      return {
-        or: fieldNames.map((fieldName) => {
-          const fieldNameParts = fieldName.split('.');
+    return orFilterVariables(
+      fieldNames.map((fieldName) => {
+        const [parentFieldName, subFieldName] = fieldName.split('.');
 
-          if (fieldNameParts.length > 1) {
-            // Composite field
-
-            return {
-              [fieldNameParts[0]]: {
-                [fieldNameParts[1]]: {
-                  ilike: `%${filter}%`,
-                },
-              },
-            };
-          }
+        if (subFieldName) {
+          // Composite field
           return {
-            [fieldName]: {
-              ilike: `%${filter}%`,
+            [parentFieldName]: {
+              [subFieldName]: {
+                ilike: `%${filter}%`,
+              },
             },
           };
-        }),
-      };
-    })
-    .filter(isDefined);
+        }
+
+        return {
+          [fieldName]: {
+            ilike: `%${filter}%`,
+          },
+        };
+      }),
+    );
+  });
 
   const {
     loading: filteredSelectedRecordsLoading,
     records: filteredSelectedRecordsData,
   } = useFindManyRecords({
-    filter: {
-      and: [
-        {
-          and: searchFilter,
-        },
-        {
-          id: {
-            in: selectedIds,
-          },
-        },
-      ],
-    },
+    filter: andFilterVariables([...searchFilters, selectedIdsFilter]),
     orderBy: orderByField,
     objectNameSingular,
+    skip: !selectedIds.length,
   });
 
+  const notFilterIds = [...selectedIds, ...excludeEntityIds];
+  const notFilter = notFilterIds.length
+    ? { not: { id: { in: notFilterIds } } }
+    : undefined;
   const { loading: recordsToSelectLoading, records: recordsToSelectData } =
     useFindManyRecords({
-      filter: {
-        and: [
-          {
-            and: searchFilter,
-          },
-          {
-            not: {
-              id: {
-                in: [...selectedIds, ...excludeEntityIds],
-              },
-            },
-          },
-        ],
-      },
+      filter: andFilterVariables([...searchFilters, notFilter]),
       limit: limit ?? DEFAULT_SEARCH_REQUEST_LIMIT,
       orderBy: orderByField,
       objectNameSingular,