openserve 2.0.3

A modern, high-performance, AI-enhanced file server built in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! Search handlers

use axum::{
    extract::{Query, State},
    response::IntoResponse,
    Json,
};
use serde::Deserialize;
use tracing::{debug, error};
use serde_json;
use axum::http::StatusCode;

use crate::{
    server::AppState,
    models::SearchRequest,
    handlers::{error_response, success_response},
};

/// Query parameters for search operations.
#[derive(Debug, Deserialize)]
pub struct SearchQuery {
    /// The search query string.
    pub q: String,
    /// The maximum number of results to return.
    pub limit: Option<usize>,
}

/// Full-text search
pub async fn search(
    Query(query): Query<SearchQuery>,
    State(state): State<AppState>,
) -> impl IntoResponse {
    debug!("Searching for: {}", query.q);

    let limit = query.limit.unwrap_or(20);

    match state.search_service.search(&query.q, limit).await {
        Ok(results) => success_response(StatusCode::OK, &serde_json::to_string(&results).unwrap_or_default()),
        Err(e) => {
            error!("Search failed: {}", e);
            error_response(axum::http::StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
        }
    }
}

/// Semantic search using AI
pub async fn semantic_search(
    State(state): State<AppState>,
    Json(request): Json<SearchRequest>,
) -> impl IntoResponse {
    debug!("Semantic search for: {}", request.query);

    let limit = request.limit.unwrap_or(10);

    match state.search_service.semantic_search(&request.query, limit).await {
        Ok(results) => success_response(StatusCode::OK, &serde_json::to_string(&results).unwrap_or_default()),
        Err(e) => {
            error!("Semantic search failed: {}", e);
            error_response(axum::http::StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
        }
    }
}

/// File-based search (search through filenames and metadata)
pub async fn file_search(
    Query(query): Query<SearchQuery>,
    State(state): State<AppState>,
) -> impl IntoResponse {
    debug!("File search for: {}", query.q);

    let limit = query.limit.unwrap_or(20);

    match state.search_service.search(&query.q, limit).await {
        Ok(results) => success_response(StatusCode::OK, &serde_json::to_string(&results).unwrap_or_default()),
        Err(e) => {
            error!("File search failed: {}", e);
            error_response(axum::http::StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
        }
    }
}