Skip to content

The open alternative to Salesforce, designed for AI.

feat(workflow): select core workflows and delete them in bulk (#25415)

Thomas Trompette5abd2abf17cf
diff --git a/packages/twenty-front/src/modules/object-core/components/CoreObjectTable.tsx b/packages/twenty-front/src/modules/object-core/components/CoreObjectTable.tsx
index ad21899cbb4..b63e0c2d91a 100644
--- a/packages/twenty-front/src/modules/object-core/components/CoreObjectTable.tsx
+++ b/packages/twenty-front/src/modules/object-core/components/CoreObjectTable.tsx
@@ -5,7 +5,11 @@ import {
CoreObjectTableBody,
CoreObjectTableRow,
} from '@/object-core/components/CoreObjectTableRow';
+import { CoreObjectTableCheckboxCell } from '@/object-core/components/CoreObjectTableCheckboxCell';
+import { CORE_OBJECT_TABLE_CHECKBOX_COLUMN_GRID_TRACK } from '@/object-core/constants/CoreObjectTableCheckboxColumnGridTrack';
import { type CoreObjectTableColumn } from '@/object-core/types/CoreObjectTableColumn';
+import { type CoreObjectTableSelection } from '@/object-core/types/CoreObjectTableSelection';
+import { getCoreObjectTableSelectionStatus } from '@/object-core/utils/getCoreObjectTableSelectionStatus';
import { SortableTableHeader } from '@/ui/layout/table/components/SortableTableHeader';
import { Table } from '@/ui/layout/table/components/Table';
import { TableCell } from '@/ui/layout/table/components/TableCell';
@@ -22,6 +26,7 @@ type CoreObjectTableProps<TItem> = {
getItemKey: (item: TItem) => string;
getItemLink?: (item: TItem) => string | undefined;
initialSort?: TableMetadata<TItem>['initialSort'];
+ selection?: CoreObjectTableSelection<TItem>;
};
const isSortableColumn = <TItem,>(
@@ -36,16 +41,46 @@ export const CoreObjectTable = <TItem,>({
getItemKey,
getItemLink,
initialSort,
+ selection,
}: CoreObjectTableProps<TItem>) => {
const { t } = useLingui();
- const gridTemplateColumns = columns
- .map((column) => column.gridTrack)
- .join(' ');
+ const isSelectable = isDefined(selection);
+
+ const selectableRowIds = isSelectable
+ ? items
+ .filter((item) => selection.isItemSelectable?.(item) ?? true)
+ .map(getItemKey)
+ : [];
+
+ const { areAllRowsSelected, areSomeRowsSelected } =
+ getCoreObjectTableSelectionStatus({
+ rowIds: selectableRowIds,
+ selectedRowIds: selection?.selectedRowIds ?? [],
+ });
+
+ const gridTemplateColumns = [
+ ...(isSelectable ? [CORE_OBJECT_TABLE_CHECKBOX_COLUMN_GRID_TRACK] : []),
+ ...columns.map((column) => column.gridTrack),
+ ].join(' ');
return (
<Table>
<TableRow gridTemplateColumns={gridTemplateColumns}>
+ {isSelectable && (
+ <TableHeader align="center" padding="0">
+ <CoreObjectTableCheckboxCell
+ checked={areAllRowsSelected || areSomeRowsSelected}
+ indeterminate={areSomeRowsSelected}
+ ariaLabel={t`Select all loaded rows`}
+ onToggle={() =>
+ selection.onToggleAllRows(
+ areAllRowsSelected ? [] : selectableRowIds,
+ )
+ }
+ />
+ </TableHeader>
+ )}
{columns.map((column) =>
isSortableColumn(column) ? (
<SortableTableHeader
@@ -66,19 +101,34 @@ export const CoreObjectTable = <TItem,>({
)}
</TableRow>
<CoreObjectTableBody>
- {items.map((item) => (
- <CoreObjectTableRow
- key={getItemKey(item)}
- gridTemplateColumns={gridTemplateColumns}
- to={getItemLink?.(item)}
- >
- {columns.map((column) => (
- <TableCell key={column.fieldName} align={column.align}>
- {column.renderCell(item)}
- </TableCell>
- ))}
- </CoreObjectTableRow>
- ))}
+ {items.map((item) => {
+ const rowId = getItemKey(item);
+
+ return (
+ <CoreObjectTableRow
+ key={rowId}
+ gridTemplateColumns={gridTemplateColumns}
+ to={getItemLink?.(item)}
+ >
+ {isSelectable && (
+ <TableCell align="center" padding="0">
+ {(selection.isItemSelectable?.(item) ?? true) && (
+ <CoreObjectTableCheckboxCell
+ checked={selection.selectedRowIds.includes(rowId)}
+ ariaLabel={t`Select row`}
+ onToggle={() => selection.onToggleRow(rowId)}
+ />
+ )}
+ </TableCell>
+ )}
+ {columns.map((column) => (
+ <TableCell key={column.fieldName} align={column.align}>
+ {column.renderCell(item)}
+ </TableCell>
+ ))}
+ </CoreObjectTableRow>
+ );
+ })}
</CoreObjectTableBody>
</Table>
);
diff --git a/packages/twenty-front/src/modules/object-core/components/CoreObjectTableCheckboxCell.tsx b/packages/twenty-front/src/modules/object-core/components/CoreObjectTableCheckboxCell.tsx
new file mode 100644
index 00000000000..f3c55ee896d
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/components/CoreObjectTableCheckboxCell.tsx
@@ -0,0 +1,41 @@
+import { styled } from '@linaria/react';
+import { type MouseEvent } from 'react';
+import { Checkbox } from 'twenty-ui/input';
+
+const StyledContainer = styled.div`
+ align-items: center;
+ display: flex;
+ height: 100%;
+ justify-content: center;
+ width: 100%;
+`;
+
+type CoreObjectTableCheckboxCellProps = {
+ checked: boolean;
+ indeterminate?: boolean;
+ ariaLabel: string;
+ onToggle: () => void;
+};
+
+export const CoreObjectTableCheckboxCell = ({
+ checked,
+ indeterminate = false,
+ ariaLabel,
+ onToggle,
+}: CoreObjectTableCheckboxCellProps) => {
+ const stopRowNavigation = (event: MouseEvent<HTMLDivElement>) => {
+ event.preventDefault();
+ event.stopPropagation();
+ };
+
+ return (
+ <StyledContainer onClick={stopRowNavigation}>
+ <Checkbox
+ checked={checked}
+ indeterminate={indeterminate}
+ aria-label={ariaLabel}
+ onCheckedChange={onToggle}
+ />
+ </StyledContainer>
+ );
+};
diff --git a/packages/twenty-front/src/modules/object-core/constants/CoreObjectTableCheckboxColumnGridTrack.ts b/packages/twenty-front/src/modules/object-core/constants/CoreObjectTableCheckboxColumnGridTrack.ts
new file mode 100644
index 00000000000..43dbb3b1a7e
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/constants/CoreObjectTableCheckboxColumnGridTrack.ts
@@ -0,0 +1 @@
+export const CORE_OBJECT_TABLE_CHECKBOX_COLUMN_GRID_TRACK = '32px';
diff --git a/packages/twenty-front/src/modules/object-core/types/CoreObjectTableSelection.ts b/packages/twenty-front/src/modules/object-core/types/CoreObjectTableSelection.ts
new file mode 100644
index 00000000000..cf83dbbda7f
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/types/CoreObjectTableSelection.ts
@@ -0,0 +1,6 @@
+export type CoreObjectTableSelection<TItem> = {
+ selectedRowIds: string[];
+ onToggleRow: (rowId: string) => void;
+ onToggleAllRows: (nextSelectedRowIds: string[]) => void;
+ isItemSelectable?: (item: TItem) => boolean;
+};
diff --git a/packages/twenty-front/src/modules/object-core/utils/__tests__/getCoreObjectTableSelectionStatus.test.ts b/packages/twenty-front/src/modules/object-core/utils/__tests__/getCoreObjectTableSelectionStatus.test.ts
new file mode 100644
index 00000000000..c89aecd2f87
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/utils/__tests__/getCoreObjectTableSelectionStatus.test.ts
@@ -0,0 +1,48 @@
+import { getCoreObjectTableSelectionStatus } from '@/object-core/utils/getCoreObjectTableSelectionStatus';
+
+describe('getCoreObjectTableSelectionStatus', () => {
+ it('should report all rows selected when every row is selected', () => {
+ expect(
+ getCoreObjectTableSelectionStatus({
+ rowIds: ['a', 'b'],
+ selectedRowIds: ['a', 'b'],
+ }),
+ ).toEqual({ areAllRowsSelected: true, areSomeRowsSelected: false });
+ });
+
+ it('should report some rows selected when only part of the table is selected', () => {
+ expect(
+ getCoreObjectTableSelectionStatus({
+ rowIds: ['a', 'b'],
+ selectedRowIds: ['a'],
+ }),
+ ).toEqual({ areAllRowsSelected: false, areSomeRowsSelected: true });
+ });
+
+ it('should report nothing selected for an empty selection', () => {
+ expect(
+ getCoreObjectTableSelectionStatus({
+ rowIds: ['a', 'b'],
+ selectedRowIds: [],
+ }),
+ ).toEqual({ areAllRowsSelected: false, areSomeRowsSelected: false });
+ });
+
+ it('should ignore selected rows that are not in the table', () => {
+ expect(
+ getCoreObjectTableSelectionStatus({
+ rowIds: ['a', 'b'],
+ selectedRowIds: ['a', 'b', 'filtered-out'],
+ }),
+ ).toEqual({ areAllRowsSelected: true, areSomeRowsSelected: false });
+ });
+
+ it('should not report all rows selected for an empty table', () => {
+ expect(
+ getCoreObjectTableSelectionStatus({
+ rowIds: [],
+ selectedRowIds: ['stale'],
+ }),
+ ).toEqual({ areAllRowsSelected: false, areSomeRowsSelected: false });
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-core/utils/__tests__/getDeletedRecordIdsFromOperation.test.ts b/packages/twenty-front/src/modules/object-core/utils/__tests__/getDeletedRecordIdsFromOperation.test.ts
new file mode 100644
index 00000000000..f5331f181b8
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/utils/__tests__/getDeletedRecordIdsFromOperation.test.ts
@@ -0,0 +1,27 @@
+import { getDeletedRecordIdsFromOperation } from '@/object-core/utils/getDeletedRecordIdsFromOperation';
+
+describe('getDeletedRecordIdsFromOperation', () => {
+ it('should read the ids of a bulk deletion', () => {
+ expect(
+ getDeletedRecordIdsFromOperation({
+ type: 'delete-many',
+ deletedRecordIds: ['workspace-1', 'workspace-2'],
+ }),
+ ).toEqual(['workspace-1', 'workspace-2']);
+ });
+
+ it('should read the id of a single deletion', () => {
+ expect(
+ getDeletedRecordIdsFromOperation({
+ type: 'delete-one',
+ deletedRecordId: 'workspace-1',
+ }),
+ ).toEqual(['workspace-1']);
+ });
+
+ it('should return nothing for an operation that carries no deleted ids', () => {
+ expect(getDeletedRecordIdsFromOperation({ type: 'destroy-one' })).toEqual(
+ [],
+ );
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-core/utils/__tests__/toggleRowIdInSelection.test.ts b/packages/twenty-front/src/modules/object-core/utils/__tests__/toggleRowIdInSelection.test.ts
new file mode 100644
index 00000000000..268c78aa4ff
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/utils/__tests__/toggleRowIdInSelection.test.ts
@@ -0,0 +1,23 @@
+import { toggleRowIdInSelection } from '@/object-core/utils/toggleRowIdInSelection';
+
+describe('toggleRowIdInSelection', () => {
+ it('should add a row that is not selected', () => {
+ expect(
+ toggleRowIdInSelection({ selectedRowIds: ['a'], rowId: 'b' }),
+ ).toEqual(['a', 'b']);
+ });
+
+ it('should remove a row that is already selected', () => {
+ expect(
+ toggleRowIdInSelection({ selectedRowIds: ['a', 'b'], rowId: 'a' }),
+ ).toEqual(['b']);
+ });
+
+ it('should not mutate the previous selection', () => {
+ const selectedRowIds = ['a'];
+
+ toggleRowIdInSelection({ selectedRowIds, rowId: 'b' });
+
+ expect(selectedRowIds).toEqual(['a']);
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-core/utils/getCoreObjectTableSelectionStatus.ts b/packages/twenty-front/src/modules/object-core/utils/getCoreObjectTableSelectionStatus.ts
new file mode 100644
index 00000000000..7028fa649c2
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/utils/getCoreObjectTableSelectionStatus.ts
@@ -0,0 +1,19 @@
+export const getCoreObjectTableSelectionStatus = ({
+ rowIds,
+ selectedRowIds,
+}: {
+ rowIds: string[];
+ selectedRowIds: string[];
+}) => {
+ const selectedRowIdsInTable = rowIds.filter((rowId) =>
+ selectedRowIds.includes(rowId),
+ );
+
+ const areAllRowsSelected =
+ rowIds.length > 0 && selectedRowIdsInTable.length === rowIds.length;
+
+ const areSomeRowsSelected =
+ selectedRowIdsInTable.length > 0 && !areAllRowsSelected;
+
+ return { areAllRowsSelected, areSomeRowsSelected };
+};
diff --git a/packages/twenty-front/src/modules/object-core/utils/getDeletedRecordIdsFromOperation.ts b/packages/twenty-front/src/modules/object-core/utils/getDeletedRecordIdsFromOperation.ts
new file mode 100644
index 00000000000..2b77b58e737
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/utils/getDeletedRecordIdsFromOperation.ts
@@ -0,0 +1,15 @@
+import { type ObjectRecordOperation } from '@/object-record/types/ObjectRecordOperation';
+
+export const getDeletedRecordIdsFromOperation = (
+ operation: ObjectRecordOperation,
+): string[] => {
+ if (operation.type === 'delete-many') {
+ return operation.deletedRecordIds;
+ }
+
+ if (operation.type === 'delete-one') {
+ return [operation.deletedRecordId];
+ }
+
+ return [];
+};
diff --git a/packages/twenty-front/src/modules/object-core/utils/toggleRowIdInSelection.ts b/packages/twenty-front/src/modules/object-core/utils/toggleRowIdInSelection.ts
new file mode 100644
index 00000000000..e18099ca089
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/utils/toggleRowIdInSelection.ts
@@ -0,0 +1,10 @@
+export const toggleRowIdInSelection = ({
+ selectedRowIds,
+ rowId,
+}: {
+ selectedRowIds: string[];
+ rowId: string;
+}) =>
+ selectedRowIds.includes(rowId)
+ ? selectedRowIds.filter((selectedRowId) => selectedRowId !== rowId)
+ : [...selectedRowIds, rowId];
diff --git a/packages/twenty-front/src/modules/object-core/workflows/components/CoreWorkflowsSelectionToContextStoreEffect.tsx b/packages/twenty-front/src/modules/object-core/workflows/components/CoreWorkflowsSelectionToContextStoreEffect.tsx
new file mode 100644
index 00000000000..fb67c7a09d6
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/workflows/components/CoreWorkflowsSelectionToContextStoreEffect.tsx
@@ -0,0 +1,52 @@
+import { useSetAtom } from 'jotai';
+import { useEffect } from 'react';
+import { isNonEmptyString } from '@sniptt/guards';
+
+import { contextStoreNumberOfSelectedRecordsComponentState } from '@/context-store/states/contextStoreNumberOfSelectedRecordsComponentState';
+import { contextStoreTargetedRecordsRuleComponentState } from '@/context-store/states/contextStoreTargetedRecordsRuleComponentState';
+import { useAtomComponentStateCallbackState } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateCallbackState';
+
+type CoreWorkflowsSelectionToContextStoreEffectProps = {
+ selectedWorkspaceWorkflowIds: string[];
+};
+
+export const CoreWorkflowsSelectionToContextStoreEffect = ({
+ selectedWorkspaceWorkflowIds,
+}: CoreWorkflowsSelectionToContextStoreEffectProps) => {
+ const targetedRecordsRuleAtom = useAtomComponentStateCallbackState(
+ contextStoreTargetedRecordsRuleComponentState,
+ );
+
+ const numberOfSelectedRecordsAtom = useAtomComponentStateCallbackState(
+ contextStoreNumberOfSelectedRecordsComponentState,
+ );
+
+ const setTargetedRecordsRule = useSetAtom(targetedRecordsRuleAtom);
+ const setNumberOfSelectedRecords = useSetAtom(numberOfSelectedRecordsAtom);
+
+ const selectedWorkspaceWorkflowIdsKey =
+ selectedWorkspaceWorkflowIds.join(',');
+
+ useEffect(() => {
+ const selectedRecordIds = selectedWorkspaceWorkflowIdsKey
+ .split(',')
+ .filter(isNonEmptyString);
+
+ setTargetedRecordsRule({ mode: 'selection', selectedRecordIds });
+ setNumberOfSelectedRecords(selectedRecordIds.length);
+ }, [
+ selectedWorkspaceWorkflowIdsKey,
+ setTargetedRecordsRule,
+ setNumberOfSelectedRecords,
+ ]);
+
+ useEffect(
+ () => () => {
+ setTargetedRecordsRule({ mode: 'selection', selectedRecordIds: [] });
+ setNumberOfSelectedRecords(0);
+ },
+ [setTargetedRecordsRule, setNumberOfSelectedRecords],
+ );
+
+ return null;
+};
diff --git a/packages/twenty-front/src/modules/object-core/workflows/hooks/__tests__/useCoreWorkflowsSelection.test.tsx b/packages/twenty-front/src/modules/object-core/workflows/hooks/__tests__/useCoreWorkflowsSelection.test.tsx
new file mode 100644
index 00000000000..f6f5cb72127
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/workflows/hooks/__tests__/useCoreWorkflowsSelection.test.tsx
@@ -0,0 +1,138 @@
+import { act, renderHook } from '@testing-library/react';
+import { Provider as JotaiProvider } from 'jotai';
+
+import { useCoreWorkflowsSelection } from '@/object-core/workflows/hooks/useCoreWorkflowsSelection';
+import { coreWorkflowsFilterSettingsState } from '@/object-core/workflows/states/coreWorkflowsFilterSettingsState';
+import { type CoreWorkflow } from '@/object-core/workflows/types/CoreWorkflow';
+import { jotaiStore } from '@/ui/utilities/state/jotai/jotaiStore';
+
+type CoreWorkflowRow = Pick<CoreWorkflow, 'id' | 'workspaceWorkflowId'>;
+
+const coreWorkflows: CoreWorkflowRow[] = [
+ { id: 'core-1', workspaceWorkflowId: 'workspace-1' },
+ { id: 'core-2', workspaceWorkflowId: 'workspace-2' },
+ { id: 'core-3', workspaceWorkflowId: null },
+];
+
+const Wrapper = ({ children }: { children: React.ReactNode }) => (
+ <JotaiProvider store={jotaiStore}>{children}</JotaiProvider>
+);
+
+const renderSelection = () =>
+ renderHook(
+ (props: { coreWorkflows: CoreWorkflowRow[] }) =>
+ useCoreWorkflowsSelection(props),
+ { wrapper: Wrapper, initialProps: { coreWorkflows } },
+ );
+
+describe('useCoreWorkflowsSelection', () => {
+ it('should map selected rows to the workspace workflows the command menu targets', () => {
+ const { result } = renderSelection();
+
+ act(() => {
+ result.current.toggleRow('core-1');
+ });
+
+ expect(result.current.selectedWorkspaceWorkflowIds).toEqual([
+ 'workspace-1',
+ ]);
+ });
+
+ it('should not target a workflow that has no workspace record', () => {
+ const { result } = renderSelection();
+
+ act(() => {
+ result.current.toggleRow('core-3');
+ });
+
+ expect(result.current.selectedRowIds).toEqual(['core-3']);
+ expect(result.current.selectedWorkspaceWorkflowIds).toEqual([]);
+ });
+
+ it('should drop the deleted rows and clear the selection when a deletion is reported', () => {
+ const { result } = renderSelection();
+
+ act(() => {
+ result.current.toggleRow('core-1');
+ });
+
+ act(() => {
+ result.current.forgetDeletedWorkspaceWorkflows(['workspace-1']);
+ });
+
+ expect(
+ result.current.displayedCoreWorkflows.map(
+ (coreWorkflow) => coreWorkflow.id,
+ ),
+ ).toEqual(['core-2', 'core-3']);
+ expect(result.current.selectedRowIds).toEqual([]);
+ });
+
+ it('should ignore a deletion that targets rows it is not showing', () => {
+ const { result } = renderSelection();
+
+ act(() => {
+ result.current.toggleRow('core-1');
+ });
+
+ act(() => {
+ result.current.forgetDeletedWorkspaceWorkflows(['workspace-elsewhere']);
+ });
+
+ expect(result.current.displayedCoreWorkflows).toHaveLength(3);
+ expect(result.current.selectedRowIds).toEqual(['core-1']);
+ });
+
+ it('should keep a deleted workflow hidden once the mirror drops its workspace record', () => {
+ const { result, rerender } = renderSelection();
+
+ act(() => {
+ result.current.forgetDeletedWorkspaceWorkflows(['workspace-1']);
+ });
+
+ rerender({
+ coreWorkflows: [
+ { id: 'core-1', workspaceWorkflowId: null },
+ { id: 'core-2', workspaceWorkflowId: 'workspace-2' },
+ ],
+ });
+
+ expect(
+ result.current.displayedCoreWorkflows.map(
+ (coreWorkflow) => coreWorkflow.id,
+ ),
+ ).toEqual(['core-2']);
+ });
+
+ it('should drop the selection when the filter settings change', () => {
+ const { result } = renderSelection();
+
+ act(() => {
+ result.current.toggleRow('core-1');
+ });
+
+ expect(result.current.selectedRowIds).toEqual(['core-1']);
+
+ act(() => {
+ jotaiStore.set(coreWorkflowsFilterSettingsState.atom, {
+ stepFilters: [],
+ });
+ });
+
+ expect(result.current.selectedRowIds).toEqual([]);
+ expect(result.current.selectedWorkspaceWorkflowIds).toEqual([]);
+ });
+
+ it('should deselect a row that is toggled twice', () => {
+ const { result } = renderSelection();
+
+ act(() => {
+ result.current.toggleRow('core-1');
+ });
+ act(() => {
+ result.current.toggleRow('core-1');
+ });
+
+ expect(result.current.selectedRowIds).toEqual([]);
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-core/workflows/hooks/useCoreWorkflowsSelection.ts b/packages/twenty-front/src/modules/object-core/workflows/hooks/useCoreWorkflowsSelection.ts
new file mode 100644
index 00000000000..951035da5a6
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/workflows/hooks/useCoreWorkflowsSelection.ts
@@ -0,0 +1,87 @@
+import { useState } from 'react';
+import { isDefined } from 'twenty-shared/utils';
+
+import { coreWorkflowsFilterSettingsState } from '@/object-core/workflows/states/coreWorkflowsFilterSettingsState';
+import { type FilterSettings } from '@/workflow/workflow-steps/filters/types/FilterSettings';
+import { type CoreWorkflow } from '@/object-core/workflows/types/CoreWorkflow';
+import { getDeletableSelectedCoreWorkflows } from '@/object-core/workflows/utils/getDeletableSelectedCoreWorkflows';
+import { toggleRowIdInSelection } from '@/object-core/utils/toggleRowIdInSelection';
+import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
+
+export const useCoreWorkflowsSelection = <
+ TCoreWorkflow extends Pick<CoreWorkflow, 'id' | 'workspaceWorkflowId'>,
+>({
+ coreWorkflows,
+}: {
+ coreWorkflows: TCoreWorkflow[];
+}) => {
+ const [selection, setSelection] = useState<{
+ filterSettings: FilterSettings;
+ rowIds: string[];
+ }>({ filterSettings: {}, rowIds: [] });
+
+ const [deletedCoreWorkflowIds, setDeletedCoreWorkflowIds] = useState<
+ string[]
+ >([]);
+
+ const coreWorkflowsFilterSettings = useAtomStateValue(
+ coreWorkflowsFilterSettingsState,
+ );
+
+ const selectedRowIds =
+ selection.filterSettings === coreWorkflowsFilterSettings
+ ? selection.rowIds
+ : [];
+
+ const selectRows = (rowIds: string[]) =>
+ setSelection({ filterSettings: coreWorkflowsFilterSettings, rowIds });
+
+ const displayedCoreWorkflows = coreWorkflows.filter(
+ (coreWorkflow) => !deletedCoreWorkflowIds.includes(coreWorkflow.id),
+ );
+
+ const deletableSelectedCoreWorkflows = getDeletableSelectedCoreWorkflows({
+ coreWorkflows: displayedCoreWorkflows,
+ selectedRowIds,
+ });
+
+ const selectedWorkspaceWorkflowIds = deletableSelectedCoreWorkflows.map(
+ (deletableCoreWorkflow) => deletableCoreWorkflow.workspaceWorkflowId,
+ );
+
+ const toggleRow = (rowId: string) =>
+ selectRows(toggleRowIdInSelection({ selectedRowIds, rowId }));
+
+ const forgetDeletedWorkspaceWorkflows = (
+ deletedWorkspaceWorkflowIds: string[],
+ ) => {
+ const coreWorkflowIdsToForget = coreWorkflows
+ .filter(
+ (coreWorkflow) =>
+ isDefined(coreWorkflow.workspaceWorkflowId) &&
+ deletedWorkspaceWorkflowIds.includes(
+ coreWorkflow.workspaceWorkflowId,
+ ),
+ )
+ .map((coreWorkflow) => coreWorkflow.id);
+
+ if (coreWorkflowIdsToForget.length === 0) {
+ return;
+ }
+
+ setDeletedCoreWorkflowIds((previousDeletedCoreWorkflowIds) => [
+ ...previousDeletedCoreWorkflowIds,
+ ...coreWorkflowIdsToForget,
+ ]);
+ selectRows([]);
+ };
+
+ return {
+ displayedCoreWorkflows,
+ selectedRowIds,
+ selectedWorkspaceWorkflowIds,
+ toggleRow,
+ selectRows,
+ forgetDeletedWorkspaceWorkflows,
+ };
+};
diff --git a/packages/twenty-front/src/modules/object-core/workflows/hooks/useHydrateSelectedWorkflowRecords.ts b/packages/twenty-front/src/modules/object-core/workflows/hooks/useHydrateSelectedWorkflowRecords.ts
new file mode 100644
index 00000000000..2f0ee7b814c
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/workflows/hooks/useHydrateSelectedWorkflowRecords.ts
@@ -0,0 +1,27 @@
+import { useCallback } from 'react';
+import { CoreObjectNameSingular } from 'twenty-shared/types';
+
+import { useFindManyRecords } from '@/object-record/hooks/useFindManyRecords';
+import { useUpsertRecordsInStore } from '@/object-record/record-store/hooks/useUpsertRecordsInStore';
+import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
+
+export const useHydrateSelectedWorkflowRecords = (
+ selectedWorkspaceWorkflowIds: string[],
+) => {
+ const { upsertRecordsInStore } = useUpsertRecordsInStore();
+
+ const handleCompleted = useCallback(
+ (records: ObjectRecord[]) => {
+ upsertRecordsInStore({ partialRecords: records });
+ },
+ [upsertRecordsInStore],
+ );
+
+ useFindManyRecords({
+ objectNameSingular: CoreObjectNameSingular.Workflow,
+ filter: { id: { in: selectedWorkspaceWorkflowIds } },
+ limit: Math.max(selectedWorkspaceWorkflowIds.length, 1),
+ skip: selectedWorkspaceWorkflowIds.length === 0,
+ onCompleted: handleCompleted,
+ });
+};
diff --git a/packages/twenty-front/src/modules/object-core/workflows/utils/__tests__/getDeletableSelectedCoreWorkflows.test.ts b/packages/twenty-front/src/modules/object-core/workflows/utils/__tests__/getDeletableSelectedCoreWorkflows.test.ts
new file mode 100644
index 00000000000..38f90011223
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/workflows/utils/__tests__/getDeletableSelectedCoreWorkflows.test.ts
@@ -0,0 +1,51 @@
+import { getDeletableSelectedCoreWorkflows } from '@/object-core/workflows/utils/getDeletableSelectedCoreWorkflows';
+
+describe('getDeletableSelectedCoreWorkflows', () => {
+ it('should pair the selected rows with their workspace workflow', () => {
+ expect(
+ getDeletableSelectedCoreWorkflows({
+ coreWorkflows: [
+ { id: 'core-1', workspaceWorkflowId: 'workspace-1' },
+ { id: 'core-2', workspaceWorkflowId: 'workspace-2' },
+ ],
+ selectedRowIds: ['core-2'],
+ }),
+ ).toEqual([
+ { coreWorkflowId: 'core-2', workspaceWorkflowId: 'workspace-2' },
+ ]);
+ });
+
+ it('should skip a selected row that has no workspace workflow yet', () => {
+ expect(
+ getDeletableSelectedCoreWorkflows({
+ coreWorkflows: [
+ { id: 'core-1', workspaceWorkflowId: null },
+ { id: 'core-2', workspaceWorkflowId: 'workspace-2' },
+ ],
+ selectedRowIds: ['core-1', 'core-2'],
+ }),
+ ).toEqual([
+ { coreWorkflowId: 'core-2', workspaceWorkflowId: 'workspace-2' },
+ ]);
+ });
+
+ it('should ignore selected ids that are no longer listed', () => {
+ expect(
+ getDeletableSelectedCoreWorkflows({
+ coreWorkflows: [{ id: 'core-1', workspaceWorkflowId: 'workspace-1' }],
+ selectedRowIds: ['core-1', 'filtered-out'],
+ }),
+ ).toEqual([
+ { coreWorkflowId: 'core-1', workspaceWorkflowId: 'workspace-1' },
+ ]);
+ });
+
+ it('should return nothing when no row is selected', () => {
+ expect(
+ getDeletableSelectedCoreWorkflows({
+ coreWorkflows: [{ id: 'core-1', workspaceWorkflowId: 'workspace-1' }],
+ selectedRowIds: [],
+ }),
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-core/workflows/utils/getDeletableSelectedCoreWorkflows.ts b/packages/twenty-front/src/modules/object-core/workflows/utils/getDeletableSelectedCoreWorkflows.ts
new file mode 100644
index 00000000000..ae623f5af08
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-core/workflows/utils/getDeletableSelectedCoreWorkflows.ts
@@ -0,0 +1,23 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type CoreWorkflow } from '@/object-core/workflows/types/CoreWorkflow';
+
+export const getDeletableSelectedCoreWorkflows = ({
+ coreWorkflows,
+ selectedRowIds,
+}: {
+ coreWorkflows: Pick<CoreWorkflow, 'id' | 'workspaceWorkflowId'>[];
+ selectedRowIds: string[];
+}) =>
+ coreWorkflows
+ .filter((coreWorkflow) => selectedRowIds.includes(coreWorkflow.id))
+ .flatMap((coreWorkflow) =>
+ isDefined(coreWorkflow.workspaceWorkflowId)
+ ? [
+ {
+ coreWorkflowId: coreWorkflow.id,
+ workspaceWorkflowId: coreWorkflow.workspaceWorkflowId,
+ },
+ ]
+ : [],
+ );
diff --git a/packages/twenty-front/src/pages/object-core/WorkflowCoreIndexPage.tsx b/packages/twenty-front/src/pages/object-core/WorkflowCoreIndexPage.tsx
index 25d79279213..757cfd1a3a6 100644
--- a/packages/twenty-front/src/pages/object-core/WorkflowCoreIndexPage.tsx
+++ b/packages/twenty-front/src/pages/object-core/WorkflowCoreIndexPage.tsx
@@ -5,6 +5,11 @@ import { AppPath, CoreObjectNameSingular } from 'twenty-shared/types';
import { getAppPath, isDefined } from 'twenty-shared/utils';
import { CoreObjectTable } from '@/object-core/components/CoreObjectTable';
+import { CoreWorkflowsSelectionToContextStoreEffect } from '@/object-core/workflows/components/CoreWorkflowsSelectionToContextStoreEffect';
+import { useCoreWorkflowsSelection } from '@/object-core/workflows/hooks/useCoreWorkflowsSelection';
+import { useHydrateSelectedWorkflowRecords } from '@/object-core/workflows/hooks/useHydrateSelectedWorkflowRecords';
+import { getDeletedRecordIdsFromOperation } from '@/object-core/utils/getDeletedRecordIdsFromOperation';
+import { useListenToObjectRecordOperationBrowserEvent } from '@/browser-event/hooks/useListenToObjectRecordOperationBrowserEvent';
import { CoreWorkflowsFilterBar } from '@/object-core/workflows/components/CoreWorkflowsFilterBar';
import { WORKFLOW_CORE_TABLE_COLUMNS } from '@/object-core/workflows/constants/WorkflowCoreTableColumns';
import {
@@ -53,6 +58,26 @@ export const WorkflowCoreIndexPage = () => {
const { ref: fetchMoreRef, inView } = useInView();
+ const {
+ displayedCoreWorkflows,
+ selectedRowIds,
+ selectedWorkspaceWorkflowIds,
+ toggleRow,
+ selectRows,
+ forgetDeletedWorkspaceWorkflows,
+ } = useCoreWorkflowsSelection({ coreWorkflows });
+
+ useHydrateSelectedWorkflowRecords(selectedWorkspaceWorkflowIds);
+
+ useListenToObjectRecordOperationBrowserEvent({
+ objectMetadataItemId: objectMetadataItem.id,
+ operationTypes: ['delete-one', 'delete-many'],
+ onObjectRecordOperationBrowserEvent: (detail) =>
+ forgetDeletedWorkspaceWorkflows(
+ getDeletedRecordIdsFromOperation(detail.operation),
+ ),
+ });
+
useEffect(() => {
if (inView && hasNextPage && !loading) {
void fetchNextPage();
@@ -82,12 +107,22 @@ export const WorkflowCoreIndexPage = () => {
<CoreObjectTable
tableId={tableId}
columns={WORKFLOW_CORE_TABLE_COLUMNS}
- items={coreWorkflows}
+ items={displayedCoreWorkflows}
getItemKey={(workflow) => workflow.id}
getItemLink={getCoreWorkflowLink}
initialSort={CORE_WORKFLOWS_INITIAL_SORT}
+ selection={{
+ selectedRowIds,
+ onToggleRow: toggleRow,
+ onToggleAllRows: selectRows,
+ isItemSelectable: (coreWorkflow) =>
+ isDefined(coreWorkflow.workspaceWorkflowId),
+ }}
/>
{hasNextPage && <StyledFetchMoreSentinel ref={fetchMoreRef} />}
+ <CoreWorkflowsSelectionToContextStoreEffect
+ selectedWorkspaceWorkflowIds={selectedWorkspaceWorkflowIds}
+ />
</StyledTableContainer>
</PageCardLayout>
</>
diff --git a/packages/twenty-front/src/pages/object-record/__tests__/RecordIndexPage.surface.test.tsx b/packages/twenty-front/src/pages/object-record/__tests__/RecordIndexPage.surface.test.tsx
index e9208a895b2..ee97abd5ad9 100644
--- a/packages/twenty-front/src/pages/object-record/__tests__/RecordIndexPage.surface.test.tsx
+++ b/packages/twenty-front/src/pages/object-record/__tests__/RecordIndexPage.surface.test.tsx
@@ -79,6 +79,24 @@ jest.mock('react-intersection-observer', () => ({
useInView: () => ({ ref: jest.fn(), inView: false }),
}));
+jest.mock(
+ '@/object-core/workflows/hooks/useHydrateSelectedWorkflowRecords',
+ () => ({
+ useHydrateSelectedWorkflowRecords: () => undefined,
+ }),
+);
+
+jest.mock(
+ '@/object-core/workflows/components/CoreWorkflowsSelectionToContextStoreEffect',
+ () => ({
+ CoreWorkflowsSelectionToContextStoreEffect: () => null,
+ }),
+);
+
+jest.mock('@/ui/utilities/state/jotai/hooks/useAtomStateValue', () => ({
+ useAtomStateValue: () => ({}),
+}));
+
jest.mock('@/object-core/components/CoreObjectTable', () => ({
CoreObjectTable: () => <div data-testid="workflow-core-index" />,
}));