feat: implementing project_plan_limits method to get limits from a new internal api

Author: geekbrother

.github/workflows/ci.yaml

@@ -44,7 +44,7 @@ jobs:
           - name: "Check Formatting"
             cmd: fmt
             args: -- --check
-            toolchain: nightly
+            toolchain: stable
             profile: default
           - name: "Unit Tests"
             cmd: test

src/project/types/project_data.rs

@@ -50,6 +50,14 @@ pub struct Quota {
     pub is_valid: bool,
 }
 
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Hash, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct PlanLimits {
+    pub tier: String,
+    pub is_above_rpc_limit: bool,
+    pub is_above_mau_limit: bool,
+}
+
 impl ProjectData {
     pub fn validate_access(
         &self,

src/registry/client.rs

@@ -1,19 +1,21 @@
 use {
     crate::{
-        project::{ProjectData, ProjectDataWithQuota},
+        project::{PlanLimits, ProjectData, ProjectDataWithQuota},
         registry::error::RegistryError,
     },
     async_trait::async_trait,
     reqwest::{
         header::{self, HeaderValue},
-        IntoUrl,
-        StatusCode,
-        Url,
+        IntoUrl, StatusCode, Url,
     },
     serde::de::DeserializeOwned,
     std::{fmt::Debug, time::Duration},
 };
 
+use once_cell::sync::Lazy;
+
+static INTERNAL_API_BASE_URI: Lazy<Url> =
+    Lazy::new(|| Url::parse("https://api.reown.com").expect("Invalid internal API base URI"));
 const INVALID_TOKEN_ERROR: &str = "invalid auth token";
 
 pub type RegistryResult<T> = Result<T, RegistryError>;
@@ -25,6 +27,7 @@ pub trait RegistryClient: 'static + Send + Sync + Debug {
         &self,
         id: &str,
     ) -> RegistryResult<Option<ProjectDataWithQuota>>;
+    async fn project_plan_limits(&self, id: &str) -> RegistryResult<Option<PlanLimits>>;
 }
 
 /// HTTP client configuration.
@@ -62,22 +65,27 @@ impl Default for HttpClientConfig {
 
 #[derive(Debug, Clone)]
 pub struct RegistryHttpClient {
-    base_url: Url,
+    base_explorer_url: Url,
+    base_internal_api_url: Url,
     http_client: reqwest::Client,
 }
 
 impl RegistryHttpClient {
-    pub fn new(base_url: impl IntoUrl, auth_token: &str, origin: &str) -> RegistryResult<Self> {
-        Self::with_config(base_url, auth_token, origin, Default::default())
+    pub fn new(
+        base_explorer_url: impl IntoUrl,
+        auth_token: &str,
+        origin: &str,
+    ) -> RegistryResult<Self> {
+        Self::with_config(base_explorer_url, auth_token, origin, Default::default())
     }
 
     pub fn with_config(
-        base_url: impl IntoUrl,
+        base_explorer_url: impl IntoUrl,
         auth_token: &str,
         origin: &str,
         config: HttpClientConfig,
     ) -> RegistryResult<Self> {
-        let mut auth_value = HeaderValue::from_str(&format!("Bearer {}", auth_token))
+        let mut auth_value = HeaderValue::from_str(&format!("Bearer {auth_token}"))
             .map_err(|_| RegistryError::Config(INVALID_TOKEN_ERROR))?;
 
         // Make sure we're not leaking auth token in debug output.
@@ -90,6 +98,8 @@ impl RegistryHttpClient {
             HeaderValue::from_str(origin).map_err(RegistryError::OriginParse)?,
         );
 
+        // We can use the same client for both explorer and internal API
+        // because the internal API is protected by the same auth token.
         let mut http_client = reqwest::Client::builder()
             .default_headers(headers)
             .pool_idle_timeout(config.pool_idle_timeout)
@@ -100,7 +110,10 @@ impl RegistryHttpClient {
         }
 
         Ok(Self {
-            base_url: base_url.into_url().map_err(RegistryError::BaseUrlIntoUrl)?,
+            base_explorer_url: base_explorer_url
+                .into_url()
+                .map_err(RegistryError::BaseUrlIntoUrl)?,
+            base_internal_api_url: INTERNAL_API_BASE_URI.clone(),
             http_client: http_client.build().map_err(RegistryError::BuildClient)?,
         })
     }
@@ -114,7 +127,29 @@ impl RegistryHttpClient {
             return Ok(None);
         }
 
-        let url = build_url(&self.base_url, project_id, quota).map_err(RegistryError::UrlBuild)?;
+        let url = build_explorer_url(&self.base_explorer_url, project_id, quota)
+            .map_err(RegistryError::UrlBuild)?;
+
+        let resp = self
+            .http_client
+            .get(url)
+            .send()
+            .await
+            .map_err(RegistryError::Transport)?;
+
+        parse_http_response(resp).await
+    }
+
+    async fn project_plan_limits_impl<T: DeserializeOwned>(
+        &self,
+        project_id: &str,
+    ) -> RegistryResult<Option<T>> {
+        if !is_valid_project_id(project_id) {
+            return Ok(None);
+        }
+
+        let url = build_internal_api_url(&self.base_internal_api_url, project_id)
+            .map_err(RegistryError::UrlBuild)?;
 
         let resp = self
             .http_client
@@ -139,16 +174,30 @@ impl RegistryClient for RegistryHttpClient {
     ) -> RegistryResult<Option<ProjectDataWithQuota>> {
         self.project_data_impl(project_id, true).await
     }
+
+    async fn project_plan_limits(&self, project_id: &str) -> RegistryResult<Option<PlanLimits>> {
+        self.project_plan_limits_impl(project_id).await
+    }
 }
 
-fn build_url(base_url: &Url, project_id: &str, quota: bool) -> Result<Url, url::ParseError> {
+fn build_explorer_url(
+    base_url: &Url,
+    project_id: &str,
+    quota: bool,
+) -> Result<Url, url::ParseError> {
     let mut url = base_url.join(&format!("/internal/project/key/{project_id}"))?;
     if quota {
         url.query_pairs_mut().append_pair("quotas", "true");
     }
     Ok(url)
 }
 
+fn build_internal_api_url(base_url: &Url, project_id: &str) -> Result<Url, url::ParseError> {
+    let mut url = base_url.join("/internal/v1/project-limits")?;
+    url.query_pairs_mut().append_pair("projectId", project_id);
+    Ok(url)
+}
+
 /// Checks if the project ID is formatted properly. It must be 32 hex
 /// characters.
 fn is_valid_project_id(project_id: &str) -> bool {
@@ -186,9 +235,7 @@ mod test {
         wiremock::{
             http::Method,
             matchers::{method, path, query_param},
-            Mock,
-            MockServer,
-            ResponseTemplate,
+            Mock, MockServer, ResponseTemplate,
         },
     };
 
@@ -350,11 +397,11 @@ mod test {
     }
 
     #[test]
-    fn test_build_url() {
+    fn test_build_explorer_url() {
         let base_url = Url::parse("http://example.com").unwrap();
         let project_id = "a".repeat(32);
 
-        let url = build_url(&base_url, &project_id, false).unwrap();
+        let url = build_explorer_url(&base_url, &project_id, false).unwrap();
         assert_eq!(
             url.as_str(),
             "http://example.com/internal/project/key/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
@@ -366,7 +413,7 @@ mod test {
         let base_url = Url::parse("http://example.com").unwrap();
         let project_id = "a".repeat(32);
 
-        let url = build_url(&base_url, &project_id, true).unwrap();
+        let url = build_explorer_url(&base_url, &project_id, true).unwrap();
         assert_eq!(
             url.as_str(),
             "http://example.com/internal/project/key/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa?quotas=true"