default to wss and fallback to http

Author: codekeyz

src/lib.rs

@@ -67,7 +67,6 @@ pub unsafe extern "C" fn sqlite3_open_v2(
     let connection = get_tokio().block_on(transport::DatabaseConnection::open(
         db_name,
         Box::new(GlobeStrategy),
-        transport::ActiveStrategy::Websocket,
     ));
     if connection.is_err() {
         return SQLITE_CANTOPEN;

src/sqlite.rs

@@ -355,10 +355,21 @@ async fn execute_sql_and_params(
     sql: &str,
     params: Vec<serde_json::Value>,
 ) -> Result<RemoteSqliteResponse, SqliteError> {
-    let result = db
-        .connection
-        .send(db.connection.get_json_request(db, sql, params))
-        .await;
+    if let transport::ActiveStrategy::Websocket = db.connection.strategy {
+        let mut request = db.connection.get_json_request(db, sql, &params);
+        match db.connection.send(&mut request).await {
+            Ok(response) => return Ok(response),
+            Err(_) => {
+                db.connection.strategy = transport::ActiveStrategy::Http;
+                if cfg!(debug_assertions) {
+                    println!("WebSocket failed, retrying with HTTP...");
+                }
+            }
+        }
+    }
+
+    let request = &mut db.connection.get_json_request(db, sql, &params);
+    let result = db.connection.send(request).await;
 
     if let Err(e) = result {
         return Err(SqliteError::new(e.to_string(), Some(SQLITE_ERROR)));

src/transport/http.rs

@@ -21,7 +21,7 @@ impl HttpStrategy {
 
 impl LibsqlInterface for HttpStrategy {
     async fn get_transaction_baton(&mut self, sql: &str) -> Result<String, SqliteError> {
-        let request = serde_json::json!({
+        let mut request = serde_json::json!({
             "requests": [
                 {
                     "type": "execute",
@@ -31,7 +31,8 @@ impl LibsqlInterface for HttpStrategy {
                 }
             ]
         });
-        let result = self.send(request).await;
+
+        let result = self.send(&mut request).await;
         if let Err(e) = result {
             return Err(SqliteError::new(
                 format!("Failed to get transaction baton: {}", e),
@@ -49,7 +50,7 @@ impl LibsqlInterface for HttpStrategy {
 
     async fn send(
         &mut self,
-        request: serde_json::Value,
+        request: &mut serde_json::Value,
     ) -> Result<RemoteSqliteResponse, SqliteError> {
         const MAX_ATTEMPTS: usize = 5;
         let mut last_error = String::new();
@@ -162,7 +163,7 @@ impl LibsqlInterface for HttpStrategy {
     fn get_json_request(
         &self,
         sql: &str,
-        params: Vec<serde_json::Value>,
+        params: &Vec<serde_json::Value>,
         baton: Option<&String>,
         is_transacting: bool,
     ) -> serde_json::Value {

src/transport/mod.rs

@@ -58,7 +58,7 @@ pub trait LibsqlInterface {
     fn get_json_request(
         &self,
         sql: &str,
-        params: Vec<serde_json::Value>,
+        params: &Vec<serde_json::Value>,
         baton: Option<&String>,
         is_transacting: bool,
     ) -> serde_json::Value;
@@ -67,7 +67,7 @@ pub trait LibsqlInterface {
 
     async fn send(
         &mut self,
-        request: serde_json::Value,
+        request: &mut serde_json::Value,
     ) -> Result<RemoteSqliteResponse, SqliteError>;
 }
 
@@ -78,17 +78,13 @@ pub enum ActiveStrategy {
 }
 
 pub struct DatabaseConnection {
-    http: HttpStrategy,
-    websocket: WebSocketStrategy,
+    pub http: HttpStrategy,
+    pub websocket: WebSocketStrategy,
     pub strategy: ActiveStrategy,
 }
 
 impl DatabaseConnection {
-    pub async fn open(
-        db_name: &str,
-        auth: Box<dyn DbAuthStrategy>,
-        strategy: ActiveStrategy,
-    ) -> Result<Self, SqliteError> {
+    pub async fn open(db_name: &str, auth: Box<dyn DbAuthStrategy>) -> Result<Self, SqliteError> {
         let reqwest_client = reqwest::Client::builder()
             .user_agent("libsqlite3_turso/1.0.0")
             .timeout(std::time::Duration::from_secs(30))
@@ -106,21 +102,16 @@ impl DatabaseConnection {
         let http = HttpStrategy::new(reqwest_client, turso_config.clone());
         let mut websocket = WebSocketStrategy::new(turso_config.clone());
 
-        if let ActiveStrategy::Websocket = strategy {
-            websocket.connect().await?;
+        websocket.connect().await?;
 
-            //wait 10 seconds for the server to respond
-            tokio::time::sleep(std::time::Duration::from_millis(500)).await;
-
-            if cfg!(debug_assertions) {
-                println!("WebSocket connection established for {}", db_name);
-            }
+        if cfg!(debug_assertions) {
+            println!("WebSocket connection established for {}", db_name);
         }
 
         Ok(Self {
             http,
             websocket,
-            strategy,
+            strategy: ActiveStrategy::Websocket,
         })
     }
 
@@ -133,19 +124,19 @@ impl DatabaseConnection {
 
     pub async fn send(
         &mut self,
-        request: serde_json::Value,
+        mut request: &mut serde_json::Value,
     ) -> Result<RemoteSqliteResponse, SqliteError> {
         match self.strategy {
-            ActiveStrategy::Http => self.http.send(request).await,
-            ActiveStrategy::Websocket => self.websocket.send(request).await,
+            ActiveStrategy::Http => self.http.send(&mut request).await,
+            ActiveStrategy::Websocket => self.websocket.send(&mut request).await,
         }
     }
 
     pub fn get_json_request(
         &self,
         db: &SQLite3,
         sql: &str,
-        params: Vec<serde_json::Value>,
+        params: &Vec<serde_json::Value>,
     ) -> serde_json::Value {
         let baton_str = {
             let baton = db.transaction_baton.lock().unwrap();

src/transport/wss.rs

@@ -233,7 +233,7 @@ impl LibsqlInterface for WebSocketStrategy {
 
     async fn send(
         &mut self,
-        mut request: serde_json::Value,
+        request: &mut serde_json::Value,
     ) -> Result<RemoteSqliteResponse, SqliteError> {
         if let WebSocketConnState::Disconnected = *self.websocket_state.lock().await {
             return Err(SqliteError::new(
@@ -309,7 +309,7 @@ impl LibsqlInterface for WebSocketStrategy {
     fn get_json_request(
         &self,
         sql: &str,
-        params: Vec<serde_json::Value>,
+        params: &Vec<serde_json::Value>,
         baton: Option<&String>,
         is_transacting: bool,
     ) -> serde_json::Value {