chore: reorganize project into monorepo

backend/src/controllers/search.rs

@@ -0,0 +1,190 @@
+use loco_rs::prelude::*;
+use sea_orm::{ConnectionTrait, DatabaseBackend, DbBackend, FromQueryResult, Statement};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::models::_entities::posts;
+use crate::services::content;
+
+#[derive(Clone, Debug, Default, Deserialize)]
+pub struct SearchQuery {
+    pub q: Option<String>,
+    pub limit: Option<u64>,
+}
+
+#[derive(Clone, Debug, Serialize, FromQueryResult)]
+pub struct SearchResult {
+    pub id: i32,
+    pub title: Option<String>,
+    pub slug: String,
+    pub description: Option<String>,
+    pub content: Option<String>,
+    pub category: Option<String>,
+    pub tags: Option<Value>,
+    pub post_type: Option<String>,
+    pub pinned: Option<bool>,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    pub updated_at: chrono::DateTime<chrono::Utc>,
+    pub rank: f64,
+}
+
+fn search_sql() -> &'static str {
+    r#"
+    SELECT
+        p.id,
+        p.title,
+        p.slug,
+        p.description,
+        p.content,
+        p.category,
+        p.tags,
+        p.post_type,
+        p.pinned,
+        p.created_at,
+        p.updated_at,
+        ts_rank_cd(
+            setweight(to_tsvector('simple', coalesce(p.title, '')), 'A') ||
+            setweight(to_tsvector('simple', coalesce(p.description, '')), 'B') ||
+            setweight(to_tsvector('simple', coalesce(p.category, '')), 'C') ||
+            setweight(to_tsvector('simple', coalesce(p.tags::text, '')), 'C') ||
+            setweight(to_tsvector('simple', coalesce(p.content, '')), 'D'),
+            plainto_tsquery('simple', $1)
+        )::float8 AS rank
+    FROM posts p
+    WHERE (
+        setweight(to_tsvector('simple', coalesce(p.title, '')), 'A') ||
+        setweight(to_tsvector('simple', coalesce(p.description, '')), 'B') ||
+        setweight(to_tsvector('simple', coalesce(p.category, '')), 'C') ||
+        setweight(to_tsvector('simple', coalesce(p.tags::text, '')), 'C') ||
+        setweight(to_tsvector('simple', coalesce(p.content, '')), 'D')
+    ) @@ plainto_tsquery('simple', $1)
+    ORDER BY rank DESC, p.created_at DESC
+    LIMIT $2
+    "#
+}
+
+fn app_level_rank(post: &posts::Model, wanted: &str) -> f64 {
+    let wanted_lower = wanted.to_lowercase();
+    let mut rank = 0.0;
+
+    if post
+        .title
+        .as_deref()
+        .unwrap_or_default()
+        .to_lowercase()
+        .contains(&wanted_lower)
+    {
+        rank += 4.0;
+    }
+
+    if post
+        .description
+        .as_deref()
+        .unwrap_or_default()
+        .to_lowercase()
+        .contains(&wanted_lower)
+    {
+        rank += 2.5;
+    }
+
+    if post
+        .content
+        .as_deref()
+        .unwrap_or_default()
+        .to_lowercase()
+        .contains(&wanted_lower)
+    {
+        rank += 1.0;
+    }
+
+    if post
+        .category
+        .as_deref()
+        .unwrap_or_default()
+        .to_lowercase()
+        .contains(&wanted_lower)
+    {
+        rank += 1.5;
+    }
+
+    if post
+        .tags
+        .as_ref()
+        .and_then(Value::as_array)
+        .map(|tags| {
+            tags.iter()
+                .filter_map(Value::as_str)
+                .any(|tag| tag.to_lowercase().contains(&wanted_lower))
+        })
+        .unwrap_or(false)
+    {
+        rank += 2.0;
+    }
+
+    rank
+}
+
+async fn fallback_search(ctx: &AppContext, q: &str, limit: u64) -> Result<Vec<SearchResult>> {
+    let mut results = posts::Entity::find().all(&ctx.db).await?;
+    results.sort_by(|left, right| right.created_at.cmp(&left.created_at));
+
+    Ok(results
+        .into_iter()
+        .map(|post| {
+            let rank = app_level_rank(&post, q);
+            (post, rank)
+        })
+        .filter(|(_, rank)| *rank > 0.0)
+        .take(limit as usize)
+        .map(|(post, rank)| SearchResult {
+            id: post.id,
+            title: post.title,
+            slug: post.slug,
+            description: post.description,
+            content: post.content,
+            category: post.category,
+            tags: post.tags,
+            post_type: post.post_type,
+            pinned: post.pinned,
+            created_at: post.created_at.into(),
+            updated_at: post.updated_at.into(),
+            rank,
+        })
+        .collect())
+}
+
+#[debug_handler]
+pub async fn search(
+    Query(query): Query<SearchQuery>,
+    State(ctx): State<AppContext>,
+) -> Result<Response> {
+    content::sync_markdown_posts(&ctx).await?;
+
+    let q = query.q.unwrap_or_default().trim().to_string();
+    if q.is_empty() {
+        return format::json(Vec::<SearchResult>::new());
+    }
+
+    let limit = query.limit.unwrap_or(20).clamp(1, 100);
+
+    let results = if ctx.db.get_database_backend() == DatabaseBackend::Postgres {
+        let statement = Statement::from_sql_and_values(
+            DbBackend::Postgres,
+            search_sql(),
+            [q.clone().into(), (limit as i64).into()],
+        );
+
+        match SearchResult::find_by_statement(statement).all(&ctx.db).await {
+            Ok(rows) => rows,
+            Err(_) => fallback_search(&ctx, &q, limit).await?,
+        }
+    } else {
+        fallback_search(&ctx, &q, limit).await?
+    };
+
+    format::json(results)
+}
+
+pub fn routes() -> Routes {
+    Routes::new().prefix("api/search/").add("/", get(search))
+}