ready-to-ship 1.0.0

package/src/modules/env.js

@@ -0,0 +1,117 @@
+const path = require('path');
+const { fileExists, parseEnvFile, readFile } = require('../utils/fileHelpers');
+const { error, success, verdict, printIssues } = require('../utils/logHelpers');
+const { isValidUrl, isValidEmail, isValidNumber } = require('../utils/parseHelpers');
+
+/**
+ * Validate environment variables
+ */
+async function validate(projectPath = process.cwd()) {
+  const issues = [];
+  const warnings = [];
+  
+  const envPath = path.join(projectPath, '.env');
+  const envExamplePath = path.join(projectPath, '.env.example');
+  
+  // Check if .env exists
+  const envExists = await fileExists(envPath);
+  const envExampleExists = await fileExists(envExamplePath);
+  
+  if (!envExists) {
+    issues.push('MISSING: .env file not found');
+  }
+  
+  if (!envExampleExists) {
+    warnings.push('WARNING: .env.example file not found (recommended for team collaboration)');
+  }
+  
+  // Parse .env.example to get expected variables
+  let expectedVars = {};
+  if (envExampleExists) {
+    expectedVars = await parseEnvFile(envExamplePath);
+  }
+  
+  // Parse .env file
+  let actualVars = {};
+  if (envExists) {
+    actualVars = await parseEnvFile(envPath);
+  }
+  
+  // Check for missing variables
+  const missingVars = Object.keys(expectedVars).filter(key => !(key in actualVars));
+  missingVars.forEach(key => {
+    issues.push(`MISSING: ${key}`);
+  });
+  
+  // Check for weak secrets
+  const secretKeys = Object.keys(actualVars).filter(key => 
+    /SECRET|KEY|PASSWORD|TOKEN/i.test(key)
+  );
+  
+  secretKeys.forEach(key => {
+    const value = actualVars[key];
+    if (!value) {
+      issues.push(`EMPTY: ${key} is empty`);
+    } else if (value.length < 32 && key.toUpperCase().includes('SECRET')) {
+      issues.push(`WEAK SECRET: ${key} (length < 32)`);
+    } else if (value.length < 16 && /PASSWORD|KEY/i.test(key)) {
+      warnings.push(`WEAK: ${key} might be too short (length < 16)`);
+    }
+  });
+  
+  // Check for unused variables (in .env but not in .env.example)
+  if (envExampleExists) {
+    const unusedVars = Object.keys(actualVars).filter(key => 
+      !(key in expectedVars) && !key.startsWith('#')
+    );
+    if (unusedVars.length > 0) {
+      warnings.push(`UNUSED: Variables in .env but not in .env.example: ${unusedVars.join(', ')}`);
+    }
+  }
+  
+  // Type validation (basic checks)
+  Object.keys(actualVars).forEach(key => {
+    const value = actualVars[key];
+    
+    if (key.includes('URL') && value && !isValidUrl(value) && !value.startsWith('${')) {
+      warnings.push(`INVALID URL: ${key} does not appear to be a valid URL`);
+    }
+    
+    if (key.includes('EMAIL') && value && !isValidEmail(value) && !value.startsWith('${')) {
+      warnings.push(`INVALID EMAIL: ${key} does not appear to be a valid email`);
+    }
+    
+    if (key.includes('PORT') && value && !isValidNumber(value)) {
+      warnings.push(`INVALID PORT: ${key} should be a number`);
+    }
+  });
+  
+  // Print results
+  console.log('\n🔹 ENV VALIDATION\n');
+  
+  if (issues.length === 0 && warnings.length === 0) {
+    success('All environment variables are properly configured');
+    verdict(true, 'ENV: READY');
+    return { passed: true, issues: [], warnings: [] };
+  }
+  
+  printIssues(issues, 'error');
+  printIssues(warnings, 'warning');
+  
+  if (issues.length === 0) {
+    verdict(true, 'ENV: READY (with warnings)');
+  } else {
+    verdict(false, 'ENV: NOT READY');
+  }
+  
+  return {
+    passed: issues.length === 0,
+    issues,
+    warnings
+  };
+}
+
+module.exports = {
+  validate
+};
+

package/src/modules/project.js

@@ -0,0 +1,175 @@
+const path = require('path');
+const { fileExists, readFile, getAllFiles } = require('../utils/fileHelpers');
+const { error, success, verdict, printIssues } = require('../utils/logHelpers');
+const { hasErrorHandling } = require('../utils/parseHelpers');
+
+/**
+ * Validate project structure and best practices
+ */
+async function validate(projectPath = process.cwd()) {
+  const issues = [];
+  const warnings = [];
+  
+  // Check for .env.example
+  const envExamplePath = path.join(projectPath, '.env.example');
+  const envExampleExists = await fileExists(envExamplePath);
+  
+  if (!envExampleExists) {
+    issues.push('.env.example missing (required for team collaboration)');
+  }
+  
+  // Check for README
+  const readmePaths = [
+    path.join(projectPath, 'README.md'),
+    path.join(projectPath, 'README.txt'),
+    path.join(projectPath, 'readme.md')
+  ];
+  
+  let readmeExists = false;
+  let readmePath = null;
+  let readmeContent = '';
+  
+  for (const readmePathOption of readmePaths) {
+    if (await fileExists(readmePathOption)) {
+      readmeExists = true;
+      readmePath = readmePathOption;
+      readmeContent = await readFile(readmePathOption) || '';
+      break;
+    }
+  }
+  
+  if (!readmeExists) {
+    issues.push('README missing');
+  } else {
+    // Check if README has meaningful content
+    const meaningfulContent = readmeContent.length > 100;
+    const hasInstallation = /install|setup|getting started/i.test(readmeContent);
+    const hasUsage = /usage|how to|example/i.test(readmeContent);
+    
+    if (!meaningfulContent) {
+      warnings.push('README exists but seems too short or empty');
+    } else if (!hasInstallation && !hasUsage) {
+      warnings.push('README missing installation or usage instructions');
+    }
+  }
+  
+  // Check folder structure
+  const expectedFolders = ['src', 'routes', 'config', 'middleware', 'controllers', 'models'];
+  const existingFolders = [];
+  
+  for (const folder of expectedFolders) {
+    const folderPath = path.join(projectPath, folder);
+    if (await fileExists(folderPath)) {
+      existingFolders.push(folder);
+    }
+  }
+  
+  // Check for src/ or similar structure
+  const srcPath = path.join(projectPath, 'src');
+  const hasSrc = await fileExists(srcPath);
+  
+  if (!hasSrc && existingFolders.length === 0) {
+    warnings.push('No standard project structure detected (src/, routes/, etc.)');
+  }
+  
+  // Check for error handling
+  let hasGlobalErrorHandler = false;
+  const errorHandlerPatterns = [
+    '**/middleware/**/*.{js,ts}',
+    '**/middleware.{js,ts}',
+    '**/error*.{js,ts}',
+    '**/src/**/*.{js,ts}'
+  ];
+  
+  for (const pattern of errorHandlerPatterns) {
+    const files = await require('../utils/fileHelpers').findFiles(pattern, projectPath);
+    for (const filePath of files.slice(0, 10)) { // Limit to first 10 files
+      const code = await readFile(filePath);
+      if (code && hasErrorHandling(code)) {
+        hasGlobalErrorHandler = true;
+        break;
+      }
+    }
+    if (hasGlobalErrorHandler) break;
+  }
+  
+  // Also check main app file
+  if (!hasGlobalErrorHandler) {
+    const mainFiles = await require('../utils/fileHelpers').findFiles('**/{app,server,index,main}.{js,ts}', projectPath);
+    for (const filePath of mainFiles.slice(0, 3)) {
+      const code = await readFile(filePath);
+      if (code && hasErrorHandling(code)) {
+        hasGlobalErrorHandler = true;
+        break;
+      }
+    }
+  }
+  
+  if (!hasGlobalErrorHandler) {
+    issues.push('Error handling middleware not found (recommended: global error handler)');
+  }
+  
+  // Check for package.json
+  const packageJsonPath = path.join(projectPath, 'package.json');
+  const packageJsonExists = await fileExists(packageJsonPath);
+  
+  if (!packageJsonExists) {
+    issues.push('package.json missing');
+  } else {
+    const packageJsonContent = await readFile(packageJsonPath);
+    if (packageJsonContent) {
+      try {
+        const pkg = JSON.parse(packageJsonContent);
+        
+        // Check for start script
+        if (!pkg.scripts || !pkg.scripts.start) {
+          warnings.push('package.json missing "start" script');
+        }
+        
+        // Check for description
+        if (!pkg.description) {
+          warnings.push('package.json missing "description" field');
+        }
+      } catch (e) {
+        warnings.push('package.json might be malformed');
+      }
+    }
+  }
+  
+  // Print results
+  console.log('\n🔹 PROJECT VALIDATION\n');
+  
+  if (readmeExists) {
+    success('README found');
+  }
+  
+  if (envExampleExists) {
+    success('.env.example found');
+  }
+  
+  if (hasGlobalErrorHandler) {
+    success('Error handling found');
+  }
+  
+  if (issues.length === 0 && warnings.length === 0) {
+    success('Project structure looks good');
+    verdict(true, 'PROJECT: READY');
+    return { passed: true, issues: [], warnings: [] };
+  }
+  
+  printIssues(issues, 'error');
+  printIssues(warnings, 'warning');
+  
+  verdict(false, 'PROJECT: NOT READY');
+  
+  return {
+    passed: issues.length === 0,
+    issues,
+    warnings
+  };
+}
+
+module.exports = {
+  validate
+};
+

package/src/modules/report.js

@@ -0,0 +1,118 @@
+const envModule = require('./env');
+const authModule = require('./auth');
+const apiModule = require('./api');
+const projectModule = require('./project');
+const securityModule = require('./security');
+const dependenciesModule = require('./dependencies');
+const databaseModule = require('./database');
+const { header, verdict, error, success } = require('../utils/logHelpers');
+
+/**
+ * Generate comprehensive report combining all checks
+ */
+async function generate(projectPath = process.cwd(), options = {}) {
+  const { json = false, verbose = false, skip = [] } = options;
+  
+  header('READY-TO-SHIP REPORT');
+  
+  // Run all validations (skip specified modules)
+  const allModules = {
+    env: envModule,
+    auth: authModule,
+    api: apiModule,
+    project: projectModule,
+    security: securityModule,
+    dependencies: dependenciesModule,
+    database: databaseModule
+  };
+  
+  const results = {};
+  for (const [name, module] of Object.entries(allModules)) {
+    if (!skip.includes(name)) {
+      results[name] = await module.validate(projectPath);
+    }
+  }
+  
+  // Calculate overall status
+  const allPassed = Object.values(results).every(result => result.passed);
+  
+  // Print summary
+  console.log('\n' + '='.repeat(50));
+  console.log('SUMMARY');
+  console.log('='.repeat(50) + '\n');
+  
+  const statusIcon = (passed) => passed ? '✅' : '❌';
+  const statusText = (passed) => passed ? 'PASS' : 'FAIL';
+  
+  // Print module statuses
+  Object.entries(results).forEach(([name, result]) => {
+    const nameUpper = name.toUpperCase().padEnd(12);
+    console.log(`${nameUpper} ${statusIcon(result.passed)} ${statusText(result.passed)}`);
+  });
+  
+  // Count issues
+  const totalIssues = Object.values(results).reduce((sum, result) => sum + (result.issues?.length || 0), 0);
+  const totalWarnings = Object.values(results).reduce((sum, result) => sum + (result.warnings?.length || 0), 0);
+  
+  console.log('\n' + '='.repeat(50));
+  console.log(`Total Issues: ${totalIssues}`);
+  console.log(`Total Warnings: ${totalWarnings}`);
+  console.log('='.repeat(50) + '\n');
+  
+  // Final verdict
+  if (allPassed) {
+    verdict(true, 'FINAL VERDICT: ✅ READY TO SHIP');
+    success('Your backend project looks ready for deployment!');
+  } else {
+    verdict(false, 'FINAL VERDICT: ❌ NOT READY');
+    error('Please fix the issues above before deploying.');
+    
+    if (verbose) {
+      console.log('\n📋 Detailed Issues:\n');
+      Object.entries(results).forEach(([module, result]) => {
+        if (result.issues && result.issues.length > 0) {
+          console.log(`\n${module.toUpperCase()}:`);
+          result.issues.forEach(issue => error(`  - ${issue}`));
+        }
+        if (result.warnings && result.warnings.length > 0) {
+          result.warnings.forEach(warning => console.log(`  ⚠️  ${warning}`));
+        }
+      });
+    }
+  }
+  
+  // Export to JSON if requested
+  if (json) {
+    const jsonReport = {
+      timestamp: new Date().toISOString(),
+      projectPath,
+      verdict: allPassed ? 'READY' : 'NOT_READY',
+      summary: Object.fromEntries(
+        Object.entries(results).map(([name, result]) => [
+          name,
+          {
+            passed: result.passed,
+            issues: result.issues?.length || 0,
+            warnings: result.warnings?.length || 0
+          }
+        ])
+      ),
+      details: results
+    };
+    
+    const fs = require('fs-extra');
+    const reportPath = require('path').join(projectPath, 'ready-to-ship-report.json');
+    await fs.writeJson(reportPath, jsonReport, { spaces: 2 });
+    console.log(`\n📄 JSON report saved to: ${reportPath}`);
+  }
+  
+  return {
+    passed: allPassed,
+    results
+  };
+}
+
+module.exports = {
+  generate
+};
+

package/src/modules/security.js

@@ -0,0 +1,149 @@
+const path = require('path');
+const { findFiles, readFile } = require('../utils/fileHelpers');
+const { error, success, verdict, printIssues } = require('../utils/logHelpers');
+
+/**
+ * Validate security configurations
+ */
+async function validate(projectPath = process.cwd()) {
+  const issues = [];
+  const warnings = [];
+  
+  // Find main app files
+  const appFiles = await findFiles('**/{app,server,index,main}.{js,ts}', projectPath);
+  const configFiles = await findFiles('**/config/**/*.{js,ts}', projectPath);
+  const middlewareFiles = await findFiles('**/middleware/**/*.{js,ts}', projectPath);
+  
+  const allFiles = [...appFiles, ...configFiles, ...middlewareFiles];
+  
+  let hasCORS = false;
+  let hasHelmet = false;
+  let hasRateLimit = false;
+  let hasSecurityHeaders = false;
+  let corsConfig = null;
+  
+  // Analyze files for security features
+  for (const filePath of allFiles.slice(0, 20)) { // Limit to first 20 files
+    const code = await readFile(filePath);
+    if (!code) continue;
+    
+    // Check for CORS
+    if (/cors|CORS/i.test(code)) {
+      hasCORS = true;
+      const corsMatch = code.match(/cors\s*\([^)]*\)/i);
+      if (corsMatch) {
+        corsConfig = corsMatch[0];
+        // Check for overly permissive CORS
+        if (/origin\s*:\s*['"]\*['"]/i.test(corsConfig)) {
+          issues.push('CORS configured with wildcard origin (*) - security risk');
+        }
+      }
+    }
+    
+    // Check for Helmet.js (security headers)
+    if (/helmet|helmet\(\)/i.test(code)) {
+      hasHelmet = true;
+      hasSecurityHeaders = true;
+    }
+    
+    // Check for security headers manually
+    if (/x-frame-options|x-content-type-options|x-xss-protection|strict-transport-security/i.test(code)) {
+      hasSecurityHeaders = true;
+    }
+    
+    // Check for rate limiting
+    if (/rateLimit|rate-limit|express-rate-limit|limiter/i.test(code)) {
+      hasRateLimit = true;
+    }
+  }
+  
+  // Check package.json for security dependencies
+  const packageJsonPath = path.join(projectPath, 'package.json');
+  const packageJsonContent = await readFile(packageJsonPath);
+  let packageJson = {};
+  
+  if (packageJsonContent) {
+    try {
+      packageJson = JSON.parse(packageJsonContent);
+    } catch (e) {
+      // Invalid JSON
+    }
+  }
+  
+  const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  const securityPackages = {
+    'helmet': 'helmet',
+    'cors': 'cors',
+    'express-rate-limit': 'express-rate-limit',
+    'express-slow-down': 'express-slow-down',
+    'hpp': 'hpp',
+    'xss': 'xss'
+  };
+  
+  Object.keys(securityPackages).forEach(pkg => {
+    if (!deps[pkg] && !hasHelmet && pkg === 'helmet') {
+      warnings.push(`Security package "${pkg}" not found (recommended: npm install ${pkg})`);
+    }
+  });
+  
+  // Security checks
+  if (!hasCORS) {
+    warnings.push('CORS middleware not detected (recommended for API security)');
+  }
+  
+  if (!hasSecurityHeaders) {
+    issues.push('Security headers not configured (use Helmet.js or configure manually)');
+  }
+  
+  if (!hasRateLimit) {
+    warnings.push('Rate limiting not detected (recommended to prevent abuse)');
+  }
+  
+  // Check for common security anti-patterns (exclude node_modules)
+  for (const filePath of allFiles.slice(0, 20)) {
+    // Skip node_modules
+    if (filePath.includes('node_modules')) continue;
+    
+    const code = await readFile(filePath);
+    if (!code) continue;
+    
+    // Check for eval usage
+    if (/\beval\s*\(/i.test(code)) {
+      issues.push(`eval() usage detected in ${path.relative(projectPath, filePath)} - security risk`);
+    }
+    
+    // Check for dangerous regex
+    if (/new RegExp\([^)]*\+/i.test(code)) {
+      warnings.push(`Dynamic regex construction in ${path.relative(projectPath, filePath)} - potential ReDoS risk`);
+    }
+  }
+  
+  // Print results
+  console.log('\n🔹 SECURITY VALIDATION\n');
+  
+  if (hasCORS) success('CORS configured');
+  if (hasSecurityHeaders) success('Security headers configured');
+  if (hasRateLimit) success('Rate limiting detected');
+  
+  if (issues.length === 0 && warnings.length === 0) {
+    success('Security configuration looks good');
+    verdict(true, 'SECURITY: READY');
+    return { passed: true, issues: [], warnings: [] };
+  }
+  
+  printIssues(issues, 'error');
+  printIssues(warnings, 'warning');
+  
+  verdict(false, 'SECURITY: NOT READY');
+  
+  return {
+    passed: issues.length === 0,
+    issues,
+    warnings
+  };
+}
+
+module.exports = {
+  validate
+};
+

package/src/utils/fileHelpers.js

@@ -0,0 +1,95 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { glob } = require('glob');
+
+/**
+ * Read file content safely
+ */
+async function readFile(filePath) {
+  try {
+    return await fs.readFile(filePath, 'utf-8');
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if file exists
+ */
+async function fileExists(filePath) {
+  try {
+    return await fs.pathExists(filePath);
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Find files matching pattern
+ */
+async function findFiles(pattern, cwd = process.cwd()) {
+  try {
+    const files = await glob(pattern, { cwd, absolute: true });
+    return files;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Get all files in directory recursively
+ */
+async function getAllFiles(dir, extensions = ['.js', '.ts', '.jsx', '.tsx']) {
+  const files = [];
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+        files.push(...await getAllFiles(fullPath, extensions));
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        if (extensions.length === 0 || extensions.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (error) {
+    // Directory doesn't exist or permission denied
+  }
+  return files;
+}
+
+/**
+ * Parse .env file
+ */
+async function parseEnvFile(filePath) {
+  const content = await readFile(filePath);
+  if (!content) return {};
+  
+  const env = {};
+  const lines = content.split('\n');
+  
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    
+    const match = trimmed.match(/^([^=]+)=(.*)$/);
+    if (match) {
+      const key = match[1].trim();
+      const value = match[2].trim().replace(/^["']|["']$/g, '');
+      env[key] = value;
+    }
+  }
+  
+  return env;
+}
+
+module.exports = {
+  readFile,
+  fileExists,
+  findFiles,
+  getAllFiles,
+  parseEnvFile
+};
+