@jmruthers/pace-core 0.6.5 → 0.6.7

package/dist/eslint-rules/rules/07-api-tech-stack.cjs

@@ -0,0 +1,263 @@
+/**
+ * API & Tech Stack Rules (Standard 7)
+ * @package @jmruthers/pace-core
+ * @module ESLintRules/rules/api-tech-stack
+ * 
+ * Enforces API and tech stack patterns from Standard 7:
+ * - RPC naming conventions (data_*, app_*)
+ * - React 19+ patterns (no class components)
+ * - import.meta.env usage (Vite) instead of process.env
+ * 
+ * Reference: packages/core/docs/standards/7-api-tech-stack-standards.md
+ */
+
+const { isPaceCoreSourceFile } = require('../utils/helpers.cjs');
+
+module.exports = {
+  rules: {
+    /**
+     * Enforce RPC naming pattern: data_* for reads, app_* for writes
+     */
+    'rpc-naming-pattern': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description: 'Enforce RPC naming pattern: data_* for read operations, app_* for write operations',
+          category: 'Best Practices',
+          recommended: true,
+          url: 'https://github.com/jmruthers/pace-core/blob/main/packages/core/docs/standards/7-api-tech-stack-standards.md'
+        },
+        messages: {
+          invalidRpcNaming: "RPC '{{rpcName}}' does not follow naming pattern. Read operations must start with 'data_', write operations must start with 'app_' (e.g., data_events_list, app_event_create)",
+          invalidRpcVerb: "RPC '{{rpcName}}' uses invalid verb '{{verb}}'. Use only: list, get, create, update, delete, read"
+        },
+        hasSuggestions: true
+      },
+      create(context) {
+        const filename = context.getFilename();
+        
+        // Exclude pace-core source files - these rules are for consuming apps
+        if (isPaceCoreSourceFile(filename)) {
+          return {};
+        }
+        
+        const validVerbs = ['list', 'get', 'create', 'update', 'delete', 'read'];
+        const readVerbs = ['list', 'get', 'read'];
+        const writeVerbs = ['create', 'update', 'delete', 'bulk_create', 'bulk_update'];
+        const rpcPattern = /^(data_|app_)[a-z0-9_]+_(list|get|create|update|delete|read|bulk_create|bulk_update)$/;
+        
+        return {
+          CallExpression(node) {
+            // Check for supabase.rpc('rpc_name', ...)
+            if (node.callee.type === 'MemberExpression' &&
+                node.callee.property &&
+                node.callee.property.name === 'rpc' &&
+                node.arguments.length > 0) {
+              
+              const firstArg = node.arguments[0];
+              if (firstArg.type === 'Literal' && typeof firstArg.value === 'string') {
+                const rpcName = firstArg.value;
+                
+                // Skip if it's a variable (can't validate at lint time)
+                if (firstArg.type !== 'Literal') {
+                  return;
+                }
+                
+                // Check if it matches the pattern
+                if (!rpcPattern.test(rpcName)) {
+                  // Extract verb if possible
+                  const parts = rpcName.split('_');
+                  const verb = parts[parts.length - 1];
+                  
+                  if (validVerbs.includes(verb) || verb.startsWith('bulk_')) {
+                    // Has valid verb but wrong prefix
+                    const isReadOperation = readVerbs.includes(verb);
+                    const isWriteOperation = writeVerbs.includes(verb) || verb.startsWith('bulk_');
+                    
+                    let suggestedPrefix = 'data_';
+                    if (isWriteOperation) {
+                      suggestedPrefix = 'app_';
+                    }
+                    
+                    context.report({
+                      node: firstArg,
+                      messageId: 'invalidRpcNaming',
+                      data: { rpcName },
+                      suggest: [{
+                        desc: `Use '${suggestedPrefix}' prefix for ${isReadOperation ? 'read' : 'write'} operations`,
+                        fix(fixer) {
+                          return null; // Complex fix
+                        }
+                      }]
+                    });
+                  } else {
+                    // Invalid verb
+                    context.report({
+                      node: firstArg,
+                      messageId: 'invalidRpcVerb',
+                      data: { rpcName, verb },
+                      suggest: [{
+                        desc: `Use valid verb: ${validVerbs.join(', ')}`,
+                        fix(fixer) {
+                          return null; // Complex fix
+                        }
+                      }]
+                    });
+                  }
+                } else {
+                  // Check if prefix matches verb type
+                  const hasDataPrefix = rpcName.startsWith('data_');
+                  const hasAppPrefix = rpcName.startsWith('app_');
+                  const parts = rpcName.split('_');
+                  const verb = parts[parts.length - 1];
+                  
+                  const isReadOperation = readVerbs.includes(verb);
+                  const isWriteOperation = writeVerbs.includes(verb) || verb.startsWith('bulk_');
+                  
+                  if (hasDataPrefix && isWriteOperation) {
+                    context.report({
+                      node: firstArg,
+                      messageId: 'invalidRpcNaming',
+                      data: { rpcName },
+                      suggest: [{
+                        desc: `Use 'app_' prefix for write operations (${verb})`,
+                        fix(fixer) {
+                          return null; // Complex fix
+                        }
+                      }]
+                    });
+                  } else if (hasAppPrefix && isReadOperation) {
+                    context.report({
+                      node: firstArg,
+                      messageId: 'invalidRpcNaming',
+                      data: { rpcName },
+                      suggest: [{
+                        desc: `Use 'data_' prefix for read operations (${verb})`,
+                        fix(fixer) {
+                          return null; // Complex fix
+                        }
+                      }]
+                    });
+                  }
+                }
+              }
+            }
+          }
+        };
+      }
+    },
+
+    /**
+     * Enforce React 19+ patterns: no class components
+     */
+    'no-class-components': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description: 'Disallow React class components. Use functional components with hooks (React 19+).',
+          category: 'Best Practices',
+          recommended: true,
+          url: 'https://github.com/jmruthers/pace-core/blob/main/packages/core/docs/standards/7-api-tech-stack-standards.md'
+        },
+        messages: {
+          classComponent: "Class components are not allowed. Use functional components with hooks instead (React 19+)."
+        },
+        hasSuggestions: true
+      },
+      create(context) {
+        const filename = context.getFilename();
+        
+        // Exclude pace-core source files - these rules are for consuming apps
+        if (isPaceCoreSourceFile(filename)) {
+          return {};
+        }
+        
+        return {
+          ClassDeclaration(node) {
+            // Check if class extends React.Component or Component
+            const hasReactExtends = node.superClass && (
+              (node.superClass.type === 'MemberExpression' && 
+               node.superClass.object?.name === 'React' && 
+               node.superClass.property?.name === 'Component') ||
+              (node.superClass.type === 'Identifier' && 
+               node.superClass.name === 'Component')
+            );
+            
+            if (hasReactExtends) {
+              context.report({
+                node,
+                messageId: 'classComponent',
+                suggest: [{
+                  desc: 'Convert to functional component with hooks',
+                  fix(fixer) {
+                    return null; // Complex conversion
+                  }
+                }]
+              });
+            }
+          }
+        };
+      }
+    },
+
+    /**
+     * Enforce import.meta.env usage instead of process.env in client code
+     */
+    'prefer-import-meta-env': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description: 'Enforce import.meta.env (Vite) instead of process.env in client code',
+          category: 'Best Practices',
+          recommended: true,
+          url: 'https://github.com/jmruthers/pace-core/blob/main/packages/core/docs/standards/7-api-tech-stack-standards.md'
+        },
+        messages: {
+          processEnvUsage: "Use 'import.meta.env' (Vite) instead of 'process.env' in client code. process.env is Node.js and won't work in browser."
+        },
+        hasSuggestions: true
+      },
+      create(context) {
+        const filename = context.getFilename();
+        
+        // Exclude pace-core source files - these rules are for consuming apps
+        if (isPaceCoreSourceFile(filename)) {
+          return {};
+        }
+        
+        // Only check client code (not server/Node.js files)
+        const isClientCode = filename.match(/\.(tsx|jsx|ts|js)$/) && 
+                            !filename.includes('server') && 
+                            !filename.includes('node') &&
+                            !filename.includes('config') &&
+                            !filename.match(/\.(config|server)\./);
+        
+        if (!isClientCode) {
+          return {};
+        }
+        
+        return {
+          MemberExpression(node) {
+            // Check for process.env usage
+            if (node.object?.type === 'Identifier' && 
+                node.object.name === 'process' &&
+                node.property?.type === 'Identifier' &&
+                node.property.name === 'env') {
+              context.report({
+                node,
+                messageId: 'processEnvUsage',
+                suggest: [{
+                  desc: 'Replace with import.meta.env',
+                  fix(fixer) {
+                    // Replace process.env with import.meta.env
+                    return fixer.replaceText(node, 'import.meta.env');
+                  }
+                }]
+              });
+            }
+          }
+        };
+      }
+    }
+  }
+};

package/dist/eslint-rules/rules/08-testing.cjs

@@ -0,0 +1,94 @@
+/**
+ * Testing Rules (Standard 8)
+ * @package @jmruthers/pace-core
+ * @module ESLintRules/rules/testing
+ * 
+ * Enforces testing patterns from Standard 8:
+ * - Test file naming conventions (*.test.ts, *.test.tsx)
+ * 
+ * Reference: packages/core/docs/standards/8-testing-documentation-standards.md
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { isPaceCoreSourceFile } = require('../utils/helpers.cjs');
+
+module.exports = {
+  rules: {
+    /**
+     * Enforce test file naming: *.test.ts or *.test.tsx
+     */
+    'test-file-naming': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: 'Enforce test file naming: *.test.ts or *.test.tsx (not *.spec.ts)',
+          category: 'Best Practices',
+          recommended: false,
+          url: 'https://github.com/jmruthers/pace-core/blob/main/packages/core/docs/standards/8-testing-documentation-standards.md'
+        },
+        messages: {
+          invalidTestFileName: "Test file '{{filename}}' should be named '{{expectedName}}.test.{{ext}}' instead of '{{currentName}}'"
+        },
+        hasSuggestions: true
+      },
+      create(context) {
+        const filename = context.getFilename();
+        
+        // Exclude pace-core source files - these rules are for consuming apps
+        if (isPaceCoreSourceFile(filename)) {
+          return {};
+        }
+        
+        // Only check test files
+        const isTestFile = filename.match(/\.(test|spec)\.(ts|tsx|js|jsx)$/);
+        if (!isTestFile) {
+          return {};
+        }
+        
+        const basename = path.basename(filename);
+        const ext = path.extname(filename);
+        const nameWithoutExt = basename.replace(ext, '');
+        
+        // Check if it uses .spec instead of .test
+        if (nameWithoutExt.endsWith('.spec')) {
+          const sourceName = nameWithoutExt.replace('.spec', '');
+          const expectedName = `${sourceName}.test${ext}`;
+          
+          return {
+            Program(node) {
+              context.report({
+                node,
+                messageId: 'invalidTestFileName',
+                data: {
+                  filename: basename,
+                  expectedName,
+                  currentName: basename
+                },
+                suggest: [{
+                  desc: `Rename to ${expectedName}`,
+                  fix(fixer) {
+                    return null; // File rename requires filesystem operation
+                  }
+                }]
+              });
+            }
+          };
+        }
+        
+        // Check if test file is colocated with source file
+        // This is a suggestion, not an error
+        const sourceFile = filename.replace(/\.(test|spec)\.(ts|tsx|js|jsx)$/, '.$2');
+        const sourceExists = fs.existsSync(sourceFile);
+        const isInTestDir = filename.includes('/__tests__/') || filename.includes('/tests/');
+        
+        if (!sourceExists && !isInTestDir) {
+          // Test file exists but source file doesn't - might be misnamed or in wrong location
+          // This is just informational, not an error
+        }
+        
+        return {};
+      }
+    }
+  }
+};

package/dist/eslint-rules/utils/helpers.cjs

@@ -0,0 +1,42 @@
+/**
+ * Shared helper functions for ESLint rules
+ * @package @jmruthers/pace-core
+ * @module ESLintRules/utils/helpers
+ */
+
+// Helper function to get pace-core alternative for restricted imports
+function getPaceCoreAlternative(importSource) {
+  const alternatives = {
+    '@radix-ui/react-avatar': '/components',
+    '@radix-ui/react-checkbox': '/components',
+    '@radix-ui/react-dialog': '/components',
+    '@radix-ui/react-label': '/components',
+    '@radix-ui/react-switch': '/components',
+    '@radix-ui/react-tabs': '/components',
+    '@radix-ui/react-toast': '/components',
+    '@radix-ui/react-tooltip': '/components',
+    'react-day-picker': '/components',
+    '@tanstack/react-table': '/components',
+    'react-hook-form': '/components',
+    'zod': '/utils',
+    'lucide-react': '/icons'
+  };
+  
+  return alternatives[importSource] || '';
+}
+
+/**
+ * Check if a file is in the pace-core source directory
+ * @param {string} filename - The file path to check
+ * @returns {boolean} - True if the file is in packages/core/src
+ */
+function isPaceCoreSourceFile(filename) {
+  // Check for both Unix and Windows path separators
+  return filename.includes('packages/core/src') || filename.includes('packages\\core\\src');
+}
+
+module.exports = {
+  getPaceCoreAlternative,
+  isPaceCoreSourceFile,
+};
+

package/dist/eslint-rules/utils/manifest-loader.cjs

@@ -0,0 +1,75 @@
+/**
+ * Shared utility for loading core-usage-manifest.json
+ * @package @jmruthers/pace-core
+ * @module ESLintRules/utils/manifest-loader
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Load manifest data
+let manifestData = null;
+try {
+  const manifestPath = path.join(__dirname, '../../../core-usage-manifest.json');
+  if (fs.existsSync(manifestPath)) {
+    manifestData = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  }
+} catch (error) {
+  // If manifest can't be loaded, rules will use hardcoded defaults
+  console.warn('Warning: Could not load core-usage-manifest.json, using defaults');
+}
+
+// Get restricted imports from manifest or use defaults
+const getRestrictedImports = () => {
+  if (manifestData && manifestData.restrictedImports) {
+    return manifestData.restrictedImports;
+  }
+  // Fallback defaults
+  return [
+    { module: '@radix-ui/react-avatar', reason: 'Use Avatar component from pace-core instead' },
+    { module: '@radix-ui/react-checkbox', reason: 'Use Checkbox component from pace-core instead' },
+    { module: '@radix-ui/react-dialog', reason: 'Use Dialog component from pace-core instead' },
+    { module: '@radix-ui/react-label', reason: 'Use Label component from pace-core instead' },
+    { module: '@radix-ui/react-slot', reason: 'Use Button component from pace-core which handles slot composition' },
+    { module: '@radix-ui/react-switch', reason: 'Use Switch component from pace-core instead' },
+    { module: '@radix-ui/react-tabs', reason: 'Use Tabs component from pace-core instead' },
+    { module: '@radix-ui/react-toast', reason: 'Use Toast component and useToast hook from pace-core instead' },
+    { module: '@radix-ui/react-tooltip', reason: 'Use Tooltip component from pace-core instead' },
+    { module: 'react-day-picker', reason: 'Use Calendar component from pace-core instead' },
+    { module: '@tanstack/react-table', reason: 'Use DataTable component and related hooks from pace-core instead. DataTable wraps and standardizes table functionality' },
+    { module: 'react-hook-form', reason: 'Use Form component and useZodForm hook from pace-core instead' },
+    { module: 'zod', reason: 'Use validation utilities and schemas from pace-core instead. pace-core provides standardized validation helpers' }
+  ];
+};
+
+// Get pace-core components from manifest or use defaults
+const getPaceCoreComponents = () => {
+  if (manifestData && manifestData.components) {
+    return manifestData.components;
+  }
+  return ['Button', 'Card', 'Dialog', 'Input', 'Form', 'Select', 'Alert', 'Badge', 'Checkbox', 'Switch', 'Textarea', 'Label', 'Table', 'DataTable', 'Toast', 'Tooltip', 'Tabs', 'Calendar', 'Avatar', 'Progress'];
+};
+
+// Get pace-core hooks from manifest or use defaults
+const getPaceCoreHooks = () => {
+  if (manifestData && manifestData.hooks) {
+    return manifestData.hooks;
+  }
+  return ['useToast', 'useDebounce', 'useUnifiedAuth', 'useEvents', 'useOrganisations', 'useFileReference', 'useStorage', 'useZodForm', 'useRBAC', 'usePermissions'];
+};
+
+// Get pace-core utils from manifest or use defaults
+const getPaceCoreUtils = () => {
+  if (manifestData && manifestData.utils) {
+    return manifestData.utils;
+  }
+  return ['formatDate', 'formatCurrency', 'formatNumber', 'formatTime', 'formatDateTime', 'cn', 'validateUserInput', 'sanitizeUserInput', 'hasPermission', 'getAppConfig'];
+};
+
+module.exports = {
+  getRestrictedImports,
+  getPaceCoreComponents,
+  getPaceCoreHooks,
+  getPaceCoreUtils,
+};
+

package/dist/hooks.d.ts

@@ -1,12 +1,12 @@
 export { u as useToast } from './useToast-AyaT-x7p.js';
-import { S as StorageUploadOptions, a as StorageUploadResult, b as StorageListOptions, c as StorageListResult, d as StorageFileInfo } from './usePublicRouteParams-ClnV4tnv.js';
-export { O as OrganisationSecurityHook, l as UseAppConfigReturn, i as UseFormDialogOptions, j as UseFormDialogReturn, U as UseOrganisationPermissionsReturn, F as UsePublicEventLogoOptions, E as UsePublicEventLogoReturn, B as UsePublicEventOptions, A as UsePublicEventReturn, D as UsePublicFileDisplayOptions, C as UsePublicFileDisplayReturn, G as UsePublicRouteParamsReturn, n as clearPublicEventCache, q as clearPublicFileDisplayCache, t as clearPublicLogoCache, z as extractEventCodeFromPath, y as generatePublicRoutePath, o as getPublicEventCacheStats, r as getPublicFileDisplayCacheStats, v as getPublicLogoCacheStats, k as useAppConfig, u as useEventTheme, h as useFormDialog, e as useOrganisationPermissions, f as useOrganisationSecurity, m as usePublicEvent, x as usePublicEventCode, s as usePublicEventLogo, p as usePublicFileDisplay, w as usePublicRouteParams, g as useZodForm } from './usePublicRouteParams-ClnV4tnv.js';
+import { S as StorageUploadOptions, a as StorageUploadResult, b as StorageListOptions, c as StorageListResult, d as StorageFileInfo } from './usePublicRouteParams-MamNgwqe.js';
+export { O as OrganisationSecurityHook, l as UseAppConfigReturn, i as UseFormDialogOptions, j as UseFormDialogReturn, U as UseOrganisationPermissionsReturn, F as UsePublicEventLogoOptions, E as UsePublicEventLogoReturn, B as UsePublicEventOptions, A as UsePublicEventReturn, D as UsePublicFileDisplayOptions, C as UsePublicFileDisplayReturn, G as UsePublicRouteParamsReturn, n as clearPublicEventCache, q as clearPublicFileDisplayCache, t as clearPublicLogoCache, z as extractEventCodeFromPath, y as generatePublicRoutePath, o as getPublicEventCacheStats, r as getPublicFileDisplayCacheStats, v as getPublicLogoCacheStats, k as useAppConfig, u as useEventTheme, h as useFormDialog, e as useOrganisationPermissions, f as useOrganisationSecurity, m as usePublicEvent, x as usePublicEventCode, s as usePublicEventLogo, p as usePublicFileDisplay, w as usePublicRouteParams, g as useZodForm } from './usePublicRouteParams-MamNgwqe.js';
 import * as React$1 from 'react';
 import { SortingState, ColumnFiltersState, ExpandedState } from '@tanstack/react-table';
-import { d as DataRecord, g as PerformanceConfig, S as ServerSideConfig, C as ChunkingConfig, i as SearchIndexConfig, h as PaginationMode, k as ServerSideParams, l as ServerSideResponse, A as AutocompleteOptions, m as GooglePlaceAutocompletePrediction, P as ParsedAddress } from './types-CkbwOr4Y.js';
+import { d as DataRecord, g as PerformanceConfig, S as ServerSideConfig, C as ChunkingConfig, i as SearchIndexConfig, h as PaginationMode, k as ServerSideParams, l as ServerSideResponse, A as AutocompleteOptions, m as GooglePlaceAutocompletePrediction, P as ParsedAddress } from './types-DXstZpNI.js';
 export { u as useComponentPerformance } from './useComponentPerformance-DE9l5RkL.js';
 import { SupabaseClient } from '@supabase/supabase-js';
-import { D as Database } from './database.generated-CzIvgcPu.js';
+import { D as Database } from './database.generated-CcnC_DRc.js';
 import { F as FileCategory, a as FileReference } from './file-reference-BavO2eQj.js';
 import 'react-hook-form';
 import 'zod';
@@ -455,8 +455,8 @@ declare const queryCacheHelpers: {
  *     FileCategory.EVENT_LOGOS
  *   );
  *
- *   if (isLoading) return <div>Loading...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
+ *   if (isLoading) return <p>Loading...</p>;
+ *   if (error) return <p>Error: {error.message}</p>;
  *
  *   return fileUrl ? <img src={fileUrl} alt="File" /> : null;
  * }