☑️ Refacto "Select All/Unselect all" on indexes

packages/twenty-front/src/modules/object-record/constants/DefaultMutationBatchSize.ts

@@ -0,0 +1 @@
+export const DEFAULT_MUTATION_BATCH_SIZE = 30;

packages/twenty-front/src/modules/object-record/constants/DeleteMaxCount.ts

@@ -0,0 +1 @@
+export const DELETE_MAX_COUNT = 10000;

packages/twenty-front/src/modules/object-record/hooks/__tests__/useDeleteManyRecords.test.tsx

@@ -49,7 +49,7 @@ describe('useDeleteManyRecords', () => {
     await act(async () => {
       const res = await result.current.deleteManyRecords(people);
       expect(res).toBeDefined();
-      expect(res).toHaveProperty('id');
+      expect(res[0]).toHaveProperty('id');
     });
 
     expect(mocks[0].result).toHaveBeenCalled();

packages/twenty-front/src/modules/object-record/hooks/__tests__/useFindManyRecords.test.tsx

@@ -1,6 +1,6 @@
-import { ReactNode } from 'react';
 import { MockedProvider } from '@apollo/client/testing';
 import { renderHook } from '@testing-library/react';
+import { ReactNode } from 'react';
 import { RecoilRoot, useSetRecoilState } from 'recoil';
 
 import { currentWorkspaceMemberState } from '@/auth/states/currentWorkspaceMemberState';

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

@@ -4,9 +4,11 @@ import { triggerDeleteRecordsOptimisticEffect } from '@/apollo/optimistic-effect
 import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
 import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
 import { useGetRecordFromCache } from '@/object-record/cache/hooks/useGetRecordFromCache';
+import { DEFAULT_MUTATION_BATCH_SIZE } from '@/object-record/constants/DefaultMutationBatchSize';
 import { useDeleteManyRecordsMutation } from '@/object-record/hooks/useDeleteManyRecordsMutation';
 import { getDeleteManyRecordsMutationResponseField } from '@/object-record/utils/getDeleteManyRecordsMutationResponseField';
 import { isDefined } from '~/utils/isDefined';
+import { sleep } from '~/utils/sleep';
 import { capitalize } from '~/utils/string/capitalize';
 
 type useDeleteOneRecordProps = {
@@ -16,6 +18,7 @@ type useDeleteOneRecordProps = {
 
 type DeleteManyRecordsOptions = {
   skipOptimisticEffect?: boolean;
+  delayInMsBetweenRequests?: number;
 };
 
 export const useDeleteManyRecords = ({
@@ -45,40 +48,62 @@ export const useDeleteManyRecords = ({
     idsToDelete: string[],
     options?: DeleteManyRecordsOptions,
   ) => {
-    const deletedRecords = await apolloClient.mutate({
-      mutation: deleteManyRecordsMutation,
-      variables: {
-        filter: { id: { in: idsToDelete } },
-      },
-      optimisticResponse: options?.skipOptimisticEffect
-        ? undefined
-        : {
-            [mutationResponseField]: idsToDelete.map((idToDelete) => ({
-              __typename: capitalize(objectNameSingular),
-              id: idToDelete,
-            })),
-          },
-      update: options?.skipOptimisticEffect
-        ? undefined
-        : (cache, { data }) => {
-            const records = data?.[mutationResponseField];
-
-            if (!records?.length) return;
-
-            const cachedRecords = records
-              .map((record) => getRecordFromCache(record.id, cache))
-              .filter(isDefined);
-
-            triggerDeleteRecordsOptimisticEffect({
-              cache,
-              objectMetadataItem,
-              recordsToDelete: cachedRecords,
-              objectMetadataItems,
-            });
-          },
-    });
-
-    return deletedRecords.data?.[mutationResponseField] ?? null;
+    const numberOfBatches = Math.ceil(
+      idsToDelete.length / DEFAULT_MUTATION_BATCH_SIZE,
+    );
+
+    const deletedRecords = [];
+
+    for (let batchIndex = 0; batchIndex < numberOfBatches; batchIndex++) {
+      const batchIds = idsToDelete.slice(
+        batchIndex * DEFAULT_MUTATION_BATCH_SIZE,
+        (batchIndex + 1) * DEFAULT_MUTATION_BATCH_SIZE,
+      );
+
+      const deletedRecordsResponse = await apolloClient.mutate({
+        mutation: deleteManyRecordsMutation,
+        variables: {
+          filter: { id: { in: batchIds } },
+        },
+        optimisticResponse: options?.skipOptimisticEffect
+          ? undefined
+          : {
+              [mutationResponseField]: batchIds.map((idToDelete) => ({
+                __typename: capitalize(objectNameSingular),
+                id: idToDelete,
+              })),
+            },
+        update: options?.skipOptimisticEffect
+          ? undefined
+          : (cache, { data }) => {
+              const records = data?.[mutationResponseField];
+
+              if (!records?.length) return;
+
+              const cachedRecords = records
+                .map((record) => getRecordFromCache(record.id, cache))
+                .filter(isDefined);
+
+              triggerDeleteRecordsOptimisticEffect({
+                cache,
+                objectMetadataItem,
+                recordsToDelete: cachedRecords,
+                objectMetadataItems,
+              });
+            },
+      });
+
+      const deletedRecordsForThisBatch =
+        deletedRecordsResponse.data?.[mutationResponseField] ?? [];
+
+      deletedRecords.push(...deletedRecordsForThisBatch);
+
+      if (isDefined(options?.delayInMsBetweenRequests)) {
+        await sleep(options.delayInMsBetweenRequests);
+      }
+    }
+
+    return deletedRecords;
   };
 
   return { deleteManyRecords };

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

@@ -0,0 +1,76 @@
+import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
+import { UseFindManyRecordsParams } from '@/object-record/hooks/useFetchMoreRecordsWithPagination';
+import { useLazyFindManyRecords } from '@/object-record/hooks/useLazyFindManyRecords';
+import { useCallback } from 'react';
+import { isDefined } from '~/utils/isDefined';
+
+type UseLazyFetchAllRecordIdsParams<T> = Omit<
+  UseFindManyRecordsParams<T>,
+  'skip'
+>;
+
+export const useFetchAllRecordIds = <T>({
+  objectNameSingular,
+  filter,
+  orderBy,
+}: UseLazyFetchAllRecordIdsParams<T>) => {
+  const { fetchMore, findManyRecords } = useLazyFindManyRecords({
+    objectNameSingular,
+    filter,
+    orderBy,
+    recordGqlFields: { id: true },
+  });
+
+  const { objectMetadataItem } = useObjectMetadataItem({
+    objectNameSingular,
+  });
+
+  const fetchAllRecordIds = useCallback(async () => {
+    if (!isDefined(findManyRecords)) {
+      return [];
+    }
+
+    const findManyRecordsDataResult = await findManyRecords();
+
+    const firstQueryResult =
+      findManyRecordsDataResult?.data?.[objectMetadataItem.namePlural];
+
+    const totalCount = firstQueryResult?.totalCount ?? 1;
+
+    const recordsCount = firstQueryResult?.edges.length ?? 0;
+
+    const recordIdSet = new Set(
+      firstQueryResult?.edges?.map((edge) => edge.node.id) ?? [],
+    );
+
+    const remainingCount = totalCount - recordsCount;
+
+    const remainingPages = Math.ceil(remainingCount / 30);
+
+    let lastCursor = firstQueryResult?.pageInfo.endCursor ?? '';
+
+    for (let i = 0; i < remainingPages; i++) {
+      const rawResult = await fetchMore?.({
+        variables: {
+          lastCursor: lastCursor,
+        },
+      });
+
+      const fetchMoreResult = rawResult?.data?.[objectMetadataItem.namePlural];
+
+      for (const edge of fetchMoreResult.edges) {
+        recordIdSet.add(edge.node.id);
+      }
+
+      lastCursor = fetchMoreResult.pageInfo.endCursor ?? '';
+    }
+
+    const recordIds = Array.from(recordIdSet);
+
+    return recordIds;
+  }, [fetchMore, findManyRecords, objectMetadataItem.namePlural]);
+
+  return {
+    fetchAllRecordIds,
+  };
+};