implement strategies for fetching turso config

Author: codekeyz

src/auth.rs

@@ -0,0 +1,64 @@
+use std::{future::Future, pin::Pin};
+
+use crate::utils::TursoConfig;
+
+pub trait DbAuthStrategy {
+    fn resolve<'a>(
+        &'a self,
+        db_name: &'a str,
+        client: &'a reqwest::Client,
+    ) -> Pin<Box<dyn Future<Output = Result<TursoConfig, Box<dyn std::error::Error>>> + Send + 'a>>;
+}
+
+pub struct GlobeStrategy;
+
+impl DbAuthStrategy for GlobeStrategy {
+    fn resolve<'a>(
+        &'a self,
+        db_name: &'a str,
+        client: &'a reqwest::Client,
+    ) -> Pin<Box<dyn Future<Output = Result<TursoConfig, Box<dyn std::error::Error>>> + Send + 'a>>
+    {
+        Box::pin(async move {
+            let globe_auth_api = std::env::var("GLOBE_DS_API")?;
+
+            let request_body = serde_json::json!({ "db_name": db_name });
+
+            let response = client
+                .post(format!("{}/db/auth", globe_auth_api))
+                .body(request_body.to_string())
+                .send()
+                .await
+                .map_err(|_| "Failed to fetch auth credentials for database")?;
+
+            if !response.status().is_success() {
+                return Err(format!("Failed to get Auth Token: {}", response.status()).into());
+            }
+
+            let json = response.json().await?;
+            let config = serde_json::from_value(json)?;
+            Ok(config)
+        })
+    }
+}
+
+pub struct EnvVarStrategy;
+
+impl DbAuthStrategy for EnvVarStrategy {
+    fn resolve<'a>(
+        &'a self,
+        _: &'a str,
+        _client: &'a reqwest::Client,
+    ) -> Pin<Box<dyn Future<Output = Result<TursoConfig, Box<dyn std::error::Error>>> + Send + 'a>>
+    {
+        Box::pin(async move {
+            let url = std::env::var("TURSO_DB_URL")?;
+            let token = std::env::var("TURSO_DB_TOKEN")?;
+
+            Ok(TursoConfig {
+                db_url: url,
+                db_token: token,
+            })
+        })
+    }
+}

src/lib.rs

@@ -15,13 +15,14 @@ use sqlite::{
 use utils::execute_async_task;
 
 use crate::{
-    proxy::get_turso_db,
+    auth::{DbAuthStrategy, GlobeStrategy},
     utils::{
         count_parameters, extract_column_names, get_tokio, sql_is_begin_transaction, sql_is_commit,
         sql_is_pragma, sql_is_rollback,
     },
 };
 
+mod auth;
 mod proxy;
 mod sqlite;
 mod utils;
@@ -70,8 +71,8 @@ pub unsafe extern "C" fn sqlite3_open_v2(
         .build()
         .unwrap();
 
-    // get turso config or return SQLITE_ERROR
-    let turso_config = get_tokio().block_on(get_turso_db(&reqwest_client, filename));
+    let auth_strategy = Box::new(GlobeStrategy);
+    let turso_config = get_tokio().block_on(auth_strategy.resolve(filename, &reqwest_client));
     if turso_config.is_err() {
         eprintln!("LibSqlite3_Turso Error: {}", turso_config.unwrap_err());
         return SQLITE_ERROR;

src/proxy.rs

@@ -230,26 +230,3 @@ pub fn get_execution_result<'a>(
 
     Ok(first_execution_result)
 }
-
-pub async fn get_turso_db(client: &Client, db_name: &str) -> Result<TursoConfig, Box<dyn Error>> {
-    let globe_auth_api = std::env::var("GLOBE_DS_API")?;
-
-    let request_body = serde_json::json!({
-        "db_name": db_name,
-    });
-
-    let response = client
-        .post(format!("{}/db/auth", globe_auth_api))
-        .body(request_body.to_string())
-        .send()
-        .await
-        .map_err(|_| "Failed to fetch auth credentials for database")?;
-
-    if !response.status().is_success() {
-        return Err(format!("Failed to get Auth Token: {}", response.status()).into());
-    }
-
-    let json = response.json().await?;
-    let db_info = serde_json::from_value(json)?;
-    Ok(db_info)
-}