Escrevendo uma API com MongoDB no Rust

1
[dependencies]
2
mongodb = "2.8.1"

1
mongodb = {version = "2.8.1", features = ["sync"]}

1
rocket = {version = "0.5.0", features = ["json"]}

1
rocket_db_pools = { version = "0.1.0", features = ["mongodb"] }

1
[default.databases.<db_name>] 
2
url = "<MongoDB Connection String>" 

1
[default.databases.db] 
2
url = "mongodb+srv://<username>:<password>@tutorial.xzpnmhw.mongodb.net/?retryWrites=true&w=majority&appName=tutorial" 

1
. 
2
├── Cargo.lock      # dependency info 
3
├── Cargo.toml      # project and dependency info 
4
├── Rocket.toml     # rocket config info 
5
└── src             # directory where our rust code lives 
6
    ├── db.rs       # file used to establish db 
7
    ├── main.rs     # file used to start the API 
8
    ├── models.rs   # file used for organization of data 
9
    └── routes.rs  # file used for API routes 

1
use rocket_db_pools::{mongodb::Client, Database}; 
2
3
#[derive(Database)] 
4
#[database("<db_name>")] 
5
pub struct MainDatabase(Client);

1
use rocket_db_pools::{mongodb::Client, Database}; 
2
3
#[derive(Database)] 
4
#[database("db")] 
5
pub struct MainDatabase(Client); 

1
mod db; 
2
mod models; 
3
mod routes; 
4
5
use rocket::{launch, routes}; 
6
use rocket_db_pools::Database; 
7
8
#[launch] 
9
fn rocket() -> _ { 
10
    rocket::build().attach(db::MainDatabase::init()).mount() 
11
}

1
use mongodb::bson::oid::ObjectId; 
2
use rocket::serde::{Deserialize, Serialize}; 
3
4
#[derive(Debug, Serialize, Deserialize)] 
5
#[serde(crate = "rocket::serde")] 
6
pub struct Recipe { 
7
    #[serde(rename = "_id", skip_serializing_if = "Option::is_none")] 
8
    pub id: Option<ObjectId>, 
9
    pub title: String, 
10
    pub ingredients: Vec<String>, 
11
    pub temperature: u32, 
12
    pub bake_time: u32, 
13
}

1
#[get("/recipes", format = "json")] 
2
pub async fn get_recipes(db: Connection<MainDatabase>) -> Json<Vec<Recipe>> { 
3
    let recipes: Cursor<Recipe> = db 
4
    .database("bread") 
5
    .collection("recipes") 
6
    .find(None, None) 
7
    .await 
8
    .expect("Failed to retrieve recipes"); 
9
     
10
    Json(recipes.try_collect().await.unwrap()) 
11
}

1
mod db; 
2
mod models; 
3
mod routes; 
4
5
use rocket::{launch, routes}; 
6
use rocket_db_pools::Database; 
7
8
#[launch] 
9
fn rocket() -> _ { 
10
    rocket::build().attach(db::MainDatabase::init()).mount( 
11
        "/", 
12
        routes![ 
13
            routes::index, 
14
            routes::get_recipes, 
15
            routes::create_recipe, 
16
            routes::get_recipe 
17
        ], 
18
    ) 
19
}

1
#[post("/recipes", data = "<data>", format = "json")] 
2
pub async fn create_recipe( 
3
    db: Connection<MainDatabase>, 
4
    data: Json<Recipe>, 
5
) -> status::Custom<Json<Value>> { 
6
    if let Ok(res) = db 
7
        .database("bread") 
8
        .collection::<Recipe>("recipes") 
9
        .insert_one(data.into_inner(), None) 
10
        .await 
11
    { 
12
        if let Some(id) = res.inserted_id.as_object_id() { 
13
            return status::Custom( 
14
                Status::Created, 
15
                Json( 
16
                    json!({"status": "success", "message": format!("Recipe ({}) created successfully", id.to_string())}), 
17
                ), 
18
            ); 
19
        } 
20
    } 
21
22
    status::Custom( 
23
        Status::BadRequest, 
24
        Json(json!({"status": "error", "message":"Recipe could not be created"})), 
25
    ) 
26
}

1
#[get("/recipes", format = "json")] 
2
pub async fn get_recipes(db: Connection<MainDatabase>) -> Json<Vec<Recipe>> { 
3
    let recipes = db 
4
        .database("bread") 
5
        .collection("recipes") 
6
        .find(None, None) 
7
        .await; 
8
9
    if let Ok(r) = recipes { 
10
        if let Ok(collected) = r.try_collect::<Vec<Recipe>>().await { 
11
            return Json(collected); 
12
        } 
13
    } 
14
15
    return Json(vec![]); 
16
}

1
#[get("/recipes/<id>", format = "json")] 
2
pub async fn get_recipe(db: Connection<MainDatabase>, id: &str) -> status::Custom<Json<Value>> { 
3
    let b_id = ObjectId::parse_str(id); 
4
5
    if b_id.is_err() { 
6
        return status::Custom( 
7
            Status::BadRequest, 
8
            Json(json!({"status": "error", "message":"Recipe ID is invalid"})), 
9
        ); 
10
    } 
11
12
    if let Ok(Some(recipe)) = db 
13
        .database("bread") 
14
        .collection::<Recipe>("recipes") 
15
        .find_one(doc! {"_id": b_id.unwrap()}, None) 
16
        .await 
17
    { 
18
        return status::Custom( 
19
            Status::Ok, 
20
            Json(json!({"status": "success", "data": recipe})), 
21
        ); 
22
    } 
23
24
    return status::Custom( 
25
        Status::NotFound, 
26
        Json(json!({"status": "success", "message": "Recipe not found"})), 
27
    ); 
28
}

1
#[put("/recipes/<id>", data = "<data>", format = "json")] 
2
pub async fn update_recipe( 
3
    db: Connection<MainDatabase>, 
4
    data: Json<Recipe>, 
5
    id: &str, 
6
) -> status::Custom<Json<Value>> { 
7
    let b_id = ObjectId::parse_str(id); 
8
9
    if b_id.is_err() { 
10
        return status::Custom( 
11
            Status::BadRequest, 
12
            Json(json!({"status": "error", "message":"Recipe ID is invalid"})), 
13
        ); 
14
    } 
15
16
    if let Ok(_) = db 
17
        .database("bread") 
18
        .collection::<Recipe>("recipes") 
19
        .update_one( 
20
            doc! {"_id": b_id.as_ref().unwrap()}, 
21
            doc! {"$set": mongodb::bson::to_document(&data.into_inner()).unwrap()}, 
22
            None, 
23
        ) 
24
        .await 
25
    { 
26
        return status::Custom( 
27
            Status::Created, 
28
            Json( 
29
                json!({"status": "success", "message": format!("Recipe ({}) updated successfully", b_id.unwrap())}), 
30
            ), 
31
        ); 
32
    }; 
33
34
    status::Custom( 
35
        Status::BadRequest, 
36
        Json( 
37
            json!({"status": "success", "message": format!("Recipe ({}) could not be updated successfully", b_id.unwrap())}), 
38
        ), 
39
    ) 
40
}

1
#[delete("/recipes/<id>")] 
2
pub async fn delete_recipe(db: Connection<MainDatabase>, id: &str) -> status::Custom<Json<Value>> { 
3
    let b_id = ObjectId::parse_str(id); 
4
5
    if b_id.is_err() { 
6
        return status::Custom( 
7
            Status::BadRequest, 
8
            Json(json!({"status": "error", "message":"Recipe ID is invalid"})), 
9
        ); 
10
    } 
11
12
    if db 
13
        .database("bread") 
14
        .collection::<Recipe>("recipes") 
15
        .delete_one(doc! {"_id": b_id.as_ref().unwrap()}, None) 
16
        .await 
17
        .is_err() 
18
    { 
19
        return status::Custom( 
20
            Status::BadRequest, 
21
            Json( 
22
                json!({"status": "error", "message":format!("Recipe ({}) could not be deleted", b_id.unwrap())}), 
23
            ), 
24
        ); 
25
    }; 
26
27
    status::Custom( 
28
        Status::Accepted, 
29
        Json( 
30
            json!({"status": "", "message": format!("Recipe ({}) successfully deleted", b_id.unwrap())}), 
31
        ), 
32
    ) 
33
}

1
curl -v --header "Content-Type: application/json" --request POST --data '{"title":"simple bread recipe","ingredients":["water, flour"], "temperature": 250, "bake_time": 120}' http://localhost:8000/recipes 

1
curl -v --header "Content-Type: application/json" \ 
2
  --request PUT --data '{"title":"new, updated title!","ingredients":["water", "flour", "salt", "sugar"], "temperature": 440, "bake_time": 60}' \ 
3
  http://localhost:8000/recipes/<_id> 

1
curl -v --header "Content-Type: application/json" --header "Accept: application/json" http://localhost:8000/recipes/ 
2
3
curl -v --header "Content-Type: application/json" --header "Accept: application/json" http://localhost:8000/recipes/<_id> 

1
curl -v --header "Content-Type: application/json" --header "Accept: application/json" --request DELETE http://localhost:8000/recipes/<_id>