diff --git a/Cargo.lock b/Cargo.lock index 6695899a1f7..0404e33240b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4105,6 +4105,7 @@ dependencies = [ "anyhow", "async-trait", "chrono", + "derive_more", "futures 0.3.34", "http_client", "itertools 0.14.0", diff --git a/tooling/crates_io_client/Cargo.toml b/tooling/crates_io_client/Cargo.toml index ea72a581839..4c3eefd60d6 100644 --- a/tooling/crates_io_client/Cargo.toml +++ b/tooling/crates_io_client/Cargo.toml @@ -20,6 +20,7 @@ doctest = false anyhow.workspace = true async-trait.workspace = true chrono.workspace = true +derive_more = { workspace = true, features = ["display"] } futures.workspace = true http_client.workspace = true itertools.workspace = true diff --git a/tooling/crates_io_client/src/crates_io_client.rs b/tooling/crates_io_client/src/crates_io_client.rs index 1b6e627dc44..27a2d759cde 100644 --- a/tooling/crates_io_client/src/crates_io_client.rs +++ b/tooling/crates_io_client/src/crates_io_client.rs @@ -29,6 +29,19 @@ pub trait CratesIoClient: Send + Sync { /// Requires a token with the `trusted-publishing` endpoint scope that /// belongs to an owner of the crate. async fn update_crate(&self, name: &CrateName, update: &CrateUpdate) -> Result; + + /// Requires a token with the `trusted-publishing` endpoint scope that + /// belongs to an owner of the crate. + async fn list_github_configs(&self, crate_name: &CrateName) -> Result>; + + /// Requires a token with the `trusted-publishing` endpoint scope that + /// belongs to an owner of the crate with a verified email address. + /// crates.io allows at most five configurations per crate. + async fn create_github_config(&self, config: &NewGitHubConfig) -> Result; + + /// Requires a token with the `trusted-publishing` endpoint scope that + /// belongs to an owner of the configuration's crate. + async fn delete_github_config(&self, id: GitHubConfigId) -> Result<()>; } #[derive(Debug, thiserror::Error)] diff --git a/tooling/crates_io_client/src/real_crates_io_client.rs b/tooling/crates_io_client/src/real_crates_io_client.rs index f282a3f9c93..3449c9320d8 100644 --- a/tooling/crates_io_client/src/real_crates_io_client.rs +++ b/tooling/crates_io_client/src/real_crates_io_client.rs @@ -17,7 +17,8 @@ const BASE_URL: &str = "https://crates.io/api/v1"; // User agent and request rate requirements: https://crates.io/data-access const USER_AGENT: &str = "Zed GPUI releases (https://github.com/zed-industries/zed)"; pub(crate) const MIN_REQUEST_INTERVAL: Duration = Duration::from_secs(1); -const MAX_PER_PAGE: u32 = 100; +const MAX_PER_PAGE: usize = 100; +const GITHUB_CONFIGS_PATH: &str = "/trusted_publishing/github_configs"; /// Reserving the send time before waiting makes concurrent requests queue up /// behind each other instead of all waking at the same instant. @@ -171,11 +172,11 @@ impl CratesIoClient for RealCratesIoClient { let mut crates = Vec::new(); loop { let mut page: CrateListResponse = self.request_json(Method::GET, url, None).await?; - let is_last_page = page.crates.is_empty(); + let is_full_page = page.crates.len() == MAX_PER_PAGE; crates.append(&mut page.crates); match page.meta.next_page { - Some(next_page) if !is_last_page => { + Some(next_page) if is_full_page => { url = Self::url(&format!("/crates{next_page}"))?; } _ => return Ok(crates), @@ -221,4 +222,51 @@ impl CratesIoClient for RealCratesIoClient { .await?; Ok(response.krate) } + + async fn list_github_configs(&self, crate_name: &CrateName) -> Result> { + #[derive(Deserialize)] + struct GitHubConfigListResponse { + github_configs: Vec, + } + + let mut url = Self::url(GITHUB_CONFIGS_PATH)?; + url.query_pairs_mut() + .append_pair("per_page", &MAX_PER_PAGE.to_string()) + .append_pair("crate", crate_name.as_str()); + let response: GitHubConfigListResponse = self.request_json(Method::GET, url, None).await?; + if response.github_configs.len() >= MAX_PER_PAGE { + return Err(anyhow::anyhow!( + "crates.io returned more GitHub Trusted Publishing configurations for `{crate_name}` than expected" + ) + .into()); + } + Ok(response.github_configs) + } + + async fn create_github_config(&self, config: &NewGitHubConfig) -> Result { + #[derive(Serialize)] + struct CreateRequest<'a> { + github_config: &'a NewGitHubConfig, + } + + #[derive(Deserialize)] + struct CreateResponse { + github_config: GitHubConfig, + } + + let body = serde_json::to_vec(&CreateRequest { + github_config: config, + }) + .context("Failed to serialize GitHub Trusted Publishing configuration")?; + let response: CreateResponse = self + .request_json(Method::POST, Self::url(GITHUB_CONFIGS_PATH)?, Some(body)) + .await?; + Ok(response.github_config) + } + + async fn delete_github_config(&self, id: GitHubConfigId) -> Result<()> { + let url = Self::url(&format!("{GITHUB_CONFIGS_PATH}/{id}"))?; + self.request_response(Method::DELETE, url, None).await?; + Ok(()) + } } diff --git a/tooling/crates_io_client/src/simulated_crates_io_client.rs b/tooling/crates_io_client/src/simulated_crates_io_client.rs index 0f0afd3ab6e..ed13bc566dc 100644 --- a/tooling/crates_io_client/src/simulated_crates_io_client.rs +++ b/tooling/crates_io_client/src/simulated_crates_io_client.rs @@ -16,9 +16,12 @@ struct CratesIoState { site_metadata: SiteMetadata, token_user: UserId, crates: BTreeMap, + github_configs: BTreeMap, latest_id: i32, } +const MAX_GITHUB_CONFIGS_PER_CRATE: usize = 5; + struct SimulatedCrate { krate: Crate, owners: Vec, @@ -38,6 +41,20 @@ impl CratesIoState { message: format!("crate `{name}` does not exist"), }) } + + /// crates.io answers non-owners of a crate with a bad request rather than + /// a permission error on the Trusted Publishing endpoints. + fn require_token_user_owns(&mut self, name: &CrateName) -> Result<()> { + let token_user = self.token_user; + if self.simulated_crate(name)?.owners.contains(&token_user) { + Ok(()) + } else { + Err(CratesIoError::Upstream { + status: StatusCode::BAD_REQUEST, + message: "You are not an owner of this crate".to_owned(), + }) + } + } } /// Keyword and category IDs are only part of single-crate responses. @@ -67,6 +84,7 @@ impl SimulatedCratesIoClient { }, token_user: UserId(1), crates: BTreeMap::new(), + github_configs: BTreeMap::new(), latest_id: 1, }), }) @@ -231,4 +249,62 @@ impl CratesIoClient for SimulatedCratesIoClient { } Ok(listed(&simulated_crate.krate)) } + + async fn list_github_configs(&self, crate_name: &CrateName) -> Result> { + let mut state = self.state.lock(); + state.require_token_user_owns(crate_name)?; + Ok(state + .github_configs + .values() + .filter(|config| &config.crate_name == crate_name) + .cloned() + .collect()) + } + + async fn create_github_config(&self, config: &NewGitHubConfig) -> Result { + let mut state = self.state.lock(); + state.require_token_user_owns(&config.crate_name)?; + let existing_configs = state + .github_configs + .values() + .filter(|existing| existing.crate_name == config.crate_name) + .count(); + if existing_configs >= MAX_GITHUB_CONFIGS_PER_CRATE { + return Err(CratesIoError::Upstream { + status: StatusCode::CONFLICT, + message: format!( + "This crate already has the maximum number of GitHub Trusted Publishing configurations ({MAX_GITHUB_CONFIGS_PER_CRATE})" + ), + }); + } + + let id = GitHubConfigId(state.next_id()); + let repository_owner_id = GitHubAccountId(state.next_id()); + let github_config = GitHubConfig { + id, + crate_name: config.crate_name.clone(), + repository_owner: config.repository_owner.clone(), + repository_owner_id, + repository_name: config.repository_name.clone(), + workflow_filename: config.workflow_filename.clone(), + environment: config.environment.clone(), + created_at: test_timestamp(), + }; + state.github_configs.insert(id, github_config.clone()); + Ok(github_config) + } + + async fn delete_github_config(&self, id: GitHubConfigId) -> Result<()> { + let mut state = self.state.lock(); + let crate_name = state + .github_configs + .get(&id) + .map(|config| config.crate_name.clone()) + .ok_or_else(|| CratesIoError::NotFound { + message: "Not Found".to_owned(), + })?; + state.require_token_user_owns(&crate_name)?; + state.github_configs.remove(&id); + Ok(()) + } } diff --git a/tooling/crates_io_client/src/tests.rs b/tooling/crates_io_client/src/tests.rs index 2ce93d0dcc0..7eecc2ebb24 100644 --- a/tooling/crates_io_client/src/tests.rs +++ b/tooling/crates_io_client/src/tests.rs @@ -131,23 +131,24 @@ fn test_error_responses_distinguish_permission_and_upstream_failures() { } #[test] -fn test_list_crates_follows_next_page_until_exhausted() { +fn test_list_crates_requests_next_page_only_after_full_page() { let (fake_http_client, requests) = recording_fake_http_client(|uri| { - let page = if uri.contains("seek=") { - json!({ - "crates": [crate_json("gpui_util")], - "meta": { "total": 2, "next_page": null, "prev_page": null }, - }) + let crates = if uri.contains("seek=") { + vec![crate_json("last")] } else { - json!({ - "crates": [crate_json("gpui")], - "meta": { - "total": 2, - "next_page": "?user_id=7&per_page=100&seek=abc", - "prev_page": null, - }, - }) + (0..100) + .map(|index| crate_json(&format!("crate_{index}"))) + .collect() }; + // crates.io can link a next page even when no more crates follow. + let page = json!({ + "crates": crates, + "meta": { + "total": 101, + "next_page": "?user_id=7&per_page=100&seek=abc", + "prev_page": null, + }, + }); (StatusCode::OK, page) }); let client = RealCratesIoClient::new(fake_http_client, ApiToken::new("secret")); @@ -159,12 +160,10 @@ fn test_list_crates_follows_next_page_until_exhausted() { })) .unwrap(); - let names = crates - .iter() - .map(|krate| krate.name.as_str()) - .collect::>(); - assert_eq!(names, ["gpui", "gpui_util"]); + assert_eq!(crates.len(), 101); + assert_eq!(crates[100].name.as_str(), "last"); let requests = requests.lock(); + assert_eq!(requests.len(), 2); assert_eq!( requests[0].uri, "https://crates.io/api/v1/crates?per_page=100&user_id=7&include_yanked=no" @@ -198,6 +197,89 @@ fn test_update_crate_sends_settings_wrapped_in_crate_object() { ); } +fn github_config_json(id: i32) -> Value { + json!({ + "id": id, + "crate": "gpui", + "repository_owner": "zed-industries", + "repository_owner_id": 79345384, + "repository_name": "zed", + "workflow_filename": "release.yml", + "environment": null, + "created_at": "2026-01-01T00:00:00Z", + }) +} + +#[test] +fn test_github_config_requests_match_crates_io_api() { + let (fake_http_client, requests) = recording_fake_http_client(|uri| { + let body = if uri.contains("crate=") { + json!({ + "github_configs": [github_config_json(3)], + "meta": { "total": 1, "next_page": null }, + }) + } else { + json!({ "github_config": github_config_json(3) }) + }; + (StatusCode::OK, body) + }); + // Separate clients keep the test from waiting on the rate limit. + let client = || RealCratesIoClient::new(fake_http_client.clone(), ApiToken::new("secret")); + let gpui = CrateName::new("gpui"); + + let configs = smol::block_on(client().list_github_configs(&gpui)).unwrap(); + smol::block_on(client().create_github_config(&NewGitHubConfig { + crate_name: gpui, + repository_owner: "zed-industries".to_owned(), + repository_name: "zed".to_owned(), + workflow_filename: "release.yml".to_owned(), + environment: None, + })) + .unwrap(); + smol::block_on(client().delete_github_config(configs[0].id)).unwrap(); + + let requests = requests.lock(); + assert_eq!( + requests[0].uri, + "https://crates.io/api/v1/trusted_publishing/github_configs?per_page=100&crate=gpui" + ); + assert_eq!(requests[1].method, Method::POST); + assert_eq!( + serde_json::from_str::(&requests[1].body).unwrap(), + json!({ + "github_config": { + "crate": "gpui", + "repository_owner": "zed-industries", + "repository_name": "zed", + "workflow_filename": "release.yml", + "environment": null, + } + }) + ); + assert_eq!(requests[2].method, Method::DELETE); + assert_eq!( + requests[2].uri, + "https://crates.io/api/v1/trusted_publishing/github_configs/3" + ); +} + +#[test] +fn test_list_github_configs_rejects_full_page() { + let (fake_http_client, _requests) = recording_fake_http_client(|_| { + let configs = (0..100).map(github_config_json).collect::>(); + let page = json!({ + "github_configs": configs, + "meta": { "total": 101, "next_page": "?crate=gpui&per_page=100&seek=abc" }, + }); + (StatusCode::OK, page) + }); + let client = RealCratesIoClient::new(fake_http_client, ApiToken::new("secret")); + + let error = smol::block_on(client.list_github_configs(&CrateName::new("gpui"))).unwrap_err(); + + assert!(matches!(error, CratesIoError::Request(_))); +} + #[test] fn test_throttle_spaces_requests_by_minimum_interval() { let throttle = RequestThrottle::new(); diff --git a/tooling/crates_io_client/src/types.rs b/tooling/crates_io_client/src/types.rs index 5272c94660f..a03f7048acc 100644 --- a/tooling/crates_io_client/src/types.rs +++ b/tooling/crates_io_client/src/types.rs @@ -1,6 +1,7 @@ use std::fmt; use chrono::{DateTime, Utc}; +use derive_more::Display; use serde::{Deserialize, Serialize}; use url::Url; @@ -8,6 +9,12 @@ use url::Url; pub struct UserId(pub i32); #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] pub struct VersionId(pub i32); +#[derive( + Debug, Display, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, +)] +pub struct GitHubConfigId(pub i32); +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub struct GitHubAccountId(pub i32); #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] pub struct CrateName(pub String); @@ -119,3 +126,27 @@ pub struct CrateUpdate { #[serde(skip_serializing_if = "Option::is_none")] pub trustpub_only: Option, } + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct GitHubConfig { + pub id: GitHubConfigId, + #[serde(rename = "crate")] + pub crate_name: CrateName, + pub repository_owner: String, + /// Lets crates.io recognize the repository after its owner is renamed. + pub repository_owner_id: GitHubAccountId, + pub repository_name: String, + pub workflow_filename: String, + pub environment: Option, + pub created_at: DateTime, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct NewGitHubConfig { + #[serde(rename = "crate")] + pub crate_name: CrateName, + pub repository_owner: String, + pub repository_name: String, + pub workflow_filename: String, + pub environment: Option, +}