Vibe Coding

# User prompt to Claude Code:
Write a bash script to back up all postgres databases,
compress them, upload to S3, and clean up files older than 7 days.
Include error handling and logging.

#!/bin/bash
set -euo pipefail

# Configuration
BACKUP_DIR="/var/backups/postgres"
S3_BUCKET="s3://my-backups/postgres"
RETENTION_DAYS=7
LOG_FILE="/var/log/pg-backup.log"
DATE=$(date +%Y-%m-%d_%H%M%S)

log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"; }

log "Starting PostgreSQL backup..."
mkdir -p "$BACKUP_DIR"

# Backup all databases
for db in $(psql -U postgres -t -c "SELECT datname FROM pg_database;"); do
  FILENAME="${db}_${DATE}.sql.gz"
  log "Backing up database: $db"

  if pg_dump -U postgres "$db" | gzip > "$BACKUP_DIR/$FILENAME"; then
    log "Successfully backed up $db"

    # Upload to S3
    if aws s3 cp "$BACKUP_DIR/$FILENAME" "$S3_BUCKET/$FILENAME"; then
      log "Uploaded $FILENAME to S3"
    else
      log "ERROR: Failed to upload to S3"
      exit 1
    fi
  else
    log "ERROR: Failed to backup $db"
    exit 1
  fi
done

# Clean up old backups
log "Cleaning up backups older than $RETENTION_DAYS days..."
find "$BACKUP_DIR" -name "*.sql.gz" -mtime +"$RETENTION_DAYS" -delete

log "Backup complete!"

# User prompt to Claude Code:
Create a Cloudflare Worker endpoint for user registration.
Validate email and password, hash the password, store in D1.
Return proper error responses. TypeScript.

interface Env {
  DB: D1Database;
}

interface RegisterBody {
  email: string;
  password: string;
}

const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

async function hashPassword(password: string): Promise<string> {
  const encoder = new TextEncoder();
  const data = encoder.encode(password);
  const hash = await crypto.subtle.digest('SHA-256', data);
  return Array.from(new Uint8Array(hash))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

function jsonResponse(data: object, status = 200): Response {
  return new Response(JSON.stringify(data), {
    status,
    headers: { 'Content-Type': 'application/json' },
  });
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== 'POST') {
      return jsonResponse({ error: 'Method not allowed' }, 405);
    }

    let body: RegisterBody;
    try {
      body = await request.json();
    } catch {
      return jsonResponse({ error: 'Invalid JSON' }, 400);
    }

    // Validate email
    if (!body.email || !EMAIL_REGEX.test(body.email)) {
      return jsonResponse({ error: 'Invalid email' }, 400);
    }

    // Validate password
    if (!body.password || body.password.length < 8) {
      return jsonResponse({
        error: 'Password must be 8+ characters'
      }, 400);
    }

    // Check if user exists
    const existing = await env.DB
      .prepare('SELECT id FROM users WHERE email = ?')
      .bind(body.email.toLowerCase())
      .first();

    if (existing) {
      return jsonResponse({ error: 'Email exists' }, 409);
    }

    // Create user
    const hashed = await hashPassword(body.password);
    const result = await env.DB
      .prepare('INSERT INTO users (email, password) VALUES (?, ?)')
      .bind(body.email.toLowerCase(), hashed)
      .run();

    return jsonResponse({
      success: true,
      userId: result.meta.last_row_id
    }, 201);
  },
};