hyprstream_appview/
http.rs1use std::sync::Arc;
2
3use axum::extract::{Extension, Query, State};
4use axum::http::StatusCode;
5use axum::response::{IntoResponse, Response};
6use axum::routing::get;
7use axum::{Json, Router};
8use hyprstream_pds_service::federation_intake::IdentityInventoryReadModel;
9use hyprstream_rpc::auth::mac::{CompartmentSet, Level, SecurityContext, VerifiedKeyMaterial};
10use serde::Deserialize;
11
12const MAX_FILTER_BYTES: usize = 256;
13const MAX_CURSOR_BYTES: usize = 2048;
14const DEFAULT_PAGE_SIZE: usize = 200;
15const MAX_PAGE_SIZE: usize = 200;
16
17#[derive(Clone)]
18struct InventoryHttpState {
19 inventory: Arc<dyn IdentityInventoryReadModel>,
20}
21
22#[derive(Clone, Debug)]
27pub struct InventoryViewer(SecurityContext);
28
29impl InventoryViewer {
30 pub fn from_verified_clearance(clearance: SecurityContext) -> Self {
32 Self(clearance)
33 }
34
35 fn unauthenticated_floor() -> Self {
36 Self(SecurityContext::new(
37 Level::Public,
38 CompartmentSet::EMPTY,
39 VerifiedKeyMaterial::Unverified,
40 ))
41 }
42}
43
44#[derive(Debug, Default, Deserialize)]
45struct InventoryQuery {
46 filter: Option<String>,
47 after: Option<String>,
48 limit: Option<usize>,
49}
50
51pub fn inventory_router(inventory: Arc<dyn IdentityInventoryReadModel>) -> Router {
58 Router::new()
59 .route("/inventory", get(query_inventory))
60 .with_state(InventoryHttpState { inventory })
61}
62
63async fn query_inventory(
64 State(state): State<InventoryHttpState>,
65 Query(query): Query<InventoryQuery>,
66 viewer: Option<Extension<InventoryViewer>>,
67) -> Response {
68 if query
69 .filter
70 .as_deref()
71 .is_some_and(|filter| filter.len() > MAX_FILTER_BYTES)
72 || query
73 .after
74 .as_deref()
75 .is_some_and(|after| after.len() > MAX_CURSOR_BYTES)
76 || query.limit == Some(0)
77 {
78 return (
79 StatusCode::BAD_REQUEST,
80 Json(serde_json::json!({"error": "invalid inventory query"})),
81 )
82 .into_response();
83 }
84 let limit = query.limit.unwrap_or(DEFAULT_PAGE_SIZE).min(MAX_PAGE_SIZE);
85 let viewer = viewer
86 .map(|Extension(viewer)| viewer)
87 .unwrap_or_else(InventoryViewer::unauthenticated_floor);
88 match state
89 .inventory
90 .query_page(
91 &viewer.0,
92 query.filter.as_deref(),
93 query.after.as_deref(),
94 limit,
95 )
96 .await
97 {
98 Ok(entries) => Json(entries).into_response(),
99 Err(error) => {
100 tracing::error!(error = %error, "inventory query failed");
101 (
102 StatusCode::INTERNAL_SERVER_ERROR,
103 Json(serde_json::json!({"error": "inventory unavailable"})),
104 )
105 .into_response()
106 }
107 }
108}
109
110#[cfg(test)]
111mod tests {
112 #![allow(clippy::expect_used, clippy::unwrap_used)]
113
114 use axum::body::{to_bytes, Body};
115 use axum::http::Request;
116 use hyprstream_pds_service::federation_intake::{InMemoryIdentityInventory, InventoryEntry};
117 use hyprstream_rpc::auth::mac::{Assurance, SecurityLabel};
118 use tower::ServiceExt;
119
120 use super::*;
121
122 #[tokio::test]
123 async fn get_inventory_returns_only_post_clearance_array() {
124 let inventory = Arc::new(InMemoryIdentityInventory::default());
125 inventory
126 .upsert_derived(
127 InventoryEntry::indexed_federated(
128 "did:web:public.example",
129 Some("alice.example".to_owned()),
130 None,
131 )
132 .unwrap(),
133 SecurityLabel::bottom(),
134 )
135 .await
136 .unwrap();
137 inventory
138 .upsert_derived(
139 InventoryEntry::indexed_federated(
140 "did:web:hidden.example",
141 Some("hidden.example".to_owned()),
142 None,
143 )
144 .unwrap(),
145 SecurityLabel::new(
146 Level::Secret,
147 Assurance::PqHybrid,
148 CompartmentSet::single(9),
149 ),
150 )
151 .await
152 .unwrap();
153 let app = inventory_router(inventory);
154
155 let response = app
156 .clone()
157 .oneshot(
158 Request::get("/inventory?filter=example")
159 .body(Body::empty())
160 .unwrap(),
161 )
162 .await
163 .unwrap();
164 assert_eq!(response.status(), StatusCode::OK);
165 let body: serde_json::Value =
166 serde_json::from_slice(&to_bytes(response.into_body(), 8192).await.unwrap()).unwrap();
167 let entries = body.as_array().expect("response must be a bare array");
168 assert_eq!(entries.len(), 1);
169 assert_eq!(entries[0]["did"], "did:web:public.example");
170 assert!(body.get("total").is_none());
171 assert!(body.get("hiddenCount").is_none());
172
173 let response = app
174 .clone()
175 .oneshot(
176 Request::get(format!(
177 "/inventory?filter={}",
178 "x".repeat(MAX_FILTER_BYTES + 1)
179 ))
180 .body(Body::empty())
181 .unwrap(),
182 )
183 .await
184 .unwrap();
185 assert_eq!(response.status(), StatusCode::BAD_REQUEST);
186
187 let privileged = InventoryViewer::from_verified_clearance(SecurityContext::new(
188 Level::Secret,
189 CompartmentSet::single(9),
190 VerifiedKeyMaterial::PqHybrid,
191 ));
192 let mut request = Request::get("/inventory?limit=1")
193 .body(Body::empty())
194 .unwrap();
195 request.extensions_mut().insert(privileged.clone());
196 let response = app.clone().oneshot(request).await.unwrap();
197 let body: serde_json::Value =
198 serde_json::from_slice(&to_bytes(response.into_body(), 8192).await.unwrap()).unwrap();
199 let page = body.as_array().unwrap();
200 assert_eq!(page.len(), 1);
201 let after = page[0]["did"].as_str().unwrap();
202
203 let mut request = Request::get(format!("/inventory?limit=1&after={after}"))
204 .body(Body::empty())
205 .unwrap();
206 request.extensions_mut().insert(privileged);
207 let response = app.oneshot(request).await.unwrap();
208 let body: serde_json::Value =
209 serde_json::from_slice(&to_bytes(response.into_body(), 8192).await.unwrap()).unwrap();
210 assert_eq!(body.as_array().unwrap().len(), 1);
211 }
212}