@jmruthers/pace-core 0.6.4 → 0.6.6

package/cursor-rules/11-performance-optimization.mdc

@@ -0,0 +1,169 @@
+---
+description: Enforce performance optimization patterns including React memoization, database query optimization, and caching strategies
+globs: ["src/**/*.{ts,tsx,js,jsx}", "supabase/migrations/**/*.sql"]
+alwaysApply: false
+paceCoreVersion: "0.6.x"
+rulesVersion: "2025-01-28"
+---
+# Performance Optimization Guide
+
+**📚 Human-Readable Standard**: See [11-performance-optimization.md](../../packages/core/docs/standards/11-performance-optimization.md) for complete documentation.
+
+This guide enforces performance optimization patterns to ensure fast, responsive applications.
+
+**AI Agent Instructions**: When writing performance-sensitive code, ALWAYS apply these optimizations. Use the decision trees below to determine when to optimize.
+
+## MUST: Optimize React Re-renders
+
+**MUST use memoization for expensive computations and stable references:**
+
+```tsx
+// ✅ CORRECT - Memoize expensive computation
+const expensiveValue = useMemo(() => computeExpensiveValue(data), [data]);
+
+// ✅ CORRECT - Stable callback reference
+const handleClick = useCallback(() => doSomething(id), [id]);
+
+// ✅ CORRECT - Memoize component
+const ExpensiveComponent = React.memo(({ data }) => <div>{/* ... */}</div>);
+
+// ❌ WRONG - Recomputes on every render
+const expensiveValue = computeExpensiveValue(data);
+const handleClick = () => doSomething(id);
+```
+
+## MUST: Avoid Creating New Objects in Render
+
+**MUST NOT create new objects/arrays in render:**
+
+```tsx
+// ❌ WRONG - New object on every render
+function Component({ items }) {
+  const config = { items, enabled: true };
+  return <Child config={config} />;
+}
+
+// ✅ CORRECT - Memoize object
+function Component({ items }) {
+  const config = useMemo(() => ({ items, enabled: true }), [items]);
+  return <Child config={config} />;
+}
+```
+
+## MUST: Use Helper Functions in RLS Policies
+
+**MUST use STABLE SECURITY DEFINER helper functions (never subqueries):**
+
+```sql
+-- ✅ CORRECT - Helper function (evaluated once)
+CREATE POLICY "rbac_select_users" ON users FOR SELECT USING (
+  check_user_organisation_access(organisation_id)
+);
+
+-- ❌ WRONG - Subquery (N+1 performance issue)
+CREATE POLICY "rbac_select_users" ON users FOR SELECT USING (
+  organisation_id IN (SELECT organisation_id FROM organisation_memberships WHERE user_id = auth.uid())
+);
+```
+
+## SHOULD: Lazy Load Heavy Components
+
+**SHOULD lazy load heavy components:**
+
+```tsx
+// ✅ CORRECT - Lazy load
+import { lazy, Suspense } from 'react';
+const HeavyComponent = lazy(() => import('./HeavyComponent'));
+<Suspense fallback={<Loading />}><HeavyComponent /></Suspense>
+```
+
+## SHOULD: Configure TanStack Query Cache
+
+**SHOULD configure appropriate cache times:**
+
+```tsx
+// ✅ CORRECT - Configure cache
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 5 * 60 * 1000,
+      cacheTime: 10 * 60 * 1000,
+      retry: 1,
+      refetchOnWindowFocus: false,
+    },
+  },
+});
+```
+
+## SHOULD: Use RPC Functions for Complex Queries
+
+**SHOULD use RPC functions instead of complex client-side queries:**
+
+```tsx
+// ✅ CORRECT - RPC for complex query
+const { data } = await supabase.rpc('data_events_list', { organisation_id: orgId });
+
+// ❌ AVOID - Complex client-side query
+const { data } = await supabase.from('events').select('*, users(*), organisations(*)').eq('organisation_id', orgId);
+```
+
+## Decision Tree: Performance Optimization
+
+**ALWAYS follow this decision tree:**
+
+```
+1. Is this expensive computation?
+   ├─ YES → Use useMemo
+   └─ NO → Don't memoize (overhead not worth it)
+
+2. Is this function passed as prop?
+   ├─ YES → Use useCallback
+   └─ NO → Regular function is fine
+
+3. Is this component expensive to render?
+   ├─ YES → Use React.memo
+   └─ NO → Regular component is fine
+
+4. Is this creating new object/array in render?
+   ├─ YES → Memoize with useMemo
+   └─ NO → Continue
+
+5. Is this RLS policy?
+   ├─ YES → Use helper function (STABLE SECURITY DEFINER)
+   └─ NO → Continue
+
+6. Is this complex query?
+   ├─ YES → Use RPC function
+   └─ NO → Client-side query is fine
+```
+
+## Performance Checklist
+
+Before committing performance-sensitive code, verify:
+
+- [ ] Expensive computations memoized
+- [ ] Callbacks stable with useCallback
+- [ ] Components memoized when appropriate
+- [ ] No new objects/arrays in render
+- [ ] Heavy components lazy loaded
+- [ ] RLS policies use helper functions
+- [ ] Queries use indexes appropriately
+- [ ] No N+1 query patterns
+- [ ] TanStack Query configured properly
+- [ ] Bundle size optimized
+
+## Common Performance Pitfalls
+
+1. **Creating new objects in render** - Memoize with useMemo
+2. **Using inline functions** - Use useCallback
+3. **Over-memoizing** - Only memoize expensive operations
+4. **Subqueries in RLS** - Use helper functions
+5. **N+1 queries** - Use joins or RPC functions
+6. **Not lazy loading** - Lazy load heavy components
+7. **Poor cache configuration** - Configure TanStack Query properly
+
+## Reference
+
+- **Standard**: `packages/core/docs/standards/11-performance-optimization.md`
+- **RLS**: See `09-rbac-compliance.mdc` for RLS performance requirements
+- **Code Quality**: See `06-code-quality.mdc` for React patterns

package/cursor-rules/12-ci-cd-integration.mdc

@@ -0,0 +1,150 @@
+---
+description: Enforce CI/CD integration patterns including automated quality checks, deployment processes, and security scanning
+globs: [".github/workflows/**/*.yml", ".github/workflows/**/*.yaml", "package.json"]
+alwaysApply: false
+paceCoreVersion: "0.6.x"
+rulesVersion: "2025-01-28"
+---
+# CI/CD Integration Guide
+
+**📚 Human-Readable Standard**: See [12-ci-cd-integration.md](../../packages/core/docs/standards/12-ci-cd-integration.md) for complete documentation.
+
+This guide enforces CI/CD integration patterns to ensure automated quality checks and consistent deployments.
+
+**AI Agent Instructions**: When setting up CI/CD pipelines, ALWAYS include the required checks below. Use the decision tree to determine what checks are needed.
+
+## MUST: Include Required CI Checks
+
+**MUST run these checks in every CI pipeline:**
+
+```yaml
+# ✅ CORRECT - Required checks
+jobs:
+  quality-checks:
+    steps:
+      - name: Lint
+        run: npm run lint
+      - name: Type check
+        run: npx tsc --noEmit
+      - name: Run tests
+        run: npm run test
+      - name: Build
+        run: npm run build
+```
+
+## MUST: Have Required Scripts
+
+**MUST have these scripts in package.json:**
+
+```json
+// ✅ CORRECT - Required scripts
+{
+  "scripts": {
+    "lint": "eslint .",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "build": "vite build"
+  }
+}
+```
+
+## SHOULD: Include Additional Checks
+
+**SHOULD include these checks:**
+
+```yaml
+# ✅ RECOMMENDED - Additional checks
+- name: Format check
+  run: npm run format:check
+- name: Security scan
+  run: npm audit --audit-level=moderate
+- name: Coverage check
+  run: npm run test:coverage
+```
+
+## MUST: Use Secrets for Sensitive Data
+
+**MUST NOT commit secrets to repository:**
+
+```yaml
+# ✅ CORRECT - Use secrets
+env:
+  SUPABASE_URL: ${{ secrets.SUPABASE_URL }}
+  VITE_SUPABASE_ANON_KEY: ${{ secrets.VITE_SUPABASE_ANON_KEY }}
+
+# ❌ WRONG - Hardcoded secrets
+env:
+  SUPABASE_URL: "https://hardcoded-url.supabase.co"
+```
+
+## SHOULD: Deploy to Staging First
+
+**SHOULD deploy to staging before production:**
+
+```yaml
+# ✅ CORRECT - Staging first
+deploy-staging:
+  if: github.ref == 'refs/heads/develop'
+  environment: staging
+
+deploy-production:
+  needs: deploy-staging
+  if: github.ref == 'refs/heads/main'
+  environment: production
+```
+
+## Decision Tree: CI/CD Setup
+
+**ALWAYS follow this decision tree:**
+
+```
+1. What type of check is this?
+   ├─ Lint → MUST include
+   ├─ Type Check → MUST include
+   ├─ Tests → MUST include
+   ├─ Build → MUST include
+   ├─ Compliance → MUST include
+   ├─ Format → SHOULD include
+   ├─ Security → SHOULD include
+   └─ Coverage → SHOULD include
+
+2. Is this sensitive data?
+   ├─ YES → Use secrets (never commit)
+   └─ NO → Can be in config
+
+3. What environment?
+   ├─ Staging → Deploy on develop branch
+   └─ Production → Deploy on main branch only
+
+4. Are migrations needed?
+   ├─ YES → Run in staging first, test in CI
+   └─ NO → Continue
+```
+
+## CI/CD Checklist
+
+Before committing CI/CD configuration, verify:
+
+- [ ] Lint check configured
+- [ ] Type check configured
+- [ ] Tests run in CI
+- [ ] Build succeeds in CI
+- [ ] Security scan configured (recommended)
+- [ ] Environment variables set as secrets
+- [ ] Staging deployment configured
+- [ ] Production deployment configured
+- [ ] Migration strategy defined
+- [ ] Required scripts in package.json
+
+## Common CI/CD Mistakes
+
+1. **Missing required checks** - Include all MUST checks
+2. **Hardcoded secrets** - Always use secrets
+3. **No staging environment** - Deploy to staging first
+4. **No rollback plan** - Document rollback process
+
+## Reference
+
+- **Standard**: `packages/core/docs/standards/12-ci-cd-integration.md`
+- **Testing**: See `04-testing-standards.mdc` for test configuration
+- **Code Quality**: See `06-code-quality.mdc` for linting

package/dist/{AuthService-Cb34EQs3.d.ts → AuthService-DmfO5rGS.d.ts}

@@ -477,6 +477,7 @@ declare class AuthService extends BaseService implements IAuthService {
     private appName;
     private errorHandler;
     private unhandledRejectionHandler;
+    private wasAuthenticatedRef;
     constructor(supabaseClient: SupabaseClient, appName?: string);
     getInstanceId(): number;
     getUser(): User | null;
@@ -499,6 +500,15 @@ declare class AuthService extends BaseService implements IAuthService {
     private startSessionRestoration;
     private finishSessionRestoration;
     private clearRestorationTimeout;
+    /**
+     * Clear pace-core persistence entries from sessionStorage
+     * This includes dialog, form, and datatable persistence
+     *
+     * @param userId - Optional user ID to clear only that user's persistence.
+     *                 If not provided, clears all pace-core persistence (for user changes).
+     * @param clearUnscoped - If true, also clears old unscoped keys (without :user: prefix)
+     */
+    private clearPersistenceOnLogin;
     private setupAuthStateListener;
     private restoreSession;
     /**

package/dist/{DataTable-BMRU8a1j.d.ts → DataTable-2N_tqbfq.d.ts}

@@ -1,5 +1,5 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { d as DataRecord, D as DataTableColumn, e as DataTableRBACConfig, f as DataTableFeatureConfig, H as HierarchicalConfig, g as PerformanceConfig, S as ServerSideConfig, h as PaginationMode, C as ChunkingConfig, i as SearchIndexConfig, j as ExportOptions, G as GetRowId, E as EmptyStateConfig, c as AggregateConfig, a as DataTableAction } from './types-CkbwOr4Y.js';
+import { d as DataRecord, D as DataTableColumn, e as DataTableRBACConfig, f as DataTableFeatureConfig, H as HierarchicalConfig, g as PerformanceConfig, S as ServerSideConfig, h as PaginationMode, C as ChunkingConfig, i as SearchIndexConfig, j as ExportOptions, G as GetRowId, E as EmptyStateConfig, c as AggregateConfig, a as DataTableAction } from './types-B-K_5VnO.js';
 import React__default from 'react';
 
 /**

package/dist/DataTable-LRJL4IRV.js

@@ -0,0 +1,15 @@
+export { ActionButtons, BulkOperationsDropdown, ColumnFactory, ColumnVisibilityDropdown, DataTable, DataTableCore, DataTableErrorBoundary, DataTableModals, DataTableToolbar, EditableRow, EmptyState, EnhancedPaginationControls, GroupHeader, GroupingDropdown, ImportModal, LoadingState, PaginationControls, UnifiedTableBody, announce, announceBulkOperation, announceFilterChange, announceLoadingState, announcePaginationChange, announceSearchResults, announceSelectionChange, announceSortChange, average, calculateAllDepths, calculateAllIndentation, calculateIndentation, calculateOptimalPageSize, cleanupLiveRegion, count, createHierarchicalStructure, defaultDataTableFeatures, exportToCSV, exportToCSVWithTableRows, generateCSVContent, getAriaSortValue, getCellRenderer, getColumnHeaderText, getHierarchicalSortConfig, getPageSizeOptions, getPaginationBinding, getRowDepth, getRowDescription, getRowIdSafe, getSortButtonLabel, groupHierarchicalData, hasValidRowId, initializeLiveRegion, isHierarchicalSortableColumn, max, min, normalizeDataTableFeatures, shouldShowColumnForRow, sortHierarchicalDataByStructure, sortHierarchicalDataWithSorting, sum, validateHierarchicalData, validatePaginationConfig } from './chunk-ZS5VO5JB.js';
+import './chunk-7TYHROIV.js';
+export { CircuitBreaker, DEFAULT_FALLBACK_CONFIG, DataChunkManager, DataTableError, DataTableErrorType, ErrorRecoveryManager, MemoryMonitor, SearchIndex, VisibilityTracker, chunkData, debounce, determinePaginationMode, getOptimalPageSizeOptions, safeExecute, throttle, useDataTablePerformance } from './chunk-S7DKJPLT.js';
+import './chunk-3O3WHILE.js';
+import './chunk-C7NSAPTL.js';
+import './chunk-FTCRZOG2.js';
+import './chunk-ZFYPMX46.js';
+import './chunk-AHU7G2R5.js';
+import './chunk-4SXLQIZO.js';
+import './chunk-3QC3KRHK.js';
+import './chunk-A55DK444.js';
+import './chunk-SD6WQY43.js';
+import './chunk-HF6O3O37.js';
+import './chunk-TTRFSOKR.js';
+import './chunk-3RG5ZIWI.js';