@ordojs/cli/dist/utils/deployment/cicd-generator.js

Command-line interface for OrdoJS framework

/**
 * @fileoverview OrdoJS CLI - CI/CD pipeline generator
 */
import { CLIError, ErrorType } from '../index.js';
/**
 * CI/CD pipeline generator for OrdoJS applications
 */
export class CICDGenerator {
    defaultConfig = {
        platform: 'github',
        nodeVersion: '18',
        pnpmVersion: '8',
        testCommand: 'pnpm test',
        buildCommand: 'pnpm build',
        deployCommand: 'pnpm deploy',
        cacheDependencies: true,
        runTests: true,
        runLinting: true,
        runSecurityScan: true,
        autoDeploy: false,
        environments: ['production', 'staging'],
        secrets: []
    };
    /**
     * Generate CI/CD pipeline configuration
     */
    generatePipeline(config, options = {}) {
        const cicdConfig = this.mergeConfig(options);
        try {
            switch (cicdConfig.platform) {
                case 'github':
                    return this.generateGitHubActions(cicdConfig, config);
                case 'gitlab':
                    return this.generateGitLabCI(cicdConfig, config);
                case 'jenkins':
                    return this.generateJenkinsPipeline(cicdConfig, config);
                default:
                    throw new Error(`Unsupported platform: ${cicdConfig.platform}`);
            }
        }
        catch (error) {
            throw new CLIError(`Failed to generate CI/CD pipeline: ${error instanceof Error ? error.message : String(error)}`, ErrorType.DEPLOYMENT, 'CICD-001');
        }
    }
    /**
     * Generate GitHub Actions workflow
     */
    generateGitHubActions(config, deploymentConfig) {
        return `name: OrdoJS CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

env:
  NODE_VERSION: '${config.nodeVersion}'
  PNPM_VERSION: '${config.pnpmVersion}'

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: \${{ env.NODE_VERSION }}

    - name: Setup pnpm
      uses: pnpm/action-setup@v2
      with:
        version: \${{ env.PNPM_VERSION }}

    - name: Get pnpm store directory
      shell: bash
      run: |
        echo "STORE_PATH=\\\${{ pnpm store path }}" >> \$GITHUB_ENV

    - name: Setup pnpm cache
      uses: actions/cache@v3
      with:
        path: \${{ env.STORE_PATH }}
        key: \${{ runner.os }}-pnpm-store-\${{ hashFiles('**/pnpm-lock.yaml') }}
        restore-keys: |
          \${{ runner.os }}-pnpm-store-

    - name: Install dependencies
      run: pnpm install --frozen-lockfile

    ${config.runLinting ? this.generateLintingStep() : ''}
    ${config.runTests ? this.generateTestStep() : ''}
    ${config.runSecurityScan ? this.generateSecurityScanStep() : ''}

  build:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' || github.event_name == 'pull_request'
    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: \${{ env.NODE_VERSION }}

    - name: Setup pnpm
      uses: pnpm/action-setup@v2
      with:
        version: \${{ env.PNPM_VERSION }}

    - name: Get pnpm store directory
      shell: bash
      run: |
        echo "STORE_PATH=\\\${{ pnpm store path }}" >> \$GITHUB_ENV

    - name: Setup pnpm cache
      uses: actions/cache@v3
      with:
        path: \${{ env.STORE_PATH }}
        key: \${{ runner.os }}-pnpm-store-\${{ hashFiles('**/pnpm-lock.yaml') }}
        restore-keys: |
          \${{ runner.os }}-pnpm-store-

    - name: Install dependencies
      run: pnpm install --frozen-lockfile

    - name: Build application
      run: ${config.buildCommand}

    - name: Upload build artifacts
      uses: actions/upload-artifact@v3
      with:
        name: build-artifacts
        path: dist/

  ${config.autoDeploy ? this.generateDeployJob(config) : ''}
`;
    }
    /**
     * Generate GitLab CI configuration
     */
    generateGitLabCI(config, deploymentConfig) {
        return `# GitLab CI/CD Pipeline for OrdoJS
image: node:${config.nodeVersion}-alpine

variables:
  PNPM_VERSION: "${config.pnpmVersion}"

cache:
  paths:
    - node_modules/
    - .pnpm-store/

stages:
  - test
  - build
  ${config.autoDeploy ? '- deploy' : ''}

before_script:
  - npm install -g pnpm@${config.pnpmVersion}
  - pnpm install --frozen-lockfile

test:
  stage: test
  script:
    ${config.runLinting ? `- pnpm lint` : ''}
    ${config.runTests ? `- ${config.testCommand}` : ''}
    ${config.runSecurityScan ? `- pnpm audit` : ''}
  artifacts:
    reports:
      junit: test-results.xml
    expire_in: 1 week

build:
  stage: build
  script:
    - ${config.buildCommand}
  artifacts:
    paths:
      - dist/
    expire_in: 1 week
  only:
    - main
    - develop

${config.autoDeploy ? this.generateGitLabDeployStage(config) : ''}
`;
    }
    /**
     * Generate Jenkins pipeline
     */
    generateJenkinsPipeline(config, deploymentConfig) {
        return `pipeline {
    agent {
        docker {
            image 'node:${config.nodeVersion}-alpine'
            args '-u root'
        }
    }

    environment {
        PNPM_VERSION = '${config.pnpmVersion}'
        NODE_ENV = 'production'
    }

    stages {
        stage('Setup') {
            steps {
                sh 'npm install -g pnpm@${config.pnpmVersion}'
                sh 'pnpm install --frozen-lockfile'
            }
        }

        ${config.runLinting ? `
        stage('Lint') {
            steps {
                sh 'pnpm lint'
            }
        }` : ''}

        ${config.runTests ? `
        stage('Test') {
            steps {
                sh '${config.testCommand}'
            }
            post {
                always {
                    publishHTML([
                        allowMissing: false,
                        alwaysLinkToLastBuild: true,
                        keepAll: true,
                        reportDir: 'coverage',
                        reportFiles: 'index.html',
                        reportName: 'Coverage Report'
                    ])
                }
            }
        }` : ''}

        ${config.runSecurityScan ? `
        stage('Security Scan') {
            steps {
                sh 'pnpm audit'
            }
        }` : ''}

        stage('Build') {
            steps {
                sh '${config.buildCommand}'
            }
            post {
                success {
                    archiveArtifacts artifacts: 'dist/**/*', fingerprint: true
                }
            }
        }

        ${config.autoDeploy ? `
        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                sh '${config.deployCommand}'
            }
        }` : ''}
    }

    post {
        always {
            cleanWs()
        }
        success {
            echo 'Pipeline completed successfully!'
        }
        failure {
            echo 'Pipeline failed!'
        }
    }
}`;
    }
    /**
     * Generate deployment job for GitHub Actions
     */
    generateDeployJob(config) {
        return `
  deploy:
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    environment: production
    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Download build artifacts
      uses: actions/download-artifact@v3
      with:
        name: build-artifacts
        path: dist/

    - name: Deploy to production
      run: ${config.deployCommand}
      env:
        ${config.secrets.map(secret => `${secret}: \${{ secrets.${secret} }}`).join('\n        ')}
`;
    }
    /**
     * Generate GitLab deploy stage
     */
    generateGitLabDeployStage(config) {
        return `
deploy:
  stage: deploy
  script:
    - ${config.deployCommand}
  environment:
    name: production
  only:
    - main
  when: manual
`;
    }
    /**
     * Generate linting step for GitHub Actions
     */
    generateLintingStep() {
        return `
    - name: Run linting
      run: pnpm lint`;
    }
    /**
     * Generate test step for GitHub Actions
     */
    generateTestStep() {
        return `
    - name: Run tests
      run: ${this.defaultConfig.testCommand}
      env:
        CI: true`;
    }
    /**
     * Generate security scan step for GitHub Actions
     */
    generateSecurityScanStep() {
        return `
    - name: Security scan
      run: pnpm audit`;
    }
    mergeConfig(options) {
        return {
            ...this.defaultConfig,
            ...options,
            environments: [...this.defaultConfig.environments, ...(options.environments || [])],
            secrets: [...this.defaultConfig.secrets, ...(options.secrets || [])]
        };
    }
}
//# sourceMappingURL=cicd-generator.js.map