use serde::{Deserialize, Serialize};
use url::Url;
use crate::config::{HOST_CRATES_IO, MAX_PER_PAGE};
use crate::error::{AppError, AppResult, ErrorKind};
use crate::http::{HttpClient, content_type_looks_json, decode_utf8};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct CrateSearchHit {
pub name: String,
pub description: String,
pub downloads: u64,
pub version: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub documentation: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_version: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_stable_version: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_version: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub recent_downloads: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub exact_match: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub yanked: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub repository: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub homepage: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct SearchMeta {
pub total: u64,
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub prev_page: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct SearchCratesData {
pub query: String,
pub page: u32,
pub per_page: u32,
pub sort: String,
pub hits: Vec<CrateSearchHit>,
pub meta: SearchMeta,
pub cache_hit: bool,
}
#[derive(Debug, Deserialize)]
struct ApiResponse {
crates: Vec<ApiCrate>,
meta: ApiMeta,
}
#[derive(Debug, Deserialize)]
struct ApiCrate {
name: String,
description: Option<String>,
downloads: u64,
newest_version: Option<String>,
max_version: Option<String>,
max_stable_version: Option<String>,
default_version: Option<String>,
documentation: Option<String>,
recent_downloads: Option<u64>,
exact_match: Option<bool>,
yanked: Option<bool>,
repository: Option<String>,
homepage: Option<String>,
}
#[derive(Debug, Deserialize)]
struct ApiMeta {
total: u64,
next_page: Option<String>,
prev_page: Option<String>,
}
pub fn clamp_search_pagination(per_page: u32, page: u32) -> (u32, u32) {
(per_page.clamp(1, MAX_PER_PAGE), page.max(1))
}
pub fn planned_url(query: &str, per_page: u32, sort: &str, page: u32) -> AppResult<Url> {
planned_url_on_host(HOST_CRATES_IO, query, per_page, sort, page)
}
pub fn planned_url_on_host(
host: &str,
query: &str,
per_page: u32,
sort: &str,
page: u32,
) -> AppResult<Url> {
let (per_page, page) = clamp_search_pagination(per_page, page);
let scheme = if host.starts_with("http://") || host.starts_with("https://") {
""
} else {
"https://"
};
let base = if scheme.is_empty() {
format!("{host}/api/v1/crates")
} else {
format!("{scheme}{host}/api/v1/crates")
};
let mut url = Url::parse(&base)
.map_err(|e| AppError::with_source(ErrorKind::Internal, "invalid crates.io base URL", e))?;
{
let mut q = url.query_pairs_mut();
q.append_pair("q", query);
q.append_pair("per_page", &per_page.to_string());
q.append_pair("sort", sort);
q.append_pair("page", &page.to_string());
}
Ok(url)
}
pub fn planned_url_with_page_token(
host: &str,
query: &str,
per_page: u32,
sort: &str,
page_token: &str,
) -> AppResult<Url> {
let token = page_token.trim();
if token.is_empty() {
return Err(AppError::new(
ErrorKind::InvalidInput,
"page token is empty",
));
}
if let Ok(page) = token.parse::<u32>() {
return planned_url_on_host(host, query, per_page, sort, page);
}
let scheme = if host.starts_with("http://") || host.starts_with("https://") {
""
} else {
"https://"
};
let base = if scheme.is_empty() {
format!("{host}/api/v1/crates")
} else {
format!("{scheme}{host}/api/v1/crates")
};
let base_url = Url::parse(&base)
.map_err(|e| AppError::with_source(ErrorKind::Internal, "invalid crates.io base URL", e))?;
let qs = token.trim_start_matches('?');
if qs.contains('=') {
let mut url = base_url;
url.set_query(Some(qs));
return Ok(url);
}
let (per_page, _) = clamp_search_pagination(per_page, 1);
let mut url = base_url;
{
let mut q = url.query_pairs_mut();
q.append_pair("q", query);
q.append_pair("per_page", &per_page.to_string());
q.append_pair("sort", sort);
q.append_pair("seek", qs);
}
Ok(url)
}
pub fn parse_search_body(
text: &str,
query: &str,
page: u32,
per_page: u32,
sort: &str,
cache_hit: bool,
) -> AppResult<SearchCratesData> {
let (per_page, page) = clamp_search_pagination(per_page, page);
let parsed: ApiResponse = serde_json::from_str(text).map_err(|e| {
AppError::with_source(ErrorKind::Parse, "failed to parse crates.io JSON", e)
})?;
let hits = parsed
.crates
.into_iter()
.map(|c| CrateSearchHit {
name: c.name,
description: c
.description
.filter(|s| !s.is_empty())
.unwrap_or_else(|| "No description available".to_string()),
downloads: c.downloads,
version: c
.newest_version
.or_else(|| c.max_version.clone())
.unwrap_or_else(|| "unknown".to_string()),
documentation: c.documentation,
max_version: c.max_version,
max_stable_version: c.max_stable_version,
default_version: c.default_version,
recent_downloads: c.recent_downloads,
exact_match: c.exact_match,
yanked: c.yanked,
repository: c.repository,
homepage: c.homepage,
})
.collect();
Ok(SearchCratesData {
query: query.to_string(),
page,
per_page,
sort: sort.to_string(),
hits,
meta: SearchMeta {
total: parsed.meta.total,
next_page: parsed.meta.next_page,
prev_page: parsed.meta.prev_page,
},
cache_hit,
})
}
pub async fn search_crates(
http: &HttpClient,
query: &str,
per_page: u32,
sort: &str,
page: u32,
) -> AppResult<SearchCratesData> {
search_crates_on_origin(
http,
&format!("https://{HOST_CRATES_IO}"),
query,
per_page,
sort,
page,
)
.await
}
pub async fn search_crates_on_origin(
http: &HttpClient,
origin: &str,
query: &str,
per_page: u32,
sort: &str,
page: u32,
) -> AppResult<SearchCratesData> {
let (per_page, page) = clamp_search_pagination(per_page, page);
let url = planned_url_on_host(origin, query, per_page, sort, page)?;
search_crates_at(http, &url, query, per_page, sort, page).await
}
pub async fn search_crates_at(
http: &HttpClient,
url: &Url,
query: &str,
per_page: u32,
sort: &str,
page: u32,
) -> AppResult<SearchCratesData> {
let resp = http.get_json(url).await?;
if resp.status.as_u16() == 404 {
return Err(AppError::from_http_status(404, "crates.io search"));
}
if !resp.status.is_success() {
return Err(AppError::from_http_status(
resp.status.as_u16(),
"crates.io search",
));
}
if resp.content_type.is_some() && !content_type_looks_json(resp.content_type.as_deref()) {
tracing::warn!(
content_type = ?resp.content_type,
"unexpected Content-Type from crates.io"
);
}
let text = decode_utf8(&resp.body)?;
parse_search_body(&text, query, page, per_page, sort, resp.cache_hit)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn planned_url_clamps_and_encodes() {
let u = planned_url("serde json", 0, "alphabetical", 0).unwrap();
assert!(u.as_str().contains("per_page=1"));
assert!(u.as_str().contains("page=1"));
assert!(u.as_str().contains("sort=alphabetical"));
assert!(u.as_str().contains("q=serde"));
let u2 = planned_url("x", 500, "relevance", 3).unwrap();
assert!(u2.as_str().contains("per_page=100"));
assert!(u2.as_str().contains("page=3"));
}
#[test]
fn clamp_search_pagination_page_and_per_page() {
assert_eq!(clamp_search_pagination(0, 0), (1, 1));
assert_eq!(clamp_search_pagination(10, 0), (10, 1));
assert_eq!(clamp_search_pagination(500, 2), (100, 2));
assert_eq!(clamp_search_pagination(25, 3), (25, 3));
}
#[test]
fn parse_fixture_serde() {
let body = include_str!("../tests/fixtures/crates_io/search_serde.json");
let data = parse_search_body(body, "serde", 1, 10, "relevance", false).unwrap();
assert_eq!(data.hits.len(), 2);
assert_eq!(data.hits[0].name, "serde");
assert_eq!(data.hits[0].exact_match, Some(true));
assert_eq!(data.hits[0].version, "1.0.210");
assert_eq!(data.hits[1].description, "No description available");
assert_eq!(data.meta.total, 2);
assert_eq!(data.meta.next_page.as_deref(), Some("page=2"));
}
#[test]
fn parse_fixture_seek_meta() {
let body = include_str!("../tests/fixtures/crates_io/search_seek_meta.json");
let data = parse_search_body(body, "example", 1, 10, "downloads", false).unwrap();
assert_eq!(
data.meta.next_page.as_deref(),
Some("seek=ABC123&per_page=10")
);
assert_eq!(data.meta.prev_page.as_deref(), Some("page=1"));
assert_eq!(data.hits[0].version, "0.1.0");
}
#[test]
fn parse_invalid_json() {
let err = parse_search_body("{", "q", 1, 10, "relevance", false).unwrap_err();
assert_eq!(err.kind(), ErrorKind::Parse);
}
#[test]
fn parse_missing_versions_uses_unknown() {
let body = r#"{"crates":[{"name":"x","downloads":1}],"meta":{"total":1}}"#;
let data = parse_search_body(body, "x", 1, 10, "new", false).unwrap();
assert_eq!(data.hits[0].version, "unknown");
assert!(data.meta.next_page.is_none());
}
#[test]
fn planned_url_on_host_http_base() {
let u = planned_url_on_host("http://127.0.0.1:9", "q", 10, "new", 1).unwrap();
assert!(u.as_str().starts_with("http://127.0.0.1:9/api/v1/crates"));
}
}