wip: get all posts route working state

backend/public/src/datasources/posts.rs

@@ -1,11 +1,15 @@
-use sqlx::PgPool;
+use sqlx::{PgPool, Pool, Postgres};
+
+use crate::routes::posts::Post;
 
 pub struct PostsDatasource;
 impl PostsDatasource {
-    pub async fn get_all(pool: PgPool) {
+    pub async fn get_all(pool: &Pool<Postgres>) -> Result<Vec<Post>, sqlx::Error> {
-        sqlx::query("SELECT title, body, created_at FROM posts ORDER BY created_at DESC LIMIT 10")
+        sqlx::query_as::<_, Post>(
-            .fetch_all(&pool)
+            "SELECT post_id, title, body, created_at FROM posts ORDER BY created_at DESC LIMIT 10",
-            .await;
+        )
+        .fetch_all(pool)
+        .await
     }
-    pub async fn get_one(pool: PgPool) {}
+    pub async fn get_one(pool: PgPool, post_id: i32) {}
 }

backend/public/src/main.rs

@@ -46,11 +46,11 @@ async fn main() {
     // build our application with some routes
     let app = Router::new()
         .nest("/", routes::root::RootRoute::routes())
-        .nest("/posts", routes::posts::PostsRoute::routes(&app_state))
+        .nest("/posts", routes::posts::PostsRoute::routes(&app_state));
-        .nest(
+    // .nest(
-            "/comments",
+    //     "/comments",
-            routes::comments::CommentsRoute::routes(&app_state),
+    //     routes::comments::CommentsRoute::routes(&app_state),
-        );
+    // );
 
     // run it with hyper
     let listener = TcpListener::bind("0.0.0.0:3000").await.unwrap();

backend/public/src/routes/comments.rs

@@ -19,21 +19,21 @@ impl CommentsRoute {
     pub fn routes(app_state: &AppState) -> axum::Router {
         // add more comment routes here!
         axum::Router::new()
-            .route("/post/:id", get(CommentsRoute::get_post_comments))
+            // .route("/post/:id", get(CommentsRoute::get_post_comments))
-            .route("/add", post(CommentsRoute::insert_comment))
+            // .route("/add", post(CommentsRoute::insert_comment))
-            .with_state(app_state.db)
+            .with_state(app_state.db.clone())
     }
 
-    async fn get_post_comments(State(pool): State<PgPool>) -> Json<()> {
+    // async fn get_post_comments(State(pool): State<PgPool>) -> Json<()> {
-        let results = CommentsDatasource::get_posts_comments(pool).await;
+    //     let results = CommentsDatasource::get_posts_comments(pool).await;
-        Json {}
+    //     Json {}
-    }
+    // }
-
+    //
-    async fn insert_comment(
+    // async fn insert_comment(
-        State(pool): State<PgPool>,
+    //     State(pool): State<PgPool>,
-        Form(comment_input): Form<CommentInput>,
+    //     Form(comment_input): Form<CommentInput>,
-    ) -> bool {
+    // ) -> bool {
-        let results = CommentsDatasource::insert_comment(pool, comment_input).await;
+    //     let results = CommentsDatasource::insert_comment(pool, comment_input).await;
-        true
+    //     true
-    }
+    // }
 }

backend/public/src/routes/posts.rs

@@ -1,32 +1,58 @@
 use crate::{datasources::posts::PostsDatasource, AppState};
-use axum::{extract::State, routing::get, Json, Router};
+use axum::{
-use sqlx::PgPool;
+    extract::State,
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    routing::get,
+    Json, Router,
+};
+use chrono::Utc;
+use serde::{Serialize, Serializer};
+use sqlx::{PgPool, Pool, Postgres};
+
+#[derive(sqlx::FromRow, Serialize)]
+pub struct Post {
+    pub post_id: i32,
+    pub title: String,
+    pub body: String,
+    #[serde(serialize_with = "serialize_datetime")]
+    pub created_at: chrono::DateTime<Utc>,
+}
 
 pub struct PostsRoute;
 impl PostsRoute {
     pub fn routes(app_state: &AppState) -> Router {
         // add more post routes here!
         Router::new()
-            .route("/", get(PostsRoute::get_all))
+            .route("/all", get(PostsRoute::get_all))
-            .route("/:id", get(PostsRoute::get_one))
+            // .route("/:id", get(PostsRoute::get_one))
-            .with_state(app_state.db)
+            .with_state(app_state.db.clone())
     }
 
     // get all posts
-    async fn get_all(State(pool): State<PgPool>) -> Json<()> {
+    async fn get_all(State(pool): State<Pool<Postgres>>) -> impl IntoResponse {
-        let results = PostsDatasource::get_all(pool).await;
+        match PostsDatasource::get_all(&pool).await {
-        Json {}
+            Ok(posts) => Ok(Json(posts)),
+            Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
+        }
     }
 
     // get one post
-    async fn get_one(State(pool): State<PgPool>) -> Json<()> {
+    // async fn get_one(State(pool): State<PgPool>) -> Json<()> {
-        let results = PostsDatasource::get_one(pool).await;
+    //     let results = PostsDatasource::get_one(pool).await;
-        Json {}
+    //     Json {}
-    }
+    // }
 
     // get the top three posts with the highest view count
-    async fn get_popular_posts(State(pool): State<PgPool>) -> Json<()> {}
+    // async fn get_popular_posts(State(pool): State<PgPool>) {}
 
     // get the top three posts with the most comments
-    async fn get_hot_posts(State(pool): State<PgPool>) -> Json<()> {}
+    // async fn get_hot_posts(State(pool): State<PgPool>) {}
+}
+
+fn serialize_datetime<S>(date: &chrono::DateTime<Utc>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    serializer.serialize_str(&date.to_rfc3339())
 }

backend/public/src/routes/root.rs

@@ -8,9 +8,8 @@ use axum::{
 pub struct RootRoute;
 impl RootRoute {
     pub fn routes() -> Router {
-        Router::new()
+        Router::new().route("/", get(RootRoute::root))
-            .route("/", get(RootRoute::root))
+        // .fallback(RootRoute::not_found)
-            .fallback(RootRoute::not_found)
     }
 
     async fn root() -> Html<&'static str> {