Skip to content

The open alternative to Salesforce, designed for AI.

fix(front): report the records an interrupted incremental delete already removed (#25549)

Thomas Trompettee73fba1dd9cd
diff --git a/packages/twenty-front/src/modules/object-record/hooks/__tests__/useIncrementalDeleteManyRecords.test.tsx b/packages/twenty-front/src/modules/object-record/hooks/__tests__/useIncrementalDeleteManyRecords.test.tsx
new file mode 100644
index 00000000000..f72fffe9e56
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/hooks/__tests__/useIncrementalDeleteManyRecords.test.tsx
@@ -0,0 +1,221 @@
+import { dispatchObjectRecordOperationBrowserEvent } from '@/browser-event/utils/dispatchObjectRecordOperationBrowserEvent';
+import { useRemoveNavigationMenuItemByTargetRecordId } from '@/navigation-menu-item/common/hooks/useRemoveNavigationMenuItemByTargetRecordId';
+import { useApolloCoreClient } from '@/object-metadata/hooks/useApolloCoreClient';
+import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
+import { useIncrementalDeleteManyRecords } from '@/object-record/hooks/useIncrementalDeleteManyRecords';
+import { useIncrementalFetchAndMutateRecords } from '@/object-record/hooks/useIncrementalFetchAndMutateRecords';
+import { useRefetchAggregateQueries } from '@/object-record/hooks/useRefetchAggregateQueries';
+import { renderHook } from '@testing-library/react';
+import { getMockObjectMetadataItemOrThrow } from '~/testing/utils/getMockObjectMetadataItemOrThrow';
+
+jest.mock('@/object-metadata/hooks/useObjectMetadataItem');
+jest.mock('@/object-metadata/hooks/useApolloCoreClient');
+jest.mock('@/object-record/hooks/useIncrementalFetchAndMutateRecords');
+jest.mock('@/object-record/hooks/useRefetchAggregateQueries');
+jest.mock('@/browser-event/utils/dispatchObjectRecordOperationBrowserEvent');
+jest.mock(
+ '@/navigation-menu-item/common/hooks/useRemoveNavigationMenuItemByTargetRecordId',
+);
+jest.mock('@/object-metadata/hooks/useObjectMetadataItems', () => ({
+ useObjectMetadataItems: () => ({ objectMetadataItems: [] }),
+}));
+jest.mock('@/object-record/hooks/useDeleteManyRecordsMutation', () => ({
+ useDeleteManyRecordsMutation: () => ({ deleteManyRecordsMutation: {} }),
+}));
+jest.mock('@/object-record/cache/hooks/useGetRecordFromCache', () => ({
+ useGetRecordFromCache: () => () => undefined,
+}));
+jest.mock('@/object-record/hooks/useObjectPermissions', () => ({
+ useObjectPermissions: () => ({ objectPermissionsByObjectMetadataId: {} }),
+}));
+jest.mock('@/object-record/record-store/hooks/useUpsertRecordsInStore', () => ({
+ useUpsertRecordsInStore: () => ({ upsertRecordsInStore: jest.fn() }),
+}));
+jest.mock(
+ '@/apollo/optimistic-effect/utils/triggerUpdateRecordOptimisticEffectByBatch',
+ () => ({
+ triggerUpdateRecordOptimisticEffectByBatch: jest.fn(),
+ }),
+);
+
+const mockUseObjectMetadataItem = jest.mocked(useObjectMetadataItem);
+const mockUseApolloCoreClient = jest.mocked(useApolloCoreClient);
+const mockUseIncrementalFetchAndMutateRecords = jest.mocked(
+ useIncrementalFetchAndMutateRecords,
+);
+const mockUseRefetchAggregateQueries = jest.mocked(useRefetchAggregateQueries);
+const mockDispatchObjectRecordOperationBrowserEvent = jest.mocked(
+ dispatchObjectRecordOperationBrowserEvent,
+);
+const mockUseRemoveNavigationMenuItemByTargetRecordId = jest.mocked(
+ useRemoveNavigationMenuItemByTargetRecordId,
+);
+
+const objectMetadataItem = getMockObjectMetadataItemOrThrow('company');
+
+describe('useIncrementalDeleteManyRecords', () => {
+ const mockIncrementalFetchAndMutate = jest.fn();
+ const mockRemoveNavigationMenuItemsByTargetRecordIds = jest.fn();
+ const mockRefetchAggregateQueries = jest.fn();
+ const mockMutate = jest.fn();
+
+ const renderDeleteHook = () =>
+ renderHook(() =>
+ useIncrementalDeleteManyRecords({
+ objectNameSingular: 'company',
+ delayInMsBetweenMutations: 0,
+ }),
+ );
+
+ const deleteBatchOf = (recordIds: string[]) => ({
+ recordIds,
+ totalFetchedCount: recordIds.length,
+ totalCount: recordIds.length,
+ abortSignal: new AbortController().signal,
+ });
+
+ beforeEach(() => {
+ jest.clearAllMocks();
+
+ mockUseObjectMetadataItem.mockReturnValue({ objectMetadataItem });
+
+ mockMutate.mockResolvedValue({});
+ mockUseApolloCoreClient.mockReturnValue({
+ mutate: mockMutate,
+ cache: {},
+ } as unknown as ReturnType<typeof useApolloCoreClient>);
+
+ mockUseIncrementalFetchAndMutateRecords.mockReturnValue({
+ incrementalFetchAndMutate: mockIncrementalFetchAndMutate,
+ progress: { displayType: 'number' },
+ isProcessing: false,
+ updateProgress: jest.fn(),
+ cancel: jest.fn(),
+ });
+
+ mockRefetchAggregateQueries.mockResolvedValue(undefined);
+ mockUseRefetchAggregateQueries.mockReturnValue({
+ refetchAggregateQueries: mockRefetchAggregateQueries,
+ });
+
+ mockUseRemoveNavigationMenuItemByTargetRecordId.mockReturnValue({
+ removeNavigationMenuItemsByTargetRecordIds:
+ mockRemoveNavigationMenuItemsByTargetRecordIds,
+ });
+ });
+
+ it('should report every deleted record when all batches succeed', async () => {
+ mockIncrementalFetchAndMutate.mockImplementation(async (mutateBatch) => {
+ await mutateBatch(deleteBatchOf(['record-1', 'record-2']));
+ await mutateBatch(deleteBatchOf(['record-3']));
+ });
+
+ const { result } = renderDeleteHook();
+
+ await expect(result.current.incrementalDeleteManyRecords()).resolves.toBe(
+ 3,
+ );
+
+ expect(mockDispatchObjectRecordOperationBrowserEvent).toHaveBeenCalledTimes(
+ 1,
+ );
+ expect(mockDispatchObjectRecordOperationBrowserEvent).toHaveBeenCalledWith({
+ objectMetadataItem,
+ operation: {
+ type: 'delete-many',
+ deletedRecordIds: ['record-1', 'record-2', 'record-3'],
+ },
+ });
+ expect(
+ mockRemoveNavigationMenuItemsByTargetRecordIds,
+ ).toHaveBeenCalledTimes(1);
+ expect(mockRemoveNavigationMenuItemsByTargetRecordIds).toHaveBeenCalledWith(
+ ['record-1', 'record-2', 'record-3'],
+ );
+ expect(mockRefetchAggregateQueries).toHaveBeenCalledTimes(1);
+ expect(mockRefetchAggregateQueries).toHaveBeenCalledWith({
+ objectMetadataNamePlural: objectMetadataItem.namePlural,
+ });
+ });
+
+ it('should report the records a failing run already deleted', async () => {
+ mockIncrementalFetchAndMutate.mockImplementation(async (mutateBatch) => {
+ await mutateBatch(deleteBatchOf(['record-1', 'record-2']));
+
+ throw new Error('Deletion failed');
+ });
+
+ const { result } = renderDeleteHook();
+
+ await expect(result.current.incrementalDeleteManyRecords()).rejects.toThrow(
+ 'Deletion failed',
+ );
+
+ expect(mockDispatchObjectRecordOperationBrowserEvent).toHaveBeenCalledTimes(
+ 1,
+ );
+ expect(mockDispatchObjectRecordOperationBrowserEvent).toHaveBeenCalledWith({
+ objectMetadataItem,
+ operation: {
+ type: 'delete-many',
+ deletedRecordIds: ['record-1', 'record-2'],
+ },
+ });
+ expect(
+ mockRemoveNavigationMenuItemsByTargetRecordIds,
+ ).toHaveBeenCalledTimes(1);
+ expect(mockRemoveNavigationMenuItemsByTargetRecordIds).toHaveBeenCalledWith(
+ ['record-1', 'record-2'],
+ );
+ expect(mockRefetchAggregateQueries).toHaveBeenCalledTimes(1);
+ });
+
+ it('should not report a deletion when no record was deleted', async () => {
+ mockIncrementalFetchAndMutate.mockRejectedValue(new Error('Fetch failed'));
+
+ const { result } = renderDeleteHook();
+
+ await expect(result.current.incrementalDeleteManyRecords()).rejects.toThrow(
+ 'Fetch failed',
+ );
+
+ expect(
+ mockDispatchObjectRecordOperationBrowserEvent,
+ ).not.toHaveBeenCalled();
+ expect(
+ mockRemoveNavigationMenuItemsByTargetRecordIds,
+ ).not.toHaveBeenCalled();
+ });
+
+ it('should keep the deletion error when the aggregate refetch also fails', async () => {
+ mockIncrementalFetchAndMutate.mockImplementation(async (mutateBatch) => {
+ await mutateBatch(deleteBatchOf(['record-1']));
+
+ throw new Error('Deletion failed');
+ });
+ mockRefetchAggregateQueries.mockRejectedValue(new Error('Refetch failed'));
+
+ const { result } = renderDeleteHook();
+
+ await expect(result.current.incrementalDeleteManyRecords()).rejects.toThrow(
+ 'Deletion failed',
+ );
+
+ expect(mockDispatchObjectRecordOperationBrowserEvent).toHaveBeenCalledTimes(
+ 1,
+ );
+ });
+
+ it('should surface a failing aggregate refetch when the deletion succeeded', async () => {
+ mockIncrementalFetchAndMutate.mockImplementation(async (mutateBatch) => {
+ await mutateBatch(deleteBatchOf(['record-1']));
+ });
+ mockRefetchAggregateQueries.mockRejectedValue(new Error('Refetch failed'));
+
+ const { result } = renderDeleteHook();
+
+ await expect(result.current.incrementalDeleteManyRecords()).rejects.toThrow(
+ 'Refetch failed',
+ );
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/hooks/useIncrementalDeleteManyRecords.ts b/packages/twenty-front/src/modules/object-record/hooks/useIncrementalDeleteManyRecords.ts
index 417a9197600..b6365fa6849 100644
--- a/packages/twenty-front/src/modules/object-record/hooks/useIncrementalDeleteManyRecords.ts
+++ b/packages/twenty-front/src/modules/object-record/hooks/useIncrementalDeleteManyRecords.ts
@@ -18,7 +18,7 @@ import { useRefetchAggregateQueries } from '@/object-record/hooks/useRefetchAggr
import { useUpsertRecordsInStore } from '@/object-record/record-store/hooks/useUpsertRecordsInStore';
import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
import { useCallback } from 'react';
-import { isDefined } from 'twenty-shared/utils';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
import { sleep } from '~/utils/sleep';
const DEFAULT_DELAY_BETWEEN_MUTATIONS_MS = 50;
@@ -224,30 +224,46 @@ export const useIncrementalDeleteManyRecords = <T>({
let totalDeletedCount = 0;
const allDeletedRecordIds: string[] = [];
- await incrementalFetchAndMutate(
- async ({ recordIds, totalCount, abortSignal }) => {
- await deleteManyRecordsBatch(recordIds, abortSignal);
+ let deletionError: unknown;
- allDeletedRecordIds.push(...recordIds);
- totalDeletedCount += recordIds.length;
+ try {
+ await incrementalFetchAndMutate(
+ async ({ recordIds, totalCount, abortSignal }) => {
+ await deleteManyRecordsBatch(recordIds, abortSignal);
- updateProgress(totalDeletedCount, totalCount);
- },
- );
+ allDeletedRecordIds.push(...recordIds);
+ totalDeletedCount += recordIds.length;
+
+ updateProgress(totalDeletedCount, totalCount);
+ },
+ );
+ } catch (error) {
+ deletionError = error;
+ }
+
+ if (isNonEmptyArray(allDeletedRecordIds)) {
+ removeNavigationMenuItemsByTargetRecordIds(allDeletedRecordIds);
+
+ dispatchObjectRecordOperationBrowserEvent({
+ objectMetadataItem,
+ operation: {
+ type: 'delete-many',
+ deletedRecordIds: allDeletedRecordIds,
+ },
+ });
+ }
await refetchAggregateQueries({
objectMetadataNamePlural: objectMetadataItem.namePlural,
+ }).catch((refetchError: unknown) => {
+ if (!isDefined(deletionError)) {
+ throw refetchError;
+ }
});
- removeNavigationMenuItemsByTargetRecordIds(allDeletedRecordIds);
-
- dispatchObjectRecordOperationBrowserEvent({
- objectMetadataItem,
- operation: {
- type: 'delete-many',
- deletedRecordIds: allDeletedRecordIds,
- },
- });
+ if (isDefined(deletionError)) {
+ throw deletionError;
+ }
return totalDeletedCount;
};