refactor: whole server refactor to consolidate post fetching

Author: realprogrammersusevim

Cargo.lock

@@ -4,13 +4,15 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+anyhow = "1.0.98"
 axum = "0.7.7"
 axum-embed = "0.1.0"
 dotenvy = "0.15.7"
 include_dir = "0.7.4"
 lazy_static = "1.5.0"
 rust-embed = "8.5.0"
 serde = { version = "1.0.217", features = ["serde_derive"] }
+serde_json = { version = "1.0.140", features = ["raw_value"] }
 sqlx = { version = "0.8.2", features = ["runtime-tokio", "sqlite"] }
 tera = "1.20.0"
 tokio = { version = "1.43.1", features = ["full"] }

Cargo.toml

@@ -0,0 +1,50 @@
+use anyhow::Result;
+use axum::response::{IntoResponse, Response};
+use rust_embed::RustEmbed;
+use sqlx::{Pool, Sqlite};
+use tera::{Context, Tera};
+
+#[derive(Clone)]
+pub struct AppState {
+    pub post_service: crate::services::post::PostService,
+    pub tera: Tera,
+}
+
+impl AppState {
+    pub fn new(pool: Pool<Sqlite>) -> Self {
+        let tera = Self::load_templates().unwrap();
+        AppState {
+            post_service: crate::services::post::PostService::new(pool),
+            tera,
+        }
+    }
+
+    fn load_templates() -> Result<Tera> {
+        #[derive(RustEmbed)]
+        #[folder = "templates/"]
+        struct TemplateAssets;
+
+        let mut tera = Tera::default();
+        let mut templates = vec![];
+
+        for path in TemplateAssets::iter() {
+            let content_bytes = TemplateAssets::get(&path)
+                .ok_or_else(|| anyhow::anyhow!("Template {} not found", path))?
+                .data;
+
+            let content = std::str::from_utf8(&content_bytes)
+                .map_err(|_| anyhow::anyhow!("Template {} not valid UTF-8", path))?;
+            templates.push((path.into_owned(), content.to_owned()))
+        }
+
+        tera.add_raw_templates(templates)
+            .expect("Can't parse templates.");
+
+        Ok(tera)
+    }
+
+    pub fn render(&self, template: &str, context: &Context) -> Result<Response> {
+        let rendered = self.tera.render(template, context)?;
+        Ok(axum::response::Html(rendered).into_response())
+    }
+}

src/app.rs

@@ -1,39 +1,31 @@
+mod app;
 mod post;
 mod routes;
 mod rss;
+mod services;
 
-use post::{Post, QueryPost};
-use routes::{about, contact, main_page, post, posts_index, Static, WellKnown};
-use rss::feed;
-
+use crate::app::AppState;
+use crate::routes::{about, contact, main_page, post, posts_index, Static, WellKnown};
+use crate::rss::feed;
 use std::env;
 
 use axum::{
     extract::{MatchedPath, Request},
-    response::{Html, IntoResponse, Response},
     routing::get,
     Router,
 };
-use lazy_static::lazy_static;
-use rust_embed::RustEmbed;
-use sqlx::{sqlite::SqlitePool, Pool, Sqlite};
-use tera::{Context, Tera};
+use sqlx::sqlite::SqlitePool;
 use tower_http::trace::TraceLayer;
 use tracing::info_span;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
-#[derive(Debug, Clone)]
-pub struct AppState {
-    pub pool: Pool<Sqlite>,
-}
-
 #[tokio::main]
 async fn main() {
     dotenvy::dotenv().ok();
     let pool = SqlitePool::connect(&env::var("DATABASE_URL").expect("No DATABASE_URL set"))
         .await
         .expect("Couldn't connect to database");
-    let state = AppState { pool };
+    let state = AppState::new(pool);
 
     let static_files = axum_embed::ServeEmbed::<Static>::with_parameters(
         None,
@@ -88,64 +80,3 @@ async fn main() {
     .expect("Failed to bind port");
     axum::serve(listener, app).await.unwrap();
 }
-
-#[derive(Debug, Clone)]
-struct MainPage {
-    title: String,
-    posts: Vec<Post>,
-}
-
-impl IntoResponse for MainPage {
-    fn into_response(self) -> Response {
-        let mut context = Context::new();
-        context.insert("title", &self.title);
-        context.insert("posts", &self.posts);
-        let rendered = TEMPLATES
-            .render("index.html", &context)
-            .expect("Failed to render template");
-        Html(rendered).into_response()
-    }
-}
-
-#[derive(Debug, Clone)]
-struct PostsPage {
-    title: String,
-    posts: Vec<Post>,
-    current_page: usize,
-    total_pages: usize,
-}
-
-impl IntoResponse for PostsPage {
-    fn into_response(self) -> Response {
-        let mut context = Context::new();
-        context.insert("title", &self.title);
-        context.insert("posts", &self.posts);
-        context.insert("current_page", &self.current_page);
-        context.insert("total_pages", &self.total_pages);
-        let rendered = TEMPLATES
-            .render("posts.html", &context)
-            .expect("Failed to render template");
-        Html(rendered).into_response()
-    }
-}
-
-#[derive(RustEmbed)]
-#[folder = "templates/"]
-struct Templates;
-
-lazy_static! {
-    pub static ref TEMPLATES: Tera = {
-        let mut tera = Tera::default();
-
-        let templates_to_add = Templates::iter().map(|path| {
-            let contents = Templates::get(path.as_ref()).unwrap().data;
-            let content_string = String::from_utf8(contents.into_owned()).unwrap();
-            (path, content_string)
-        });
-
-        tera.add_raw_templates(templates_to_add)
-            .expect("Failed to add raw templates");
-
-        return tera;
-    };
-}

src/main.rs

@@ -1,13 +1,6 @@
-use crate::{AppState, TEMPLATES};
-
-use axum::{
-    extract::State,
-    response::{Html, IntoResponse, Response},
-};
 use serde::Serialize;
-use tera::Context;
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
 pub struct Commit {
     pub id: String,
     pub date: String,
@@ -47,77 +40,7 @@ pub struct QueryPost {
     pub commits: Option<String>,
 }
 
-impl QueryPost {
-    pub async fn fetch(id: &str, app: State<AppState>) -> Result<QueryPost, sqlx::Error> {
-        sqlx::query_as!(
-            QueryPost,
-            r#"
-        SELECT *
-        FROM posts
-        WHERE id = ? AND content_type != 'special'
-        "#,
-            id,
-        )
-        .fetch_one(&app.pool)
-        .await
-    }
-
-    pub async fn fetch_special(id: &str, app: State<AppState>) -> Result<QueryPost, sqlx::Error> {
-        sqlx::query_as!(
-            QueryPost,
-            r#"
-        SELECT *
-        FROM posts
-        WHERE id = ? AND content_type = 'special'
-        "#,
-            id
-        )
-        .fetch_one(&app.pool)
-        .await
-    }
-
-    pub async fn into_post(self, app: State<AppState>) -> Post {
-        let commits = match self.commits {
-            Some(commits) => {
-                // The commit ids for the post are stored as a whitespace-separated string
-                let commits_clone = commits.clone();
-                let commit_ids: Vec<&str> = commits_clone.split_whitespace().collect();
-                let mut commits = Vec::new();
-                for commit_id in commit_ids {
-                    let commit = sqlx::query_as!(
-                        Commit,
-                        r#"
-                    SELECT id, date, subject, body
-                    FROM commits
-                    WHERE id = ?
-                    "#,
-                        commit_id
-                    )
-                    .fetch_one(&app.pool)
-                    .await
-                    .unwrap();
-
-                    commits.push(commit);
-                }
-
-                Some(commits)
-            }
-            None => None,
-        };
-
-        Post {
-            id: self.id,
-            title: self.title,
-            content_type: self.content_type,
-            link: self.link,
-            via: self.via,
-            quote_author: self.quote_author,
-            date: self.date,
-            content: self.content,
-            real_commits: commits,
-        }
-    }
-}
+impl QueryPost {}
 
 #[derive(Debug, Clone, Serialize)]
 pub struct Post {
@@ -131,14 +54,3 @@ pub struct Post {
     pub content: String,
     pub real_commits: Option<Vec<Commit>>,
 }
-
-impl IntoResponse for Post {
-    fn into_response(self) -> Response {
-        let mut context = Context::new();
-        context.insert("post", &self);
-        let rendered = TEMPLATES
-            .render("post.html", &context)
-            .expect("Failed to render template");
-        Html(rendered).into_response()
-    }
-}