refactor(nango): overhaul crate with connect_session.rs and connection.rs modules (#3711)

Author: devin-ai-integration[bot]

Cargo.lock

@@ -42,27 +42,24 @@ pub async fn create_connect_session(
         .map_err(|e| IntegrationError::Auth(e.to_string()))?;
     let user_id = claims.sub;
 
-    let req = hypr_nango::NangoConnectSessionRequest {
-        end_user: hypr_nango::NangoConnectSessionRequestUser {
+    let req = hypr_nango::CreateConnectSessionRequest {
+        end_user: hypr_nango::EndUser {
             id: user_id,
             display_name: None,
             email: None,
+            tags: None,
         },
         organization: None,
-        allowed_integrations: vec![],
+        allowed_integrations: None,
         integrations_config_defaults: None,
     };
 
-    let res = state.nango.create_connect_session(req).await?;
+    let session = state.nango.create_connect_session(req).await?;
 
-    match res {
-        hypr_nango::NangoConnectSessionResponse::Ok { token, expires_at } => {
-            Ok(Json(ConnectSessionResponse { token, expires_at }))
-        }
-        hypr_nango::NangoConnectSessionResponse::Error { code } => {
-            Err(IntegrationError::Nango(code))
-        }
-    }
+    Ok(Json(ConnectSessionResponse {
+        token: session.token,
+        expires_at: session.expires_at,
+    }))
 }
 
 fn extract_token(headers: &HeaderMap) -> Result<&str> {

crates/api-integration/src/routes/connect.rs

@@ -1,5 +1,11 @@
+use serde::de::DeserializeOwned;
+
 use crate::proxy::NangoProxyBuilder;
-use crate::types::*;
+use crate::types::NangoIntegration;
+
+pub(crate) fn append_query(url: &mut url::Url, key: &str, value: &str) {
+    url.query_pairs_mut().append_pair(key, value);
+}
 
 #[derive(Clone, Default)]
 pub struct NangoClientBuilder {
@@ -48,41 +54,27 @@ impl NangoClientBuilder {
     }
 }
 
-impl NangoClient {
-    pub async fn get_connection(
-        &self,
-        connection_id: impl std::fmt::Display,
-    ) -> Result<NangoGetConnectionResponseData, crate::Error> {
-        let mut url = self.api_base.clone();
-        url.set_path(&format!("/connection/{}", connection_id));
-
-        let res: NangoGetConnectionResponse = self.client.get(url).send().await?.json().await?;
-        match res {
-            NangoGetConnectionResponse::Ok(data) => Ok(*data),
-            NangoGetConnectionResponse::Error { message } => Err(crate::Error::NangoError(message)),
-        }
+pub(crate) async fn check_response(
+    response: reqwest::Response,
+) -> Result<reqwest::Response, crate::Error> {
+    let status = response.status();
+    if status.is_success() {
+        Ok(response)
+    } else {
+        let status_code = status.as_u16();
+        let body = response.text().await.unwrap_or_default();
+        Err(crate::Error::Api(status_code, body))
     }
+}
 
-    pub async fn create_connect_session(
-        &self,
-        req: NangoConnectSessionRequest,
-    ) -> Result<NangoConnectSessionResponse, crate::Error> {
-        let mut url = self.api_base.clone();
-        url.set_path("/connect/sessions");
-
-        let res = self
-            .client
-            .post(url)
-            .header("Content-Type", "application/json")
-            .json(&req)
-            .send()
-            .await?
-            .json()
-            .await?;
-
-        Ok(res)
-    }
+pub(crate) async fn parse_response<T: DeserializeOwned>(
+    response: reqwest::Response,
+) -> Result<T, crate::Error> {
+    let response = check_response(response).await?;
+    Ok(response.json().await?)
+}
 
+impl NangoClient {
     pub fn for_connection(
         &self,
         integration: NangoIntegration,

crates/nango/src/client.rs

@@ -0,0 +1,117 @@
+use std::collections::HashMap;
+
+use crate::client::NangoClient;
+use crate::common_derives;
+
+common_derives! {
+    pub struct CreateConnectSessionRequest {
+        pub end_user: EndUser,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub organization: Option<Organization>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub allowed_integrations: Option<Vec<String>>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub integrations_config_defaults: Option<HashMap<String, IntegrationConfigDefault>>,
+    }
+}
+
+common_derives! {
+    pub struct EndUser {
+        pub id: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub email: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub display_name: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub tags: Option<HashMap<String, String>>,
+    }
+}
+
+common_derives! {
+    pub struct Organization {
+        pub id: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub display_name: Option<String>,
+    }
+}
+
+common_derives! {
+    pub struct IntegrationConfigDefault {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub user_scopes: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub connection_config: Option<ConnectionConfigOverride>,
+    }
+}
+
+common_derives! {
+    pub struct ConnectionConfigOverride {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub oauth_scopes_override: Option<String>,
+    }
+}
+
+common_derives! {
+    pub struct ConnectSession {
+        pub token: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub connect_link: Option<String>,
+        pub expires_at: String,
+    }
+}
+
+common_derives! {
+    pub struct ReconnectSessionRequest {
+        pub connection_id: String,
+        pub integration_id: String,
+    }
+}
+
+#[derive(serde::Deserialize)]
+pub(crate) struct DataWrapper<T> {
+    pub data: T,
+}
+
+impl NangoClient {
+    pub async fn create_connect_session(
+        &self,
+        req: CreateConnectSessionRequest,
+    ) -> Result<ConnectSession, crate::Error> {
+        let mut url = self.api_base.clone();
+        url.set_path("/connect/sessions");
+
+        let response = self.client.post(url).json(&req).send().await?;
+        let wrapper: DataWrapper<ConnectSession> = crate::client::parse_response(response).await?;
+        Ok(wrapper.data)
+    }
+
+    pub async fn reconnect_session(
+        &self,
+        req: ReconnectSessionRequest,
+    ) -> Result<ConnectSession, crate::Error> {
+        let mut url = self.api_base.clone();
+        url.set_path("/connect/sessions/reconnect");
+
+        let response = self.client.post(url).json(&req).send().await?;
+        let wrapper: DataWrapper<ConnectSession> = crate::client::parse_response(response).await?;
+        Ok(wrapper.data)
+    }
+
+    pub async fn get_connect_session(&self) -> Result<ConnectSession, crate::Error> {
+        let mut url = self.api_base.clone();
+        url.set_path("/connect/session");
+
+        let response = self.client.get(url).send().await?;
+        let wrapper: DataWrapper<ConnectSession> = crate::client::parse_response(response).await?;
+        Ok(wrapper.data)
+    }
+
+    pub async fn delete_connect_session(&self) -> Result<(), crate::Error> {
+        let mut url = self.api_base.clone();
+        url.set_path("/connect/session");
+
+        let response = self.client.delete(url).send().await?;
+        crate::client::check_response(response).await?;
+        Ok(())
+    }
+}