Create TeamApiClient and route all team data requests through it

Author: Kobzol

src/actions.rs

@@ -7,6 +7,7 @@ use serde::{Deserialize, Serialize};
 use tera::{Context, Tera};
 
 use crate::github::{self, GithubClient, Repository};
+use crate::team_data::TeamApiClient;
 
 #[async_trait]
 pub trait Action {
@@ -106,6 +107,7 @@ impl<'a> Action for Step<'a> {
     async fn call(&self) -> anyhow::Result<String> {
         let mut gh = GithubClient::new_from_env();
         gh.set_retry_rate_limit(true);
+        let team_api = TeamApiClient::new_from_env();
 
         let mut context = Context::new();
         let mut results = HashMap::new();
@@ -130,6 +132,7 @@ impl<'a> Action for Step<'a> {
                     let kind = *kind;
                     let repository = repository.clone();
                     let gh = gh.clone();
+                    let team_api = team_api.clone();
                     let query = query.clone();
                     handles.push(tokio::task::spawn(async move {
                         let _permit = semaphore.acquire().await?;
@@ -148,6 +151,7 @@ impl<'a> Action for Step<'a> {
                                 mcps_groups.contains(&name.as_str())
                                     && repository.full_name.contains("rust-lang/compiler-team"),
                                 &gh,
+                                &team_api,
                             )
                             .await?;
                         Ok((name, kind, issues))

src/bin/project_goals.rs

@@ -1,4 +1,5 @@
 use clap::Parser;
+use triagebot::team_data::TeamApiClient;
 use triagebot::zulip::client::ZulipClient;
 use triagebot::{github::GithubClient, handlers::project_goals};
 
@@ -24,9 +25,11 @@ async fn main() -> anyhow::Result<()> {
     let opt = Opt::parse();
     let gh = GithubClient::new_from_env();
     let zulip = ZulipClient::new_from_env();
+    let team_api = TeamApiClient::new_from_env();
     project_goals::ping_project_goals_owners(
         &gh,
         &zulip,
+        &team_api,
         opt.dry_run,
         opt.days_threshold,
         &opt.next_meeting_date,

src/github.rs

@@ -1,3 +1,4 @@
+use crate::team_data::TeamApiClient;
 use anyhow::{anyhow, Context};
 use async_trait::async_trait;
 use bytes::Bytes;
@@ -240,9 +241,9 @@ impl User {
             .await
     }
 
-    pub async fn is_team_member<'a>(&'a self, client: &'a GithubClient) -> anyhow::Result<bool> {
+    pub async fn is_team_member<'a>(&'a self, client: &'a TeamApiClient) -> anyhow::Result<bool> {
         log::trace!("Getting team membership for {:?}", self.login);
-        let permission = crate::team_data::teams(client).await?;
+        let permission = client.teams().await?;
         let map = permission.teams;
         let is_triager = map
             .get("wg-triage")
@@ -268,10 +269,10 @@ impl User {
 
 // Returns the ID of the given user, if the user is in the `all` team.
 pub async fn get_id_for_username(
-    client: &GithubClient,
+    client: &TeamApiClient,
     login: &str,
 ) -> anyhow::Result<Option<u64>> {
-    let permission = crate::team_data::teams(client).await?;
+    let permission = client.teams().await?;
     let map = permission.teams;
     let login = login.to_lowercase();
     Ok(map["all"]
@@ -282,21 +283,21 @@ pub async fn get_id_for_username(
 }
 
 pub async fn get_team(
-    client: &GithubClient,
+    client: &TeamApiClient,
     team: &str,
 ) -> anyhow::Result<Option<rust_team_data::v1::Team>> {
-    let permission = crate::team_data::teams(client).await?;
+    let permission = client.teams().await?;
     let mut map = permission.teams;
     Ok(map.swap_remove(team))
 }
 
 /// Fetches a Rust team via its GitHub team name.
 pub async fn get_team_by_github_name(
-    client: &GithubClient,
+    client: &TeamApiClient,
     org: &str,
     team: &str,
 ) -> anyhow::Result<Option<rust_team_data::v1::Team>> {
-    let teams = crate::team_data::teams(client).await?;
+    let teams = client.teams().await?;
     for rust_team in teams.teams.into_values() {
         if let Some(github) = &rust_team.github {
             for gh_team in &github.teams {
@@ -2059,10 +2060,11 @@ impl<'q> IssuesQuery for Query<'q> {
         repo: &'a Repository,
         include_fcp_details: bool,
         include_mcp_details: bool,
-        client: &'a GithubClient,
+        gh_client: &'a GithubClient,
+        team_api_client: &'a TeamApiClient,
     ) -> anyhow::Result<Vec<crate::actions::IssueDecorator>> {
         let issues = repo
-            .get_issues(&client, self)
+            .get_issues(&gh_client, self)
             .await
             .with_context(|| "Unable to get issues.")?;
 
@@ -2075,7 +2077,7 @@ impl<'q> IssuesQuery for Query<'q> {
         };
 
         let zulip_map = if include_fcp_details {
-            Some(crate::team_data::zulip_map(client).await?)
+            Some(team_api_client.zulip_map().await?)
         } else {
             None
         };
@@ -2111,7 +2113,7 @@ impl<'q> IssuesQuery for Query<'q> {
                             ("".to_string(), "".to_string())
                         } else {
                             let comment = issue
-                                .get_comment(&client, fk_initiating_comment.try_into()?)
+                                .get_comment(&gh_client, fk_initiating_comment.try_into()?)
                                 .await
                                 .with_context(|| {
                                     format!(
@@ -2176,7 +2178,7 @@ impl<'q> IssuesQuery for Query<'q> {
             };
 
             let mcp_details = if include_mcp_details {
-                let first100_comments = issue.get_first100_comments(&client).await?;
+                let first100_comments = issue.get_first100_comments(&gh_client).await?;
                 let (zulip_link, concerns) = if !first100_comments.is_empty() {
                     let split = re_zulip_link
                         .split(&first100_comments[0].body)
@@ -2891,7 +2893,8 @@ pub trait IssuesQuery {
         repo: &'a Repository,
         include_fcp_details: bool,
         include_mcp_details: bool,
-        client: &'a GithubClient,
+        gh_client: &'a GithubClient,
+        team_api_client: &'a TeamApiClient,
     ) -> anyhow::Result<Vec<crate::actions::IssueDecorator>>;
 }
 
@@ -2904,6 +2907,7 @@ impl IssuesQuery for LeastRecentlyReviewedPullRequests {
         _include_fcp_details: bool,
         _include_mcp_details: bool,
         client: &'a GithubClient,
+        _team_api_client: &'a TeamApiClient,
     ) -> anyhow::Result<Vec<crate::actions::IssueDecorator>> {
         use cynic::QueryBuilder;
         use github_graphql::queries;
@@ -3122,6 +3126,7 @@ impl IssuesQuery for DesignMeetings {
         _include_fcp_details: bool,
         _include_mcp_details: bool,
         client: &'a GithubClient,
+        _team_api_client: &'a TeamApiClient,
     ) -> anyhow::Result<Vec<crate::actions::IssueDecorator>> {
         use github_graphql::project_items::ProjectV2ItemContent;
 

src/handlers.rs

@@ -1,6 +1,7 @@
 use crate::config::{self, Config, ConfigurationError};
 use crate::github::{Event, GithubClient, IssueCommentAction, IssuesAction, IssuesEvent};
 use crate::handlers::pr_tracking::ReviewerWorkqueue;
+use crate::team_data::TeamApiClient;
 use crate::zulip::client::ZulipClient;
 use octocrab::Octocrab;
 use parser::command::{assign::AssignCommand, Command, Input};
@@ -374,6 +375,7 @@ command_handlers! {
 pub struct Context {
     pub github: GithubClient,
     pub zulip: ZulipClient,
+    pub team_api: TeamApiClient,
     pub db: crate::db::ClientPool,
     pub username: String,
     pub octocrab: Octocrab,

src/handlers/assign.rs

@@ -388,7 +388,7 @@ async fn determine_assignee(
     diff: &[FileDiff],
 ) -> anyhow::Result<(Option<ReviewerSelection>, bool)> {
     let mut db_client = ctx.db.get().await;
-    let teams = crate::team_data::teams(&ctx.github).await?;
+    let teams = &ctx.team_api.teams().await?;
     if let Some(name) = assign_command {
         // User included `r?` in the opening PR body.
         match find_reviewer_from_names(
@@ -564,12 +564,12 @@ pub(super) async fn handle_command(
     event: &Event,
     cmd: AssignCommand,
 ) -> anyhow::Result<()> {
-    let is_team_member = if let Err(_) | Ok(false) = event.user().is_team_member(&ctx.github).await
-    {
-        false
-    } else {
-        true
-    };
+    let is_team_member =
+        if let Err(_) | Ok(false) = event.user().is_team_member(&ctx.team_api).await {
+            false
+        } else {
+            true
+        };
 
     // Don't handle commands in comments from the bot. Some of the comments it
     // posts contain commands to instruct the user, not things that the bot
@@ -599,7 +599,7 @@ pub(super) async fn handle_command(
             return Ok(());
         }
 
-        let teams = crate::team_data::teams(&ctx.github).await?;
+        let teams = ctx.team_api.teams().await?;
 
         let assignee = match cmd {
             AssignCommand::Claim => event.user().login.clone(),

src/handlers/close.rs

@@ -12,7 +12,7 @@ pub(super) async fn handle_command(
     let issue = event.issue().unwrap();
     let is_team_member = event
         .user()
-        .is_team_member(&ctx.github)
+        .is_team_member(&ctx.team_api)
         .await
         .unwrap_or(false);
     if !is_team_member {

src/handlers/major_change.rs

@@ -247,7 +247,7 @@ pub(super) async fn handle_command(
 
     let is_team_member = event
         .user()
-        .is_team_member(&ctx.github)
+        .is_team_member(&ctx.team_api)
         .await
         .ok()
         .unwrap_or(false);

src/handlers/nominate.rs

@@ -14,12 +14,12 @@ pub(super) async fn handle_command(
     event: &Event,
     cmd: NominateCommand,
 ) -> anyhow::Result<()> {
-    let is_team_member = if let Err(_) | Ok(false) = event.user().is_team_member(&ctx.github).await
-    {
-        false
-    } else {
-        true
-    };
+    let is_team_member =
+        if let Err(_) | Ok(false) = event.user().is_team_member(&ctx.team_api).await {
+            false
+        } else {
+            true
+        };
 
     if !is_team_member {
         let cmnt = ErrorComment::new(

src/handlers/notification.rs

@@ -69,7 +69,7 @@ pub(super) async fn handle(ctx: &Context, event: &Event) -> anyhow::Result<()> {
     //
     // If the user intended to ping themselves, they can add the GitHub comment
     // via the Zulip interface.
-    match get_id_for_username(&ctx.github, &event.user().login).await {
+    match get_id_for_username(&ctx.team_api, &event.user().login).await {
         Ok(Some(id)) => {
             users_notified.insert(id.try_into().unwrap());
         }
@@ -136,7 +136,7 @@ async fn id_from_user(
         //
         // We may also want to be able to categorize into these buckets
         // *after* the ping occurs and is initially processed.
-        let team = match github::get_team_by_github_name(&ctx.github, org, team).await {
+        let team = match github::get_team_by_github_name(&ctx.team_api, org, team).await {
             Ok(Some(team)) => team,
             Ok(None) => {
                 // If the team is in rust-lang*, then this is probably an error (potentially user
@@ -170,7 +170,7 @@ async fn id_from_user(
             Some(team.name),
         )))
     } else {
-        let id = get_id_for_username(&ctx.github, login)
+        let id = get_id_for_username(&ctx.team_api, login)
             .await
             .with_context(|| format!("failed to get user {} ID", login))?;
         let Some(id) = id else {

src/handlers/ping.rs

@@ -18,12 +18,12 @@ pub(super) async fn handle_command(
     event: &Event,
     team_name: PingCommand,
 ) -> anyhow::Result<()> {
-    let is_team_member = if let Err(_) | Ok(false) = event.user().is_team_member(&ctx.github).await
-    {
-        false
-    } else {
-        true
-    };
+    let is_team_member =
+        if let Err(_) | Ok(false) = event.user().is_team_member(&ctx.team_api).await {
+            false
+        } else {
+            true
+        };
 
     if !is_team_member {
         let cmnt = ErrorComment::new(
@@ -49,7 +49,7 @@ pub(super) async fn handle_command(
             return Ok(());
         }
     };
-    let team = github::get_team(&ctx.github, &gh_team).await?;
+    let team = github::get_team(&ctx.team_api, &gh_team).await?;
     let team = match team {
         Some(team) => team,
         None => {