revamp home api

update the implementation of `/api/prism/v1/home`
remove titles of alerts, dashboards, correlations, filters from home api

updated response -
```
{
    "alerts_info": {
        "total": 0,
        "silenced": 0,
        "resolved": 0,
        "triggered": 0,
        "low": 0,
        "medium": 0,
        "high": 0,
        "critical": 0
    },
    "stats_details": [
        {
            "date": "2025-04-30",
            "events": 0,
            "ingestion_size": 0,
            "storage_size": 0
        },
        {
            "date": "2025-05-01",
            "events": 0,
            "ingestion_size": 0,
            "storage_size": 0
        },
        {
            "date": "2025-05-02",
            "events": 3866860,
            "ingestion_size": 5260602290,
            "storage_size": 736510108
        },
        {
            "date": "2025-05-03",
            "events": 0,
            "ingestion_size": 0,
            "storage_size": 0
        },
        {
            "date": "2025-05-04",
            "events": 0,
            "ingestion_size": 0,
            "storage_size": 0
        },
        {
            "date": "2025-05-05",
            "events": 0,
            "ingestion_size": 0,
            "storage_size": 0
        },
        {
            "date": "2025-05-06",
            "events": 2027400,
            "ingestion_size": 2757834546,
            "storage_size": 384782870
        }
    ],
    "datasets": [
        {
            "title": "test15",
            "dataset_type": "Logs"
        }
    ]
}
```

add another api to be called from prism
`/api/prism/v1/home/search`

server sends title and id of alerts, dashboards, correlations, filters

```
{
    "alerts": [],
    "correlations": [],
    "dashboards": [],
    "filters": [
        {
            "title": "body not null",
            "id": "e71d1affa4ad72136e03092a717a4b0e0c3fd6d643a09572ad65e1748a5c2df8"
        },
        {
            "title": "select *",
            "id": "6fe16f99b05566d7d4a598a7f0fa2604379d75164cdda5657c7fdbf61e54a555"
        }
    ]
}
```

update datasets api -
update readers priviledge - add `GetRetention` action
remove distinct values from datasets api
prism to call the query apis directly for p_src_ip and p_user_agent

Author: nikhilsinhaparseable

src/handlers/http/modal/server.rs

@@ -148,8 +148,10 @@ impl ParseableServer for Server {
 }
 
 impl Server {
-    pub fn get_prism_home() -> Resource {
-        web::resource("/home").route(web::get().to(http::prism_home::home_api))
+    pub fn get_prism_home() -> Scope {
+        web::scope("/home")
+            .service(web::resource("").route(web::get().to(http::prism_home::home_api)))
+            .service(web::resource("/search").route(web::get().to(http::prism_home::home_search)))
     }
 
     pub fn get_prism_logstream() -> Scope {

src/handlers/http/prism_home.rs

@@ -19,7 +19,7 @@
 use actix_web::{web, HttpRequest, Responder};
 
 use crate::{
-    prism::home::{generate_home_response, PrismHomeError},
+    prism::home::{generate_home_response, generate_home_search_response, PrismHomeError},
     utils::actix::extract_session_key_from_req,
 };
 
@@ -37,3 +37,12 @@ pub async fn home_api(req: HttpRequest) -> Result<impl Responder, PrismHomeError
 
     Ok(web::Json(res))
 }
+
+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 res = generate_home_search_response(&key).await?;
+
+    Ok(web::Json(res))
+}

src/prism/home/mod.rs

@@ -44,7 +44,7 @@ use crate::{
 type StreamMetadataResponse = Result<(String, Vec<ObjectStoreFormat>, DataSetType), PrismHomeError>;
 
 #[derive(Debug, Serialize, Default)]
-struct StreamInfo {
+struct StreamStats {
     // stream_count: u32,
     // log_source_count: u32,
     stats_summary: Stats,
@@ -79,40 +79,25 @@ struct DataSet {
 
 #[derive(Debug, Serialize)]
 pub struct HomeResponse {
-    alert_titles: Vec<TitleAndId>,
     alerts_info: AlertsInfo,
-    correlation_titles: Vec<TitleAndId>,
-    stream_info: StreamInfo,
     stats_details: Vec<DatedStats>,
-    stream_titles: Vec<String>,
     datasets: Vec<DataSet>,
-    dashboard_titles: Vec<TitleAndId>,
-    filter_titles: Vec<TitleAndId>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct HomeSearchResponse {
+    alerts: Vec<TitleAndId>,
+    correlations: Vec<TitleAndId>,
+    dashboards: Vec<TitleAndId>,
+    filters: Vec<TitleAndId>,
 }
 
 pub async fn generate_home_response(key: &SessionKey) -> Result<HomeResponse, PrismHomeError> {
     // Execute these operations concurrently
-    let (
-        stream_titles_result,
-        alert_titles_result,
-        correlation_titles_result,
-        dashboards_result,
-        filters_result,
-        alerts_info_result,
-    ) = tokio::join!(
-        get_stream_titles(key),
-        get_alert_titles(key),
-        get_correlation_titles(key),
-        get_dashboard_titles(key),
-        get_filter_titles(key),
-        get_alerts_info()
-    );
+    let (stream_titles_result, alerts_info_result) =
+        tokio::join!(get_stream_titles(key), get_alerts_info());
 
     let stream_titles = stream_titles_result?;
-    let alert_titles = alert_titles_result?;
-    let correlation_titles = correlation_titles_result?;
-    let dashboard_titles = dashboards_result?;
-    let filter_titles = filters_result?;
     let alerts_info = alerts_info_result?;
 
     // Generate dates for date-wise stats
@@ -161,7 +146,7 @@ pub async fn generate_home_response(key: &SessionKey) -> Result<HomeResponse, Pr
         futures::future::join_all(stats_futures).await;
 
     let mut stream_details = Vec::new();
-    let mut summary = StreamInfo::default();
+    let mut summary = StreamStats::default();
 
     for result in stats_results {
         match result {
@@ -179,104 +164,11 @@ pub async fn generate_home_response(key: &SessionKey) -> Result<HomeResponse, Pr
     }
 
     Ok(HomeResponse {
-        stream_info: summary,
         stats_details: stream_details,
-        stream_titles,
         datasets,
-        alert_titles,
-        correlation_titles,
-        dashboard_titles,
-        filter_titles,
         alerts_info,
     })
 }
-
-// Helper functions to split the work
-
-async fn get_stream_titles(key: &SessionKey) -> Result<Vec<String>, PrismHomeError> {
-    let stream_titles: Vec<String> = PARSEABLE
-        .storage
-        .get_object_store()
-        .list_streams()
-        .await
-        .map_err(|e| PrismHomeError::Anyhow(anyhow::Error::new(e)))?
-        .into_iter()
-        .filter(|logstream| {
-            Users.authorize(key.clone(), Action::ListStream, Some(logstream), None)
-                == crate::rbac::Response::Authorized
-        })
-        .sorted()
-        .collect_vec();
-
-    Ok(stream_titles)
-}
-
-async fn get_alert_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
-    let alert_titles = ALERTS
-        .list_alerts_for_user(key.clone())
-        .await?
-        .iter()
-        .map(|alert| TitleAndId {
-            title: alert.title.clone(),
-            id: alert.id.to_string(),
-        })
-        .collect_vec();
-
-    Ok(alert_titles)
-}
-
-async fn get_correlation_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
-    let correlation_titles = CORRELATIONS
-        .list_correlations(key)
-        .await?
-        .iter()
-        .map(|corr| TitleAndId {
-            title: corr.title.clone(),
-            id: corr.id.clone(),
-        })
-        .collect_vec();
-
-    Ok(correlation_titles)
-}
-
-async fn get_dashboard_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
-    let dashboard_titles = DASHBOARDS
-        .list_dashboards(key)
-        .await
-        .iter()
-        .map(|dashboard| TitleAndId {
-            title: dashboard.name.clone(),
-            id: dashboard
-                .dashboard_id
-                .as_ref()
-                .ok_or_else(|| anyhow::Error::msg("Dashboard ID is null"))
-                .unwrap()
-                .clone(),
-        })
-        .collect_vec();
-
-    Ok(dashboard_titles)
-}
-
-async fn get_filter_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
-    let filter_titles = FILTERS
-        .list_filters(key)
-        .await
-        .iter()
-        .map(|filter| TitleAndId {
-            title: filter.filter_name.clone(),
-            id: filter
-                .filter_id
-                .as_ref()
-                .ok_or_else(|| anyhow::Error::msg("Filter ID is null"))
-                .unwrap()
-                .clone(),
-        })
-        .collect_vec();
-
-    Ok(filter_titles)
-}
-
 async fn get_stream_metadata(
     stream: String,
 ) -> Result<(String, Vec<ObjectStoreFormat>, DataSetType), PrismHomeError> {
@@ -374,6 +266,114 @@ async fn get_stream_stats_for_date(
     ))
 }
 
+pub async fn generate_home_search_response(
+    key: &SessionKey,
+) -> 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 alerts = alert_titles?;
+    let correlations = correlation_titles?;
+    let dashboards = dashboard_titles?;
+    let filters = filter_titles?;
+
+    Ok(HomeSearchResponse {
+        alerts,
+        correlations,
+        dashboards,
+        filters,
+    })
+}
+
+// Helper functions to split the work
+async fn get_stream_titles(key: &SessionKey) -> Result<Vec<String>, PrismHomeError> {
+    let stream_titles: Vec<String> = PARSEABLE
+        .storage
+        .get_object_store()
+        .list_streams()
+        .await
+        .map_err(|e| PrismHomeError::Anyhow(anyhow::Error::new(e)))?
+        .into_iter()
+        .filter(|logstream| {
+            Users.authorize(key.clone(), Action::ListStream, Some(logstream), None)
+                == crate::rbac::Response::Authorized
+        })
+        .sorted()
+        .collect_vec();
+
+    Ok(stream_titles)
+}
+
+async fn get_alert_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
+    let alert_titles = ALERTS
+        .list_alerts_for_user(key.clone())
+        .await?
+        .iter()
+        .map(|alert| TitleAndId {
+            title: alert.title.clone(),
+            id: alert.id.to_string(),
+        })
+        .collect_vec();
+
+    Ok(alert_titles)
+}
+
+async fn get_correlation_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
+    let correlation_titles = CORRELATIONS
+        .list_correlations(key)
+        .await?
+        .iter()
+        .map(|corr| TitleAndId {
+            title: corr.title.clone(),
+            id: corr.id.clone(),
+        })
+        .collect_vec();
+
+    Ok(correlation_titles)
+}
+
+async fn get_dashboard_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
+    let dashboard_titles = DASHBOARDS
+        .list_dashboards(key)
+        .await
+        .iter()
+        .map(|dashboard| TitleAndId {
+            title: dashboard.name.clone(),
+            id: dashboard
+                .dashboard_id
+                .as_ref()
+                .ok_or_else(|| anyhow::Error::msg("Dashboard ID is null"))
+                .unwrap()
+                .clone(),
+        })
+        .collect_vec();
+
+    Ok(dashboard_titles)
+}
+
+async fn get_filter_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
+    let filter_titles = FILTERS
+        .list_filters(key)
+        .await
+        .iter()
+        .map(|filter| TitleAndId {
+            title: filter.filter_name.clone(),
+            id: filter
+                .filter_id
+                .as_ref()
+                .ok_or_else(|| anyhow::Error::msg("Filter ID is null"))
+                .unwrap()
+                .clone(),
+        })
+        .collect_vec();
+
+    Ok(filter_titles)
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum PrismHomeError {
     #[error("Error: {0}")]