Can we use a Layered Architecture Pattern in Rust?

Can we use a layered architecture pattern in a Rust codebase? Like using controller, service, and persistent layers? Yes, we can, but we may need to implement it slightly differently than in most programming languages like Java, C#, etc. How we implement the pattern may also depend on the Rust web framework we use. Rust enforces programming safety at the compiler level, particularly for memory safety. Therefore, coding-wise, we need to align with what the programming language allows and prohibits.

Rust Forces Us To Think (Harder)

Rust forces us to think harder when programming unless we know Rust like the back of our hand. Rust enforces memory safety. To achieve that, Rust introduces a new paradigm in programming. Therefore, how we usually code and think in other languages may not work in Rust.

A layered architecture pattern in Rust is a sound choice to start with

Although some people label Rust a systems programming language, we can use it to create business applications. Also, there are web frameworks available for Rust that will help us in our development effort. These Rust web frameworks include Actix-Web and Rocket.

Business applications do not resemble tools, system programs, or device drivers, which are usually very technical in coding. Meanwhile, the codes in business applications must be easier to understand and properly organized.

A simple example of using a layered architecture pattern in Rust is as follows, using Rocket.

│   Cargo.lock
│   Cargo.toml
│   README.md
│   Rocket.toml
│               
└───src
    │   main.rs
    │   
    ├───alerto_common
    │       alerto_common.rs
    │       alerto_common_controller_dtos.rs
    │       alerto_common_entities.rs
    │       alerto_common_service_dtos.rs
    │       mod.rs
    │       
    ├───alerto_controller
    │       alert_controller.rs
    │       mod.rs
    │       tenant_controller.rs
    │       
    ├───alerto_dao
    │       alert_dao.rs
    │       mod.rs
    │       tenant_dao.rs
    │       
    └───alerto_service
            alert_service.rs
            mod.rs
            tenant_service.rs

│ Cargo.lock

│ Cargo.toml

│ README.md

│ Rocket.toml

│

└───src

│ main.rs

│

├───alerto_common

│ alerto_common.rs

│ alerto_common_controller_dtos.rs

│ alerto_common_entities.rs

│ alerto_common_service_dtos.rs

│ mod.rs

│

├───alerto_controller

│ alert_controller.rs

│ mod.rs

│ tenant_controller.rs

│

├───alerto_dao

│ alert_dao.rs

│ mod.rs

│ tenant_dao.rs

│

└───alerto_service

alert_service.rs

mod.rs

tenant_service.rs

As we can see, we have a decent codebase organization which is something we should always have in business applications. With Rocket, our main function may look similar to the following codes.

mod alerto_common;
mod alerto_controller;
mod alerto_service;
mod alerto_dao;

#[macro_use] extern crate rocket;
use rocket_db_pools::{Database};

use crate::alerto_common::alerto_common::{AlertoDB};
use crate::alerto_controller::tenant_controller::tenant_create;

#[launch]
fn rocket() -> _ {
    rocket::build().attach(AlertoDB::init())
        .mount("/tenants", routes![tenant_create])
}

mod alerto_common;

mod alerto_controller;

mod alerto_service;

mod alerto_dao;

#[macro_use] extern crate rocket;

use rocket_db_pools::{Database};

use crate::alerto_common::alerto_common::{AlertoDB};

use crate::alerto_controller::tenant_controller::tenant_create;

#[launch]

fn rocket() -> _ {

rocket::build().attach(AlertoDB::init())

.mount("/tenants", routes![tenant_create])

}

Then, our request handler looks like the following codes to handle specific HTTP requests.

#[post("/", data = "<request>")]
pub async fn tenant_create(request: Json<CreateTenantRequest<'_>>, mut db_conn: Connection<AlertoDB>) -> Option<String> {

    let createTenantRequest = request.into_inner();

    let result = createTenantRequest.validate();

    
    let serviceRequest  = CreateTenantServiceRequest {
         name: createTenantRequest.name,
         description: createTenantRequest.description
    };
    
    create_tenant(serviceRequest, db_conn).await;

    return Option::Some(String::from("ok"));
}

#[post("/", data = "<request>")]

pub async fn tenant_create(request: Json<CreateTenantRequest<'_>>, mut db_conn: Connection<AlertoDB>) -> Option<String> {

let createTenantRequest = request.into_inner();

let result = createTenantRequest.validate();

let serviceRequest = CreateTenantServiceRequest {

name: createTenantRequest.name,

description: createTenantRequest.description

};

create_tenant(serviceRequest, db_conn).await;

return Option::Some(String::from("ok"));

}

Now it is apparent that our database connections come from some pool from the web framework. See the following posts.

Implementing a layered architecture pattern may mean pushing that database connection to the persistent layer. Then, we invoke SQL commands in that bottom layer.

If this is acceptable, then, by all means, proceed with a layered architecture pattern in Rust.