@jmruthers/pace-core 0.6.9 → 0.6.11

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

@@ -0,0 +1,109 @@
+/**
+ * @file useDataTablePaginationSync
+ * @package @jmruthers/pace-core
+ * @module DataTable/hooks
+ *
+ * Computes validated initial page size, effective page size, and applies
+ * the pagination-fix effect so the table never uses an invalid pageSize or out-of-bounds pageIndex.
+ */
+
+import { useMemo, useEffect } from 'react';
+import type { DataTableState, DataTableStateActions } from './useDataTableState';
+import type { NormalizedDataTableFeatureConfig } from '../types';
+import type { createLogger } from '../../../utils/core/logger';
+
+export interface UseDataTablePaginationSyncParams {
+  secureFeatures: NormalizedDataTableFeatureConfig;
+  finalPageSizeOptions: number[];
+  state: DataTableState;
+  stateActions: DataTableStateActions;
+  finalDataCount: number;
+  initialPageSize: number;
+  logger: ReturnType<typeof createLogger>;
+}
+
+export interface UseDataTablePaginationSyncReturn {
+  validatedInitialPageSize: number;
+  effectivePageSize: number;
+}
+
+export function useDataTablePaginationSync(
+  params: UseDataTablePaginationSyncParams
+): UseDataTablePaginationSyncReturn {
+  const {
+    secureFeatures,
+    finalPageSizeOptions,
+    state,
+    stateActions,
+    finalDataCount,
+    initialPageSize,
+    logger,
+  } = params;
+
+  const validatedInitialPageSize = useMemo(() => {
+    if (!secureFeatures.pagination || !finalPageSizeOptions.length) {
+      return initialPageSize;
+    }
+    if (finalPageSizeOptions.includes(initialPageSize)) {
+      return initialPageSize;
+    }
+    const sortedOptions = [...finalPageSizeOptions].sort((a, b) => a - b);
+    const closestOption = sortedOptions.reduce((prev, curr) =>
+      Math.abs(curr - initialPageSize) < Math.abs(prev - initialPageSize)
+        ? curr
+        : prev
+    );
+    logger.warn(
+      `initialPageSize ${initialPageSize} is not available in page size options [${finalPageSizeOptions.join(', ')}]. Using closest option: ${closestOption}`
+    );
+    return closestOption;
+  }, [
+    initialPageSize,
+    finalPageSizeOptions,
+    secureFeatures.pagination,
+    logger,
+  ]);
+
+  const effectivePageSize = useMemo(() => {
+    if (!secureFeatures.pagination || !finalPageSizeOptions.length) {
+      return state.pagination.pageSize;
+    }
+    if (!finalPageSizeOptions.includes(state.pagination.pageSize)) {
+      return validatedInitialPageSize;
+    }
+    return state.pagination.pageSize;
+  }, [
+    state.pagination.pageSize,
+    validatedInitialPageSize,
+    secureFeatures.pagination,
+    finalPageSizeOptions,
+  ]);
+
+  useEffect(() => {
+    if (secureFeatures.pagination && finalPageSizeOptions.length > 0) {
+      const needsFix = !finalPageSizeOptions.includes(state.pagination.pageSize);
+      const currentPageSize = effectivePageSize || validatedInitialPageSize;
+      const totalPages =
+        currentPageSize > 0 ? Math.ceil(finalDataCount / currentPageSize) : 0;
+      const pageIndexOutOfBounds =
+        totalPages > 0 && state.pagination.pageIndex >= totalPages;
+      if (needsFix || pageIndexOutOfBounds) {
+        stateActions.setPagination({
+          pageSize: validatedInitialPageSize,
+          pageIndex: 0,
+        });
+      }
+    }
+  }, [
+    secureFeatures.pagination,
+    finalPageSizeOptions,
+    state.pagination.pageSize,
+    state.pagination.pageIndex,
+    validatedInitialPageSize,
+    stateActions,
+    effectivePageSize,
+    finalDataCount,
+  ]);
+
+  return { validatedInitialPageSize, effectivePageSize };
+}

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

@@ -0,0 +1,280 @@
+/**
+ * @file Unit tests for useDataTablePermissions
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Hooks
+ */
+
+import { renderHook, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useDataTablePermissions } from './useDataTablePermissions';
+import type { DataTableFeatureConfig } from '../../types';
+
+type CanResult = { can: boolean; isLoading: boolean; error: null };
+
+const mockUseUnifiedAuth = vi.fn(() => ({
+  user: { id: 'user-1' },
+  selectedOrganisation: { id: 'org-1' },
+  selectedEvent: { event_id: 'event-1' },
+  supabase: {},
+}));
+
+const mockUseResolvedScope = vi.fn(() => ({
+  resolvedScope: { organisationId: 'org-1', appId: 'app-1', eventId: 'event-1' },
+  isLoading: false,
+}));
+
+// Mock useCan - it takes (userId, scope, permission, pageId?, useCache?, precomputedSuperAdmin?, appName?)
+const mockUseCan = vi.fn<(...args: any[]) => CanResult>();
+
+vi.mock('../../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuth(),
+  UnifiedAuthProvider: (props: { children: unknown }) => props.children,
+}));
+
+// Mock individual hook files since barrel was removed
+vi.mock('../../../rbac/hooks/useResolvedScope', () => ({
+  useResolvedScope: (...args: unknown[]) => mockUseResolvedScope(...args),
+}));
+
+vi.mock('../../../rbac/hooks/usePermissions', () => ({
+  useCan: (...args: Parameters<typeof mockUseCan>) => mockUseCan(...args),
+}));
+
+vi.mock('../../../hooks/useToast', () => ({
+  useToast: () => ({
+    toast: vi.fn(),
+  }),
+}));
+
+vi.mock('../../../utils/core/logger', () => {
+  const mockLoggerInstance = {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  };
+  return {
+    createLogger: () => mockLoggerInstance,
+    logger: mockLoggerInstance,
+  };
+});
+
+const mockIsSuperAdmin = vi.fn().mockResolvedValue({ ok: true, data: false });
+
+vi.mock('../../../rbac/api', () => ({
+  isSuperAdmin: (...args: unknown[]) => mockIsSuperAdmin(...args),
+}));
+
+describe('useDataTablePermissions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockUseCan.mockImplementation(() => ({ can: false, isLoading: false, error: null }));
+    mockIsSuperAdmin.mockResolvedValue({ ok: true, data: false });
+  });
+
+  describe('Validation', () => {
+    it('requires either pageId or pageName', () => {
+      expect(() =>
+        renderHook(() => useDataTablePermissions({}, {}))
+      ).toThrow('rbac.pageId or rbac.pageName');
+    });
+
+    it('accepts pageId', () => {
+      const { result } = renderHook(() =>
+        useDataTablePermissions({ pageId: 'users' }, {})
+      );
+      expect(result.current.effectivePageId).toBe('users');
+    });
+
+    it('accepts pageName', () => {
+      const { result } = renderHook(() =>
+        useDataTablePermissions({ pageName: 'Users Page' }, {})
+      );
+      expect(result.current.effectivePageId).toBe('Users Page');
+    });
+  });
+
+  describe('Permission Checks', () => {
+    it('filters features based on permission results', () => {
+      const featureConfig: DataTableFeatureConfig = {
+        creation: true,
+        editing: true,
+        deletion: true,
+        deleteSelected: true,
+        export: true,
+        import: true,
+      };
+
+      const allowedPermissions = new Set(['read:page.users', 'update:page.users']);
+
+      // useCan signature: (userId, scope, permission, pageId?, useCache?, precomputedSuperAdmin?, appName?)
+      mockUseCan.mockImplementation((_userId, _scope, permission) => ({
+        can: allowedPermissions.has(permission),
+        isLoading: false,
+        error: null,
+      }));
+
+      const { result } = renderHook(() =>
+        useDataTablePermissions({ pageId: 'users' }, featureConfig)
+      );
+
+      expect(result.current.secureFeatures.creation).toBe(false);
+      expect(result.current.secureFeatures.editing).toBe(true);
+      expect(result.current.secureFeatures.deletion).toBe(false);
+      expect(result.current.secureFeatures.deleteSelected).toBe(false);
+      expect(result.current.secureFeatures.export).toBe(true);
+      expect(result.current.secureFeatures.import).toBe(false);
+    });
+
+    it('checks all required permissions', () => {
+      mockUseCan.mockImplementation(() => ({ can: false, isLoading: false, error: null }));
+
+      renderHook(() => useDataTablePermissions({ pageId: 'users' }, {}));
+
+      // useCan signature: (userId, scope, permission, pageId?, useCache?, precomputedSuperAdmin?, appName?)
+      const permissions = mockUseCan.mock.calls.map((call) => call[2] as string); // permission is 3rd parameter (index 2)
+      expect(permissions).toContain('read:page.users');
+      expect(permissions).toContain('create:page.users');
+      expect(permissions).toContain('update:page.users');
+      expect(permissions).toContain('delete:page.users');
+    });
+
+    it('uses read permission for export', () => {
+      // useCan signature: (userId, scope, permission, pageId?, useCache?, precomputedSuperAdmin?, appName?)
+      mockUseCan.mockImplementation((_userId, _scope, permission) => ({
+        can: permission === 'read:page.users',
+        isLoading: false,
+        error: null,
+      }));
+
+      const { result } = renderHook(() =>
+        useDataTablePermissions({ pageId: 'users' }, { export: true })
+      );
+
+      expect(result.current.secureFeatures.export).toBe(true);
+      expect(result.current.permissions.canExport.can).toBe(true);
+    });
+
+    it('uses create permission for import', () => {
+      // useCan signature: (userId, scope, permission, pageId?, useCache?, precomputedSuperAdmin?, appName?)
+      mockUseCan.mockImplementation((_userId, _scope, permission) => ({
+        can: permission === 'create:page.users',
+        isLoading: false,
+        error: null,
+      }));
+
+      const { result } = renderHook(() =>
+        useDataTablePermissions({ pageId: 'users' }, { import: true })
+      );
+
+      expect(result.current.secureFeatures.import).toBe(true);
+      expect(result.current.permissions.canImport.can).toBe(true);
+    });
+  });
+
+  describe('Super Admin Bypass', () => {
+    it('bypasses all permission checks for super admin', async () => {
+      mockIsSuperAdmin.mockResolvedValue({ ok: true, data: true });
+      mockUseCan.mockImplementation(() => ({ can: false, isLoading: false, error: null }));
+
+      const { result } = renderHook(() =>
+        useDataTablePermissions({ pageId: 'users' }, {
+          creation: true,
+          editing: true,
+          deletion: true,
+        })
+      );
+
+      // Wait for super admin check to complete
+      await waitFor(() => {
+        expect(result.current.permissions.canCreate.can).toBe(true);
+      }, { timeout: 2000 });
+
+      expect(result.current.permissions.canRead.can).toBe(true);
+      expect(result.current.permissions.canUpdate.can).toBe(true);
+      expect(result.current.permissions.canDelete.can).toBe(true);
+      expect(result.current.secureFeatures.creation).toBe(true);
+      expect(result.current.secureFeatures.editing).toBe(true);
+      expect(result.current.secureFeatures.deletion).toBe(true);
+    });
+
+    it('handles super admin check loading state', () => {
+      mockIsSuperAdmin.mockImplementation(() => new Promise(() => {})); // Never resolves
+      mockUseCan.mockImplementation(() => ({ can: false, isLoading: false, error: null }));
+
+      const { result } = renderHook(() =>
+        useDataTablePermissions({ pageId: 'users' }, {})
+      );
+
+      // Should show loading while checking super admin
+      expect(result.current.permissions.canRead.isLoading).toBe(true);
+    });
+  });
+
+  describe('Scope Resolution', () => {
+    it('uses resolved scope for permission checks', () => {
+      mockUseResolvedScope.mockReturnValue({
+        resolvedScope: { organisationId: 'org-1', appId: 'app-1', eventId: 'event-1' },
+        isLoading: false,
+      });
+
+      renderHook(() => useDataTablePermissions({ pageId: 'users' }, {}));
+
+      // useCan signature: (userId, scope, permission, pageId?, useCache?, precomputedSuperAdmin?, appName?)
+      const scopes = mockUseCan.mock.calls.map((call) => call[1]); // scope is 2nd parameter (index 1)
+      expect(scopes.every(scope => 
+        scope.organisationId === 'org-1' && 
+        scope.appId === 'app-1' && 
+        scope.eventId === 'event-1'
+      )).toBe(true);
+    });
+
+    it('handles scope loading state', () => {
+      mockUseResolvedScope.mockReturnValue({
+        resolvedScope: null,
+        isLoading: true,
+      });
+
+      const { result } = renderHook(() =>
+        useDataTablePermissions({ pageId: 'users' }, {})
+      );
+
+      // Should still work with empty scope for page-level permissions
+      expect(result.current.permissions).toBeDefined();
+    });
+  });
+
+  describe('Feature Security', () => {
+    it('disables features when permissions are denied', () => {
+      mockUseCan.mockImplementation(() => ({ can: false, isLoading: false, error: null }));
+
+      const { result } = renderHook(() =>
+        useDataTablePermissions({ pageId: 'users' }, {
+          creation: true,
+          editing: true,
+          deletion: true,
+        })
+      );
+
+      expect(result.current.secureFeatures.creation).toBe(false);
+      expect(result.current.secureFeatures.editing).toBe(false);
+      expect(result.current.secureFeatures.deletion).toBe(false);
+    });
+
+    it('preserves feature config when permissions are granted', () => {
+      mockUseCan.mockImplementation(() => ({ can: true, isLoading: false, error: null }));
+
+      const { result } = renderHook(() =>
+        useDataTablePermissions({ pageId: 'users' }, {
+          creation: true,
+          editing: false,
+          deletion: true,
+        })
+      );
+
+      expect(result.current.secureFeatures.creation).toBe(true);
+      expect(result.current.secureFeatures.editing).toBe(false);
+      expect(result.current.secureFeatures.deletion).toBe(true);
+    });
+  });
+});