rust

Rust Best Practices

Overview

Aspect	Recommendation
Edition	Rust 2021
Error Handling	Result with ? operator
Async Runtime	Tokio
Serialization	serde
Web Framework	Axum or Actix-web

---

Project Structure

src/
├── main.rs              # Binary entry point
├── lib.rs               # Library root
├── config.rs            # Configuration
├── error.rs             # Error types
├── models/
│   ├── mod.rs
│   └── user.rs
├── handlers/            # Route handlers
│   ├── mod.rs
│   └── users.rs
├── services/            # Business logic
│   ├── mod.rs
│   └── user_service.rs
└── db/
    ├── mod.rs
    └── repository.rs
tests/
├── integration_test.rs
Cargo.toml

---

Error Handling

Custom Error Type

// src/error.rs
use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json,
};
use serde_json::json;

#[derive(Debug)]
pub enum AppError {
    NotFound(String),
    BadRequest(String),
    Internal(String),
    Unauthorized,
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, message) = match self {
            Self::NotFound(msg) => (StatusCode::NOT_FOUND, msg),
            Self::BadRequest(msg) => (StatusCode::BAD_REQUEST, msg),
            Self::Internal(msg) => (StatusCode::INTERNAL_SERVER_ERROR, msg),
            Self::Unauthorized => (StatusCode::UNAUTHORIZED, "Unauthorized".into()),
        };

        (status, Json(json!({ "error": message }))).into_response()
    }
}

// Convert from other error types
impl From<sqlx::Error> for AppError {
    fn from(err: sqlx::Error) -> Self {
        match err {
            sqlx::Error::RowNotFound => Self::NotFound("Resource not found".into()),
            _ => Self::Internal(err.to_string()),
        }
    }
}

pub type Result<T> = std::result::Result<T, AppError>;

Using Result

// ✅ Good - Use ? operator
fn parse_config(path: &str) -> Result<Config, ConfigError> {
    let content = std::fs::read_to_string(path)?;
    let config: Config = serde_json::from_str(&content)?;
    Ok(config)
}

// ✅ Good - Early return pattern
fn process_user(id: u32) -> Result<User, AppError> {
    let user = find_user(id).ok_or(AppError::NotFound("User not found".into()))?;
    
    if !user.is_active {
        return Err(AppError::BadRequest("User is inactive".into()));
    }
    
    Ok(user)
}

// ❌ Bad - Unwrap in production code
fn bad_example() {
    let value = risky_operation().unwrap(); // Don't do this
}