@jmruthers/pace-core 0.6.9 → 0.6.11

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

@@ -8,11 +8,9 @@
  * Handles scope resolution, permission checks, and secure feature configuration.
  */
 
-import { useMemo, useRef, useState, useEffect } from 'react';
+import { useMemo } from 'react';
 import { useUnifiedAuth } from '../../../providers/services/UnifiedAuthProvider';
-import { useCan, useResolvedScope } from '../../../rbac/hooks';
-import { createLogger } from '../../../utils/core/logger';
-import { isSuperAdmin } from '../../../rbac/api';
+import { useCan } from '../../../rbac/hooks/usePermissions';
 import {
   normalizeDataTableFeatures,
   type DataTableFeatureConfig,
@@ -21,6 +19,8 @@ import {
   type DataRecord,
 } from '../types';
 import type { Permission } from '../../../rbac/types';
+import { useDataTableSuperAdmin } from './useDataTableSuperAdmin';
+import { useDataTableScope } from './useDataTableScope';
 
 /**
  * Return value of the useDataTablePermissions hook.
@@ -39,6 +39,51 @@ export interface UseDataTablePermissionsReturn {
   effectivePageId: string | undefined;
 }
 
+type UseCanResult = ReturnType<typeof useCan>;
+
+/**
+ * Builds a permission result that bypasses checks for super admins.
+ * When super admin is confirmed, returns can: true; otherwise uses the useCan result.
+ */
+function toSuperAdminAwarePermission(
+  result: UseCanResult,
+  isSuperAdminUser: boolean | null,
+  isCheckingSuperAdmin: boolean
+): UseCanResult {
+  if (isSuperAdminUser === true) {
+    return {
+      can: true,
+      isLoading: false,
+      error: null,
+      refetch: result.refetch,
+    };
+  }
+  return {
+    can: result.can,
+    isLoading: (isSuperAdminUser === null && isCheckingSuperAdmin) || result.isLoading,
+    error: result.error,
+    refetch: result.refetch,
+  };
+}
+
+/**
+ * Applies permission flags to normalized features; disables features the user cannot perform.
+ */
+function applyPermissionsToFeatures(
+  normalizedFeatures: NormalizedDataTableFeatureConfig,
+  permissions: UseDataTablePermissionsReturn['permissions']
+): NormalizedDataTableFeatureConfig {
+  return {
+    ...normalizedFeatures,
+    creation: normalizedFeatures.creation && permissions.canCreate.can,
+    editing: normalizedFeatures.editing && permissions.canUpdate.can,
+    deletion: normalizedFeatures.deletion && permissions.canDelete.can,
+    deleteSelected: normalizedFeatures.deleteSelected && permissions.canDelete.can,
+    export: normalizedFeatures.export && permissions.canExport.can,
+    import: normalizedFeatures.import && permissions.canImport.can,
+  };
+}
+
 /**
  * Hook for managing RBAC permissions in DataTable components.
  * Handles scope resolution, permission checks, and secure feature configuration.
@@ -48,208 +93,34 @@ export interface UseDataTablePermissionsReturn {
  * @param features - Feature configuration to secure
  * @returns Permission checks and secure feature configuration
  */
-export function useDataTablePermissions<TData extends DataRecord>(
+export function useDataTablePermissions<_TData extends DataRecord>(
   rbac: DataTableRBACConfig,
   features: DataTableFeatureConfig = {}
 ): UseDataTablePermissionsReturn {
-  const logger = createLogger('DataTablePermissions');
-  const authResult = useUnifiedAuth();
-  const user = authResult.user;
-
-  // Super admin status - check if user has super admin privileges
-  // Super admins bypass all permission checks (similar to PaceAppLayout)
-  // PERFORMANCE OPTIMIZATION: Check super admin once and share with all useCan hooks to avoid duplicate queries
-  // Use null to indicate "not checked yet" vs false which means "checked and not super admin"
-  const [isSuperAdminUser, setIsSuperAdminUser] = useState<boolean | null>(null);
-  const [isCheckingSuperAdmin, setIsCheckingSuperAdmin] = useState<boolean>(() => !!user?.id);
-  const lastCheckedUserIdRef = useRef<string | null>(null);
-  const isCheckingRef = useRef<boolean>(false);
-
-  useEffect(() => {
-    // Skip if already checked for this user ID
-    if (lastCheckedUserIdRef.current === user?.id && isSuperAdminUser !== null) {
-      return;
-    }
-
-    // Skip if already checking
-    if (isCheckingRef.current) {
-      return;
-    }
-
-    const checkSuperAdminStatus = async () => {
-      if (!user?.id) {
-        setIsSuperAdminUser(false); // No user = not super admin
-        setIsCheckingSuperAdmin(false);
-        lastCheckedUserIdRef.current = null;
-        return;
-      }
-
-      // Mark as checking and track user ID
-      isCheckingRef.current = true;
-      lastCheckedUserIdRef.current = user.id;
+  const { user, selectedOrganisation, selectedEvent, supabase } = useUnifiedAuth();
+  const { isSuperAdminUser, isCheckingSuperAdmin } = useDataTableSuperAdmin(user?.id);
 
-      const startTime = Date.now();
-      setIsCheckingSuperAdmin(true);
-      
-      // Add timeout to prevent infinite hanging
-      const timeoutId = setTimeout(() => {
-        logger.warn('useDataTablePermissions', 'Super admin check taking longer than 5 seconds', {
-          userId: user?.id,
-          elapsedMs: Date.now() - startTime,
-        });
-      }, 5000);
-
-      try {
-        const superAdminStatus = await isSuperAdmin(user.id);
-        setIsSuperAdminUser(superAdminStatus);
-      } catch (error) {
-        const elapsed = Date.now() - startTime;
-        logger.error('useDataTablePermissions', 'Error checking super admin status', {
-          userId: user?.id,
-          error,
-          elapsedMs: elapsed,
-        });
-        setIsSuperAdminUser(false); // Error = assume not super admin for security
-      } finally {
-        clearTimeout(timeoutId);
-        setIsCheckingSuperAdmin(false);
-        isCheckingRef.current = false;
-      }
-    };
-
-    checkSuperAdminStatus();
-  }, [user?.id, logger]);
-
-  // MANDATORY: Check all permissions upfront - ALWAYS enforce RBAC
-  // Use page-based permissions exclusively
   const pageId = rbac?.pageId;
   const pageName = rbac?.pageName;
-
-  // Early validation - need either pageId or pageName
   if (!pageId && !pageName) {
     throw new Error('DataTable requires either rbac.pageId or rbac.pageName for permission checking');
   }
-
-  // Use pageId if provided, otherwise use pageName (will be resolved by RBAC engine)
   const effectivePageId = pageId || pageName;
 
-  /**
-   * RBAC Scope Resolution
-   * 
-   * This section handles the complex task of determining the current organisational
-   * and event context for permission checks. The scope (org/event/app) changes
-   * dynamically based on what the user has selected in the UI.
-   * 
-   * Key complexity: Permission hooks (useCan) must not re-run on every render,
-   * but they need the latest scope. We use a ref to maintain a stable scope object
-   * that only changes when the actual scope values change, preventing infinite loops
-   * while ensuring permissions are always checked with current context.
-   */
-
-  // Use shared scope resolution hook for consistent RBAC scoping
-  const { selectedOrganisation, selectedEvent, supabase } = useUnifiedAuth();
-  
-  const { resolvedScope: rawResolvedScope, isLoading: scopeLoading } = useResolvedScope({
+  const { consistentScope } = useDataTableScope({
+    selectedOrganisation,
+    selectedEvent,
     supabase,
-    selectedOrganisationId: selectedOrganisation?.id || null,
-    selectedEventId: selectedEvent?.event_id || null,
-    selectedEventOrganisationId: selectedEvent?.organisation_id || null
+    pageId,
+    pageName,
   });
 
-  /**
-   * Stable scope ref to prevent permission hooks from re-running constantly.
-   * 
-   * Without this, every permission check would trigger on every render because
-   * the scope object gets a new reference on each render. By using a ref and
-   * only updating it when values actually change, we:
-   * 1. Prevent infinite loops in permission hooks
-   * 2. Maintain performance
-   * 3. Still ensure permissions check against the current scope
-   */
-  const stableScopeRef = useRef<{ organisationId?: string; appId?: string; eventId?: string }>({ 
-    organisationId: undefined, 
-    appId: undefined, 
-    eventId: undefined 
-  });
-
-  // Only update the stable scope if the resolved scope has actually changed
-  // This prevents unnecessary re-renders while maintaining up-to-date permission checks
-  // Allow scope updates even when organisationId is undefined (for users without orgs, like profile pages)
-  if (rawResolvedScope) {
-    const newScope = {
-      organisationId: rawResolvedScope.organisationId,
-      appId: rawResolvedScope.appId,
-      eventId: rawResolvedScope.eventId
-    };
-    
-    // Only update if the scope has actually changed
-    if (stableScopeRef.current.organisationId !== newScope.organisationId ||
-        stableScopeRef.current.eventId !== newScope.eventId ||
-        stableScopeRef.current.appId !== newScope.appId) {
-      stableScopeRef.current = {
-        organisationId: newScope.organisationId,
-        appId: newScope.appId,
-        eventId: newScope.eventId
-      };
-    }
-  } else if (!rawResolvedScope && !scopeLoading) {
-    // Reset to empty scope when no resolved scope and resolution is complete (e.g., user logged out)
-    stableScopeRef.current = { organisationId: undefined, appId: undefined, eventId: undefined };
-  }
-
-  const stableScope = stableScopeRef.current;
-
-  /**
-   * Effective scope for permission checks.
-   * 
-   * Use the resolved scope once scope resolution is complete, even if organisationId is undefined.
-   * This allows permission checks for users without organisations (e.g., profile pages).
-   * The database function rbac_check_permission_simplified can handle NULL organisation_id.
-   * 
-   * PERFORMANCE OPTIMIZATION: For page-level permissions with pageId (UUID), we don't need to wait
-   * for full scope resolution. The database function can handle page-level permissions without
-   * organisationId or appId. We only need to wait if:
-   * 1. We're using pageName (not UUID) and need appId to resolve it, OR
-   * 2. We need organisationId for resource-level permissions (but we're using page-level here)
-   * 
-   * This allows permission checks to proceed in parallel with scope resolution, reducing load time.
-   */
-  const isPageName = !pageId && !!pageName; // We're using pageName, not a UUID pageId
-  const needsAppIdForResolution = isPageName; // Only need appId if we're resolving a pageName
-  
-  // PERFORMANCE FIX: For page-level permissions with UUID pageId, we can proceed immediately
-  // The database function handles page-level permissions without requiring full scope
-  // Only wait if we're using pageName (which needs appId to resolve) or if scope is critical
-  // For page-level permissions, organisationId and appId are optional
-  const hasPageId = !!pageId && typeof pageId === 'string';
-  const canProceedWithoutFullScope = hasPageId && !isPageName; // UUID pageId doesn't need appId
-  
-  // Wait for scope resolution only if:
-  // 1. We're using pageName and don't have appId yet (needed to resolve pageName to pageId), OR
-  // 2. Scope is loading AND we don't have a UUID pageId (can't proceed without scope)
-  // This allows permission checks to start earlier for UUID pageIds, reducing load time
-  const shouldWaitForScope = (needsAppIdForResolution && !stableScope.appId) || 
-                             (scopeLoading && !canProceedWithoutFullScope);
-  
-  // Use available scope immediately if we can proceed, otherwise wait
-  // For page-level permissions, empty scope is acceptable (database handles it)
-  const effectiveScope = (!shouldWaitForScope && (stableScope.organisationId || stableScope.appId || stableScope.eventId || canProceedWithoutFullScope)) 
-    ? stableScope 
-    : (canProceedWithoutFullScope ? { organisationId: undefined, eventId: undefined, appId: undefined } : null);
-
-  // Always call hooks with consistent parameters to avoid React hooks order violations
   const userId = user?.id || '';
   const readPermission = `read:page.${effectivePageId}` as unknown as Permission;
   const createPermission = `create:page.${effectivePageId}` as unknown as Permission;
   const updatePermission = `update:page.${effectivePageId}` as unknown as Permission;
   const deletePermission = `delete:page.${effectivePageId}` as unknown as Permission;
 
-  // Always use a consistent scope object to prevent hooks order violations
-  // When scope is loading or we need appId for pageName resolution, use empty scope which will cause useCan to wait
-  // When scope resolution is complete (even with undefined organisationId), use the resolved scope
-  // This allows permission checks for users without organisations (e.g., profile pages)
-  const consistentScope = effectiveScope || { organisationId: undefined, eventId: undefined, appId: undefined };
-
   // Check permissions using useCan hooks
   // PERFORMANCE OPTIMIZATION: Pass precomputed super admin status to avoid duplicate checks
   // Each useCan hook would normally check super admin separately (6+ queries), but we check once here
@@ -266,86 +137,36 @@ export function useDataTablePermissions<TData extends DataRecord>(
   const canExportResult = useCan(userId, consistentScope, readPermission, effectivePageId, true, isSuperAdminUser); // Use read permission for export
   const canImportResult = useCan(userId, consistentScope, createPermission, effectivePageId, true, isSuperAdminUser); // Use create permission for import
 
-  // Create permission wrappers that bypass checks for super admins
-  // Super admins get can: true for all permissions, but we preserve isLoading and error states
-  // to maintain consistent API with useCan return type
-  // React 19 fix: Read isLoading directly from result objects to ensure we get the latest state
-  // instead of relying on memoized object references which may not update properly in React 19
-  // CRITICAL FIX: When isSuperAdminUser is true, immediately grant all permissions without waiting
-  // for useCan results. This ensures super admins can use DataTable features immediately.
-  const permissions = useMemo(() => {
-    // Helper to create a permission result that bypasses for super admins
-    // If super admin check is still loading, we show loading state to prevent premature "Access Denied"
-    // Once super admin check completes, if user is super admin, all permissions are true
-    // Otherwise, use the normal permission check results
-    const createSuperAdminAwarePermission = (result: ReturnType<typeof useCan>) => {
-      // CRITICAL: If super admin is confirmed, immediately grant permission
-      // Don't wait for useCan results - super admins bypass all checks
-      if (isSuperAdminUser === true) {
-        return {
-          can: true,
-          isLoading: false,
-          error: null,
-          refetch: result.refetch,
-        };
-      }
-      
-      // For non-super-admins or while checking, use normal permission results
-      return {
-        can: result.can,
-        isLoading: (isSuperAdminUser === null && isCheckingSuperAdmin) || result.isLoading,
-        error: result.error,
-        refetch: result.refetch,
-      };
-    };
-
-    return {
-      canRead: createSuperAdminAwarePermission(canReadResult),
-      canCreate: createSuperAdminAwarePermission(canCreateResult),
-      canUpdate: createSuperAdminAwarePermission(canUpdateResult),
-      canDelete: createSuperAdminAwarePermission(canDeleteResult),
-      canExport: createSuperAdminAwarePermission(canExportResult),
-      canImport: createSuperAdminAwarePermission(canImportResult),
-    };
-  }, [
-    isSuperAdminUser,
-    isCheckingSuperAdmin,
-    // React 19 fix: Include individual properties instead of entire objects to ensure proper dependency tracking
-    canReadResult.can,
-    canReadResult.isLoading,
-    canReadResult.error,
-    canCreateResult.can,
-    canCreateResult.isLoading,
-    canCreateResult.error,
-    canUpdateResult.can,
-    canUpdateResult.isLoading,
-    canUpdateResult.error,
-    canDeleteResult.can,
-    canDeleteResult.isLoading,
-    canDeleteResult.error,
-    canExportResult.can,
-    canExportResult.isLoading,
-    canExportResult.error,
-    canImportResult.can,
-    canImportResult.isLoading,
-    canImportResult.error,
-  ]);
+  const permissions = useMemo(
+    () => ({
+      canRead: toSuperAdminAwarePermission(canReadResult, isSuperAdminUser, isCheckingSuperAdmin),
+      canCreate: toSuperAdminAwarePermission(canCreateResult, isSuperAdminUser, isCheckingSuperAdmin),
+      canUpdate: toSuperAdminAwarePermission(canUpdateResult, isSuperAdminUser, isCheckingSuperAdmin),
+      canDelete: toSuperAdminAwarePermission(canDeleteResult, isSuperAdminUser, isCheckingSuperAdmin),
+      canExport: toSuperAdminAwarePermission(canExportResult, isSuperAdminUser, isCheckingSuperAdmin),
+      canImport: toSuperAdminAwarePermission(canImportResult, isSuperAdminUser, isCheckingSuperAdmin),
+    }),
+    [
+      isSuperAdminUser,
+      isCheckingSuperAdmin,
+      canReadResult,
+      canCreateResult,
+      canUpdateResult,
+      canDeleteResult,
+      canExportResult,
+      canImportResult,
+    ]
+  );
 
-  // MANDATORY: Features are automatically filtered by permissions
   const normalizedFeatures = useMemo(
     () => normalizeDataTableFeatures(features),
     [features]
   );
 
-  const secureFeatures: NormalizedDataTableFeatureConfig = useMemo(() => ({
-    ...normalizedFeatures,
-    creation: normalizedFeatures.creation && permissions.canCreate.can,
-    editing: normalizedFeatures.editing && permissions.canUpdate.can,
-    deletion: normalizedFeatures.deletion && permissions.canDelete.can,
-    deleteSelected: normalizedFeatures.deleteSelected && permissions.canDelete.can,
-    export: normalizedFeatures.export && permissions.canExport.can,
-    import: normalizedFeatures.import && permissions.canImport.can,
-  }), [normalizedFeatures, permissions.canCreate.can, permissions.canUpdate.can, permissions.canDelete.can, permissions.canExport.can, permissions.canImport.can]);
+  const secureFeatures = useMemo(
+    () => applyPermissionsToFeatures(normalizedFeatures, permissions),
+    [normalizedFeatures, permissions]
+  );
 
   return {
     permissions,

package/src/components/DataTable/hooks/useDataTablePipeline.test.tsx

@@ -0,0 +1,219 @@
+/**
+ * @file useDataTablePipeline Hook Tests
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Hooks
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { useDataTablePipeline } from './useDataTablePipeline';
+import type { DataRecord, DataTableColumn, NormalizedDataTableFeatureConfig } from '../types';
+import type { DataTableState, DataTableStateActions } from './useDataTableState';
+
+const TEST_TIMEOUT = 10000;
+
+const mockLogger = { error: vi.fn(), warn: vi.fn(), info: vi.fn(), debug: vi.fn() };
+
+const mockPerformanceHook = {
+  paginationMode: 'client' as const,
+  pageSizeOptions: [10, 25, 50],
+  isLoading: false,
+  searchQuery: '',
+  setSearchQuery: vi.fn(),
+  fetchServerData: vi.fn(),
+  serverData: null,
+  cleanup: vi.fn(),
+};
+const mockDataPipeline = {
+  finalTableData: [],
+  dataCount: 0,
+  hierarchicalState: {},
+  hierarchicalValidation: { isValid: true, errors: [] },
+};
+const mockPaginationSync = { validatedInitialPageSize: 10, effectivePageSize: 10 };
+const mockEffectiveActions = {
+  secureHandlers: {},
+  effectiveActions: [],
+};
+const mockTableInstance = {
+  table: {
+    getRowModel: () => ({ rows: [] }),
+    getVisibleFlatColumns: () => [],
+  },
+};
+const mockKeyboardNav = {};
+const mockImportModalFocus = { lastFocusedElementRef: { current: null } };
+
+vi.mock('../../../hooks/useDataTablePerformance', () => ({
+  useDataTablePerformance: () => mockPerformanceHook,
+}));
+vi.mock('./useDataTableDataPipeline', () => ({
+  useDataTableDataPipeline: () => mockDataPipeline,
+}));
+vi.mock('./useDataTablePaginationSync', () => ({
+  useDataTablePaginationSync: () => mockPaginationSync,
+}));
+vi.mock('./useServerSideDataEffect', () => ({
+  useServerSideDataEffect: () => ({}),
+}));
+vi.mock('./useDataTableEffectiveActions', () => ({
+  useDataTableEffectiveActions: () => mockEffectiveActions,
+}));
+vi.mock('./useDataTableTableInstance', () => ({
+  useDataTableTableInstance: () => mockTableInstance,
+}));
+vi.mock('./useKeyboardNavigation', () => ({
+  useKeyboardNavigation: () => mockKeyboardNav,
+}));
+vi.mock('./useImportModalFocus', () => ({
+  useImportModalFocus: () => mockImportModalFocus,
+}));
+
+interface TestRecord extends DataRecord {
+  id: string;
+  name: string;
+}
+
+function makeState(): DataTableState {
+  return {
+    sorting: [],
+    columnFilters: [],
+    columnVisibility: {},
+    grouping: [],
+    expanded: {},
+    pagination: { pageIndex: 0, pageSize: 10 },
+    columnOrder: ['id', 'name'],
+    rowSelection: {},
+    isCreating: false,
+    creationData: {},
+    editingRowId: null,
+    editingData: {},
+    showImportModal: false,
+    showFilterRow: false,
+    searchQuery: '',
+  };
+}
+
+function makeStateActions(): DataTableStateActions {
+  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(),
+    clearRowSelection: vi.fn(),
+    setEditingRow: vi.fn(),
+    clearEditingRow: vi.fn(),
+    setCreationData: vi.fn(),
+    setShowImportModal: vi.fn(),
+    setShowFilterRow: vi.fn(),
+    setSearchQuery: vi.fn(),
+    setGlobalFilter: vi.fn(),
+  };
+}
+
+function makeSecureFeatures(): NormalizedDataTableFeatureConfig {
+  return {
+    creation: false,
+    editing: false,
+    deletion: false,
+    selection: false,
+    columnVisibility: false,
+    columnReordering: false,
+    pagination: true,
+    search: false,
+    export: false,
+    import: false,
+    filtering: false,
+    grouping: false,
+  };
+}
+
+function makeDeletionRefs() {
+  return {
+    dataSnapshotRef: { current: [] as TestRecord[] },
+    pendingDeletionsRef: { current: new Set<string>() },
+    deletionTimeoutRef: { current: null as ReturnType<typeof setTimeout> | null },
+  };
+}
+
+const columns: DataTableColumn<TestRecord>[] = [
+  { id: 'id', accessorKey: 'id', header: 'ID' },
+  { id: 'name', accessorKey: 'name', header: 'Name' },
+];
+
+const baseParams = {
+  data: [] as TestRecord[],
+  effectiveData: [] as TestRecord[],
+  columns,
+  state: makeState(),
+  stateActions: makeStateActions(),
+  rowSelection: {},
+  effectiveColumnOrder: ['id', 'name'],
+  updateSavedColumnVisibility: vi.fn(),
+  updateColumnOrder: vi.fn(),
+  secureFeatures: makeSecureFeatures(),
+  permissions: {
+    canRead: { can: true, isLoading: false, error: null },
+    canCreate: { can: false, isLoading: false, error: null },
+    canUpdate: { can: false, isLoading: false, error: null },
+    canDelete: { can: false, isLoading: false, error: null },
+    canImport: { can: false, isLoading: false, error: null },
+    canExport: { can: false, isLoading: false, error: null },
+  },
+  deletionRefs: makeDeletionRefs(),
+  isDeleting: false,
+  setIsDeleting: vi.fn(),
+  actions: [],
+  resolvedGetRowId: (row: TestRecord) => row.id,
+  initialPageSize: 10,
+  externalIsLoading: false,
+  isPrint: false,
+  effectivePageId: 'test-page' as string | undefined,
+  logger: mockLogger as never,
+  title: 'Test',
+  description: undefined,
+  variant: 'default' as const,
+  virtualHeight: 400,
+  aggregates: [],
+  shouldAllowRenderAfterTimeout: false,
+  rbac: {},
+};
+
+describe('[unit] useDataTablePipeline', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns layoutProps and guardInputs', () => {
+    const { result } = renderHook(() => useDataTablePipeline<TestRecord>(baseParams));
+    expect(result.current.layoutProps).toBeDefined();
+    expect(result.current.guardInputs).toBeDefined();
+  }, TEST_TIMEOUT);
+
+  it('guardInputs contains table, dataLength, finalTableDataLength, columnsLength, isLoading, effectivePageId, finalPaginationMode', () => {
+    const { result } = renderHook(() => useDataTablePipeline<TestRecord>(baseParams));
+    const g = result.current.guardInputs;
+    expect(g.table).toBe(mockTableInstance.table);
+    expect(g.dataLength).toBe(0);
+    expect(g.finalTableDataLength).toBe(0);
+    expect(g.columnsLength).toBe(2);
+    expect(typeof g.isLoading).toBe('boolean');
+    expect(g.effectivePageId).toBe('test-page');
+    expect(g.finalPaginationMode).toBe('client');
+  }, TEST_TIMEOUT);
+
+  it('layoutProps contains table, title, state, stateActions, secureFeatures', () => {
+    const { result } = renderHook(() => useDataTablePipeline<TestRecord>(baseParams));
+    const layout = result.current.layoutProps;
+    expect(layout.table).toBe(mockTableInstance.table);
+    expect(layout.title).toBe('Test');
+    expect(layout.state).toBe(baseParams.state);
+    expect(layout.stateActions).toBe(baseParams.stateActions);
+    expect(layout.secureFeatures).toBe(baseParams.secureFeatures);
+  }, TEST_TIMEOUT);
+});