Add support for the /oauth2/token-info endpoint (#733)

* Add support for the /oauth2/token-info endpoint

* Wrap `UniffiWpComApiClient` instead of aliasing it

* Clippy fixes

Author: jkmassel

native/swift/Sources/wordpress-api/Exports.swift

@@ -19,6 +19,8 @@ public typealias MiddlewarePipeline = WordPressAPIInternal.WpApiMiddlewarePipeli
 public typealias MiddlewarePipelineBuilder = WordPressAPIInternal.WpApiMiddlewarePipelineBuilder
 public typealias ApiDiscoveryAuthenticationMiddleware = WordPressAPIInternal.ApiDiscoveryAuthenticationMiddleware
 public typealias RetryAfterMiddleware = WordPressAPIInternal.RetryAfterMiddleware
+public typealias WpApiClientDelegate = WordPressAPIInternal.WpApiClientDelegate
+public typealias WpAppNotifier = WordPressAPIInternal.WpAppNotifier
 
 // MARK: - Login
 
@@ -129,3 +131,6 @@ public typealias WpSiteHealthTestsRequestExecutor = WordPressAPIInternal.WpSiteH
 
 // MARK: - WordPress.org
 public typealias WordPressOrgApiClient = WordPressAPIInternal.WordPressOrgApiClient
+
+// MARK: - WordPress.com
+public typealias TokenValidationParameters = WordPressAPIInternal.TokenValidationParameters

native/swift/Sources/wordpress-api/WPComApiClient.swift

@@ -0,0 +1,20 @@
+import Foundation
+import WordPressAPIInternal
+
+public class WPComApiClient {
+    private let internalClient: WordPressAPIInternal.UniffiWpComApiClient
+    private let delegate: WpApiClientDelegate
+
+    public init(delegate: WpApiClientDelegate) {
+        self.delegate = delegate // We need to retain this ourselves because it's passed to a Rust object
+        self.internalClient = UniffiWpComApiClient(delegate: delegate)
+    }
+
+    public var oauth2: Oauth2RequestExecutor {
+        internalClient.oauth2()
+    }
+
+    public var jetpackConnection: JetpackConnectionRequestExecutor {
+        internalClient.jetpackConnection()
+    }
+}

native/swift/Tests/wordpress-api/Support/Mocks.swift

@@ -0,0 +1,8 @@
+import Foundation
+import WordPressAPI
+
+final class MockAppNotifier: WpAppNotifier {
+    func requestedWithInvalidAuthentication() async {
+        // no-op
+    }
+}

wp_api/src/wp_com/client.rs

@@ -1,6 +1,8 @@
 use super::endpoint::jetpack_connection_endpoint::{
     JetpackConnectionRequestBuilder, JetpackConnectionRequestExecutor,
 };
+use super::endpoint::oauth2::{Oauth2RequestBuilder, Oauth2RequestExecutor};
+use crate::api_client_generate_request_builder;
 use crate::{
     ParsedUrl, WpApiClientDelegate, api_client_generate_api_client,
     api_client_generate_endpoint_impl, auth::WpAuthenticationProvider,
@@ -24,14 +26,17 @@ impl UniffiWpComApiRequestBuilder {
 
 pub struct WpComApiRequestBuilder {
     jetpack_connection: Arc<JetpackConnectionRequestBuilder>,
+    oauth2: Arc<Oauth2RequestBuilder>,
 }
 
 impl WpComApiRequestBuilder {
     pub fn new(api_root_url: Arc<ParsedUrl>, auth_provider: Arc<WpAuthenticationProvider>) -> Self {
-        Self {
-            jetpack_connection: JetpackConnectionRequestBuilder::new(api_root_url, auth_provider)
-                .into(),
-        }
+        api_client_generate_request_builder!(
+            api_root_url,
+            auth_provider;
+            jetpack_connection,
+            oauth2
+        )
     }
 }
 
@@ -52,6 +57,7 @@ impl UniffiWpComApiClient {
 
 pub struct WpComApiClient {
     jetpack_connection: Arc<JetpackConnectionRequestExecutor>,
+    oauth2: Arc<Oauth2RequestExecutor>,
 }
 
 impl WpComApiClient {
@@ -62,8 +68,10 @@ impl WpComApiClient {
         api_client_generate_api_client!(
             api_root_url,
             delegate;
-            jetpack_connection
+            jetpack_connection,
+            oauth2
         )
     }
 }
 api_client_generate_endpoint_impl!(WpComApi, jetpack_connection);
+api_client_generate_endpoint_impl!(WpComApi, oauth2);

wp_api/src/wp_com/endpoint.rs

@@ -1 +1,2 @@
 pub mod jetpack_connection_endpoint;
+pub mod oauth2;

wp_api/src/wp_com/endpoint/oauth2.rs

@@ -0,0 +1,18 @@
+use crate::wp_com::oauth2::{TokenValidationParameters, TokenValidationResponse};
+use crate::{
+    request::endpoint::{AsNamespace, DerivedRequest},
+    wp_com::WpComNamespace,
+};
+use wp_derive_request_builder::WpDerivedRequest;
+
+#[derive(WpDerivedRequest)]
+enum Oauth2Request {
+    #[get(url = "/token-info", params = &TokenValidationParameters, output = TokenValidationResponse)]
+    FetchInfo,
+}
+
+impl DerivedRequest for Oauth2Request {
+    fn namespace() -> impl AsNamespace {
+        WpComNamespace::Oauth2
+    }
+}

wp_api/src/wp_com/mod.rs

@@ -5,6 +5,7 @@ use std::{num::ParseIntError, str::FromStr};
 pub mod client;
 pub mod endpoint;
 pub mod jetpack_connection;
+pub mod oauth2;
 
 impl_as_query_value_for_new_type!(WpComSiteId);
 uniffi::custom_newtype!(WpComSiteId, u64);
@@ -26,12 +27,14 @@ impl std::fmt::Display for WpComSiteId {
 }
 
 pub(crate) enum WpComNamespace {
+    Oauth2,
     V2,
 }
 
 impl AsNamespace for WpComNamespace {
     fn as_str(&self) -> &str {
         match self {
+            WpComNamespace::Oauth2 => "/oauth2",
             WpComNamespace::V2 => "/wpcom/v2",
         }
     }

wp_api/src/wp_com/oauth2.rs

@@ -0,0 +1,73 @@
+use crate::url_query::AppendUrlQueryPairs;
+use crate::url_query::QueryPairs;
+use serde::{Deserialize, Serialize};
+use wp_serde_helper::deserialize_u64_or_string;
+
+#[derive(Debug, Serialize, uniffi::Record)]
+pub struct TokenValidationParameters {
+    pub client_id: String,
+    pub token: String,
+}
+
+impl AppendUrlQueryPairs for TokenValidationParameters {
+    fn append_query_pairs(&self, query_pairs_mut: &mut QueryPairs) {
+        query_pairs_mut.append_pair("client_id", &self.client_id);
+        query_pairs_mut.append_pair("token", &self.token);
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, uniffi::Record)]
+pub struct TokenValidationResponse {
+    #[serde(default, deserialize_with = "deserialize_u64_or_string")]
+    pub client_id: u64,
+    #[serde(default, deserialize_with = "deserialize_u64_or_string")]
+    pub user_id: u64,
+    pub blog_id: Option<u64>,
+    pub scope: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use url::Url;
+
+    #[test]
+    fn test_token_validation_parameters_append_query_pairs() {
+        let mut url = Url::parse("https://public-api.wordpress.com/oauth2/token-info")
+            .expect("Failed to parse url");
+
+        let params = TokenValidationParameters {
+            client_id: "11".to_string(),
+            token: "test_token".to_string(),
+        };
+
+        let mut query_pairs = url.query_pairs_mut();
+        params.append_query_pairs(&mut query_pairs);
+
+        assert_eq!(
+            query_pairs.finish().as_str(),
+            "https://public-api.wordpress.com/oauth2/token-info?client_id=11&token=test_token"
+        );
+    }
+
+    #[test]
+    fn test_token_validation_response_deserialization() {
+        let json_str =
+            r#"{"client_id":"11","user_id":"1234567890","blog_id":null,"scope":"global"}"#;
+        let response: TokenValidationResponse = serde_json::from_str(json_str).unwrap();
+
+        assert_eq!(response.client_id, 11);
+        assert_eq!(response.user_id, 1234567890);
+        assert_eq!(response.blog_id, None);
+        assert_eq!(response.scope, "global");
+    }
+
+    #[test]
+    fn test_token_validation_error_response() {
+        let json_str =
+            r#"{"error":"invalid_request","error_description":"The specified token is invalid."}"#;
+        let result = serde_json::from_str::<TokenValidationResponse>(json_str);
+
+        assert!(result.is_err());
+    }
+}

wp_api/tests/wpcom/oauth2/invalid-token-info.json

@@ -0,0 +1 @@
+{"error":"invalid_request","error_description":"The specified token is invalid."}

wp_api/tests/wpcom/oauth2/token-info.json

@@ -0,0 +1 @@
+{"client_id":"11","user_id":"1234567890","blog_id":null,"scope":"global"}