POSTGRESgit ap! LFG

lambda/Cargo.toml

@@ -11,7 +11,7 @@ lambda_http = "0.9.0"
 lambda_runtime = "0.9.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.111"
-sqlx = { version = "0.7.3", features = ["runtime-tokio", "postgres"] }
+sqlx = { version = "0.7.3", features = ["runtime-tokio", "macros", "postgres", "uuid"] }
 tokio = { version = "1", features = ["macros"] }
 tracing = { version = "0.1", features = ["log"] }
 tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }

lambda/src/lib.rs

@@ -4,5 +4,5 @@ pub mod recipe;
 pub mod services;
 
 pub trait Repository<T>: Send + Sync {
-    fn find_by_id(&self, id: Uuid) -> Option<T>;
+    async fn find_by_id(&self, id: Uuid) -> Option<T>;
 }

lambda/src/main.rs

@@ -30,10 +30,11 @@ async fn main() -> Result<(), Error> {
         .without_time()
         .init();
 
+    let recipe_service = services::recipes().await;
     let app = Router::new()
         .route("/", get(root))
         .route("/ping", get(ping))
-        .nest("/recipes", services::recipes());
+        .nest("/recipes", recipe_service);
 
     run(app).await
 }

lambda/src/recipe/mod.rs

@@ -1,7 +1,8 @@
 use serde::{Deserialize, Serialize};
+use sqlx::FromRow;
 use uuid::Uuid;
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, FromRow, Serialize)]
 pub struct Recipe {
     id: Uuid,
     name: String,

lambda/src/services/mod.rs

@@ -1,6 +1,7 @@
-use axum::Router;
 use axum::routing::get;
-use crate::services::recipes::TestRecipeRepository;
+use axum::Router;
+
+use crate::services::recipes::PostgresRecipeRepository;
 
 mod recipes;
 
@@ -9,12 +10,21 @@ struct ApplicationContext<T> {
     pub repo: T,
 }
 
-pub fn recipes() -> Router {
+pub async fn recipes() -> Router {
+    let db_username = std::env::var("DB_USERNAME").unwrap_or_else(|_| "postgres".to_string());
+    let db_password = std::env::var("DB_PASSWORD").unwrap_or_else(|_| "password1234".to_string());
+    let db_host = std::env::var("DB_HOST").unwrap_or_else(|_| "db".to_string());
+    let db_port = std::env::var("DB_PORT").unwrap_or_else(|_| "5432".to_string());
+    let db_name = std::env::var("DB_NAME").unwrap_or_else(|_| "meal-planner".to_string());
+    let db_connection_str = format!(
+        "postgresql://{db_username}:{db_password}@{db_host}:{db_port}/{db_name}"
+    );
+
     let recipe_context = ApplicationContext {
-        repo: TestRecipeRepository {}
+        repo: PostgresRecipeRepository::new(&db_connection_str).await,
     };
 
     Router::new()
-        .route("/:id", get(recipes::read_one::<TestRecipeRepository>))
+        .route("/:id", get(recipes::read_one::<PostgresRecipeRepository>))
         .with_state(recipe_context)
 }

lambda/src/services/recipes.rs

@@ -1,6 +1,10 @@
+use std::time::Duration;
+
 use axum::extract::{Path, State};
 use axum::http::StatusCode;
 use axum::Json;
+use sqlx::postgres::PgPoolOptions;
+use sqlx::{Error, PgPool, Postgres};
 use uuid::Uuid;
 
 use crate::recipe::Recipe;
@@ -10,12 +14,38 @@ use crate::Repository;
 #[derive(Clone)]
 pub(super) struct TestRecipeRepository {}
 
-impl Repository<Recipe> for TestRecipeRepository {
-    fn find_by_id(&self, id: Uuid) -> Option<Recipe> {
-        if id.is_nil() {
-            return Some(Recipe::default());
+#[derive(Clone)]
+pub(super) struct PostgresRecipeRepository {
+    pool: PgPool,
+}
+
+impl PostgresRecipeRepository {
+    pub(super) async fn new(url: &str) -> Self {
+        let pool: PgPool = PgPoolOptions::new()
+            .max_connections(5)
+            .acquire_timeout(Duration::from_secs(3))
+            .connect(&url)
+            .await
+            .expect("Can\'t connect to database");
+
+        Self { pool }
+    }
+}
+
+impl Repository<Recipe> for PostgresRecipeRepository {
+    async fn find_by_id(&self, id: Uuid) -> Option<Recipe> {
+        let result: Result<Recipe, Error> = sqlx::query_as("SELECT * FROM recipes WHERE id = $1")
+            .bind(id)
+            .fetch_one(&self.pool)
+            .await;
+
+        match result {
+            Ok(recipe) => Some(recipe),
+            Err(err) => {
+                dbg!(err);
+                None
+            },
         }
-        None
     }
 }
 
@@ -26,7 +56,7 @@ pub(super) async fn read_one<T>(
 where
     T: Repository<Recipe>,
 {
-    if let Some(recipe) = state.repo.find_by_id(id) {
+    if let Some(recipe) = state.repo.find_by_id(id).await {
         return Ok(Json(recipe));
     }