Axum Framework: The Ultimate Guide (2023)

Various backend frameworks offer distinct features and capabilities in web development using Rust, a language renowned for its performance and safety. Among these, the Axum framework is a unique and powerful option. This expanded chapter delves into the intricate details of backend web development using Rust, with a special focus on the Axum framework.

Axum, emerging as a modern and asynchronous web framework, is tailored to optimize scalable and efficient web application development. Its introduction in the Rust ecosystem marks a significant advancement, catering to the contemporary needs of web developers seeking performance and simplicity.

The Uniqueness of Axum in Rust

Axum sets itself apart by integrating Rust’s powerful asynchronous capabilities into web development. This integration is pivotal for creating applications that are not only efficient but also capable of handling a multitude of concurrent tasks, a common requirement in modern web applications. Axum's approach to asynchronous programming, utilizing Rust's native async/await syntax, makes it a robust choice for developers leveraging these advanced features.

Axum’s Design Philosophy: Simplicity, Composability, and Scalability

Axum is engineered with three core principles:

1. Simplicity: Despite its powerful features, Axum maintains a simple and intuitive interface for developers. This simplicity is evident in its straightforward approach to routing and request handling, making it accessible to developers new to Rust’s web development scene.

2. Composability: Axum encourages a modular approach, allowing developers to compose their applications from smaller, reusable components. This modularity promotes clean code and enhances the maintainability and scalability of applications.

3. Scalability: With its asynchronous foundation, Axum is inherently scalable and capable of handling many concurrent requests with minimal overhead. This makes it an ideal choice for high-traffic web applications where performance is critical.

Prerequisites for Learning and Using Axum

Before diving into the intricacies of Axum, it’s crucial to be equipped with certain prerequisites:

• Rust Knowledge: A solid understanding of Rust is essential. This includes familiarity with Rust’s syntax, concepts like ownership and borrowing, and the concurrency model, especially async/await.

• Backend Development Fundamentals: A grasp of basic backend development concepts, such as HTTP protocols, RESTful architecture, and CRUD operations, is beneficial.

• Rust Toolchain Installation: Installing the Rust toolchain, including Cargo, on your development machine is a prerequisite. This can be done by following the installation guide on rust-lang.org.

Additional Learning Resources

For those new to Rust or backend development, various resources are available:

• Rust’s Official Documentation: A comprehensive guide to the Rust language, perfect for beginners and experienced developers.

• Online Tutorials and Courses: Many online platforms offer courses specifically focused on Rust and web development.

• Community Forums and Discussions: Platforms like Reddit, Stack Overflow, and Rust’s user forums are valuable for seeking help and engaging with other Rust developers.

Conclusion

This expanded chapter thoroughly introduces the Axum framework within the Rust ecosystem. Understanding Axum's unique position, design philosophy, and the prerequisites needed to master it lays a solid foundation for exploring its capabilities in depth. The subsequent chapters will delve into specific features of Axum, such as routing, middleware, and error handling, and guide you through building a complete web application using Axum.

In the landscape of Rust's web development frameworks, Axum emerges as a distinctive choice, particularly for building asynchronous web applications. Developed by the Tokio team, Axum leverages Rust's robust asynchronous capabilities, offering a performance and user-friendly framework. This chapter explores the Axum framework in-depth, unveiling its components, design, and integration with Rust's asynchronous ecosystem.

Axum's Foundation: Built on Tokio

Axum is intricately built on top of Tokio, a widely used asynchronous runtime in Rust. This relationship is central to understanding Axum's capabilities, as it inherits Tokio's efficiency in handling asynchronous tasks and I/O operations. Tokio's event-driven architecture allows Axum to manage multiple concurrent operations effectively, making it highly suitable for real-time applications.

Core Features of Axum

Axum stands out with several key features that cater to the needs of modern web development:

1. High-Performance Architecture:

   • Axum is designed for speed and efficiency, leveraging Rust's performance characteristics.

   • Its integration with Tokio ensures optimal handling of asynchronous operations, which is critical for high-throughput applications.

2. Ergonomic Design:

   • Despite its high-performance capabilities, Axum does not compromise on usability.

   • It offers an ergonomic API that simplifies the development process, making it accessible even for those new to Rust's asynchronous model.

3. Composability and Flexibility:

   • Axum promotes a modular approach, allowing developers to compose applications using reusable components.

   • This flexibility extends to integrating with other libraries and tools in the Rust ecosystem, enhancing Axum’s functionality.

4. Strong Focus on Asynchronous Programming:

   • Asynchronous programming is at the heart of Axum, utilizing Rust's async/await syntax for non-blocking code execution.

   • This focus enables efficient handling of multiple concurrent connections, a key requirement in modern web development.

Axum's Asynchronous Nature

The asynchronous aspect of Axum is not just an add-on but a core feature. It allows developers to write concurrent applications effortlessly, essential in a world where high responsiveness and handling multiple requests simultaneously are the norms.

Routing Mechanisms in Axum

Axum's routing system is both powerful and intuitive, playing a pivotal role in how web applications are structured:

• Declarative Routing: Axum uses a declarative syntax for defining routes. This approach makes associating specific URLs and HTTP methods with corresponding handler functions straightforwardly.

• Flexible Route Handling: Developers can define routes that capture different HTTP methods and paths, offering great control over processing requests.

• Example of a Route Definition:

  use axum::{routing::get, Router};
  
  #[tokio::main]
  async fn main() {
      let app = Router::new().route("/", get(|| async { "Hello, Rustacean!" }));
      // Additional code to run the application...
  }
  

  Use our Online Code Editor

  This example defines a simple route for the root path ("/"), responding to GET requests with a welcoming message.

Extensibility and Integration

Axum’s architecture is not just about handling HTTP requests; it’s about providing a foundation upon which complex, feature-rich applications can be built:

• Middleware and Filters: Axum supports middleware and filters, enabling developers to process requests and responses modularly. This is essential for tasks like authentication, logging, and request modification.

• Integration with Other Libraries: The framework is designed to work seamlessly with various Rust libraries, enhancing its capabilities. This includes integration with database libraries, authentication tools, and templating engines.

A Vibrant Ecosystem

Axum benefits from a vibrant ecosystem that includes extensions, community contributions, and support for various third-party libraries. This ecosystem is crucial in extending Axum's capabilities beyond its core features.

Conclusion

This chapter comprehensively explores the Axum framework, highlighting its integration with Tokio, focusing on asynchronous programming and a powerful routing system. The chapter also discussed the framework’s ergonomic design, composability, and extensible nature. As we progress, the subsequent chapters will delve into practical aspects of using Axum, such as detailed routing, middleware implementation, and building a complete web application.

In the world of web development with Axum, routing forms the backbone of how HTTP requests are handled. This chapter delves into the intricacies of Axum’s routing mechanism, a feature that sets it apart in the Rust web framework ecosystem. Routing in Axum is not just about directing HTTP requests to the appropriate handlers but crafting an intuitive and efficient pathway for these requests, ensuring a seamless and scalable web application structure.

The Essence of Routing

Routing in web frameworks, including Axum, involves mapping incoming HTTP requests to specific handlers based on criteria like the URL path and HTTP method. This mapping is critical in structuring the application and defining how different requests are processed.

Axum’s Routing Mechanisms

Axum provides a highly flexible and expressive routing system, allowing for detailed and precise control over request handling:

• Declarative Syntax: Axum’s routing is defined using a declarative macro system, making it clear and intuitive. This approach simplifies associating specific request paths and methods with their corresponding handler functions.

• Route Definition Example:

  use axum::{routing::get, Router};
  
  #[tokio::main]
  async fn main() {
      let app = Router::new().route("/", get(|| async { "Hello, Rustacean!" }));
      // Additional server setup...
  }
  

  Use our Online Code Editor

  This snippet creates a basic route for the root path ("/"). This route responds to GET requests with a simple greeting, showcasing the straightforward nature of defining routes in Axum.

Flexible and Intuitive Handling

Axum’s routing system is flexible and intuitive, offering several features below.

Handling Different HTTP Methods: Axum allows defining routes for various HTTP methods like GET, POST, PUT, and DELETE. This flexibility is crucial for creating RESTful APIs.

use axum::{routing::{get, post, put, delete}, Router};

let app = Router::new()
    .route("/", get(root_handler))
    .route("/create", post(create_handler))
    .route("/update", put(update_handler))
    .route("/delete", delete(delete_handler));

Dynamic URL Parameters: Routes can capture dynamic parameters from the URL, enabling the creation of more interactive and responsive endpoints.

use axum::{routing::get, Router, extract::Path};

async fn user_handler(Path(user_id): Path<u32>) -> String {
    format!("User ID: {}", user_id)
}

let app = Router::new().route("/user/:user_id", get(user_handler));

Nested Routes and Scoping: Axum supports nested routing and scoping, allowing developers to group related routes and apply common configurations, such as middleware, to these groups.

use axum::{routing::get, Router};

let users_routes = Router::new().route("/list", get(users_list));
let posts_routes = Router::new().route("/all", get(posts_all));

let app = Router::new().nest("/users", users_routes).nest("/posts", posts_routes);

Middleware Integration in Routes: Axum can be augmented with middleware, enhancing their functionality with additional processing layers, such as authentication or logging.

use axum::{Router, routing::get, middleware::from_fn};

async fn auth_middleware<B>(req: Request<B>, next: Next<B>) -> Result<Response, Infallible> {
    // Authentication logic...
}

let app = Router::new().route("/", get(root_handler)).layer(from_fn(auth_middleware));

Advanced Route Handling Techniques

Beyond basic routing, Axum provides capabilities for more complex routing scenarios:

Path Prefixes and Route Aggregation: Developers can define path prefixes for a group of routes, simplifying the management of route hierarchies.

use axum::{Router, routing::get};

let api_routes = Router::new().route("/v1/items", get(items_handler));
let app = Router::new().nest("/api", api_routes);

Error Handling in Routes: Axum routes can be equipped with error handling mechanisms, ensuring graceful handling and response to erroneous requests.

use axum::{Router, routing::get, http::StatusCode, response::Response, Error};

async fn handle_error(error: Error) -> (StatusCode, String) {
    (StatusCode::INTERNAL_SERVER_ERROR, format!("Something went wrong: {}", error))
}

let app = Router::new().route("/", get(root_handler)).handle_error(handle_error);

Combining Routes with Other Framework Features: Routes in Axum can seamlessly integrate with other features of the framework, such as request extractors and response modifiers, to create a holistic application flow.

use axum::{Router, routing::get, extract::Query, response::Json};

async fn search_handler(Query(params): Query<HashMap<String, String>>) -> Json<Value> {
    // Process query parameters...
}

let app = Router::new().route("/search", get(search_handler));

Using a declarative macro:

In Axum, routes are defined using a declarative macro called route!. This macro associates an HTTP method and URL pattern with a handler function. For example:

use axum::{routing::get, Router};

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, Rustacean!" }));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

With the following dependencies in Cargo.toml:

[dependencies]
axum = "0.6.20"
serde = { version = "1.0.188", features = ["derive"] }
tokio = { version = "1.32.0", features = ["full"] }

In the above example, we defined a route for the root path ("/"). The route specifies the HTTP method (in this case, get) and the handler function to execute when a matching request is received.

Run the application, and you get the request:

Conclusion

This chapter has offered an in-depth exploration of routing in the Axum framework, from defining routes to more advanced techniques like nested routing, middleware integration, and error handling. Also, it has underscored the importance and versatility of routing in creating efficient and scalable web applications with Axum.

In the following chapters, we will explore other pivotal aspects of Axum, such as middleware functionality, error-handling strategies, and building a complete application using these features.

This chapter will delve into the crucial concepts of middleware and filters in the Axum framework. Middleware and filters are key components in building robust and efficient web applications, allowing for the interception and manipulation of requests and responses within the application pipeline. This chapter aims to comprehensively understand how middleware and filters work in Axum, their uses, and how to implement them effectively.

Understanding Middleware

Middleware in Axum acts as a layer between the request coming into your server and the request reaching your route handler. It can modify, log, or make decisions based on the incoming request, and similarly, it can alter or inspect the response before it's sent back to the client.

Key Aspects of Middleware:

• Request Processing: Middleware can process requests before reaching the route handlers.

• Response Alteration: Middleware can modify the responses after the route handlers have processed the request.

• Logging and Monitoring: Middleware is often used for logging requests and responses for monitoring and debugging purposes.

• Authentication and Authorization: Middleware can handle authentication and authorization logic, restricting access to certain routes.

Filters: Conditional Request Handling

Filters in Axum are used to handle requests based on specific criteria conditionally. They are similar to middleware but are often used for more granular control over request handling based on attributes like headers, query parameters, or path segments.

Key Aspects of Filters:

• Selective Request Handling: Filters can decide whether to process a request or pass it along without changes.

• Data Extraction: Filters can extract data from requests for use in route handlers.

• Preconditions and Validations: Filters are useful for validating requests before they reach the handler.

Implementing Middleware in Axum

Implementing middleware in Axum involves creating a function or struct that adheres to the middleware pattern and then attaching it to the application or specific routes.

Example of a Simple Logging Middleware:

use axum::{middleware::from_fn, Router, routing::get, http::Request};

async fn logging_middleware<B>(req: Request<B>, next: Next<B>) -> Result<Response, Infallible> {
    println!("Request received: {:?}", req.uri());
    next.run(req).await
}

let app = Router::new()
    .route("/", get(root_handler))
    .layer(from_fn(logging_middleware));

In this example, a simple logging middleware prints out the URI of each incoming request.

Utilizing Filters for Enhanced Request Handling

Filters in Axum are implemented by defining criteria that requests must meet to be processed by a specific route handler. They can be custom-made or utilize built-in extractors provided by Axum.

Example of a Path Parameter Filter:

use axum::{routing::get, Router, extract::Path};

async fn user_handler(Path(user_id): Path<u32>) -> String {
    format!("User ID: {}", user_id)
}

let app = Router::new().route("/user/:user_id", get(user_handler));

Here, the Path extractor is used as a filter to capture and pass the user ID to the handler function.

Advanced Middleware Techniques

For more complex scenarios, developers can create advanced middleware that performs intricate operations:

• Chaining Middleware: Middleware can be chained together, allowing multiple processing layers for requests and responses.

• Asynchronous Middleware: Middleware can perform asynchronous operations like database queries or calling external services.

Conclusion

This chapter has explored the concept and implementation of middleware and filters in Axum, highlighting their importance in enhancing the functionality and security of web applications.

Middleware and filters provide developers powerful tools to manage request and response processing efficiently, from simple logging to complex authentication systems.

The subsequent chapters will focus on advanced topics, including error-handling strategies and building a web application using Axum.

This chapter focuses on the critical aspect of error handling in Axum. Efficient error management is essential for maintaining the reliability and user-friendliness of web applications. Axum provides robust mechanisms for handling errors gracefully, allowing developers to manage unexpected situations effectively and ensure a smooth user experience.

The Importance of Error Handling

Proper error handling is crucial in web development for several reasons:

• User Experience: Clear and informative error messages enhance the user experience.

• Application Stability: Handling errors properly prevents crashes and keeps the application stable.

• Debugging and Maintenance: Well-handled errors make debugging and maintaining the application easier.

Error Handling Mechanisms in Axum

Axum offers various tools and patterns for handling errors, making it possible to create comprehensive error management strategies that suit different application needs.

Basic Error Handling:

• Result Types: Axum handlers can return Result types, allowing for the natural use of Rust’s error-handling capabilities.

• Custom Error Types: Developers can define custom error types to represent different error conditions within their application.

Example of Basic Error Handling:

use axum::{handler::get, http::StatusCode, Router, response::IntoResponse};

async fn handler() -> Result<String, MyError> {
    Err(MyError::new("An error occurred"))
}

#[derive(Debug)]
struct MyError {
    message: String,
}

impl MyError {
    fn new(message: &str) -> Self {
        MyError { message: message.to_string() }
    }
}

impl IntoResponse for MyError {
    fn into_response(self) -> axum::response::Response {
        (StatusCode::INTERNAL_SERVER_ERROR, self.message).into_response()
    }
}

let app = Router::new().route("/", get(handler));

In this example, the handler function returns a Result type. If an error occurs, it returns a custom MyError type, which is then converted into an HTTP response.

Advanced Error Handling Techniques:

• Error Propagation: Axum allows for the propagation of errors up the middleware stack, providing flexibility in managing and responding to errors.

• Global Error Handlers: Developers can implement global error handlers to catch and respond to errors that occur anywhere in the application.

Example of a Global Error Handler:

use axum::{error_handling::HandleErrorLayer, Router, BoxError};

async fn global_error_handler(error: BoxError) -> (StatusCode, String) {
    if error.is::<MyError>() {
        (StatusCode::BAD_REQUEST, "Custom error occurred".to_string())
    } else {
        (StatusCode::INTERNAL_SERVER_ERROR, "Internal server error".to_string())
    }
}

let app = Router::new()
    .route("/", get(handler))
    .layer(HandleErrorLayer::new(global_error_handler));

In this example, HandleErrorLayer is used to set up a global error handler that catches and processes errors from anywhere in the application.

Best Practices for Error Handling in Axum

Effective error handling in Axum involves several best practices:

• Use Descriptive Error Messages: Provide clear and descriptive messages for errors to aid debugging and user communication.

• Log Errors: Logging errors are crucial for monitoring and diagnosing issues in production.

• Graceful Degradation: Design error responses to degrade gracefully, ensuring the application remains functional even when errors occur.

Conclusion

This chapter explored Axum's various facets of error handling, emphasizing its significance in building reliable and user-friendly web applications.

By leveraging Axum’s error-handling features, developers can create robust applications capable of dealing with unexpected situations gracefully.

In the next chapter, we will apply these concepts practically, demonstrating how to build a complete web application using Axum, incorporating routing, middleware, and error-handling strategies.

This chapter focuses on utilizing Axum to build RESTful APIs, a modern web application development cornerstone.

REST (Representational State Transfer) is an architectural style that leverages HTTP protocols to create scalable and maintainable web services. With its efficient routing and asynchronous processing capabilities, Axum is particularly well-suited for building these types of APIs.

Understanding REST Principles in Axum

RESTful APIs in Axum adhere to key REST principles like statelessness, uniform interface, and resource-based routes. We will explore how Axum’s features align with these principles to create efficient and scalable APIs.

Setting Up a Basic RESTful API in Axum

We set up a basic RESTful API structure in Axum, focusing on CRUD (Create, Read, Update, Delete) operations.

Defining Resource Endpoints

Endpoints in a RESTful API correspond to resources. In Axum, these are defined using its routing system.

Example: Defining a User Resource

use axum::{Router, routing::get, Json};
use serde_json::json;

async fn list_users() -> Json<Vec<String>> {
    Json(vec!["User 1".into(), "User 2".into()])
}

async fn get_user() -> Json<String> {
    Json("User 1".into())
}

let app = Router::new()
    .route("/users", get(list_users))
    .route("/users/:id", get(get_user));

Handling HTTP Methods

Each RESTful operation typically corresponds to an HTTP method: GET for read, POST for create, PUT/PATCH for update, and DELETE for delete.

Example: CRUD Operations for User

use axum::{routing::{get, post, put, delete}, Router, Json};

let app = Router::new()
    .route("/users", get(list_users).post(create_user))
    .route("/users/:id", get(get_user).put(update_user).delete(delete_user));

Integrating Database Connectivity

A vital part of any RESTful API is interaction with a database. We’ll integrate a database connection using Rust’s ORM libraries like Diesel or SQLx.

Setting Up a Database Connection

For our example, let’s use SQLx for asynchronous database operations.

Cargo.toml Dependencies:

[dependencies]
axum = "0.6.20"
sqlx = "0.6.0"
tokio = { version = "1.32.0", features = ["full"] }

Database Connection Example:

use sqlx::postgres::PgPoolOptions;
use std::env;

#[tokio::main]
async fn main() {
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new()
        .connect(&database_url)
        .await
        .expect("Failed to connect to database");

    // Rest of the application setup...
}

Creating CRUD Operations with Database Interaction

Integrating CRUD operations with database interaction in Axum involves using asynchronous functions to interact with the database.

Example: Read Operation with Database

use axum::{Router, routing::get, Json};
use sqlx::PgPool;

async fn list_users(db_pool: PgPool) -> Json<Vec<User>> {
    let users = sqlx::query_as!(User, "SELECT * FROM users")
        .fetch_all(&db_pool)
        .await
        .expect("Failed to fetch users");

    Json(users)
}

// Assume User is a struct representing the user model.

Here, list_users asynchronously fetches user data from the database and returns it as JSON.

Conclusion

This chapter provided a comprehensive guide to building RESTful APIs using Axum, covering everything from defining resource endpoints and handling HTTP methods to integrating database connections for full CRUD functionality.

This approach showcases Axum's capabilities in creating scalable and efficient web services, making it an excellent choice for modern backend development.

The subsequent chapters will delve into more advanced topics, such as authentication, advanced error handling, and performance optimization in Axum-based RESTful APIs.

In this chapter, we'll apply the concepts and techniques learned in previous chapters to build a practical web application using Axum. Our project will be a basic RESTful API for task management, showcasing how to integrate routing, middleware, error handling, and database connectivity into a cohesive application.

Project Overview

The task management application will allow users to create, retrieve, update, and delete tasks. Each task will have attributes like an ID, title, and completion status. We'll use a PostgreSQL database to store the task data.

Setting Up the Project

First, set up a new Rust project and add Axum and other necessary dependencies to your Cargo.toml.

Cargo.toml:

[dependencies]
axum = "0.7.2"
sqlx = { version = "0.7.3", features = ["postgres", "runtime-tokio-native-tls"] }
serde = { version = "1.0.193", features = ["derive"] }
tokio = { version = "1.34.0", features = ["full"] }

Defining the Data Model

We'll define a Task struct to represent our tasks and use Serde for serialization.

task.rs:

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct Task {
    pub id: i32,
    pub title: String,
    pub completed: bool,
}

// Additional implementation if needed...

Establishing Database Connectivity

Using SQLx, establish an asynchronous connection to the PostgreSQL database.

Database Setup:

use sqlx::postgres::PgPoolOptions;
use std::env;

#[tokio::main]
async fn main() {
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let db_pool = PgPoolOptions::new()
        .connect(&database_url)
        .await
        .expect("Failed to connect to the database");

    // Continue setting up the application...
}

Implementing CRUD Operations

We'll implement the CRUD operations for the task management application.

Example: Create a Task

use axum::{Extension, Json, extract::Path};
use axum::http::StatusCode;
use serde::{Deserialize, Serialize};
use sqlx::{FromRow, PgPool};

pub async fn create_task(Json(task): Json<Task>, Extension(db_pool): Extension<PgPool>) -> Result<Json<Task>, StatusCode> {
    let mut tx = db_pool.begin().await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    let task = sqlx::query_as::<_, Task>("INSERT INTO tasks (title, completed) VALUES ($1, $2) RETURNING id, title, completed")
        .bind(&task.title)
        .bind(task.completed)
        .fetch_one(&mut *tx)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    tx.commit().await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    Ok(Json(task))
}
// Router setup with the `create_task` route...

Other CRUD operations will look like:

/ Function to create the tasks table if it doesn't exist
pub async fn create_tasks_table(db_pool: &PgPool) {
    sqlx::query(
        "CREATE TABLE IF NOT EXISTS tasks (
            id SERIAL PRIMARY KEY,
            title VARCHAR(255) NOT NULL,
            completed BOOLEAN NOT NULL
        )"
    )
        .execute(db_pool)
        .await
        .expect("Failed to create tasks table");
}

pub async fn list_tasks(Extension(db_pool): Extension<PgPool>) -> Json<Vec<Task>> {
    let tasks = sqlx::query_as::<_, Task>("SELECT * FROM tasks")
        .fetch_all(&db_pool)
        .await
        .expect("Failed to fetch tasks");

    Json(tasks)
}

pub async fn get_task(Path(task_id): Path<i32>, Extension(db_pool): Extension<PgPool>) -> Json<Task> {
    let task = sqlx::query_as::<_, Task>("SELECT * FROM tasks WHERE id = $1")
        .bind(task_id)
        .fetch_one(&db_pool)
        .await
        .expect("Failed to fetch task");

    Json(task)
}

pub async fn update_task(Path(task_id): Path<i32>, Json(updated_task): Json<Task>, Extension(db_pool): Extension<PgPool>) -> Result<Json<Task>, StatusCode> {
    let mut tx = db_pool.begin().await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    let task = sqlx::query_as::<_, Task>("UPDATE tasks SET title = $1, completed = $2 WHERE id = $3 RETURNING id, title, completed")
        .bind(&updated_task.title)
        .bind(updated_task.completed)
        .bind(task_id)
        .fetch_one(&mut *tx)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    tx.commit().await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    Ok(Json(task))
}

pub async fn delete_task(Path(task_id): Path<i32>, Extension(db_pool): Extension<PgPool>) -> Json<String> {
    sqlx::query("DELETE FROM tasks WHERE id = $1")
        .bind(task_id)
        .execute(&db_pool)
        .await
        .expect("Failed to delete task");

    Json(format!("Task with id {} deleted successfully", task_id))
}

Routing and Handlers

Set up routes for each CRUD operation and associate them with their respective handler functions.

Routing Setup:

let app = Router::new()
    .route("/tasks", post(create_task).get(list_tasks))
    .route("/tasks/:id", get(get_task).put(update_task).delete(delete_task))
    .layer(Extension(db_pool));

Adding Middleware and Error Handling

Integrate middleware for logging and global error handlers for managing application errors.

Middleware and Error Handling:

use axum::{middleware::from_fn, error_handling::HandleErrorLayer};

// Middleware and error handling setup...

Running the Application

Finally, configure and run the Axum server to host the application.

Running the Server:

mod task;
use task::*;

use std::env;
use axum::{Extension, Router};
use axum::routing::{get, post};
use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() {
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set.");

    let db_pool = PgPoolOptions::new()
        .connect(&database_url)
        .await
        .expect("Failed to connect to the database");

    // Create the tasks table if it doesn't already exist
    create_tasks_table(&db_pool).await;

    let app = Router::new()
        .route("/tasks", post(create_task).get(list_tasks))
        .route("/tasks/:id", get(get_task).put(update_task).delete(delete_task))
        .layer(Extension(db_pool));

    let addr = "127.0.0.1:3000".parse().unwrap();

    // run our app with hyper, listening globally on the addr.
    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();

    println!("Server is running at https://{}", addr);

    axum::serve(listener, app).await.unwrap();
}