+1 -1

Cargo.toml

reviewed

··· 22 22 fjall = { git = "https://github.com/90-008/fjall.git", version = "3.1.4", features = ["lz4", "zstd"] } 23 23 base64 = "0.22.1" 24 24 futures = "0.3.32" 25 25 - tower-http = { version = "0.6.8", features = ["cors"] } 25 25 + tower-http = { version = "0.6.8", features = ["cors", "trace"] }

+85 -47

src/main.rs

reviewed

··· 175 175 .route("/xrpc/app.bsky.draft.deleteDraft", post(delete_draft)) 176 176 .fallback(proxy_request) 177 177 .layer(tower_http::cors::CorsLayer::permissive()) 178 178 + .layer(tower_http::trace::TraceLayer::new_for_http()) 178 179 .with_state(app_state); 179 180 180 181 let port = std::env::var("PORT") ··· 195 196 } 196 197 197 198 async fn proxy_request(req: Request) -> Result<Response, StatusCode> { 199 199 + tracing::info!("Proxying request: {} {}", req.method(), req.uri()); 198 200 let client = reqwest::Client::new(); 199 201 let uri = req.uri(); 200 202 let mut url = format!("https://public.api.bsky.app{}", uri.path()); ··· 258 260 let doc = match hydrant.resolver().resolve_doc(&seed_did).await { 259 261 Ok(d) => d, 260 262 Err(e) => { 261 261 - tracing::warn!("Could not resolve DID doc for seed account {}: {}", seed_did, e); 263 263 + tracing::warn!( 264 264 + "Could not resolve DID doc for seed account {}: {}", 265 265 + seed_did, 266 266 + e 267 267 + ); 262 268 return; 263 269 } 264 270 }; ··· 328 334 #[derive(Deserialize)] 329 335 struct GetPostThreadParams { 330 336 uri: String, 337 337 + #[serde(default)] 331 338 depth: Option<usize>, 332 332 - #[serde(rename = "parentHeight")] 339 339 + #[serde(default, rename = "parentHeight")] 333 340 parent_height: Option<usize>, 334 341 } 335 342 ··· 340 347 // let hydrant = &app_state.hydrant; 341 348 let query_str = req.uri().query().unwrap_or(""); 342 349 let Ok(params) = serde_urlencoded::from_str::<GetPostThreadParams>(query_str) else { 343 343 - return proxy_request(req).await; 350 350 + return Err(StatusCode::BAD_REQUEST); 344 351 }; 345 352 346 353 let viewer_did = get_auth_did(&req); ··· 522 529 // let hydrant = &app_state.hydrant; 523 530 let query_str = req.uri().query().unwrap_or(""); 524 531 let Ok(params) = serde_urlencoded::from_str::<GetProfileParams>(query_str) else { 525 525 - return proxy_request(req).await; 532 532 + return Err(StatusCode::BAD_REQUEST); 526 533 }; 527 534 528 535 let Ok(ident) = AtIdentifier::new(&params.actor) else { 529 529 - return proxy_request(req).await; 536 536 + return Err(StatusCode::BAD_REQUEST); 530 537 }; 531 538 532 539 if let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await { ··· 696 703 #[derive(Deserialize)] 697 704 struct GetAuthorFeedParams { 698 705 actor: String, 706 706 + #[serde(default)] 699 707 limit: Option<usize>, 708 708 + #[serde(default)] 700 709 cursor: Option<String>, 701 710 } 702 711 ··· 707 716 // let hydrant = &app_state.hydrant; 708 717 let query_str = req.uri().query().unwrap_or(""); 709 718 let Ok(params) = serde_urlencoded::from_str::<GetAuthorFeedParams>(query_str) else { 710 710 - return proxy_request(req).await; 719 719 + return Err(StatusCode::BAD_REQUEST); 711 720 }; 712 721 713 722 let Ok(ident) = AtIdentifier::new(&params.actor) else { 714 714 - return proxy_request(req).await; 723 723 + return Err(StatusCode::BAD_REQUEST); 715 724 }; 716 725 717 726 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { ··· 763 772 #[derive(Deserialize)] 764 773 struct GetLikesParams { 765 774 uri: String, 775 775 + #[serde(default)] 766 776 limit: Option<usize>, 777 777 + #[serde(default)] 767 778 cursor: Option<String>, 768 779 } 769 780 ··· 774 785 // let hydrant = &app_state.hydrant; 775 786 let query_str = req.uri().query().unwrap_or(""); 776 787 let Ok(params) = serde_urlencoded::from_str::<GetLikesParams>(query_str) else { 777 777 - return proxy_request(req).await; 788 788 + return Err(StatusCode::BAD_REQUEST); 778 789 }; 779 790 780 791 let limit = params.limit.unwrap_or(50).min(100); ··· 848 859 // let hydrant = &app_state.hydrant; 849 860 let query_str = req.uri().query().unwrap_or(""); 850 861 let Ok(params) = serde_urlencoded::from_str::<GetLikesParams>(query_str) else { 851 851 - return proxy_request(req).await; 862 862 + return Err(StatusCode::BAD_REQUEST); 852 863 }; 853 864 854 865 let limit = params.limit.unwrap_or(50).min(100); ··· 964 975 #[derive(Deserialize)] 965 976 struct GetFollowsParams { 966 977 actor: String, 978 978 + #[serde(default)] 967 979 limit: Option<usize>, 980 980 + #[serde(default)] 968 981 cursor: Option<String>, 969 982 } 970 983 ··· 975 988 // let hydrant = &app_state.hydrant; 976 989 let query_str = req.uri().query().unwrap_or(""); 977 990 let Ok(params) = serde_urlencoded::from_str::<GetFollowsParams>(query_str) else { 978 978 - return proxy_request(req).await; 991 991 + return Err(StatusCode::BAD_REQUEST); 979 992 }; 980 993 981 994 let Ok(ident) = AtIdentifier::new(&params.actor) else { 982 982 - return proxy_request(req).await; 995 995 + return Err(StatusCode::BAD_REQUEST); 983 996 }; 984 997 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { 985 998 return proxy_request(req).await; ··· 1028 1041 // let hydrant = &app_state.hydrant; 1029 1042 let query_str = req.uri().query().unwrap_or(""); 1030 1043 let Ok(params) = serde_urlencoded::from_str::<GetFollowsParams>(query_str) else { 1031 1031 - return proxy_request(req).await; 1044 1044 + return Err(StatusCode::BAD_REQUEST); 1032 1045 }; 1033 1046 1034 1047 let Ok(ident) = AtIdentifier::new(&params.actor) else { 1035 1035 - return proxy_request(req).await; 1048 1048 + return Err(StatusCode::BAD_REQUEST); 1036 1049 }; 1037 1050 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { 1038 1051 return proxy_request(req).await; ··· 1171 1184 1172 1185 #[derive(Deserialize)] 1173 1186 struct GetBookmarksParams { 1187 1187 + #[serde(default)] 1174 1188 limit: Option<usize>, 1189 1189 + #[serde(default)] 1175 1190 cursor: Option<String>, 1176 1191 } 1177 1192 ··· 1386 1401 1387 1402 #[derive(Deserialize)] 1388 1403 struct GetDraftsParams { 1404 1404 + #[serde(default)] 1389 1405 limit: Option<usize>, 1406 1406 + #[serde(default)] 1390 1407 cursor: Option<String>, 1391 1408 } 1392 1409 ··· 1447 1464 1448 1465 #[derive(Deserialize)] 1449 1466 struct GetTimelineParams { 1467 1467 + #[serde(default)] 1450 1468 algorithm: Option<String>, 1469 1469 + #[serde(default)] 1451 1470 limit: Option<usize>, 1471 1471 + #[serde(default)] 1452 1472 cursor: Option<String>, 1453 1473 } 1454 1474 ··· 1459 1479 // let hydrant = &app_state.hydrant; 1460 1480 let query_str = req.uri().query().unwrap_or(""); 1461 1481 let Ok(params) = serde_urlencoded::from_str::<GetTimelineParams>(query_str) else { 1462 1462 - return proxy_request(req).await; 1482 1482 + return Err(StatusCode::BAD_REQUEST); 1463 1483 }; 1464 1484 1465 1485 let Some(did_str) = get_auth_did(&req) else { ··· 1467 1487 }; 1468 1488 1469 1489 let Ok(ident) = AtIdentifier::new(&did_str) else { 1470 1470 - return proxy_request(req).await; 1490 1490 + return Err(StatusCode::BAD_REQUEST); 1471 1491 }; 1472 1492 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { 1473 1493 return proxy_request(req).await; ··· 1605 1625 #[derive(Deserialize)] 1606 1626 struct GetQuotesParams { 1607 1627 uri: String, 1628 1628 + #[serde(default)] 1608 1629 cid: Option<String>, 1630 1630 + #[serde(default)] 1609 1631 limit: Option<usize>, 1632 1632 + #[serde(default)] 1610 1633 cursor: Option<String>, 1611 1634 } 1612 1635 ··· 1617 1640 // let hydrant = &app_state.hydrant; 1618 1641 let query_str = req.uri().query().unwrap_or(""); 1619 1642 let Ok(params) = serde_urlencoded::from_str::<GetQuotesParams>(query_str) else { 1620 1620 - return proxy_request(req).await; 1643 1643 + return Err(StatusCode::BAD_REQUEST); 1621 1644 }; 1622 1645 1623 1646 let limit = params.limit.unwrap_or(50).min(100); ··· 1703 1726 #[derive(Deserialize)] 1704 1727 struct GetActorLikesParams { 1705 1728 actor: String, 1729 1729 + #[serde(default)] 1706 1730 limit: Option<usize>, 1731 1731 + #[serde(default)] 1707 1732 cursor: Option<String>, 1708 1733 } 1709 1734 ··· 1714 1739 // let hydrant = &app_state.hydrant; 1715 1740 let query_str = req.uri().query().unwrap_or(""); 1716 1741 let Ok(params) = serde_urlencoded::from_str::<GetActorLikesParams>(query_str) else { 1717 1717 - return proxy_request(req).await; 1742 1742 + return Err(StatusCode::BAD_REQUEST); 1718 1743 }; 1719 1744 1720 1745 let Ok(ident) = AtIdentifier::new(&params.actor) else { 1721 1721 - return proxy_request(req).await; 1746 1746 + return Err(StatusCode::BAD_REQUEST); 1722 1747 }; 1723 1748 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { 1724 1749 return proxy_request(req).await; ··· 1766 1791 // let hydrant = &app_state.hydrant; 1767 1792 let query_str = req.uri().query().unwrap_or(""); 1768 1793 let Ok(params) = serde_urlencoded::from_str::<GetRelationshipsParams>(query_str) else { 1769 1769 - return proxy_request(req).await; 1794 1794 + return Err(StatusCode::BAD_REQUEST); 1770 1795 }; 1771 1796 1772 1797 let others = extract_query_array(query_str, "others"); ··· 1775 1800 } 1776 1801 1777 1802 let Ok(ident) = AtIdentifier::new(&params.actor) else { 1778 1778 - return proxy_request(req).await; 1803 1803 + return Err(StatusCode::BAD_REQUEST); 1779 1804 }; 1780 1805 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { 1781 1806 return proxy_request(req).await; ··· 1869 1894 // let hydrant = &app_state.hydrant; 1870 1895 let query_str = req.uri().query().unwrap_or(""); 1871 1896 let Ok(params) = serde_urlencoded::from_str::<GetFollowsParams>(query_str) else { 1872 1872 - return proxy_request(req).await; 1897 1897 + return Err(StatusCode::BAD_REQUEST); 1873 1898 }; 1874 1899 1875 1900 let Some(did_str) = get_auth_did(&req) else { 1876 1901 return Err(StatusCode::UNAUTHORIZED); 1877 1902 }; 1878 1903 let Ok(auth_ident) = AtIdentifier::new(&did_str) else { 1879 1879 - return proxy_request(req).await; 1904 1904 + return Err(StatusCode::BAD_REQUEST); 1880 1905 }; 1881 1906 let Ok(auth_repo) = app_state.hydrant.repos.resolve(&auth_ident).await else { 1882 1907 return proxy_request(req).await; ··· 1905 1930 } 1906 1931 1907 1932 let Ok(ident) = AtIdentifier::new(&params.actor) else { 1908 1908 - return proxy_request(req).await; 1933 1933 + return Err(StatusCode::BAD_REQUEST); 1909 1934 }; 1910 1935 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { 1911 1936 return proxy_request(req).await; ··· 1973 1998 // let hydrant = &app_state.hydrant; 1974 1999 let query_str = req.uri().query().unwrap_or(""); 1975 2000 let Ok(params) = serde_urlencoded::from_str::<GetFollowsParams>(query_str) else { 1976 1976 - return proxy_request(req).await; 2001 2001 + return Err(StatusCode::BAD_REQUEST); 1977 2002 }; 1978 2003 1979 2004 let Some(did_str) = get_auth_did(&req) else { 1980 2005 return Err(StatusCode::UNAUTHORIZED); 1981 2006 }; 1982 2007 let Ok(ident) = AtIdentifier::new(&did_str) else { 1983 1983 - return proxy_request(req).await; 2008 2008 + return Err(StatusCode::BAD_REQUEST); 1984 2009 }; 1985 2010 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { 1986 2011 return proxy_request(req).await; ··· 2022 2047 #[derive(Deserialize)] 2023 2048 struct GetListParams { 2024 2049 list: String, 2050 2050 + #[serde(default)] 2025 2051 limit: Option<usize>, 2052 2052 + #[serde(default)] 2026 2053 cursor: Option<String>, 2027 2054 } 2028 2055 let Ok(params) = serde_urlencoded::from_str::<GetListParams>(query_str) else { 2029 2029 - return proxy_request(req).await; 2056 2056 + return Err(StatusCode::BAD_REQUEST); 2030 2057 }; 2031 2058 2032 2059 let Ok(uri) = jacquard_common::types::string::AtUri::new(&params.list) else { 2033 2033 - return proxy_request(req).await; 2060 2060 + return Err(StatusCode::BAD_REQUEST); 2034 2061 }; 2035 2062 let author_ident = uri.authority(); 2036 2063 let rkey = uri ··· 2127 2154 // let hydrant = &app_state.hydrant; 2128 2155 let query_str = req.uri().query().unwrap_or(""); 2129 2156 let Ok(params) = serde_urlencoded::from_str::<GetAuthorFeedParams>(query_str) else { 2130 2130 - return proxy_request(req).await; 2157 2157 + return Err(StatusCode::BAD_REQUEST); 2131 2158 }; 2132 2159 2133 2160 let Ok(ident) = AtIdentifier::new(&params.actor) else { 2134 2134 - return proxy_request(req).await; 2161 2161 + return Err(StatusCode::BAD_REQUEST); 2135 2162 }; 2136 2163 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { 2137 2164 return proxy_request(req).await; ··· 2178 2205 // let hydrant = &app_state.hydrant; 2179 2206 let query_str = req.uri().query().unwrap_or(""); 2180 2207 let Ok(params) = serde_urlencoded::from_str::<GetAuthorFeedParams>(query_str) else { 2181 2181 - return proxy_request(req).await; 2208 2208 + return Err(StatusCode::BAD_REQUEST); 2182 2209 }; 2183 2210 2184 2211 let Ok(ident) = AtIdentifier::new(&params.actor) else { 2185 2185 - return proxy_request(req).await; 2212 2212 + return Err(StatusCode::BAD_REQUEST); 2186 2213 }; 2187 2214 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { 2188 2215 return proxy_request(req).await; ··· 2221 2248 // let hydrant = &app_state.hydrant; 2222 2249 let query_str = req.uri().query().unwrap_or(""); 2223 2250 let Ok(params) = serde_urlencoded::from_str::<GetAuthorFeedParams>(query_str) else { 2224 2224 - return proxy_request(req).await; 2251 2251 + return Err(StatusCode::BAD_REQUEST); 2225 2252 }; 2226 2253 2227 2254 let Ok(ident) = AtIdentifier::new(&params.actor) else { 2228 2228 - return proxy_request(req).await; 2255 2255 + return Err(StatusCode::BAD_REQUEST); 2229 2256 }; 2230 2257 let Ok(repo) = app_state.hydrant.repos.resolve(&ident).await else { 2231 2258 return proxy_request(req).await; ··· 2282 2309 feed: String, 2283 2310 } 2284 2311 let Ok(params) = serde_urlencoded::from_str::<GetFeedGeneratorParams>(query_str) else { 2285 2285 - return proxy_request(req).await; 2312 2312 + return Err(StatusCode::BAD_REQUEST); 2286 2313 }; 2287 2314 2288 2315 let Ok(uri) = jacquard_common::types::string::AtUri::new(&params.feed) else { 2289 2289 - return proxy_request(req).await; 2316 2316 + return Err(StatusCode::BAD_REQUEST); 2290 2317 }; 2291 2318 let author_ident = uri.authority(); 2292 2319 let rkey = uri ··· 2509 2536 2510 2537 let query_str = req.uri().query().unwrap_or(""); 2511 2538 let Ok(params) = serde_urlencoded::from_str::<GetBookmarksParams>(query_str) else { 2512 2512 - return proxy_request(req).await; 2539 2539 + return Err(StatusCode::BAD_REQUEST); 2513 2540 }; 2514 2541 2515 2542 let limit = params.limit.unwrap_or(50).min(100); ··· 2723 2750 2724 2751 #[derive(Deserialize)] 2725 2752 struct ListNotificationsParams { 2753 2753 + #[serde(default)] 2726 2754 limit: Option<usize>, 2755 2755 + #[serde(default)] 2727 2756 cursor: Option<String>, 2728 2757 } 2729 2758 ··· 2879 2908 #[derive(Deserialize)] 2880 2909 struct GetFeedParams { 2881 2910 feed: String, 2911 2911 + #[serde(default)] 2882 2912 limit: Option<usize>, 2913 2913 + #[serde(default)] 2883 2914 cursor: Option<String>, 2884 2915 } 2885 2916 ··· 2887 2918 // let hydrant = &app_state.hydrant; 2888 2919 let query_str = req.uri().query().unwrap_or(""); 2889 2920 let Ok(params) = serde_urlencoded::from_str::<GetFeedParams>(query_str) else { 2890 2890 - return proxy_request(req).await; 2921 2921 + return Err(StatusCode::BAD_REQUEST); 2891 2922 }; 2892 2923 2893 2924 let Ok(uri) = jacquard_common::types::string::AtUri::new(&params.feed) else { 2894 2894 - return proxy_request(req).await; 2925 2925 + return Err(StatusCode::BAD_REQUEST); 2895 2926 }; 2896 2927 let author_ident = uri.authority(); 2897 2928 let rkey = uri ··· 2911 2942 2912 2943 let val_json = serde_json::to_value(&record.value).unwrap_or(serde_json::json!({})); 2913 2944 let Some(service_did) = val_json.get("did").and_then(|d| d.as_str()) else { 2914 2914 - return proxy_request(req).await; 2945 2945 + return Err(StatusCode::BAD_REQUEST); 2915 2946 }; 2916 2947 2917 2948 let Ok(service_did_parsed) = jacquard_common::types::string::Did::new(service_did) else { 2918 2918 - return proxy_request(req).await; 2949 2949 + return Err(StatusCode::BAD_REQUEST); 2919 2950 }; 2920 2951 2921 2952 let Ok((doc_data, _)) = app_state ··· 3017 3048 .into_response()) 3018 3049 } 3019 3050 3020 3020 - async fn get_well_known_did( 3021 3021 - req: Request, 3022 3022 - ) -> Result<Response, StatusCode> { 3023 3023 - let host = req.headers().get("host").and_then(|h| h.to_str().ok()).unwrap_or("localhost:8000"); 3024 3024 - 3051 3051 + async fn get_well_known_did(req: Request) -> Result<Response, StatusCode> { 3052 3052 + let host = req 3053 3053 + .headers() 3054 3054 + .get("host") 3055 3055 + .and_then(|h| h.to_str().ok()) 3056 3056 + .unwrap_or("localhost:8000"); 3057 3057 + 3025 3058 let did = if host.contains(':') { 3026 3059 format!("did:web:{}", host.replace(':', "%3A")) 3027 3060 } else { 3028 3061 format!("did:web:{}", host) 3029 3062 }; 3030 3063 3031 3031 - let scheme = if host.starts_with("localhost") || host.starts_with("127.0.0.1") { "http" } else { "https" }; 3064 3064 + let scheme = if host.starts_with("localhost") || host.starts_with("127.0.0.1") { 3065 3065 + "http" 3066 3066 + } else { 3067 3067 + "https" 3068 3068 + }; 3032 3069 let service_endpoint = format!("{}://{}", scheme, host); 3033 3070 3034 3071 Ok(Json(serde_json::json!({ ··· 3048 3085 "serviceEndpoint": service_endpoint 3049 3086 } 3050 3087 ] 3051 3051 - })).into_response()) 3088 3088 + })) 3089 3089 + .into_response()) 3052 3090 }