@jmruthers/pace-core 0.6.1 → 0.6.2

package/scripts/audit/core/checks/routes.cjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/**
+ * Route Protection Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/Routes
+ * 
+ * Checks for:
+ * - Routes without PagePermissionGuard
+ * - Incorrect route nesting
+ * - Missing route error boundaries
+ */
+
+const fs = require('fs');
+const { getRelativePath, getLineNumber } = require('../utils.cjs');
+
+const routesCheck = {
+  name: 'routes',
+  description: 'Route protection (PagePermissionGuard, route nesting)',
+  severity: 'error',
+  
+  async run(context) {
+    const { projectRoot, files } = context;
+    const issues = [];
+    const warnings = [];
+    const suggestions = [];
+    
+    if (!files || files.length === 0) {
+      return { issues, warnings, suggestions };
+    }
+    
+    for (const filePath of files) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const relativePath = getRelativePath(filePath, projectRoot);
+        const normalizedPath = relativePath.replace(/\\/g, '/');
+        
+        // Skip pace-core package files - routes check is for consuming applications, not the library itself
+        // Note: Library components (like ProtectedRoute, PaceAppLayout) ARE the route protection components
+        // They don't need to use PagePermissionGuard - they provide the protection functionality
+        const isPaceCorePackage = normalizedPath.includes('packages/core/') || normalizedPath.startsWith('packages/core/');
+        if (isPaceCorePackage) {
+          continue; // Skip library files (including examples)
+        }
+        
+        // Skip root-level src directory - in pace-core repository, this is a demo/showcase app
+        const isRootSrc = normalizedPath.startsWith('src/') && !normalizedPath.includes('packages/');
+        if (isRootSrc) {
+          continue; // Skip demo app files
+        }
+        
+        // Skip scripts directory - utility scripts don't need route protection validation
+        const isScript = normalizedPath.startsWith('scripts/') || normalizedPath.includes('/scripts/');
+        if (isScript) {
+          continue; // Skip script files
+        }
+        
+        // Check for route definitions
+        const routePatterns = [
+          /<Route\s+path=["'][^"']+["']/g,
+          /<Route\s+element\s*=/g,
+          /createBrowserRouter\s*\(/g,
+          /createRoutesFromElements/g
+        ];
+        
+        const hasRoutes = routePatterns.some(pattern => pattern.test(content));
+        
+        if (hasRoutes) {
+          // Check for PagePermissionGuard
+          const hasPagePermissionGuard = content.includes('PagePermissionGuard') ||
+                                       content.includes('from \'@jmruthers/pace-core/rbac\'');
+          
+          if (!hasPagePermissionGuard && !relativePath.includes('test') && !relativePath.includes('spec')) {
+            issues.push({
+              type: 'unprotected-route',
+              file: relativePath,
+              message: 'Route file found without PagePermissionGuard',
+              recommendation: 'Wrap routes with PagePermissionGuard from @jmruthers/pace-core/rbac to enforce permissions'
+            });
+          }
+          
+          // Check for route nesting issues
+          const routeCount = (content.match(/<Route/g) || []).length;
+          if (routeCount > 0) {
+            // Check if routes are properly nested
+            const hasRoutesWrapper = content.includes('<Routes') || content.includes('<BrowserRouter');
+            if (!hasRoutesWrapper) {
+              warnings.push({
+                type: 'route-nesting',
+                file: relativePath,
+                message: 'Route elements found but may not be wrapped in <Routes>',
+                recommendation: 'Ensure all Route elements are wrapped in <Routes> component'
+              });
+            }
+          }
+        }
+        
+        // Check for error boundaries around routes
+        if (hasRoutes && !content.includes('ErrorBoundary') && !content.includes('error-boundary')) {
+          suggestions.push({
+            type: 'missing-route-error-boundary',
+            file: relativePath,
+            message: 'Routes without error boundary',
+            recommendation: 'Wrap routes with ErrorBoundary to catch and handle route errors gracefully'
+          });
+        }
+        
+      } catch (error) {
+        // Skip files with errors
+      }
+    }
+    
+    return { issues, warnings, suggestions };
+  }
+};
+
+module.exports = routesCheck;

package/scripts/audit/core/checks/state.cjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+/**
+ * State Management Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/State
+ * 
+ * Checks for:
+ * - Improper state lifting
+ * - Prop drilling (too many levels)
+ * - Missing state normalization
+ * - Unnecessary global state
+ */
+
+const fs = require('fs');
+const { getRelativePath, getLineNumber } = require('../utils.cjs');
+
+const stateCheck = {
+  name: 'state',
+  description: 'State management patterns (prop drilling, state lifting)',
+  severity: 'suggestion',
+  
+  async run(context) {
+    const { projectRoot, files } = context;
+    const issues = [];
+    const warnings = [];
+    const suggestions = [];
+    
+    if (!files || files.length === 0) {
+      return { issues, warnings, suggestions };
+    }
+    
+    for (const filePath of files) {
+      try {
+        // Only check React component files
+        if (!filePath.match(/\.(tsx|jsx)$/)) {
+          continue;
+        }
+        
+        const content = fs.readFileSync(filePath, 'utf8');
+        const relativePath = getRelativePath(filePath, projectRoot);
+        const normalizedPath = relativePath.replace(/\\/g, '/');
+        
+        // Skip pace-core package files - state check is for consuming applications, not the library itself
+        // Note: Library components are designed to have many props for configurability - this is not prop drilling
+        const isPaceCorePackage = normalizedPath.includes('packages/core/') || normalizedPath.startsWith('packages/core/');
+        if (isPaceCorePackage) {
+          continue; // Skip library files
+        }
+        
+        // Skip root-level src directory - in pace-core repository, this is a demo/showcase app
+        const isRootSrc = normalizedPath.startsWith('src/') && !normalizedPath.includes('packages/');
+        if (isRootSrc) {
+          continue; // Skip demo app files
+        }
+        
+        // Skip scripts directory - utility scripts don't need state management validation
+        const isScript = normalizedPath.startsWith('scripts/') || normalizedPath.includes('/scripts/');
+        if (isScript) {
+          continue; // Skip script files
+        }
+        
+        // Check for prop drilling (component with many props that are just passed through)
+        const componentPattern = /(?:function|const)\s+(\w+)\s*[=\(]\s*\([^)]*\)/g;
+        let match;
+        while ((match = componentPattern.exec(content)) !== null) {
+          const propsMatch = match[0].match(/\(([^)]+)\)/);
+          if (propsMatch) {
+            const props = propsMatch[1].split(',').map(p => p.trim()).filter(p => p);
+            
+            // Check if component has many props (potential prop drilling)
+            if (props.length > 8) {
+              suggestions.push({
+                type: 'many-props',
+                file: relativePath,
+                line: getLineNumber(content, match.index),
+                message: `Component has ${props.length} props - may indicate prop drilling`,
+                recommendation: 'Consider using context or state management library if props are passed through multiple levels'
+              });
+            }
+            
+            // Check if props are just passed through to children
+            const componentBody = content.substring(match.index, Math.min(content.length, match.index + 1000));
+            const passThroughProps = props.filter(prop => {
+              const propName = prop.split(':')[0].trim();
+              return new RegExp(`<\\w+\\s+[^>]*${propName}=`, 'g').test(componentBody);
+            });
+            
+            if (passThroughProps.length > props.length * 0.7 && props.length > 3) {
+              suggestions.push({
+                type: 'prop-drilling',
+                file: relativePath,
+                line: getLineNumber(content, match.index),
+                message: 'Component appears to be passing most props through to children',
+                recommendation: 'Consider lifting state up or using React Context to avoid prop drilling'
+              });
+            }
+          }
+        }
+        
+        // Check for unnecessary useState when data comes from props
+        const useStatePattern = /const\s+\[(\w+),\s*set\w+\]\s*=\s*useState/g;
+        let stateMatch;
+        while ((stateMatch = useStatePattern.exec(content)) !== null) {
+          const stateVar = stateMatch[1];
+          const beforeState = content.substring(Math.max(0, stateMatch.index - 200), stateMatch.index);
+          
+          // Check if there's a prop with the same name
+          const propPattern = new RegExp(`(?:props\\.|\\{\\s*${stateVar}\\s*\\})`, 'g');
+          if (propPattern.test(beforeState)) {
+            suggestions.push({
+              type: 'unnecessary-state',
+              file: relativePath,
+              line: getLineNumber(content, stateMatch.index),
+              message: `State variable '${stateVar}' may duplicate a prop`,
+              recommendation: 'If state comes from props, consider using the prop directly or use derived state pattern'
+            });
+          }
+        }
+        
+      } catch (error) {
+        // Skip files with errors
+      }
+    }
+    
+    return { issues, warnings, suggestions };
+  }
+};
+
+module.exports = stateCheck;

package/scripts/audit/core/checks/structure.cjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/**
+ * File Structure Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/Structure
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const structureCheck = {
+  name: 'structure',
+  description: 'File structure checks (required/recommended directories)',
+  severity: 'error',
+  
+  async run(context) {
+    const { projectRoot } = context;
+    const issues = [];
+    const warnings = [];
+    
+    // Skip structure checks if this is the pace-core repository itself
+    // Structure checks are for consuming applications, not the library repository
+    // Detect pace-core repository by checking if packages/core exists
+    const packagesCorePath = path.join(projectRoot, 'packages', 'core');
+    const isPaceCoreRepository = fs.existsSync(packagesCorePath);
+    
+    if (isPaceCoreRepository) {
+      // This is the pace-core library repository, not a consuming app
+      // Skip structure checks - the library has its own structure
+      return { issues: [], warnings: [], suggestions: [] };
+    }
+    
+    const requiredDirs = ['src'];
+    const recommendedDirs = ['src/components', 'src/hooks', 'src/utils', 'src/pages'];
+    
+    requiredDirs.forEach(dir => {
+      const dirPath = path.join(projectRoot, dir);
+      if (!fs.existsSync(dirPath)) {
+        issues.push({
+          type: 'missing-directory',
+          file: dir,
+          message: `Required directory '${dir}' is missing`,
+          recommendation: `Create the '${dir}' directory`
+        });
+      }
+    });
+    
+    recommendedDirs.forEach(dir => {
+      const dirPath = path.join(projectRoot, dir);
+      if (!fs.existsSync(dirPath)) {
+        warnings.push({
+          type: 'missing-directory',
+          file: dir,
+          message: `Recommended directory '${dir}' is missing`,
+          recommendation: `Consider creating the '${dir}' directory for better organization`
+        });
+      }
+    });
+    
+    return { issues, warnings, suggestions: [] };
+  }
+};
+
+module.exports = structureCheck;