@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/components/DataTable/hooks/useDataTableEffectiveActions.test.ts

@@ -0,0 +1,461 @@
+/**
+ * @file useDataTableEffectiveActions Hook Tests
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Hooks
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useDataTableEffectiveActions } from './useDataTableEffectiveActions';
+import type { DataRecord } from '../types';
+import type { NormalizedDataTableFeatureConfig } from '../types';
+
+const TEST_TIMEOUT = 10000;
+
+const mockToast = vi.fn();
+vi.mock('../../../hooks/useToast', () => ({
+  useToast: () => ({ toast: (...args: unknown[]) => mockToast(...args) }),
+  toast: (...args: unknown[]) => mockToast(...args),
+}));
+
+const mockLogger = {
+  error: vi.fn(),
+  warn: vi.fn(),
+  info: vi.fn(),
+  debug: vi.fn(),
+};
+
+interface TestRecord extends DataRecord {
+  id: string;
+  name: string;
+}
+
+function makeDeletionRefs() {
+  return {
+    dataSnapshotRef: { current: [] as TestRecord[] },
+    pendingDeletionsRef: { current: new Set<string>() },
+    deletionTimeoutRef: { current: null as ReturnType<typeof setTimeout> | null },
+  };
+}
+
+function makePermissions(overrides: { canCreate?: boolean; canUpdate?: boolean; canDelete?: boolean; canImport?: boolean; canExport?: boolean } = {}) {
+  return {
+    canCreate: { can: true, isLoading: false, error: null },
+    canUpdate: { can: true, isLoading: false, error: null },
+    canDelete: { can: true, isLoading: false, error: null },
+    canRead: { can: true, isLoading: false, error: null },
+    canImport: { can: false, isLoading: false, error: null },
+    canExport: { can: false, isLoading: false, error: null },
+    ...overrides,
+  };
+}
+
+function makeSecureFeatures(overrides: Partial<NormalizedDataTableFeatureConfig> = {}): NormalizedDataTableFeatureConfig {
+  return {
+    creation: false,
+    editing: true,
+    deletion: true,
+    selection: false,
+    columnVisibility: false,
+    columnReordering: false,
+    pagination: false,
+    search: false,
+    export: false,
+    import: false,
+    filtering: false,
+    grouping: false,
+    ...overrides,
+  };
+}
+
+function makeStateActions() {
+  return {
+    setSorting: vi.fn(),
+    setColumnFilters: vi.fn(),
+    setColumnVisibility: vi.fn(),
+    setGrouping: vi.fn(),
+    setExpanded: vi.fn(),
+    setPagination: vi.fn(),
+    setColumnOrder: vi.fn(),
+    setRowSelection: vi.fn(),
+    toggleRowSelection: vi.fn(),
+    setEditingRow: vi.fn(),
+    clearEditingRow: vi.fn(),
+    setCreationData: vi.fn(),
+    setShowImportModal: vi.fn(),
+    setShowFilterRow: vi.fn(),
+    setSearchQuery: vi.fn(),
+    setGlobalFilter: vi.fn(),
+  };
+}
+
+describe('[unit] useDataTableEffectiveActions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('returns secureHandlers with onEditRow when canUpdate and wrappedOnEditRow provided', () => {
+    const wrappedOnEditRow = vi.fn();
+    const onDeleteRow = vi.fn();
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions(),
+        secureFeatures: makeSecureFeatures({ editing: true, deletion: true }),
+        actions: [],
+        wrappedOnEditRow,
+        onDeleteRow,
+        stateActions: makeStateActions(),
+        data: [],
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    expect(result.current.secureHandlers.onEditRow).toBe(wrappedOnEditRow);
+    expect(result.current.secureHandlers.onDeleteRow).toBe(onDeleteRow);
+  }, TEST_TIMEOUT);
+
+  it('returns secureHandlers without onEditRow when canUpdate is false', () => {
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions({ canUpdate: false }),
+        secureFeatures: makeSecureFeatures({ editing: true }),
+        actions: [],
+        wrappedOnEditRow: vi.fn(),
+        stateActions: makeStateActions(),
+        data: [],
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    expect(result.current.secureHandlers.onEditRow).toBeUndefined();
+  }, TEST_TIMEOUT);
+
+  it('effectiveActions includes Edit and Delete when features enabled and handlers present', () => {
+    const stateActions = makeStateActions();
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions(),
+        secureFeatures: makeSecureFeatures({ editing: true, deletion: true }),
+        actions: [],
+        wrappedOnEditRow: vi.fn(),
+        onDeleteRow: vi.fn(),
+        stateActions,
+        data: [{ id: '1', name: 'A' }],
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    const labels = result.current.effectiveActions.map((a) => a.label);
+    expect(labels).toContain('Edit');
+    expect(labels).toContain('Delete');
+  }, TEST_TIMEOUT);
+
+  it('does not add Delete action when canDelete is false', () => {
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions({ canDelete: false }),
+        secureFeatures: makeSecureFeatures({ deletion: true }),
+        actions: [],
+        onDeleteRow: vi.fn(),
+        stateActions: makeStateActions(),
+        data: [],
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    const deleteAction = result.current.effectiveActions.find((a) => a.label === 'Delete');
+    expect(deleteAction).toBeUndefined();
+  }, TEST_TIMEOUT);
+
+  it('delete handler shows success toast after successful delete and timeout', async () => {
+    const onDeleteRow = vi.fn();
+    const setIsDeleting = vi.fn();
+    const data = [{ id: '1', name: 'A' }];
+    const refs = makeDeletionRefs();
+
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions(),
+        secureFeatures: makeSecureFeatures({ deletion: true }),
+        actions: [],
+        onDeleteRow,
+        stateActions: makeStateActions(),
+        data,
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: refs,
+        isDeleting: false,
+        setIsDeleting,
+        logger: mockLogger as never,
+      })
+    );
+
+    const deleteAction = result.current.effectiveActions.find((a) => a.label === 'Delete');
+    expect(deleteAction).toBeDefined();
+    expect(deleteAction!.onClick).toBeDefined();
+
+    await act(async () => {
+      deleteAction!.onClick!(data[0]);
+    });
+
+    expect(onDeleteRow).toHaveBeenCalledWith(data[0]);
+    act(() => {
+      vi.advanceTimersByTime(150);
+    });
+    expect(mockToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: 'Delete Successful',
+        description: 'Row deleted successfully',
+        variant: 'default',
+      })
+    );
+  }, TEST_TIMEOUT);
+
+  it('delete handler shows failure toast and logs when onDeleteRow throws', async () => {
+    const onDeleteRow = vi.fn().mockRejectedValue(new Error('DB error'));
+    const data = [{ id: '1', name: 'A' }];
+    const refs = makeDeletionRefs();
+
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions(),
+        secureFeatures: makeSecureFeatures({ deletion: true }),
+        actions: [],
+        onDeleteRow,
+        stateActions: makeStateActions(),
+        data,
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: refs,
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+
+    const deleteAction = result.current.effectiveActions.find((a) => a.label === 'Delete');
+    expect(deleteAction).toBeDefined();
+
+    await act(async () => {
+      deleteAction!.onClick!(data[0]);
+    });
+
+    expect(mockLogger.error).toHaveBeenCalledWith('Delete error:', expect.any(Error));
+    expect(mockToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: 'Delete Failed',
+        description: 'DB error',
+        variant: 'destructive',
+      })
+    );
+  }, TEST_TIMEOUT);
+
+  it('delete handler awaits promise returned by onDeleteRow', async () => {
+    let resolveDelete: () => void;
+    const deletePromise = new Promise<void>((r) => {
+      resolveDelete = r;
+    });
+    const onDeleteRow = vi.fn(() => deletePromise);
+    const data = [{ id: '1', name: 'A' }];
+    const refs = makeDeletionRefs();
+
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions(),
+        secureFeatures: makeSecureFeatures({ deletion: true }),
+        actions: [],
+        onDeleteRow,
+        stateActions: makeStateActions(),
+        data,
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: refs,
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+
+    const deleteAction = result.current.effectiveActions.find((a) => a.label === 'Delete');
+    expect(deleteAction).toBeDefined();
+
+    const handlerPromise = act(async () => {
+      deleteAction!.onClick!(data[0]);
+    });
+
+    resolveDelete!();
+    await handlerPromise;
+
+    act(() => {
+      vi.advanceTimersByTime(150);
+    });
+    expect(mockToast).toHaveBeenCalledWith(
+      expect.objectContaining({ title: 'Delete Successful' })
+    );
+  }, TEST_TIMEOUT);
+
+  it('returns secureHandlers with onCreateRow when canCreate and wrappedOnCreateRow provided', () => {
+    const wrappedOnCreateRow = vi.fn();
+    const permissions = makePermissions();
+    permissions.canCreate = { can: true, isLoading: false, error: null };
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions,
+        secureFeatures: makeSecureFeatures({ creation: true }),
+        actions: [],
+        wrappedOnCreateRow,
+        stateActions: makeStateActions(),
+        data: [],
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    expect(result.current.secureHandlers.onCreateRow).toBe(wrappedOnCreateRow);
+  }, TEST_TIMEOUT);
+
+  it('returns secureHandlers without onCreateRow when canCreate is false', () => {
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions({ canCreate: false }),
+        secureFeatures: makeSecureFeatures({ creation: true }),
+        actions: [],
+        wrappedOnCreateRow: vi.fn(),
+        stateActions: makeStateActions(),
+        data: [],
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    expect(result.current.secureHandlers.onCreateRow).toBeUndefined();
+  }, TEST_TIMEOUT);
+
+  it('returns secureHandlers with onImport when canImport and onImport provided', () => {
+    const onImport = vi.fn();
+    const permissions = makePermissions();
+    permissions.canImport = { can: true, isLoading: false, error: null };
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions,
+        secureFeatures: makeSecureFeatures(),
+        actions: [],
+        onImport,
+        stateActions: makeStateActions(),
+        data: [],
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    expect(result.current.secureHandlers.onImport).toBe(onImport);
+  }, TEST_TIMEOUT);
+
+  it('returns secureHandlers with onExport when canExport and onExport provided', () => {
+    const onExport = vi.fn();
+    const permissions = makePermissions();
+    permissions.canExport = { can: true, isLoading: false, error: null };
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions,
+        secureFeatures: makeSecureFeatures(),
+        actions: [],
+        onExport,
+        stateActions: makeStateActions(),
+        data: [],
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    expect(result.current.secureHandlers.onExport).toBe(onExport);
+  }, TEST_TIMEOUT);
+
+  it('returns secureHandlers with onDeleteSelected when canDelete and onDeleteSelected provided', () => {
+    const onDeleteSelected = vi.fn();
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions(),
+        secureFeatures: makeSecureFeatures({ deletion: true }),
+        actions: [],
+        onDeleteRow: vi.fn(),
+        onDeleteSelected,
+        stateActions: makeStateActions(),
+        data: [],
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    expect(result.current.secureHandlers.onDeleteSelected).toBe(onDeleteSelected);
+  }, TEST_TIMEOUT);
+
+  it('returns secureHandlers without onDeleteSelected when canDelete is false', () => {
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions({ canDelete: false }),
+        secureFeatures: makeSecureFeatures({ deletion: true }),
+        actions: [],
+        onDeleteSelected: vi.fn(),
+        stateActions: makeStateActions(),
+        data: [],
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    expect(result.current.secureHandlers.onDeleteSelected).toBeUndefined();
+  }, TEST_TIMEOUT);
+
+  it('Edit action onClick calls setEditingRow with row id and cell value record', () => {
+    const stateActions = makeStateActions();
+    const data = [{ id: 'r1', name: 'Alice' }];
+    const { result } = renderHook(() =>
+      useDataTableEffectiveActions<TestRecord>({
+        permissions: makePermissions(),
+        secureFeatures: makeSecureFeatures({ editing: true, deletion: false }),
+        actions: [],
+        wrappedOnEditRow: vi.fn(),
+        stateActions,
+        data,
+        resolvedGetRowId: (row) => row.id,
+        deletionRefs: makeDeletionRefs(),
+        isDeleting: false,
+        setIsDeleting: vi.fn(),
+        logger: mockLogger as never,
+      })
+    );
+    const editAction = result.current.effectiveActions.find((a) => a.label === 'Edit');
+    expect(editAction).toBeDefined();
+    act(() => {
+      editAction!.onClick!(data[0]);
+    });
+    expect(stateActions.setEditingRow).toHaveBeenCalledWith('r1', expect.objectContaining({ id: 'r1', name: 'Alice' }));
+  }, TEST_TIMEOUT);
+});

package/src/components/DataTable/hooks/useDataTableEffectiveActions.ts

@@ -0,0 +1,238 @@
+/**
+ * @file useDataTableEffectiveActions
+ * @package @jmruthers/pace-core
+ * @module DataTable/hooks
+ *
+ * Builds secureHandlers and effectiveActions (Edit/Delete with RBAC and deletion batching).
+ */
+
+import { useMemo } from 'react';
+import { Edit, Trash2 } from 'lucide-react';
+import { toast } from '../../../hooks/useToast';
+import { toCellValueRecord } from '../ui/table/cellValueUtils';
+import type { DataRecord, DataTableAction, NormalizedDataTableFeatureConfig } from '../types';
+import type { DataTableDeletionBatchingRefs } from './useDataTableDeletionBatching';
+import type { DataTableStateActions } from './useDataTableState';
+import type { UseDataTablePermissionsReturn } from './useDataTablePermissions';
+import type { ImportHandlerResult } from '../ui/modals/importModalPersistence';
+import type { createLogger } from '../../../utils/core/logger';
+
+export interface UseDataTableEffectiveActionsParams<TData extends DataRecord> {
+  permissions: UseDataTablePermissionsReturn['permissions'];
+  secureFeatures: NormalizedDataTableFeatureConfig;
+  actions: DataTableAction<TData>[];
+  wrappedOnCreateRow?: (data: Partial<TData>) => void;
+  wrappedOnEditRow?: (row: TData, data: Partial<TData>) => void;
+  onDeleteRow?: (row: TData) => void;
+  onCreateRow?: (data: Partial<TData>) => void;
+  onImport?: (data: TData[]) => ImportHandlerResult;
+  onExport?: (options: import('../types').ExportOptions<TData>) => void | Promise<void>;
+  onDeleteSelected?: (selectedRows: Record<string, boolean>) => void;
+  stateActions: DataTableStateActions;
+  data: TData[];
+  resolvedGetRowId: (row: TData, index: number) => string;
+  deletionRefs: DataTableDeletionBatchingRefs<TData>;
+  isDeleting: boolean;
+  setIsDeleting: React.Dispatch<React.SetStateAction<boolean>>;
+  logger: ReturnType<typeof createLogger>;
+}
+
+function createDeleteHandler<TData extends DataRecord>(params: {
+  permissions: UseDataTableEffectiveActionsParams<TData>['permissions'];
+  onDeleteRow: (row: TData) => void | Promise<unknown>;
+  data: TData[];
+  resolvedGetRowId: (row: TData, index: number) => string;
+  deletionRefs: DataTableDeletionBatchingRefs<TData>;
+  isDeleting: boolean;
+  setIsDeleting: React.Dispatch<React.SetStateAction<boolean>>;
+  logger: ReturnType<typeof createLogger>;
+}): (row: TData) => Promise<void> {
+  const {
+    permissions,
+    onDeleteRow,
+    data,
+    resolvedGetRowId,
+    deletionRefs,
+    isDeleting,
+    setIsDeleting,
+    logger,
+  } = params;
+  const { dataSnapshotRef, pendingDeletionsRef, deletionTimeoutRef } = deletionRefs;
+
+  return async (row: TData) => {
+    if (!permissions.canDelete.can) {
+      toast({
+        title: 'Delete Failed',
+        description: 'Insufficient permissions to delete this resource',
+        variant: 'destructive',
+      });
+      return;
+    }
+    const rowIndex = data.findIndex((r) => r === row);
+    const rowId = resolvedGetRowId(row, rowIndex >= 0 ? rowIndex : 0);
+    if (!isDeleting) {
+      dataSnapshotRef.current = [...data];
+      setIsDeleting(true);
+    }
+    pendingDeletionsRef.current.add(rowId);
+    if (deletionTimeoutRef.current) {
+      clearTimeout(deletionTimeoutRef.current);
+    }
+    try {
+      const result = onDeleteRow(row);
+      const isPromise =
+        result !== undefined &&
+        result !== null &&
+        typeof result === 'object' &&
+        'then' in result &&
+        typeof (result as { then: unknown }).then === 'function';
+      if (isPromise) {
+        await (result as Promise<unknown>);
+      }
+      pendingDeletionsRef.current.delete(rowId);
+      deletionTimeoutRef.current = setTimeout(() => {
+        if (pendingDeletionsRef.current.size === 0) {
+          setIsDeleting(false);
+          dataSnapshotRef.current = data;
+          toast({
+            title: 'Delete Successful',
+            description: 'Row deleted successfully',
+            variant: 'default',
+          });
+        }
+      }, 150);
+    } catch (error) {
+      logger.error('Delete error:', error);
+      pendingDeletionsRef.current.delete(rowId);
+      if (pendingDeletionsRef.current.size === 0) {
+        setIsDeleting(false);
+        dataSnapshotRef.current = data;
+      }
+      toast({
+        title: 'Delete Failed',
+        description: error instanceof Error ? error.message : 'Failed to delete row',
+        variant: 'destructive',
+      });
+    }
+  };
+}
+
+export interface UseDataTableEffectiveActionsReturn<TData extends DataRecord> {
+  secureHandlers: {
+    onEditRow?: (row: TData, data: Partial<TData>) => void;
+    onDeleteRow?: (row: TData) => void;
+    onCreateRow?: (data: Partial<TData>) => void;
+    onImport?: (data: TData[]) => ImportHandlerResult;
+    onExport?: (options: import('../types').ExportOptions<TData>) => void | Promise<void>;
+    onDeleteSelected?: (selectedRows: Record<string, boolean>) => void;
+  };
+  effectiveActions: DataTableAction<TData>[];
+}
+
+export function useDataTableEffectiveActions<TData extends DataRecord>(
+  params: UseDataTableEffectiveActionsParams<TData>
+): UseDataTableEffectiveActionsReturn<TData> {
+  const {
+    permissions,
+    secureFeatures,
+    actions,
+    wrappedOnCreateRow,
+    wrappedOnEditRow,
+    onDeleteRow,
+    stateActions,
+    data,
+    resolvedGetRowId,
+    deletionRefs,
+    isDeleting,
+    setIsDeleting,
+    logger,
+  } = params;
+
+  const secureHandlers = useMemo(() => {
+    return {
+      onEditRow: permissions.canUpdate.can ? wrappedOnEditRow : undefined,
+      onDeleteRow: permissions.canDelete.can ? onDeleteRow : undefined,
+      onCreateRow: permissions.canCreate.can ? wrappedOnCreateRow : undefined,
+      onImport: permissions.canImport.can ? params.onImport : undefined,
+      onExport: permissions.canExport.can ? params.onExport : undefined,
+      onDeleteSelected: permissions.canDelete.can ? params.onDeleteSelected : undefined,
+    };
+  }, [
+    permissions.canUpdate.can,
+    permissions.canDelete.can,
+    permissions.canCreate.can,
+    permissions.canImport.can,
+    permissions.canExport.can,
+    wrappedOnEditRow,
+    onDeleteRow,
+    wrappedOnCreateRow,
+    params.onImport,
+    params.onExport,
+    params.onDeleteSelected,
+  ]);
+
+  const effectiveActions = useMemo(() => {
+    const result = [...actions];
+    if (
+      secureFeatures.editing &&
+      secureHandlers.onEditRow &&
+      !result.some((a) => a.label === 'Edit')
+    ) {
+      result.push({
+        label: 'Edit',
+        onClick: (row: TData) => {
+          if (!permissions.canUpdate.can) {
+            throw new Error('Insufficient permissions to edit this resource');
+          }
+          const rowIndex = data.findIndex((r) => r === row);
+          const rowId = resolvedGetRowId(row, rowIndex >= 0 ? rowIndex : 0);
+          stateActions.setEditingRow(rowId, toCellValueRecord(row));
+        },
+        icon: Edit,
+        testId: 'edit',
+        hidden: !permissions.canUpdate.can,
+      });
+    }
+    if (
+      secureFeatures.deletion &&
+      secureHandlers.onDeleteRow &&
+      !result.some((a) => a.label === 'Delete')
+    ) {
+      const handleDelete = createDeleteHandler({
+        permissions,
+        onDeleteRow: secureHandlers.onDeleteRow,
+        data,
+        resolvedGetRowId,
+        deletionRefs,
+        isDeleting,
+        setIsDeleting,
+        logger,
+      });
+      result.push({
+        label: 'Delete',
+        onClick: handleDelete,
+        icon: Trash2,
+        testId: 'delete',
+        variant: 'destructive' as const,
+        hidden: !permissions.canDelete.can,
+      });
+    }
+    return result;
+  }, [
+    actions,
+    secureFeatures.editing,
+    secureFeatures.deletion,
+    secureHandlers.onEditRow,
+    secureHandlers.onDeleteRow,
+    permissions,
+    stateActions,
+    data,
+    resolvedGetRowId,
+    deletionRefs,
+    isDeleting,
+    setIsDeleting,
+    logger,
+  ]);
+
+  return { secureHandlers, effectiveActions };
+}