From 0018500a6a6df7fa79bd4ca91561cf3eec3e1e3d Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Fri, 6 Nov 2026 12:43:11 +0000 Subject: [PATCH] crates_io_client: Add endpoints for listing, adding, and removing crate owners (#66524) Following the OpenAPI spec, this adds the crate owner endpoints to our crates.io client. Release Notes: - N/A --- .../crates_io_client/src/crates_io_client.rs | 19 ++ .../src/real_crates_io_client.rs | 95 ++++++++- .../src/simulated_crates_io_client.rs | 181 +++++++++++++++++- tooling/crates_io_client/src/tests.rs | 105 ++++++++++ tooling/crates_io_client/src/types.rs | 56 ++++++ 5 files changed, 447 insertions(+), 9 deletions(-) diff --git a/tooling/crates_io_client/src/crates_io_client.rs b/tooling/crates_io_client/src/crates_io_client.rs index 27a2d759cde..d110a822a79 100644 --- a/tooling/crates_io_client/src/crates_io_client.rs +++ b/tooling/crates_io_client/src/crates_io_client.rs @@ -30,6 +30,25 @@ pub trait CratesIoClient: Send + Sync { /// belongs to an owner of the crate. async fn update_crate(&self, name: &CrateName, update: &CrateUpdate) -> Result; + /// Lists both user and team owners. + async fn list_owners(&self, name: &CrateName) -> Result>; + + /// Returns one outcome per requested owner. + /// + /// Requires a token with the `change-owners` endpoint scope that belongs + /// to a user owner of the crate. crates.io accepts at most ten owners per + /// request. + async fn add_owners( + &self, + name: &CrateName, + owners: &[OwnerLogin], + ) -> Result>; + + /// Requires a token with the `change-owners` endpoint scope that belongs + /// to a user owner of the crate. crates.io rejects removing the last user + /// owner. + async fn remove_owners(&self, name: &CrateName, owners: &[OwnerLogin]) -> 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>; 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 3449c9320d8..5389e32e90f 100644 --- a/tooling/crates_io_client/src/real_crates_io_client.rs +++ b/tooling/crates_io_client/src/real_crates_io_client.rs @@ -61,11 +61,12 @@ impl RealCratesIoClient { Ok(Url::parse(&format!("{BASE_URL}{path}")).context("Invalid crates.io URL")?) } - fn crate_url(name: &CrateName) -> Result { + fn crate_url(name: &CrateName, subpath: &[&str]) -> Result { let mut url = Self::url("/crates")?; url.path_segments_mut() .map_err(|()| anyhow::anyhow!("crates.io URL cannot have path segments"))? - .push(name.as_str()); + .push(name.as_str()) + .extend(subpath); Ok(url) } @@ -126,6 +127,67 @@ impl RealCratesIoClient { Ok(serde_json::from_slice(&body) .with_context(|| format!("Failed to parse crates.io response from {url}"))?) } + + /// Adding and removing owners share their request and response bodies. + async fn change_owners( + &self, + method: Method, + name: &CrateName, + owners: &[OwnerLogin], + ) -> Result { + #[derive(Serialize)] + struct ChangeOwnersRequest<'a> { + owners: &'a [OwnerLogin], + } + + #[derive(Deserialize)] + struct ChangeOwnersResponse { + msg: String, + } + + let body = serde_json::to_vec(&ChangeOwnersRequest { owners }) + .context("Failed to serialize crate owners")?; + let response: ChangeOwnersResponse = self + .request_json(method, Self::crate_url(name, &["owners"])?, Some(body)) + .await?; + Ok(response.msg) + } +} + +/// crates.io joins one sentence per added owner with commas, which crate +/// names, usernames, and team logins cannot contain. +fn parse_owner_additions(message: &str, crate_name: &CrateName) -> Vec { + let invited_suffix = format!(" has been invited to be an owner of crate {crate_name}"); + let already_invited_suffix = + format!(" already has a pending invitation to be an owner of crate {crate_name}"); + let team_suffix = format!(" has been added as an owner of crate {crate_name}"); + + message + .split(',') + .map(|sentence| { + let user = sentence.strip_prefix("Crates.io user "); + if let Some(username) = user.and_then(|rest| rest.strip_suffix(&invited_suffix)) { + OwnerAddition::UserInvited { + username: username.to_owned(), + } + } else if let Some(username) = + user.and_then(|rest| rest.strip_suffix(&already_invited_suffix)) + { + OwnerAddition::UserAlreadyInvited { + username: username.to_owned(), + } + } else if let Some(login) = sentence + .strip_prefix("team ") + .and_then(|rest| rest.strip_suffix(&team_suffix)) + { + OwnerAddition::TeamAdded { + login: login.to_owned(), + } + } else { + OwnerAddition::Other(sentence.to_owned()) + } + }) + .collect() } #[async_trait] @@ -192,7 +254,7 @@ impl CratesIoClient for RealCratesIoClient { versions: Option>, } - let mut url = Self::crate_url(name)?; + let mut url = Self::crate_url(name, &[])?; url.query_pairs_mut() .append_pair("include", "versions,keywords,categories"); let response: CrateResponse = self.request_json(Method::GET, url, None).await?; @@ -218,11 +280,36 @@ impl CratesIoClient for RealCratesIoClient { let body = serde_json::to_vec(&UpdateRequest { krate: update }) .context("Failed to serialize crate update")?; let response: UpdateResponse = self - .request_json(Method::PATCH, Self::crate_url(name)?, Some(body)) + .request_json(Method::PATCH, Self::crate_url(name, &[])?, Some(body)) .await?; Ok(response.krate) } + async fn list_owners(&self, name: &CrateName) -> Result> { + #[derive(Deserialize)] + struct OwnersResponse { + users: Vec, + } + + let url = Self::crate_url(name, &["owners"])?; + let response: OwnersResponse = self.request_json(Method::GET, url, None).await?; + Ok(response.users) + } + + async fn add_owners( + &self, + name: &CrateName, + owners: &[OwnerLogin], + ) -> Result> { + let message = self.change_owners(Method::PUT, name, owners).await?; + Ok(parse_owner_additions(&message, name)) + } + + async fn remove_owners(&self, name: &CrateName, owners: &[OwnerLogin]) -> Result<()> { + self.change_owners(Method::DELETE, name, owners).await?; + Ok(()) + } + async fn list_github_configs(&self, crate_name: &CrateName) -> Result> { #[derive(Deserialize)] struct GitHubConfigListResponse { 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 ed13bc566dc..6a8a26af5e6 100644 --- a/tooling/crates_io_client/src/simulated_crates_io_client.rs +++ b/tooling/crates_io_client/src/simulated_crates_io_client.rs @@ -25,9 +25,55 @@ const MAX_GITHUB_CONFIGS_PER_CRATE: usize = 5; struct SimulatedCrate { krate: Crate, owners: Vec, + team_owners: Vec, + invited_owners: Vec, versions: Vec, } +impl SimulatedCrate { + fn require_owner_rights(&self, user: UserId) -> Result<()> { + if self.owners.contains(&user) { + Ok(()) + } else { + Err(CratesIoError::PermissionDenied { + status: StatusCode::FORBIDDEN, + message: "only owners have permission to modify owners".to_owned(), + }) + } + } + + fn matches(login: &OwnerLogin, owner: &Owner) -> bool { + match (login, owner) { + ( + OwnerLogin::Username(username) + | OwnerLogin::CratesIoUser(username) + | OwnerLogin::GitHubUser(username), + Owner::User(user), + ) => user.login.eq_ignore_ascii_case(username), + (OwnerLogin::GitHubTeam { .. }, Owner::Team(team)) => { + team.login.eq_ignore_ascii_case(&login.to_string()) + } + _ => false, + } + } + + fn all_owners(&self) -> impl Iterator + '_ { + let users = self + .owners + .iter() + .map(|id| Owner::User(simulated_user(*id))); + let teams = self.team_owners.iter().cloned().map(Owner::Team); + users.chain(teams) + } +} + +fn bad_request(message: String) -> CratesIoError { + CratesIoError::Upstream { + status: StatusCode::BAD_REQUEST, + message, + } +} + impl CratesIoState { fn next_id(&mut self) -> i32 { self.latest_id += 1; @@ -66,6 +112,14 @@ fn listed(krate: &Crate) -> Crate { } } +fn simulated_user(id: UserId) -> User { + User { + id, + login: format!("user-{}", id.0), + name: None, + } +} + fn test_timestamp() -> DateTime { DateTime::from_timestamp(1_767_225_600, 0).unwrap_or_default() } @@ -126,12 +180,41 @@ impl SimulatedCratesIoClient { categories: Some(Vec::new()), }, owners: vec![owner], + team_owners: Vec::new(), + invited_owners: Vec::new(), versions: Vec::new(), }, ); name } + pub fn test_owner(&self, name: &CrateName, owner: UserId) -> Result<()> { + self.state.lock().simulated_crate(name)?.owners.push(owner); + Ok(()) + } + + pub fn test_team_owner(&self, name: &CrateName, login: &str) -> Result { + let mut state = self.state.lock(); + let id = TeamId(state.next_id()); + state.simulated_crate(name)?.team_owners.push(Team { + id, + login: login.to_owned(), + name: None, + }); + Ok(id) + } + + /// Users invited through [`CratesIoClient::add_owners`] that have not + /// accepted yet. + pub fn invited_owners(&self, name: &CrateName) -> Result> { + Ok(self + .state + .lock() + .simulated_crate(name)? + .invited_owners + .clone()) + } + /// Changes crate fields that have no dedicated helper, such as its /// keywords or download counts. pub fn update_test_crate( @@ -166,11 +249,7 @@ impl SimulatedCratesIoClient { edition: None, crate_size: 0, checksum: String::new(), - published_by: Some(User { - id: publisher, - login: format!("user-{}", publisher.0), - name: None, - }), + published_by: Some(simulated_user(publisher)), }, ); simulated_crate.krate.default_version = Some(num); @@ -250,6 +329,98 @@ impl CratesIoClient for SimulatedCratesIoClient { Ok(listed(&simulated_crate.krate)) } + async fn list_owners(&self, name: &CrateName) -> Result> { + let mut state = self.state.lock(); + Ok(state.simulated_crate(name)?.all_owners().collect()) + } + + async fn add_owners( + &self, + name: &CrateName, + owners: &[OwnerLogin], + ) -> Result> { + let mut state = self.state.lock(); + let token_user = state.token_user; + let simulated_crate = state.simulated_crate(name)?; + simulated_crate.require_owner_rights(token_user)?; + if owners.len() > 10 { + return Err(bad_request( + "too many invites for this request - maximum 10".to_owned(), + )); + } + if let Some(login) = owners.iter().find(|login| { + simulated_crate + .all_owners() + .any(|owner| SimulatedCrate::matches(login, &owner)) + }) { + return Err(bad_request(format!("`{login}` is already an owner"))); + } + + let mut additions = Vec::new(); + for login in owners { + let team_id = TeamId(state.next_id()); + let simulated_crate = state.simulated_crate(name)?; + let addition = match login { + OwnerLogin::GitHubTeam { .. } => { + simulated_crate.team_owners.push(Team { + id: team_id, + login: login.to_string(), + name: None, + }); + OwnerAddition::TeamAdded { + login: login.to_string(), + } + } + OwnerLogin::Username(username) + | OwnerLogin::CratesIoUser(username) + | OwnerLogin::GitHubUser(username) => { + let username = username.clone(); + if simulated_crate.invited_owners.contains(login) { + OwnerAddition::UserAlreadyInvited { username } + } else { + simulated_crate.invited_owners.push(login.clone()); + OwnerAddition::UserInvited { username } + } + } + }; + additions.push(addition); + } + Ok(additions) + } + + async fn remove_owners(&self, name: &CrateName, owners: &[OwnerLogin]) -> Result<()> { + let mut state = self.state.lock(); + let token_user = state.token_user; + let simulated_crate = state.simulated_crate(name)?; + simulated_crate.require_owner_rights(token_user)?; + + let mut removed = Vec::new(); + for login in owners { + let matching = simulated_crate + .all_owners() + .filter(|owner| SimulatedCrate::matches(login, owner)) + .collect::>(); + if matching.is_empty() { + return Err(bad_request(format!( + "could not find owner with login `{login}`" + ))); + } + removed.extend(matching); + } + let is_removed_user = |id: &UserId| removed.contains(&Owner::User(simulated_user(*id))); + if simulated_crate.owners.iter().all(is_removed_user) { + return Err(bad_request( + "cannot remove all individual owners of a crate. Team member don't have permission to modify owners, so at least one individual owner is required.".to_owned(), + )); + } + + simulated_crate.owners.retain(|id| !is_removed_user(id)); + simulated_crate + .team_owners + .retain(|team| !removed.contains(&Owner::Team(team.clone()))); + Ok(()) + } + async fn list_github_configs(&self, crate_name: &CrateName) -> Result> { let mut state = self.state.lock(); state.require_token_user_owns(crate_name)?; diff --git a/tooling/crates_io_client/src/tests.rs b/tooling/crates_io_client/src/tests.rs index 7eecc2ebb24..942fb61cf39 100644 --- a/tooling/crates_io_client/src/tests.rs +++ b/tooling/crates_io_client/src/tests.rs @@ -280,6 +280,111 @@ fn test_list_github_configs_rejects_full_page() { assert!(matches!(error, CratesIoError::Request(_))); } +#[test] +fn test_owner_endpoints_match_crates_io_api() { + // Listing owners and changing them share a URL, so one response serves both. + let (fake_http_client, requests) = recording_fake_http_client(|_| { + let body = json!({ + "users": [ + { + "kind": "user", + "id": 436643, + "login": "MrSubidubi", + "url": "https://github.com/MrSubidubi", + "name": "Finn Evers", + "avatar": null, + "github_username_matches": true, + }, + { + "kind": "team", + "id": 12586, + "login": "github:zed-industries:crates-io", + "url": "https://github.com/zed-industries", + "name": "crates-io", + "avatar": null, + }, + ], + "msg": "Crates.io user maxbrunsfeld has been invited to be an owner of crate gpui,\ + Crates.io user mikayla-maki already has a pending invitation to be an owner of crate gpui,\ + team github:zed-industries:crates-io has been added as an owner of crate gpui,\ + owners changed", + "ok": true, + }); + (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 owner_logins = [ + OwnerLogin::Username("maxbrunsfeld".to_owned()), + OwnerLogin::CratesIoUser("maxbrunsfeld".to_owned()), + OwnerLogin::GitHubUser("maxbrunsfeld".to_owned()), + OwnerLogin::GitHubTeam { + organization: "zed-industries".to_owned(), + team: "crates-io".to_owned(), + }, + ]; + + let owners = smol::block_on(client().list_owners(&gpui)).unwrap(); + let additions = smol::block_on(client().add_owners(&gpui, &owner_logins)).unwrap(); + smol::block_on(client().remove_owners(&gpui, &owner_logins)).unwrap(); + + assert_eq!( + owners, + [ + Owner::User(User { + id: UserId(436643), + login: "MrSubidubi".to_owned(), + name: Some("Finn Evers".to_owned()), + }), + Owner::Team(Team { + id: TeamId(12586), + login: "github:zed-industries:crates-io".to_owned(), + name: Some("crates-io".to_owned()), + }), + ] + ); + assert_eq!( + additions, + [ + OwnerAddition::UserInvited { + username: "maxbrunsfeld".to_owned(), + }, + OwnerAddition::UserAlreadyInvited { + username: "mikayla-maki".to_owned(), + }, + OwnerAddition::TeamAdded { + login: "github:zed-industries:crates-io".to_owned(), + }, + OwnerAddition::Other("owners changed".to_owned()), + ] + ); + let requests = requests.lock(); + let expected_body = json!({ + "owners": [ + "maxbrunsfeld", + "crates.io:maxbrunsfeld", + "github:maxbrunsfeld", + "github:zed-industries:crates-io", + ] + }); + for (request, method) in requests + .iter() + .zip([Method::GET, Method::PUT, Method::DELETE]) + { + assert_eq!(request.method, method); + assert_eq!(request.uri, "https://crates.io/api/v1/crates/gpui/owners"); + } + assert_eq!( + serde_json::from_str::(&requests[1].body).unwrap(), + expected_body + ); + assert_eq!( + serde_json::from_str::(&requests[2].body).unwrap(), + expected_body + ); +} + #[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 a03f7048acc..70096c0ab96 100644 --- a/tooling/crates_io_client/src/types.rs +++ b/tooling/crates_io_client/src/types.rs @@ -8,6 +8,8 @@ use url::Url; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] pub struct UserId(pub i32); #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub struct TeamId(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, @@ -113,6 +115,60 @@ pub struct User { pub name: Option, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Team { + pub id: TeamId, + /// For example `github:zed-industries:crates-io`. + pub login: String, + pub name: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "kind", rename_all = "lowercase")] +pub enum Owner { + User(User), + Team(Team), +} + +/// Identifies an owner to add or remove. +#[derive(Debug, Display, Clone, PartialEq, Eq, Hash)] +pub enum OwnerLogin { + /// A crates.io user, or a GitHub user when removing owners. crates.io + /// rejects names that match different accounts. + #[display("{_0}")] + Username(String), + #[display("crates.io:{_0}")] + CratesIoUser(String), + #[display("github:{_0}")] + GitHubUser(String), + #[display("github:{organization}:{team}")] + GitHubTeam { organization: String, team: String }, +} + +/// The outcome of adding one owner, as crates.io describes it. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum OwnerAddition { + /// The user becomes an owner once they accept the invitation. + UserInvited { + username: String, + }, + UserAlreadyInvited { + username: String, + }, + /// Teams become owners immediately. + TeamAdded { + login: String, + }, + /// A message this client does not recognize. + Other(String), +} + +impl Serialize for OwnerLogin { + fn serialize(&self, serializer: S) -> Result { + serializer.collect_str(self) + } +} + #[derive(Debug, Clone, PartialEq, Eq)] pub struct CrateDetails { pub krate: Crate,