@girardmedia/bootspring 1.2.0 → 2.0.3

package/core/deploy-workflow.js

@@ -0,0 +1,836 @@
+/**
+ * Bootspring Deploy Workflow Engine
+ *
+ * Handles deployment workflows with pre-deployment validation,
+ * target detection, and execution.
+ *
+ * @package bootspring
+ * @module core/deploy-workflow
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { execSync, spawn } = require('child_process');
+
+/**
+ * Deployment targets configuration
+ */
+const DEPLOY_TARGETS = {
+  vercel: {
+    name: 'Vercel',
+    description: 'Deploy to Vercel (recommended for Next.js)',
+    detect: ['vercel.json', '.vercel'],
+    cli: 'vercel',
+    installCmd: 'npm install -g vercel',
+    deployCmd: 'vercel --prod',
+    previewCmd: 'vercel',
+    frameworks: ['nextjs', 'react', 'vue', 'svelte', 'nuxt', 'astro'],
+    envFile: '.env.production',
+    docs: 'https://vercel.com/docs'
+  },
+  railway: {
+    name: 'Railway',
+    description: 'Deploy to Railway (great for full-stack apps)',
+    detect: ['railway.json', 'railway.toml', '.railway'],
+    cli: 'railway',
+    installCmd: 'npm install -g @railway/cli',
+    deployCmd: 'railway up',
+    previewCmd: 'railway up --detach',
+    frameworks: ['nextjs', 'node', 'python', 'go', 'rust'],
+    envFile: '.env.production',
+    docs: 'https://docs.railway.app'
+  },
+  fly: {
+    name: 'Fly.io',
+    description: 'Deploy to Fly.io (edge deployment)',
+    detect: ['fly.toml'],
+    cli: 'fly',
+    installCmd: 'curl -L https://fly.io/install.sh | sh',
+    deployCmd: 'fly deploy',
+    previewCmd: 'fly deploy --build-only',
+    frameworks: ['docker', 'node', 'go', 'rust', 'python'],
+    envFile: '.env.production',
+    docs: 'https://fly.io/docs'
+  },
+  netlify: {
+    name: 'Netlify',
+    description: 'Deploy to Netlify (static sites & serverless)',
+    detect: ['netlify.toml', '.netlify'],
+    cli: 'netlify',
+    installCmd: 'npm install -g netlify-cli',
+    deployCmd: 'netlify deploy --prod',
+    previewCmd: 'netlify deploy',
+    frameworks: ['react', 'vue', 'svelte', 'gatsby', 'astro', 'nextjs'],
+    envFile: '.env.production',
+    docs: 'https://docs.netlify.com'
+  },
+  docker: {
+    name: 'Docker',
+    description: 'Build Docker image for deployment',
+    detect: ['Dockerfile', 'docker-compose.yml', 'docker-compose.yaml'],
+    cli: 'docker',
+    installCmd: 'Install Docker Desktop from https://docker.com',
+    deployCmd: 'docker build -t app . && docker push',
+    previewCmd: 'docker build -t app .',
+    frameworks: ['any'],
+    envFile: '.env.production',
+    docs: 'https://docs.docker.com'
+  },
+  aws: {
+    name: 'AWS Amplify',
+    description: 'Deploy to AWS Amplify',
+    detect: ['amplify.yml', 'amplify'],
+    cli: 'amplify',
+    installCmd: 'npm install -g @aws-amplify/cli',
+    deployCmd: 'amplify push',
+    previewCmd: 'amplify status',
+    frameworks: ['react', 'nextjs', 'vue', 'angular'],
+    envFile: '.env.production',
+    docs: 'https://docs.amplify.aws'
+  }
+};
+
+/**
+ * Deployment phases
+ */
+const DEPLOY_PHASES = {
+  validate: {
+    name: 'Pre-flight Validation',
+    description: 'Validate project readiness for deployment',
+    required: true
+  },
+  target: {
+    name: 'Target Detection',
+    description: 'Detect or configure deployment target',
+    required: true
+  },
+  build: {
+    name: 'Build',
+    description: 'Build production assets',
+    required: true
+  },
+  quality: {
+    name: 'Quality Checks',
+    description: 'Run pre-deploy quality gates',
+    required: false
+  },
+  deploy: {
+    name: 'Deploy',
+    description: 'Execute deployment',
+    required: true
+  },
+  verify: {
+    name: 'Verification',
+    description: 'Verify deployment success',
+    required: false
+  }
+};
+
+/**
+ * DeployWorkflowEngine class
+ */
+class DeployWorkflowEngine {
+  constructor(projectRoot, options = {}) {
+    this.projectRoot = projectRoot;
+    this.bootspringDir = path.join(projectRoot, '.bootspring');
+    this.deployDir = path.join(this.bootspringDir, 'deploy');
+    this.statePath = path.join(this.deployDir, 'workflow-state.json');
+    this.options = options;
+    this.state = null;
+  }
+
+  /**
+   * Check if workflow exists
+   */
+  hasWorkflow() {
+    return fs.existsSync(this.statePath);
+  }
+
+  /**
+   * Initialize workflow
+   */
+  initializeWorkflow(target = null) {
+    // Ensure directories exist
+    if (!fs.existsSync(this.deployDir)) {
+      fs.mkdirSync(this.deployDir, { recursive: true });
+    }
+
+    this.state = {
+      version: '1.0.0',
+      startedAt: new Date().toISOString(),
+      lastUpdated: new Date().toISOString(),
+      target: target,
+      phases: {},
+      config: {
+        dryRun: this.options.dryRun || false,
+        skipQuality: this.options.skipQuality || false,
+        env: this.options.env || 'production'
+      },
+      history: []
+    };
+
+    // Initialize phases
+    for (const [phaseId, phase] of Object.entries(DEPLOY_PHASES)) {
+      this.state.phases[phaseId] = {
+        name: phase.name,
+        status: 'pending',
+        required: phase.required,
+        startedAt: null,
+        completedAt: null,
+        result: null,
+        error: null
+      };
+    }
+
+    this.saveState();
+  }
+
+  /**
+   * Load state
+   */
+  loadState() {
+    if (fs.existsSync(this.statePath)) {
+      this.state = JSON.parse(fs.readFileSync(this.statePath, 'utf-8'));
+    }
+    return this.state;
+  }
+
+  /**
+   * Save state
+   */
+  saveState() {
+    this.state.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+  }
+
+  /**
+   * Get next phase
+   */
+  getNextPhase() {
+    const phaseOrder = ['validate', 'target', 'build', 'quality', 'deploy', 'verify'];
+
+    for (const phaseId of phaseOrder) {
+      const phase = this.state.phases[phaseId];
+      if (phase.status === 'pending' || phase.status === 'in_progress') {
+        return phaseId;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Start phase
+   */
+  startPhase(phaseId) {
+    this.state.phases[phaseId].status = 'in_progress';
+    this.state.phases[phaseId].startedAt = new Date().toISOString();
+    this.saveState();
+  }
+
+  /**
+   * Complete phase
+   */
+  completePhase(phaseId, result = null) {
+    this.state.phases[phaseId].status = 'completed';
+    this.state.phases[phaseId].completedAt = new Date().toISOString();
+    this.state.phases[phaseId].result = result;
+    this.state.history.push({
+      phase: phaseId,
+      action: 'completed',
+      timestamp: new Date().toISOString()
+    });
+    this.saveState();
+  }
+
+  /**
+   * Fail phase
+   */
+  failPhase(phaseId, error) {
+    this.state.phases[phaseId].status = 'failed';
+    this.state.phases[phaseId].completedAt = new Date().toISOString();
+    this.state.phases[phaseId].error = error;
+    this.saveState();
+  }
+
+  /**
+   * Skip phase
+   */
+  skipPhase(phaseId) {
+    this.state.phases[phaseId].status = 'skipped';
+    this.saveState();
+  }
+
+  /**
+   * Get progress
+   */
+  getProgress() {
+    const phases = Object.entries(this.state.phases).map(([id, phase]) => ({
+      id,
+      ...phase
+    }));
+
+    const completed = phases.filter(p => p.status === 'completed').length;
+    const total = phases.filter(p => p.required).length;
+
+    return {
+      phases,
+      target: this.state.target,
+      overall: {
+        completed,
+        total,
+        percentage: Math.round((completed / total) * 100)
+      },
+      startedAt: this.state.startedAt,
+      lastUpdated: this.state.lastUpdated,
+      isComplete: phases.every(p =>
+        p.status === 'completed' || p.status === 'skipped' || !p.required
+      )
+    };
+  }
+
+  /**
+   * Reset workflow
+   */
+  resetWorkflow() {
+    if (fs.existsSync(this.deployDir)) {
+      fs.rmSync(this.deployDir, { recursive: true });
+    }
+    this.state = null;
+  }
+
+  // ==========================================
+  // Phase Implementations
+  // ==========================================
+
+  /**
+   * Run validation phase
+   */
+  async runValidation() {
+    const checks = {
+      packageJson: false,
+      nodeModules: false,
+      buildScript: false,
+      gitClean: false,
+      envFile: false
+    };
+
+    const issues = [];
+    const warnings = [];
+
+    // Check package.json
+    const packageJsonPath = path.join(this.projectRoot, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      checks.packageJson = true;
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+      // Check build script
+      if (pkg.scripts?.build) {
+        checks.buildScript = true;
+      } else {
+        issues.push('No build script found in package.json');
+      }
+    } else {
+      issues.push('No package.json found');
+    }
+
+    // Check node_modules
+    if (fs.existsSync(path.join(this.projectRoot, 'node_modules'))) {
+      checks.nodeModules = true;
+    } else {
+      warnings.push('node_modules not found - run npm install first');
+    }
+
+    // Check git status
+    try {
+      const gitStatus = execSync('git status --porcelain', {
+        cwd: this.projectRoot,
+        encoding: 'utf-8'
+      });
+      if (!gitStatus.trim()) {
+        checks.gitClean = true;
+      } else {
+        warnings.push('Uncommitted changes detected');
+      }
+    } catch {
+      warnings.push('Not a git repository');
+    }
+
+    // Check .env.production or .env.local
+    const envPaths = ['.env.production', '.env.local', '.env'];
+    for (const envPath of envPaths) {
+      if (fs.existsSync(path.join(this.projectRoot, envPath))) {
+        checks.envFile = true;
+        break;
+      }
+    }
+    if (!checks.envFile) {
+      warnings.push('No environment file found (.env.production, .env.local, or .env)');
+    }
+
+    const passed = issues.length === 0;
+
+    return {
+      passed,
+      checks,
+      issues,
+      warnings,
+      summary: passed ? 'Validation passed' : `${issues.length} issues found`
+    };
+  }
+
+  /**
+   * Detect deployment target
+   */
+  async detectTarget() {
+    const detected = [];
+    const recommendations = [];
+
+    // Check for existing configs
+    for (const [targetId, target] of Object.entries(DEPLOY_TARGETS)) {
+      for (const detectFile of target.detect) {
+        const filePath = path.join(this.projectRoot, detectFile);
+        if (fs.existsSync(filePath)) {
+          detected.push({
+            id: targetId,
+            name: target.name,
+            file: detectFile,
+            confidence: 'high'
+          });
+          break;
+        }
+      }
+    }
+
+    // Check CLI availability
+    const available = [];
+    for (const [targetId, target] of Object.entries(DEPLOY_TARGETS)) {
+      if (this.checkCliInstalled(target.cli)) {
+        available.push({
+          id: targetId,
+          name: target.name,
+          cli: target.cli
+        });
+      }
+    }
+
+    // Detect framework and recommend
+    const framework = this.detectFramework();
+    if (framework) {
+      for (const [targetId, target] of Object.entries(DEPLOY_TARGETS)) {
+        if (target.frameworks.includes(framework) || target.frameworks.includes('any')) {
+          recommendations.push({
+            id: targetId,
+            name: target.name,
+            reason: `Works well with ${framework}`
+          });
+        }
+      }
+    }
+
+    // Set state target if exactly one detected
+    if (detected.length === 1 && !this.state.target) {
+      this.state.target = detected[0].id;
+    }
+
+    return {
+      detected,
+      available,
+      recommendations,
+      framework,
+      selected: this.state.target
+    };
+  }
+
+  /**
+   * Check if CLI is installed
+   */
+  checkCliInstalled(cli) {
+    try {
+      execSync(`which ${cli}`, { encoding: 'utf-8', stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Detect framework
+   */
+  detectFramework() {
+    const packageJsonPath = path.join(this.projectRoot, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) return null;
+
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    if (deps.next) return 'nextjs';
+    if (deps['@angular/core']) return 'angular';
+    if (deps.vue) return 'vue';
+    if (deps.svelte) return 'svelte';
+    if (deps.gatsby) return 'gatsby';
+    if (deps.astro) return 'astro';
+    if (deps.nuxt) return 'nuxt';
+    if (deps.react) return 'react';
+    if (deps.express) return 'node';
+
+    return null;
+  }
+
+  /**
+   * Set target
+   */
+  setTarget(targetId) {
+    if (!DEPLOY_TARGETS[targetId]) {
+      throw new Error(`Unknown target: ${targetId}`);
+    }
+    this.state.target = targetId;
+    this.saveState();
+  }
+
+  /**
+   * Run build phase
+   */
+  async runBuild() {
+    const packageJsonPath = path.join(this.projectRoot, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+    const buildScript = pkg.scripts?.build;
+    if (!buildScript) {
+      throw new Error('No build script found');
+    }
+
+    if (this.state.config.dryRun) {
+      return {
+        dryRun: true,
+        command: 'npm run build',
+        skipped: true
+      };
+    }
+
+    // Execute build
+    return new Promise((resolve, reject) => {
+      const buildProcess = spawn('npm', ['run', 'build'], {
+        cwd: this.projectRoot,
+        stdio: 'pipe',
+        shell: true
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      buildProcess.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      buildProcess.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      buildProcess.on('close', (code) => {
+        if (code === 0) {
+          resolve({
+            success: true,
+            command: 'npm run build',
+            output: stdout.slice(-500) // Last 500 chars
+          });
+        } else {
+          reject(new Error(`Build failed with code ${code}: ${stderr.slice(-200)}`));
+        }
+      });
+    });
+  }
+
+  /**
+   * Run quality checks
+   */
+  async runQualityChecks() {
+    if (this.state.config.skipQuality) {
+      return { skipped: true };
+    }
+
+    const checks = {
+      lint: { passed: null, output: '' },
+      typecheck: { passed: null, output: '' },
+      test: { passed: null, output: '' }
+    };
+
+    const packageJsonPath = path.join(this.projectRoot, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+    // Run lint if available
+    if (pkg.scripts?.lint) {
+      try {
+        execSync('npm run lint', { cwd: this.projectRoot, encoding: 'utf-8', stdio: 'pipe' });
+        checks.lint.passed = true;
+      } catch (error) {
+        checks.lint.passed = false;
+        checks.lint.output = error.message;
+      }
+    }
+
+    // Run typecheck if TypeScript
+    if (pkg.scripts?.typecheck || pkg.scripts?.['type-check']) {
+      const script = pkg.scripts.typecheck ? 'typecheck' : 'type-check';
+      try {
+        execSync(`npm run ${script}`, { cwd: this.projectRoot, encoding: 'utf-8', stdio: 'pipe' });
+        checks.typecheck.passed = true;
+      } catch (error) {
+        checks.typecheck.passed = false;
+        checks.typecheck.output = error.message;
+      }
+    }
+
+    // Run tests if available (but don't fail deploy on test failure)
+    if (pkg.scripts?.test) {
+      try {
+        execSync('npm test -- --passWithNoTests', { cwd: this.projectRoot, encoding: 'utf-8', stdio: 'pipe' });
+        checks.test.passed = true;
+      } catch {
+        checks.test.passed = false;
+        // Don't fail on test failures, just warn
+      }
+    }
+
+    const allPassed = Object.values(checks).every(c => c.passed === null || c.passed === true);
+
+    return {
+      passed: allPassed,
+      checks,
+      summary: allPassed ? 'All quality checks passed' : 'Some checks failed'
+    };
+  }
+
+  /**
+   * Run deployment
+   */
+  async runDeploy() {
+    const target = DEPLOY_TARGETS[this.state.target];
+    if (!target) {
+      throw new Error('No deployment target configured');
+    }
+
+    // Check CLI is installed
+    if (!this.checkCliInstalled(target.cli)) {
+      throw new Error(`${target.cli} CLI not installed. Run: ${target.installCmd}`);
+    }
+
+    if (this.state.config.dryRun) {
+      return {
+        dryRun: true,
+        target: target.name,
+        command: target.deployCmd,
+        skipped: true
+      };
+    }
+
+    // Execute deployment
+    const deployCmd = this.state.config.env === 'preview' ? target.previewCmd : target.deployCmd;
+
+    return new Promise((resolve, reject) => {
+      const deployProcess = spawn(deployCmd, [], {
+        cwd: this.projectRoot,
+        stdio: 'pipe',
+        shell: true
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      deployProcess.stdout.on('data', (data) => {
+        stdout += data.toString();
+        process.stdout.write(data);
+      });
+
+      deployProcess.stderr.on('data', (data) => {
+        stderr += data.toString();
+        process.stderr.write(data);
+      });
+
+      deployProcess.on('close', (code) => {
+        if (code === 0) {
+          // Try to extract URL from output
+          const urlMatch = stdout.match(/https?:\/\/[^\s]+/);
+          resolve({
+            success: true,
+            target: target.name,
+            url: urlMatch ? urlMatch[0] : null,
+            output: stdout.slice(-500)
+          });
+        } else {
+          reject(new Error(`Deployment failed with code ${code}`));
+        }
+      });
+    });
+  }
+
+  /**
+   * Run verification
+   */
+  async runVerification() {
+    const deployResult = this.state.phases.deploy.result;
+
+    if (!deployResult?.url) {
+      return {
+        skipped: true,
+        reason: 'No deployment URL available'
+      };
+    }
+
+    // Simple HTTP check
+    try {
+      const https = require('https');
+      const http = require('http');
+      const protocol = deployResult.url.startsWith('https') ? https : http;
+
+      return new Promise((resolve) => {
+        const req = protocol.get(deployResult.url, (res) => {
+          resolve({
+            passed: res.statusCode >= 200 && res.statusCode < 400,
+            statusCode: res.statusCode,
+            url: deployResult.url
+          });
+        });
+
+        req.on('error', () => {
+          resolve({
+            passed: false,
+            error: 'Could not reach deployment URL'
+          });
+        });
+
+        req.setTimeout(10000, () => {
+          req.destroy();
+          resolve({
+            passed: false,
+            error: 'Request timed out'
+          });
+        });
+      });
+    } catch {
+      return {
+        skipped: true,
+        reason: 'Verification not available'
+      };
+    }
+  }
+
+  /**
+   * Get target info
+   */
+  getTargetInfo(targetId) {
+    return DEPLOY_TARGETS[targetId] || null;
+  }
+
+  /**
+   * Get all targets
+   */
+  getAllTargets() {
+    return Object.entries(DEPLOY_TARGETS).map(([id, target]) => ({
+      id,
+      ...target
+    }));
+  }
+
+  /**
+   * Generate deployment config for target
+   */
+  generateTargetConfig(targetId) {
+    const target = DEPLOY_TARGETS[targetId];
+    if (!target) return null;
+
+    switch (targetId) {
+      case 'vercel':
+        return {
+          file: 'vercel.json',
+          content: JSON.stringify({
+            '$schema': 'https://openapi.vercel.sh/vercel.json',
+            'buildCommand': 'npm run build',
+            'devCommand': 'npm run dev',
+            'installCommand': 'npm install'
+          }, null, 2)
+        };
+
+      case 'railway':
+        return {
+          file: 'railway.toml',
+          content: `[build]
+builder = "nixpacks"
+
+[deploy]
+startCommand = "npm start"
+restartPolicyType = "on_failure"
+restartPolicyMaxRetries = 3
+`
+        };
+
+      case 'fly':
+        return {
+          file: 'fly.toml',
+          content: `app = "my-app"
+primary_region = "iad"
+
+[build]
+  builder = "heroku/buildpacks:20"
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+`
+        };
+
+      case 'netlify':
+        return {
+          file: 'netlify.toml',
+          content: `[build]
+  command = "npm run build"
+  publish = ".next"
+
+[[plugins]]
+  package = "@netlify/plugin-nextjs"
+`
+        };
+
+      case 'docker':
+        return {
+          file: 'Dockerfile',
+          content: `FROM node:20-alpine AS base
+
+FROM base AS deps
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN npm run build
+
+FROM base AS runner
+WORKDIR /app
+ENV NODE_ENV production
+COPY --from=builder /app/public ./public
+COPY --from=builder /app/.next/standalone ./
+COPY --from=builder /app/.next/static ./.next/static
+
+EXPOSE 3000
+ENV PORT 3000
+CMD ["node", "server.js"]
+`
+        };
+
+      default:
+        return null;
+    }
+  }
+}
+
+module.exports = {
+  DeployWorkflowEngine,
+  DEPLOY_TARGETS,
+  DEPLOY_PHASES
+};