Send linked accounts in user JSON (deploy 6)

Author: carols10cents

Diff for: crates/crates_io_database/src/models/user.rs

@@ -11,6 +11,8 @@ use crate::models::{Crate, CrateOwner, Email, Owner, OwnerKind};
 use crate::schema::{crate_owners, emails, linked_accounts, users};
 use crates_io_diesel_helpers::{lower, pg_enum};
 
+use std::fmt::{Display, Formatter};
+
 /// The model representing a row in the `users` database table.
 #[derive(Clone, Debug, Queryable, Identifiable, Selectable)]
 pub struct User {
@@ -77,6 +79,17 @@ impl User {
             .await
             .optional()
     }
+
+    /// Queries for the linked accounts belonging to a particular user
+    pub async fn linked_accounts(
+        &self,
+        conn: &mut AsyncPgConnection,
+    ) -> QueryResult<Vec<LinkedAccount>> {
+        LinkedAccount::belonging_to(self)
+            .select(LinkedAccount::as_select())
+            .load(conn)
+            .await
+    }
 }
 
 /// Represents a new user record insertable to the `users` table
@@ -133,6 +146,22 @@ pg_enum! {
     }
 }
 
+impl Display for AccountProvider {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Github => write!(f, "GitHub"),
+        }
+    }
+}
+
+impl AccountProvider {
+    pub fn url(&self, login: &str) -> String {
+        match self {
+            Self::Github => format!("https://github.com/{login}"),
+        }
+    }
+}
+
 /// Represents an OAuth account record linked to a user record.
 #[derive(Associations, Identifiable, Selectable, Queryable, Debug, Clone)]
 #[diesel(

Diff for: src/controllers/user/other.rs

@@ -16,12 +16,12 @@ pub struct GetResponse {
     pub user: EncodablePublicUser,
 }
 
-/// Find user by login.
+/// Find user by username.
 #[utoipa::path(
     get,
     path = "/api/v1/users/{user}",
     params(
-        ("user" = String, Path, description = "Login name of the user"),
+        ("user" = String, Path, description = "Crates.io username of the user"),
     ),
     tag = "users",
     responses((status = 200, description = "Successful Response", body = inline(GetResponse))),
@@ -41,7 +41,11 @@ pub async fn find_user(
         .first(&mut conn)
         .await?;
 
-    Ok(Json(GetResponse { user: user.into() }))
+    let linked_accounts = user.linked_accounts(&mut conn).await?;
+
+    Ok(Json(GetResponse {
+        user: EncodablePublicUser::with_linked_accounts(user, &linked_accounts),
+    }))
 }
 
 #[derive(Debug, Serialize, utoipa::ToSchema)]

Diff for: src/snapshots/crates_io__openapi__tests__openapi_snapshot.snap

@@ -865,6 +865,17 @@ snapshot_kind: text
             "format": "int32",
             "type": "integer"
           },
+          "linked_accounts": {
+            "description": "The accounts linked to this crates.io account.",
+            "example": [],
+            "items": {
+              "$ref": "#/components/schemas/LinkedAccount"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "login": {
             "description": "The user's GitHub login name.",
             "example": "ghost",
@@ -4167,7 +4178,7 @@ snapshot_kind: text
         "operationId": "find_user",
         "parameters": [
           {
-            "description": "Login name of the user",
+            "description": "Crates.io username of the user",
             "in": "path",
             "name": "user",
             "required": true,
@@ -4196,7 +4207,7 @@ snapshot_kind: text
             "description": "Successful Response"
           }
         },
-        "summary": "Find user by login.",
+        "summary": "Find user by username.",
         "tags": [
           "users"
         ]

Diff for: src/tests/routes/users/read.rs

@@ -22,6 +22,13 @@ async fn show() {
     assert_eq!(json.user.login, "Bar");
     assert_eq!(json.user.username, "Bar");
     assert_eq!(json.user.url, "https://github.com/Bar");
+
+    let accounts = json.user.linked_accounts.unwrap();
+    assert_eq!(accounts.len(), 1);
+    let account = &accounts[0];
+    assert_eq!(account.provider, "GitHub");
+    assert_eq!(account.login, "Bar");
+    assert_eq!(account.url, "https://github.com/Bar");
 }
 
 #[tokio::test(flavor = "multi_thread")]

Diff for: src/tests/util/test_app.rs

@@ -3,8 +3,8 @@ use crate::config::{
     self, Base, CdnLogQueueConfig, CdnLogStorageConfig, DatabasePools, DbPoolConfig,
 };
 use crate::middleware::cargo_compat::StatusCodeConfig;
-use crate::models::NewEmail;
 use crate::models::token::{CrateScope, EndpointScope};
+use crate::models::{AccountProvider, NewEmail, NewLinkedAccount};
 use crate::rate_limiter::{LimitedAction, RateLimiterConfig};
 use crate::storage::StorageConfig;
 use crate::tests::util::chaosproxy::ChaosProxy;
@@ -114,19 +114,28 @@ impl TestApp {
         self.0.test_database.async_connect().await
     }
 
-    /// Create a new user with a verified email address in the database
-    /// (`<username>@example.com`) and return a mock user session.
+    /// Create a new user with a verified email address (`<username>@example.com`)
+    /// and a linked GitHub account in the database and return a mock user session.
     ///
     /// This method updates the database directly
     pub async fn db_new_user(&self, username: &str) -> MockCookieUser {
         let mut conn = self.db_conn().await;
 
         let email = format!("{username}@example.com");
 
-        let user = crate::tests::new_user(username)
-            .insert(&mut conn)
-            .await
-            .unwrap();
+        let new_user = crate::tests::new_user(username);
+        let user = new_user.insert(&mut conn).await.unwrap();
+
+        let linked_account = NewLinkedAccount::builder()
+            .user_id(user.id)
+            .provider(AccountProvider::Github)
+            .account_id(user.gh_id)
+            .access_token(&new_user.gh_access_token)
+            .login(&user.gh_login)
+            .maybe_avatar(user.gh_avatar.as_deref())
+            .build();
+
+        linked_account.insert_or_update(&mut conn).await.unwrap();
 
         let new_email = NewEmail::builder()
             .user_id(user.id)

Diff for: src/views.rs

@@ -2,8 +2,8 @@ use chrono::{DateTime, Utc};
 
 use crate::external_urls::remove_blocked_urls;
 use crate::models::{
-    ApiToken, Category, Crate, Dependency, DependencyKind, Keyword, Owner, ReverseDependency, Team,
-    TopVersions, User, Version, VersionDownload, VersionOwnerAction,
+    ApiToken, Category, Crate, Dependency, DependencyKind, Keyword, LinkedAccount, Owner,
+    ReverseDependency, Team, TopVersions, User, Version, VersionDownload, VersionOwnerAction,
 };
 use crates_io_github as github;
 
@@ -790,9 +790,15 @@ pub struct EncodablePublicUser {
     /// The user's GitHub profile URL.
     #[schema(example = "https://github.com/ghost")]
     pub url: String,
+
+    /// The accounts linked to this crates.io account.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[schema(no_recursion, example = json!([]))]
+    pub linked_accounts: Option<Vec<EncodableLinkedAccount>>,
 }
 
-/// Converts a `User` model into an `EncodablePublicUser` for JSON serialization.
+/// Converts a `User` model into an `EncodablePublicUser` for JSON serialization. Does not include
+/// linked accounts.
 impl From<User> for EncodablePublicUser {
     fn from(user: User) -> Self {
         let User {
@@ -805,13 +811,87 @@ impl From<User> for EncodablePublicUser {
         } = user;
         let url = format!("https://github.com/{gh_login}");
         let username = username.unwrap_or(gh_login);
+
+        EncodablePublicUser {
+            id,
+            login: username.clone(),
+            username,
+            name,
+            avatar: gh_avatar,
+            url,
+            linked_accounts: None,
+        }
+    }
+}
+
+impl EncodablePublicUser {
+    pub fn with_linked_accounts(user: User, linked_accounts: &[LinkedAccount]) -> Self {
+        let User {
+            id,
+            name,
+            username,
+            gh_login,
+            gh_avatar,
+            ..
+        } = user;
+        let url = format!("https://github.com/{gh_login}");
+        let username = username.unwrap_or(gh_login);
+
+        let linked_accounts = if linked_accounts.is_empty() {
+            None
+        } else {
+            Some(linked_accounts.iter().map(Into::into).collect())
+        };
+
         EncodablePublicUser {
             id,
             login: username.clone(),
             username,
             name,
             avatar: gh_avatar,
             url,
+            linked_accounts,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, utoipa::ToSchema)]
+#[schema(as = LinkedAccount)]
+pub struct EncodableLinkedAccount {
+    /// The service providing this linked account.
+    #[schema(example = "GitHub")]
+    pub provider: String,
+
+    /// The linked account's login name.
+    #[schema(example = "ghost")]
+    pub login: String,
+
+    /// The linked account's avatar URL, if set.
+    #[schema(example = "https://avatars2.githubusercontent.com/u/1234567?v=4")]
+    pub avatar: Option<String>,
+
+    /// The linked account's profile URL on the provided service.
+    #[schema(example = "https://github.com/ghost")]
+    pub url: String,
+}
+
+/// Converts a `LinkedAccount` model into an `EncodableLinkedAccount` for JSON serialization.
+impl From<&LinkedAccount> for EncodableLinkedAccount {
+    fn from(linked_account: &LinkedAccount) -> Self {
+        let LinkedAccount {
+            provider,
+            login,
+            avatar,
+            ..
+        } = linked_account;
+
+        let url = provider.url(login);
+
+        Self {
+            provider: provider.to_string(),
+            login: login.clone(),
+            avatar: avatar.clone(),
+            url,
         }
     }
 }
@@ -1140,6 +1220,7 @@ mod tests {
                     name: None,
                     avatar: None,
                     url: String::new(),
+                    linked_accounts: None,
                 },
                 time: NaiveDate::from_ymd_opt(2017, 1, 6)
                     .unwrap()