cp .env.example .env

# Database Configuration
DATABASE_URL=sqlite:stateset.db?mode=rwc  # For SQLite (development)
# DATABASE_URL=postgres://username:password@localhost/stateset_db  # For PostgreSQL

# JWT Configuration
JWT_SECRET=your_secure_jwt_secret_key_change_in_production
JWT_EXPIRATION=3600              # 1 hour in seconds
JWT_REFRESH_EXPIRATION=604800    # 7 days in seconds

# Server Configuration
PORT=8080
HOST=0.0.0.0
APP_ENV=development

# Logging
RUST_LOG=stateset_api=debug,tower_http=debug,sea_orm=debug,info

# Optional: Redis (if using caching)
# REDIS_URL=redis://localhost:6379

# Database
database_url = "sqlite:stateset.db?mode=rwc"
auto_migrate = true  # Automatically run migrations on startup

# Server
host = "0.0.0.0"
port = 8080

# Cache (optional)
[cache]
cache_type = "memory"  # or "redis" if Redis is configured
capacity = 1000
default_ttl_secs = 300

# Using the migration binary
cargo run --bin migration

# Or using SQLx CLI (if installed)
sqlx migrate run

# Quick build for development
cargo build

# Or using the Makefile
make build

# Optimized build for production
cargo build --release

# Or using the Makefile
make build-release

# Build only the main API server
cargo build --bin stateset-api

# Build the minimal server (lightweight version)
cargo build --bin minimal-server

# Build the gRPC server
cargo build --bin grpc-server

# Build performance testing tools
cargo build --bin orders-bench
cargo build --bin orders-mock-server

# Run in development mode
cargo run

# Or using the Makefile
make run

# Run with specific binary
cargo run --bin stateset-api

# Run release build
./target/release/stateset-api

# Run minimal server (lightweight, fewer features)
cargo run --bin minimal-server

# Run gRPC server
cargo run --bin grpc-server

# Run mock server for testing
cargo run --bin orders-mock-server

# Health check
curl http://localhost:8080/health

# Should return:
# {"status":"healthy"}

src/
├── commands/        # Write operations (Command pattern)
├── queries/         # Read operations (Query pattern)
├── handlers/        # HTTP request handlers
├── services/        # Business logic
├── entities/        # Database entities (SeaORM)
├── models/          # Domain models
├── repositories/    # Data access layer
└── main.rs         # Application entry point

# Install cargo-watch
cargo install cargo-watch

# Run with auto-reload
cargo watch -x run

# Format code
cargo fmt

# Run linter
cargo clippy

# Check for security issues
cargo audit

# Generate documentation
cargo doc --open

# Run all tests
cargo test

# Run specific test
cargo test test_create_order

# Run tests with output
cargo test -- --nocapture

# Run tests with backtrace
RUST_BACKTRACE=1 cargo test

# Run integration tests only
cargo test --test '*'

# Using Makefile
make test

#[cfg(test)]
mod tests {
    use super::*;
    
    #[tokio::test]
    async fn test_create_order() {
        // Test implementation
        let service = OrderService::new(db_pool);
        let order = service.create_order(cmd).await.unwrap();
        assert_eq!(order.status, "pending");
    }
}

# Run order throughput benchmark
cargo run --bin orders-bench

# Start mock server for load testing
cargo run --bin orders-mock-server

# In another terminal, run benchmarks
ab -n 1000 -c 10 http://localhost:8080/orders

http://localhost:8080/swagger-ui

# Generate Rust code from proto files
cargo build  # Automatically generates during build

# For other languages, use protoc directly
protoc --go_out=. --go-grpc_out=. proto/*.proto

# Clear build cache
cargo clean

# Update dependencies
cargo update

# Check for specific errors
cargo build 2>&1 | tee build_errors.log

# Test database connection
psql $DATABASE_URL -c "SELECT 1"

# For SQLite, check file permissions
ls -la stateset.db

# Reset database
rm stateset.db  # For SQLite
# OR
DROP DATABASE stateset_db; CREATE DATABASE stateset_db;  # For PostgreSQL

# Find process using port 8080
lsof -i :8080

# Kill the process
kill -9 <PID>

# Or use a different port
PORT=3000 cargo run

# Reset migrations
cargo run --bin migration -- reset

# Run migrations step by step
cargo run --bin migration -- up

# Enable debug logging
RUST_LOG=debug cargo run

# Enable backtrace for errors
RUST_BACKTRACE=1 cargo run

# Use debugger (VS Code or IntelliJ Rust)
# Add breakpoints and run in debug mode

# Profile the application
cargo build --release
valgrind --tool=callgrind ./target/release/stateset-api

# Check database queries
RUST_LOG=sea_orm=debug cargo run

# Monitor resource usage
htop  # While application is running