stack for backend of edcopo landing page

[mbaneshi]

how create backend with
Actix-web for handling HTTP requests, APIs, and concurrency.
SQLx for asynchronous database interactions with PostgreSQL.
Tokio as the asynchronous runtime for optimal performance.

[mbaneshi]

Creating a backend with Actix-web, SQLx, and Tokio in Rust is a powerful combination for building high-performance web applications. Below is a step-by-step guide on how to set up and create a backend with these components.

Prerequisites

1. Rust: Ensure you have Rust installed. You can install it via rustup from [here](https://www.rust-lang.org/learn/get-started).
2. PostgreSQL: You need a running PostgreSQL database to interact with.

Step 1: Initialize a New Rust Project

First, create a new Rust project:

cargo new actix-web-sqlx-backend --bin
cd actix-web-sqlx-backend

Step 2: Add Dependencies to Cargo.toml

Edit your Cargo.toml file to include the dependencies for Actix-web, SQLx, PostgreSQL, and Tokio.

[dependencies]
actix-web = "4.0"  # Web framework
tokio = { version = "1", features = ["full"] }  # Async runtime
sqlx = { version = "0.6", features = ["postgres", "runtime-tokio-native-tls"] }  # SQLx with PostgreSQL and Tokio runtime
serde = { version = "1.0", features = ["derive"] }  # For JSON serialization
serde_json = "1.0"  # JSON handling
dotenv = "0.15"  # For managing environment variables
actix-rt = "2.5.0"  # For Actix async runtime

Step 3: Create .env File for Database Configuration

Create a .env file in the root of your project to store your PostgreSQL connection string:

DATABASE_URL=postgres://user:password@localhost/database_name

Replace user, password, localhost, and database_name with your actual PostgreSQL connection details.

Step 4: Set Up Actix Web Server with SQLx

Now, let's create the basic structure for handling HTTP requests, interacting with PostgreSQL, and serving responses asynchronously.

Create the main src/main.rs file:

use actix_web::{web, App, HttpServer, Responder, HttpResponse};
use sqlx::postgres::PgPoolOptions;
use serde::{Deserialize, Serialize};
use std::env;
use tokio;

#[derive(Serialize, Deserialize)]
struct Item {
    id: i32,
    name: String,
}

async fn get_items(pool: web::Data<sqlx::PgPool>) -> impl Responder {
    let rows = sqlx::query!("SELECT id, name FROM items")
        .fetch_all(pool.get_ref())
        .await
        .unwrap();

    let items: Vec<Item> = rows
        .into_iter()
        .map(|row| Item {
            id: row.id,
            name: row.name,
        })
        .collect();

    HttpResponse::Ok().json(items)
}

async fn create_item(
    pool: web::Data<sqlx::PgPool>,
    item: web::Json<Item>,
) -> impl Responder {
    let result = sqlx::query!("INSERT INTO items (name) VALUES ($1) RETURNING id", item.name)
        .bind(&item.name)
        .fetch_one(pool.get_ref())
        .await;

    match result {
        Ok(record) => HttpResponse::Created().json(record),
        Err(_) => HttpResponse::InternalServerError().body("Error creating item"),
    }
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // Load the environment variables from .env file
    dotenv::dotenv().ok();

    // Get the database URL from the environment
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL not set");

    // Create a PostgreSQL connection pool
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await
        .expect("Failed to create pool");

    // Start the Actix-web server
    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(pool.clone()))  // Share the DB pool across handlers
            .route("/items", web::get().to(get_items)) // GET /items endpoint
            .route("/items", web::post().to(create_item)) // POST /items endpoint
    })
    .bind("127.0.0.1:8080")?  // Run the server on localhost:8080
    .run()
    .await
}

Step 5: Set Up Database Schema

You need to create a table in your PostgreSQL database to hold the items. You can create this table manually or through a migration. Here’s a simple SQL schema for the items table:

CREATE TABLE items (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL
);

You can run this SQL script in your PostgreSQL client to create the necessary table.

Step 6: Run the Application

1. Ensure your PostgreSQL server is running, and the DATABASE_URL in the .env file is correct.
2. Build and run the application:

cargo run

You should see something like:

Listening on http://127.0.0.1:8080

Step 7: Testing the Application

You can test the application using curl or Postman.

1. Create an item (POST):

   curl -X POST http://localhost:8080/items -H "Content-Type: application/json" -d '{"name": "Test Item"}'

2. Get all items (GET):

   curl http://localhost:8080/items

Step 8: (Optional) Add Error Handling and Logging

For better production-level code, you may want to handle errors more gracefully and add logging. Actix provides excellent support for error handling, and you can use the log and env_logger crates to enable logging in your application.

You can enhance error handling by using Result types and returning appropriate HTTP status codes.

Conclusion

You've now set up a basic backend application using Actix-web for handling HTTP requests, SQLx for asynchronous PostgreSQL database interactions, and Tokio for asynchronous runtime. This setup is highly scalable and can handle many concurrent requests efficiently. You can expand this with more complex routes, additional database operations, and authentication depending on your needs.