feat: add search

Added search functionality. The design is inspired by Simon Willison's
search on his blog.

Author: realprogrammersusevim

Cargo.lock

@@ -7,12 +7,14 @@ edition = "2021"
 anyhow = "1.0.98"
 axum = "0.7.7"
 axum-embed = "0.1.0"
+chrono = { version = "0.4.41", features = ["serde"] }
 dotenvy = "0.15.7"
 include_dir = "0.7.4"
 lazy_static = "1.5.0"
 r2d2 = "0.8.10"
 r2d2_sqlite = { version = "0.30.0", features = ["bundled"] }
-rusqlite = { version = "0.36.0", features = ["bundled"] }
+regex = "1.11.1"
+rusqlite = { version = "0.36.0", features = ["bundled", "unlock_notify"] }
 rust-embed = "8.5.0"
 serde = { version = "1.0.217", features = ["serde_derive"] }
 serde_json = { version = "1.0.140", features = ["raw_value"] }

Cargo.toml

@@ -8,14 +8,16 @@ use tera::{Context, Tera};
 #[derive(Debug, Clone)]
 pub struct AppState {
     pub post_service: crate::services::post::PostService,
+    pub search_service: crate::services::search::SearchService,
     pub tera: Tera,
 }
 
 impl AppState {
     pub fn new(pool: Pool<SqliteConnectionManager>) -> Self {
         let tera = Self::load_templates().unwrap();
         AppState {
-            post_service: crate::services::post::PostService::new(pool),
+            post_service: crate::services::post::PostService::new(pool.clone()),
+            search_service: crate::services::search::SearchService::new(pool),
             tera,
         }
     }

src/app.rs

@@ -5,7 +5,7 @@ mod rss;
 mod services;
 
 use crate::app::AppState;
-use crate::routes::{about, contact, main_page, post, posts_index, Static, WellKnown};
+use crate::routes::{about, contact, main_page, post, posts_index, search, Static, WellKnown};
 use crate::rss::feed;
 use std::env;
 
@@ -59,6 +59,7 @@ async fn main() {
 
     let app = Router::new()
         .route("/", get(main_page))
+        .route("/search", get(search))
         .route("/posts", get(posts_index))
         .route("/about", get(about))
         .route("/contact", get(contact))

src/main.rs

@@ -1,4 +1,4 @@
-use crate::app::AppState;
+use crate::{app::AppState, services::search_query::SearchQuery};
 use axum::{
     extract::{Path, Query, State},
     http::StatusCode,
@@ -20,6 +20,12 @@ pub async fn main_page(state: State<AppState>) -> Response {
     }
 }
 
+#[derive(Debug, Deserialize)]
+pub struct SearchParams {
+    q: Option<String>,
+    page: Option<usize>,
+}
+
 #[derive(Deserialize)]
 pub struct Pagination {
     page: Option<usize>,
@@ -73,6 +79,37 @@ pub async fn post(Path(id): Path<String>, state: State<AppState>) -> Response {
     }
 }
 
+pub async fn search(Query(params): Query<SearchParams>, state: State<AppState>) -> Response {
+    let query_str = params.q.unwrap_or_default();
+    let page = params.page.unwrap_or(1);
+    let per_page = 10;
+
+    let search_query = SearchQuery::from_raw(&query_str);
+    match state
+        .search_service
+        .search(&search_query, page, per_page)
+        .await
+    {
+        Ok((posts, total)) => {
+            let mut context = Context::new();
+            context.insert("query", &query_str);
+            context.insert("posts", &posts);
+            context.insert("current_page", &page);
+
+            let total_pages = (total as f64 / per_page as f64).ceil() as usize;
+            context.insert("total_pages", &total_pages);
+            context.insert("per_page", &per_page);
+            context.insert("total_results", &total);
+
+            state.render("search.html", &context).unwrap()
+        }
+        Err(err) => {
+            tracing::error!("Search failed: {:?}", err);
+            StatusCode::INTERNAL_SERVER_ERROR.into_response()
+        }
+    }
+}
+
 #[derive(RustEmbed, Clone)]
 #[folder = "static/"]
 pub struct Static;

src/routes.rs

@@ -1 +1,3 @@
 pub mod post;
+pub mod search;
+pub mod search_query;

src/services/mod.rs

@@ -0,0 +1,127 @@
+use super::{post::PostService, search_query::SearchQuery};
+use anyhow::Context;
+use r2d2::Pool;
+use r2d2_sqlite::SqliteConnectionManager;
+use rusqlite::Row;
+use tokio::task;
+
+#[derive(Clone, Debug)]
+pub struct SearchService {
+    pool: Pool<SqliteConnectionManager>,
+}
+
+impl SearchService {
+    pub fn new(pool: Pool<SqliteConnectionManager>) -> Self {
+        Self { pool }
+    }
+
+    fn row_to_post(row: &Row) -> rusqlite::Result<crate::post::Post> {
+        PostService::row_to_post(row)
+    }
+
+    pub async fn search(
+        &self,
+        query: &SearchQuery,
+        page: usize,
+        per_page: usize,
+    ) -> anyhow::Result<(Vec<crate::post::Post>, usize)> {
+        // Create a full clone of the query data to move into the thread
+        let owned_query = SearchQuery {
+            text_query: query.text_query.clone(),
+            tags: query.tags.clone(),
+            from_date: query.from_date.clone(),
+            to_date: query.to_date.clone(),
+        };
+        let offset = (page - 1) * per_page;
+        let pool = self.pool.clone();
+
+        let (posts, total) = task::spawn_blocking(move || {
+            let conn = pool.get()?;
+            let base_query = if owned_query.text_query.is_empty() {
+                "FROM posts".to_string()
+            } else {
+                "FROM posts INNER JOIN posts_fts ON posts.rowid = posts_fts.rowid".to_string()
+            };
+
+            let mut conditions = vec![];
+            let mut params: Vec<Box<dyn rusqlite::ToSql>> = vec![];
+
+            if !owned_query.text_query.is_empty() {
+                conditions.push("posts_fts MATCH ?".to_string());
+                params.push(Box::new(owned_query.text_query.clone()));
+            }
+
+            for tag in &owned_query.tags {
+                conditions.push("EXISTS (SELECT 1 FROM json_each(posts.tags) WHERE value = ?)".to_string());
+                params.push(Box::new(tag));
+            }
+
+            if let Some(date) = &owned_query.from_date {
+                conditions.push("posts.date >= ?".to_string());
+                params.push(Box::new(date));
+            }
+            if let Some(date) = &owned_query.to_date {
+                conditions.push("posts.date <= ?".to_string());
+                params.push(Box::new(date));
+            }
+
+            let where_clause = if !conditions.is_empty() {
+                format!("WHERE {}", conditions.join(" AND "))
+            } else {
+                "".to_string()
+            };
+
+            let order_clause = if owned_query.text_query.is_empty() {
+                "ORDER BY date DESC".to_string()
+            } else {
+                "ORDER BY rank".to_string()
+            };
+
+            // Prepare count query first (borrows params immutably)
+            let count_query = format!(
+                "SELECT COUNT(*)
+                {}
+                {}",
+                base_query, where_clause
+            );
+            let total: i64 = conn.query_row(
+                &count_query,
+                rusqlite::params_from_iter(params.iter().map(|p| &**p)),
+                |r| r.get(0),
+            )?;
+
+            // Main query to fetch posts (takes ownership of params)
+            let posts_query = format!(
+                "SELECT posts.*
+                {}
+                {}
+                {}
+                LIMIT ? OFFSET ?",
+                base_query, where_clause, order_clause
+            );
+
+            let mut stmt = conn.prepare(&posts_query)?;
+            params.push(Box::new(per_page as i64));
+            params.push(Box::new(offset as i64));
+
+            // Execute query and collect results
+            let iter = stmt.query_map(
+                rusqlite::params_from_iter(params.iter().map(|p| &**p)),
+                Self::row_to_post,
+            )?;
+            let mut posts = Vec::new();
+            for post in iter {
+                posts.push(post?);
+            }
+
+            Ok::<_, anyhow::Error>((posts, total as usize))
+        })
+        .await?
+        .context("Search execution failed")?;
+
+        let post_service = PostService::new(self.pool.clone());
+        let posts_with_commits = post_service.bulk_convert_to_posts(posts).await?;
+
+        Ok((posts_with_commits, total))
+    }
+}

src/services/search.rs

@@ -0,0 +1,42 @@
+use regex::Regex;
+
+#[derive(Debug, Default)]
+pub struct SearchQuery {
+    pub text_query: String,
+    pub tags: Vec<String>,
+    pub from_date: Option<String>,
+    pub to_date: Option<String>,
+}
+
+impl SearchQuery {
+    pub fn from_raw(raw: &str) -> Self {
+        let mut result = SearchQuery::default();
+        let tag_re = Regex::new(r"tag:([^\s]+)").unwrap();
+        let date_re = Regex::new(r"(from|to):(\d{4}-\d{2}-\d{2})").unwrap();
+
+        // Extract tags
+        for cap in tag_re.captures_iter(raw) {
+            if let Some(tag) = cap.get(1).map(|m| m.as_str().to_string()) {
+                result.tags.push(tag);
+            }
+        }
+
+        // Extract dates
+        for cap in date_re.captures_iter(raw) {
+            if let (Some(typ), Some(date)) = (cap.get(1), cap.get(2)) {
+                match typ.as_str() {
+                    "from" => result.from_date = Some(date.as_str().to_string()),
+                    "to" => result.to_date = Some(date.as_str().to_string()),
+                    _ => (),
+                }
+            }
+        }
+
+        // Clean text query
+        result.text_query = tag_re.replace_all(raw, "").to_string();
+        result.text_query = date_re.replace_all(&result.text_query, "").to_string();
+        result.text_query = result.text_query.trim().to_string();
+
+        result
+    }
+}

src/services/search_query.rs

@@ -20,6 +20,11 @@ header {
     box-sizing: border-box;
 }
 
+/* Special case adjustment */
+form:not(.nav-search-form) .search-box {
+  max-width: 400px;
+}
+
 /* Use a clean sans-serif for headings */
 h1, h2, h3 {
     font-family: 'Lato', sans-serif;
@@ -168,12 +173,39 @@ footer p {
     margin: 0; /* Remove margin from footer text */
 }
 
+
 /* Style for permalinks */
 p > a[href^="/post/"] {
     font-size: 0.9em;
     color: #666;
 }
 
+/* Search Form Styles */
+.search-box {
+  padding: 12px 15px;
+  border: 1px solid #ddd;
+  border-radius: 30px;
+  font-size: 16px;
+  width: 100%;
+  max-width: 100%;
+  margin: 15px 0;
+  background: #f5f5f5;
+}
+
+.search-btn {
+  background-color: #0056b3;
+  color: white;
+  border: none;
+  padding: 8px 16px;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 16px;
+}
+
+.search-btn:hover {
+  background-color: #004494;
+}
+
 /* Pagination Styles */
 .pagination {
     text-align: center;

static/css/style.css

@@ -27,6 +27,7 @@ <h1><a href="/">Jonathan's Blog</a></h1>
         <a href="/posts">Archive</a>
         <a href="/about">About</a>
         <a href="/contact">Contact</a>
+        <a href="/search">Search</a>
       </nav>
     </header>
     {% block content %} {% endblock %}