# Initialize collection
mkdir fullstack-tools && cd fullstack-tools
dr export . fullstack-tools --git

# Create collection structure
mkdir -p bin/{frontend,backend,database,deployment}
mkdir -p docs/{frontend,backend,database,deployment}
mkdir -p helpers

#!/usr/bin/env bash
### DOC
# Start React development server with hot reload
# Includes environment setup and dependency checks
### DOC
set -euo pipefail

source "$DR_CONFIG/helpers/pkg.sh"
validatePkg node npm

main() {
  if [[ ! -f "package.json" ]]; then
    echo "❌ No package.json found. Run from React project root."
    exit 1
  fi

  echo "🚀 Starting React development server..."

  # Install dependencies if node_modules missing
  if [[ ! -d "node_modules" ]]; then
    echo "📦 Installing dependencies..."
    npm install
  fi

  # Start development server
  BROWSER=none npm start

  echo "✅ Development server started at http://localhost:3000"
}

main "$@"

#!/usr/bin/env bash
### DOC
# Build optimized production React bundle
# Includes bundle analysis and size warnings
### DOC
set -euo pipefail

source "$DR_CONFIG/helpers/pkg.sh"
validatePkg node npm

main() {
  echo "🏗️  Building production React app..."

  # Clean previous build
  rm -rf build/

  # Build with production optimizations
  NODE_ENV=production npm run build

  # Show build info
  echo "📊 Build completed!"
  echo "📁 Build size:"
  du -sh build/

  # Check for large files
  echo "🔍 Large files (>500KB):"
  find build/ -size +500k -type f -exec ls -lh {} \; | awk '{ print $5 "\t" $9 }'

  echo "✅ Production build ready in build/ directory"
}

main "$@"

#!/usr/bin/env bash
### DOC
# Run comprehensive frontend test suite
# Includes unit tests, integration tests, and coverage
### DOC
set -euo pipefail

source "$DR_CONFIG/helpers/pkg.sh"
validatePkg node npm

main() {
  local test_type="${1:-all}"

  echo "🧪 Running frontend tests: $test_type"

  case "$test_type" in
    unit)
      npm run test:unit -- --coverage
      ;;
    integration)
      npm run test:integration
      ;;
    e2e)
      npm run test:e2e
      ;;
    all | *)
      echo "🔬 Running unit tests..."
      npm run test:unit -- --coverage

      echo "🔗 Running integration tests..."
      npm run test:integration

      echo "🌐 Running E2E tests..."
      npm run test:e2e
      ;;
  esac

  echo "✅ Frontend tests completed!"
}

main "$@"

#!/usr/bin/env bash
### DOC
# Start Node.js backend with auto-restart
# Includes database connection check
### DOC
set -euo pipefail

source "$DR_CONFIG/helpers/pkg.sh"
validatePkg node npm

main() {
  if [[ ! -f "server.js" && ! -f "app.js" && ! -f "index.js" ]]; then
    echo "❌ No main server file found"
    exit 1
  fi

  echo "🚀 Starting Node.js development server..."

  # Check database connection
  if ! dr backend/check-db-connection; then
    echo "⚠️  Database connection failed, starting anyway..."
  fi

  # Install dependencies
  if [[ ! -d "node_modules" ]]; then
    npm install
  fi

  # Start with nodemon for auto-restart
  if command -v nodemon >/dev/null; then
    nodemon server.js
  else
    echo "💡 Tip: Install nodemon for auto-restart: npm install -g nodemon"
    node server.js
  fi
}

main "$@"

#!/usr/bin/env bash
### DOC
# Verify database connection and schema
### DOC
set -euo pipefail

source "$DR_CONFIG/helpers/pkg.sh"
validatePkg psql

main() {
  local db_url="${DATABASE_URL:-postgresql://localhost:5432/myapp}"

  echo "🔍 Checking database connection..."

  if psql "$db_url" -c "SELECT 1;" >/dev/null 2>&1; then
    echo "✅ Database connection successful"

    # Check if tables exist
    local table_count
    table_count=$(psql "$db_url" -t -c "SELECT count(*) FROM information_schema.tables WHERE table_schema = 'public';" | xargs)

    echo "📊 Found $table_count tables in database"
    return 0
  else
    echo "❌ Database connection failed"
    echo "💡 Check DATABASE_URL: $db_url"
    return 1
  fi
}

main "$@"

#!/usr/bin/env bash
### DOC
# Test API endpoints with comprehensive checks
### DOC
set -euo pipefail

source "$DR_CONFIG/helpers/pkg.sh"
validatePkg curl jq

main() {
  local base_url="${1:-http://localhost:3001}"

  echo "🔍 Testing API endpoints at $base_url"

  # Health check
  echo "🏥 Checking health endpoint..."
  if curl -s "$base_url/health" | jq -e '.status == "ok"' >/dev/null; then
    echo "✅ Health check passed"
  else
    echo "❌ Health check failed"
    return 1
  fi

  # Test authentication
  echo "🔐 Testing authentication..."
  local token
  token=$(curl -s -X POST "$base_url/auth/login" \
    -H "Content-Type: application/json" \
    -d '{"username":"test","password":"test"}' | jq -r '.token')

  if [[ "$token" != "null" && -n "$token" ]]; then
    echo "✅ Authentication successful"
  else
    echo "❌ Authentication failed"
    return 1
  fi

  # Test protected endpoint
  echo "🛡️  Testing protected endpoint..."
  if curl -s "$base_url/api/user" \
    -H "Authorization: Bearer $token" | jq -e '.id' >/dev/null; then
    echo "✅ Protected endpoint accessible"
  else
    echo "❌ Protected endpoint failed"
    return 1
  fi

  echo "✅ All API tests passed!"
}

main "$@"

#!/usr/bin/env bash
### DOC
# Set up development database with sample data
### DOC
set -euo pipefail

source "$DR_CONFIG/helpers/pkg.sh"
validatePkg psql docker

main() {
  local db_name="${1:-myapp_dev}"

  echo "🗄️  Setting up development database: $db_name"

  # Start PostgreSQL with Docker if not running
  if ! pgrep -x "postgres" >/dev/null; then
    echo "🐳 Starting PostgreSQL with Docker..."
    docker run -d \
      --name postgres-dev \
      -e POSTGRES_DB="$db_name" \
      -e POSTGRES_USER=dev \
      -e POSTGRES_PASSWORD=password \
      -p 5432:5432 \
      postgres:13

    echo "⏳ Waiting for PostgreSQL to start..."
    sleep 5
  fi

  # Run migrations
  if [[ -f "migrations/init.sql" ]]; then
    echo "🔄 Running migrations..."
    psql "postgresql://dev:password@localhost:5432/$db_name" <migrations/init.sql
  fi

  # Load sample data
  if [[ -f "seeds/sample_data.sql" ]]; then
    echo "🌱 Loading sample data..."
    psql "postgresql://dev:password@localhost:5432/$db_name" <seeds/sample_data.sql
  fi

  echo "✅ Development database ready!"
  echo "🔗 Connection string: postgresql://dev:password@localhost:5432/$db_name"
}

main "$@"

#!/usr/bin/env bash
### DOC
# Run database migrations with rollback support
### DOC
set -euo pipefail

source "$DR_CONFIG/helpers/pkg.sh"
validatePkg psql

main() {
  local action="${1:-up}"
  local db_url="${DATABASE_URL:-postgresql://dev:password@localhost:5432/myapp_dev}"

  echo "🔄 Running database migrations: $action"

  case "$action" in
    up)
      echo "⬆️  Applying migrations..."
      for migration in migrations/*.up.sql; do
        if [[ -f "$migration" ]]; then
          echo "📝 Applying $(basename "$migration")"
          psql "$db_url" <"$migration"
        fi
      done
      ;;
    down)
      echo "⬇️  Rolling back migrations..."
      for migration in migrations/*.down.sql; do
        if [[ -f "$migration" ]]; then
          echo "↩️  Rolling back $(basename "$migration")"
          psql "$db_url" <"$migration"
        fi
      done
      ;;
    status)
      echo "📊 Migration status..."
      psql "$db_url" -c "SELECT * FROM schema_migrations ORDER BY version DESC LIMIT 10;"
      ;;
    *)
      echo "Usage: dr database/migrate [up|down|status]"
      exit 1
      ;;
  esac

  echo "✅ Migration $action completed!"
}

main "$@"

#!/usr/bin/env bash
### DOC
# Deploy full-stack application to staging environment
### DOC
set -euo pipefail

source "$DR_CONFIG/helpers/git.sh"
source "$DR_CONFIG/helpers/pkg.sh"
validatePkg git docker

main() {
  echo "🚀 Deploying to staging environment..."

  # Ensure we're on main branch
  local current_branch
  current_branch=$(git_current_branch)
  if [[ "$current_branch" != "main" ]]; then
    echo "❌ Must deploy from main branch (currently on $current_branch)"
    exit 1
  fi

  # Build frontend
  echo "🏗️  Building frontend..."
  cd frontend/
  dr fullstack/build-production
  cd ..

  # Build backend Docker image
  echo "🐳 Building backend Docker image..."
  docker build -t myapp-backend:staging backend/

  # Deploy with docker-compose
  echo "📦 Deploying with docker-compose..."
  docker-compose -f docker-compose.staging.yml up -d

  # Wait for services
  echo "⏳ Waiting for services to start..."
  sleep 30

  # Health check
  if dr deployment/health-check staging; then
    echo "✅ Staging deployment successful!"
    echo "🌐 Frontend: https://staging.myapp.com"
    echo "🔗 API: https://api-staging.myapp.com"
  else
    echo "❌ Health check failed"
    dr deployment/rollback staging
    exit 1
  fi
}

main "$@"

#!/usr/bin/env bash
### DOC
# Comprehensive health check for deployed application
### DOC
set -euo pipefail

source "$DR_CONFIG/helpers/pkg.sh"
validatePkg curl

main() {
  local environment="${1:-staging}"

  case "$environment" in
    staging)
      local frontend_url="https://staging.myapp.com"
      local api_url="https://api-staging.myapp.com"
      ;;
    production)
      local frontend_url="https://myapp.com"
      local api_url="https://api.myapp.com"
      ;;
    *)
      echo "❌ Unknown environment: $environment"
      exit 1
      ;;
  esac

  echo "🏥 Running health checks for $environment..."

  # Check frontend
  echo "🌐 Checking frontend at $frontend_url..."
  if curl -s -f "$frontend_url" >/dev/null; then
    echo "✅ Frontend is accessible"
  else
    echo "❌ Frontend health check failed"
    return 1
  fi

  # Check API health endpoint
  echo "🔗 Checking API at $api_url..."
  if curl -s "$api_url/health" | grep -q "ok"; then
    echo "✅ API is healthy"
  else
    echo "❌ API health check failed"
    return 1
  fi

  # Check database connectivity
  echo "🗄️  Checking database connectivity..."
  if curl -s "$api_url/health/db" | grep -q "connected"; then
    echo "✅ Database is connected"
  else
    echo "❌ Database connectivity check failed"
    return 1
  fi

  echo "✅ All health checks passed for $environment!"
}

main "$@"

# Team member imports collection
dr import [email protected]:company/fullstack-tools.git fs

# Start development environment
dr fs/database/setup-dev
dr fs/backend/dev-server &
dr fs/frontend/dev-server

# Run tests before committing
dr fs/frontend/run-tests
dr fs/backend/test-api

# Build and test
dr fs/frontend/build-production
dr fs/backend/run-tests

# Deploy to staging
dr fs/deployment/deploy-staging

# Reviewer runs automated checks
dr fs/frontend/run-tests unit
dr fs/backend/test-api http://localhost:3001
dr fs/deployment/health-check staging

# Performance testing
dr fs/frontend/build-production
ls -la frontend/build/ # Check bundle sizes

# Final testing
dr fs/frontend/run-tests all
dr fs/backend/test-api

# Deploy to staging for final QA
dr fs/deployment/deploy-staging
dr fs/deployment/health-check staging

# Production deployment (after approval)
dr fs/deployment/deploy-production
dr fs/deployment/health-check production