fix: home search api

nikhilsinhaparseable · nikhilsinhaparseable · commit 041ef30b2323 · 2025-05-07T05:30:57.000-04:00
request - `http://localhost:8000/api/prism/v1/home/search?key=frontend`

response -
```
{
    "resources": [
        {
            "id": "e890c2f70362528b57d528b65a39de62bbd3c65f90f6923dce25e27a8a66e8a4",
            "name": "select flags not 0",
            "resource_type": "Filter"
        },
        {
            "id": "e71d1affa4ad72136e03092a717a4b0e0c3fd6d643a09572ad65e1748a5c2df8",
            "name": "body not null",
            "resource_type": "Filter"
        },
        {
            "id": "6fe16f99b05566d7d4a598a7f0fa2604379d75164cdda5657c7fdbf61e54a555",
            "name": "select *",
            "resource_type": "Filter"
        },
        {
            "id": "fcda9d6a2b98c3368cbf1d903bb408e59f084df2dcb7c7d5d7b044e800ec1437",
            "name": "frontend limit",
            "resource_type": "Filter"
        }
    ]
}
```
diff --git a/src/handlers/http/prism_home.rs b/src/handlers/http/prism_home.rs
@@ -23,6 +23,8 @@ use crate::{
     utils::actix::extract_session_key_from_req,
 };
 
+const HOME_SEARCH_QUERY_PARAM: &str = "key";
+
 /// Fetches the data to populate Prism's home
 ///
 ///
@@ -41,8 +43,22 @@ pub async fn home_api(req: HttpRequest) -> Result<impl Responder, PrismHomeError
 pub async fn home_search(req: HttpRequest) -> Result<impl Responder, PrismHomeError> {
     let key = extract_session_key_from_req(&req)
         .map_err(|err| PrismHomeError::Anyhow(anyhow::Error::msg(err.to_string())))?;
+    let query_string = req.query_string();
+    if query_string.is_empty() {
+        return Ok(web::Json(serde_json::json!({})));
+    }
+    // Validate query string format
+    let query_parts: Vec<&str> = query_string.split('=').collect();
+    if query_parts.len() != 2 || query_parts[0] != HOME_SEARCH_QUERY_PARAM {
+        return Err(PrismHomeError::InvalidQueryParameter(
+            HOME_SEARCH_QUERY_PARAM.to_string(),
+        ));
+    }
 
-    let res = generate_home_search_response(&key).await?;
+    let query_value = query_parts[1].to_lowercase();
+    let res = generate_home_search_response(&key, &query_value).await?;
+    let json_res = serde_json::to_value(res)
+        .map_err(|err| PrismHomeError::Anyhow(anyhow::Error::msg(err.to_string())))?;
 
-    Ok(web::Json(res))
+    Ok(web::Json(json_res))
 }
diff --git a/src/prism/home/mod.rs b/src/prism/home/mod.rs
@@ -50,12 +50,6 @@ struct DatedStats {
     storage_size: u64,
 }
 
-#[derive(Debug, Serialize)]
-struct TitleAndId {
-    title: String,
-    id: String,
-}
-
 #[derive(Debug, Serialize)]
 enum DataSetType {
     Logs,
@@ -76,12 +70,25 @@ pub struct HomeResponse {
     datasets: Vec<DataSet>,
 }
 
+#[derive(Debug, Serialize)]
+pub enum ResourceType {
+    Alert,
+    Correlation,
+    Dashboard,
+    Filter,
+    DataSet,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Resource {
+    id: String,
+    name: String,
+    resource_type: ResourceType,
+}
+
 #[derive(Debug, Serialize)]
 pub struct HomeSearchResponse {
-    alerts: Vec<TitleAndId>,
-    correlations: Vec<TitleAndId>,
-    dashboards: Vec<TitleAndId>,
-    filters: Vec<TitleAndId>,
+    resources: Vec<Resource>,
 }
 
 pub async fn generate_home_response(key: &SessionKey) -> Result<HomeResponse, PrismHomeError> {
@@ -255,25 +262,37 @@ async fn get_stream_stats_for_date(
 
 pub async fn generate_home_search_response(
     key: &SessionKey,
+    query_value: &str,
 ) -> Result<HomeSearchResponse, PrismHomeError> {
-    let (alert_titles, correlation_titles, dashboard_titles, filter_titles) = tokio::join!(
-        get_alert_titles(key),
-        get_correlation_titles(key),
-        get_dashboard_titles(key),
-        get_filter_titles(key)
+    let mut resources = Vec::new();
+    let (alert_titles, correlation_titles, dashboard_titles, filter_titles, stream_titles) = tokio::join!(
+        get_alert_titles(key, query_value),
+        get_correlation_titles(key, query_value),
+        get_dashboard_titles(key, query_value),
+        get_filter_titles(key, query_value),
+        get_stream_titles(key)
     );
 
     let alerts = alert_titles?;
+    resources.extend(alerts);
     let correlations = correlation_titles?;
+    resources.extend(correlations);
     let dashboards = dashboard_titles?;
+    resources.extend(dashboards);
     let filters = filter_titles?;
-
-    Ok(HomeSearchResponse {
-        alerts,
-        correlations,
-        dashboards,
-        filters,
-    })
+    resources.extend(filters);
+    let stream_titles = stream_titles?;
+
+    for title in stream_titles {
+        if title.to_lowercase().contains(query_value) {
+            resources.push(Resource {
+                id: title.clone(),
+                name: title,
+                resource_type: ResourceType::DataSet,
+            });
+        }
+    }
+    Ok(HomeSearchResponse { resources })
 }
 
 // Helper functions to split the work
@@ -295,59 +314,108 @@ async fn get_stream_titles(key: &SessionKey) -> Result<Vec<String>, PrismHomeErr
     Ok(stream_titles)
 }
 
-async fn get_alert_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
-    let alert_titles = ALERTS
+async fn get_alert_titles(
+    key: &SessionKey,
+    query_value: &str,
+) -> Result<Vec<Resource>, PrismHomeError> {
+    let alerts = ALERTS
         .list_alerts_for_user(key.clone())
         .await?
         .iter()
-        .map(|alert| TitleAndId {
-            title: alert.title.clone(),
-            id: alert.id.to_string(),
+        .filter_map(|alert| {
+            if alert.title.to_lowercase().contains(query_value)
+                || alert.id.to_string().to_lowercase().contains(query_value)
+            {
+                Some(Resource {
+                    id: alert.id.to_string(),
+                    name: alert.title.clone(),
+                    resource_type: ResourceType::Alert,
+                })
+            } else {
+                None
+            }
         })
         .collect_vec();
 
-    Ok(alert_titles)
+    Ok(alerts)
 }
 
-async fn get_correlation_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
-    let correlation_titles = CORRELATIONS
+async fn get_correlation_titles(
+    key: &SessionKey,
+    query_value: &str,
+) -> Result<Vec<Resource>, PrismHomeError> {
+    let correlations = CORRELATIONS
         .list_correlations(key)
         .await?
         .iter()
-        .map(|corr| TitleAndId {
-            title: corr.title.clone(),
-            id: corr.id.clone(),
+        .filter_map(|correlation| {
+            if correlation.title.to_lowercase().contains(query_value)
+                || correlation.id.to_lowercase().contains(query_value)
+            {
+                Some(Resource {
+                    id: correlation.id.to_string(),
+                    name: correlation.title.clone(),
+                    resource_type: ResourceType::Correlation,
+                })
+            } else {
+                None
+            }
         })
         .collect_vec();
 
-    Ok(correlation_titles)
+    Ok(correlations)
 }
 
-async fn get_dashboard_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
+async fn get_dashboard_titles(
+    key: &SessionKey,
+    query_value: &str,
+) -> Result<Vec<Resource>, PrismHomeError> {
     let dashboard_titles = DASHBOARDS
         .list_dashboards(key)
         .await
         .iter()
-        .map(|dashboard| TitleAndId {
-            title: dashboard.name.clone(),
-            id: dashboard.dashboard_id.as_ref().unwrap().clone(),
+        .filter_map(|dashboard| {
+            let dashboard_id = dashboard.dashboard_id.as_ref().unwrap().clone();
+            if dashboard.name.to_lowercase().contains(query_value)
+                || dashboard_id.to_lowercase().contains(query_value)
+            {
+                Some(Resource {
+                    id: dashboard_id,
+                    name: dashboard.name.clone(),
+                    resource_type: ResourceType::Dashboard,
+                })
+            } else {
+                None
+            }
         })
         .collect_vec();
 
     Ok(dashboard_titles)
 }
 
-async fn get_filter_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
+async fn get_filter_titles(
+    key: &SessionKey,
+    query_value: &str,
+) -> Result<Vec<Resource>, PrismHomeError> {
     let filter_titles = FILTERS
         .list_filters(key)
         .await
         .iter()
-        .map(|filter| TitleAndId {
-            title: filter.filter_name.clone(),
-            id: filter.filter_id.as_ref().unwrap().clone(),
+        .filter_map(|filter| {
+            let filter_id = filter.filter_id.as_ref().unwrap().clone();
+            if filter.filter_name.to_lowercase().contains(query_value)
+                || filter_id.to_lowercase().contains(query_value)
+            {
+                Some(Resource {
+                    id: filter_id,
+                    name: filter.filter_name.clone(),
+                    resource_type: ResourceType::Filter,
+                })
+            } else {
+                None
+            }
         })
         .collect_vec();
-
     Ok(filter_titles)
 }
 
@@ -363,6 +431,8 @@ pub enum PrismHomeError {
     StreamError(#[from] StreamError),
     #[error("ObjectStorageError: {0}")]
     ObjectStorageError(#[from] ObjectStorageError),
+    #[error("Invalid query parameter: {0}")]
+    InvalidQueryParameter(String),
 }
 
 impl actix_web::ResponseError for PrismHomeError {
@@ -373,6 +443,7 @@ impl actix_web::ResponseError for PrismHomeError {
             PrismHomeError::CorrelationError(e) => e.status_code(),
             PrismHomeError::StreamError(e) => e.status_code(),
             PrismHomeError::ObjectStorageError(_) => StatusCode::INTERNAL_SERVER_ERROR,
+            PrismHomeError::InvalidQueryParameter(_) => StatusCode::BAD_REQUEST,
         }
     }
 
