0.32.0: migration from anyhow to libsql::Error

Author: psarna

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "libsql-client"
-version = "0.31.11"
+version = "0.32.0"
 edition = "2021"
 license = "Apache-2.0"
 description = "HTTP-based client for libSQL and sqld"
@@ -27,13 +27,13 @@ serde = "1.0.159"
 tracing = "0.1.37"
 futures = "0.3.28"
 fallible-iterator = "0.2.0"
-libsql = { version = "0.1.6", optional = true }
+libsql = { version = "0.1.11", default-features = false }
 
 [features]
 default = ["local_backend", "hrana_backend", "reqwest_backend", "mapping_names_to_values_in_rows"]
 workers_backend = ["worker", "futures-util"]
 reqwest_backend = ["reqwest"]
-local_backend = ["libsql"]
+local_backend = ["libsql/core", "libsql/replication"]
 spin_backend = ["spin-sdk", "http", "bytes"]
 hrana_backend = ["hrana-client"]
 separate_url_for_queries = []

src/client.rs

@@ -57,7 +57,7 @@ impl Client {
     ) -> Result<BatchResult> {
         match self {
             #[cfg(feature = "local_backend")]
-            Self::Local(l) => l.raw_batch(stmts),
+            Self::Local(l) => l.raw_batch(stmts).await,
             #[cfg(any(
                 feature = "reqwest_backend",
                 feature = "workers_backend",
@@ -179,7 +179,7 @@ impl Client {
     pub async fn execute(&self, stmt: impl Into<Statement> + Send) -> Result<ResultSet> {
         match self {
             #[cfg(feature = "local_backend")]
-            Self::Local(l) => l.execute(stmt),
+            Self::Local(l) => l.execute(stmt).await,
             #[cfg(any(
                 feature = "reqwest_backend",
                 feature = "workers_backend",
@@ -218,7 +218,7 @@ impl Client {
     ) -> Result<ResultSet> {
         match self {
             #[cfg(feature = "local_backend")]
-            Self::Local(l) => l.execute_in_transaction(tx_id, stmt),
+            Self::Local(l) => l.execute_in_transaction(tx_id, stmt).await,
             #[cfg(any(
                 feature = "reqwest_backend",
                 feature = "workers_backend",
@@ -235,7 +235,7 @@ impl Client {
     pub(crate) async fn commit_transaction(&self, tx_id: u64) -> Result<()> {
         match self {
             #[cfg(feature = "local_backend")]
-            Self::Local(l) => l.commit_transaction(tx_id),
+            Self::Local(l) => l.commit_transaction(tx_id).await,
             #[cfg(any(
                 feature = "reqwest_backend",
                 feature = "workers_backend",
@@ -252,7 +252,7 @@ impl Client {
     pub(crate) async fn rollback_transaction(&self, tx_id: u64) -> Result<()> {
         match self {
             #[cfg(feature = "local_backend")]
-            Self::Local(l) => l.rollback_transaction(tx_id),
+            Self::Local(l) => l.rollback_transaction(tx_id).await,
             #[cfg(any(
                 feature = "reqwest_backend",
                 feature = "workers_backend",

src/hrana.rs

@@ -188,7 +188,7 @@ impl Client {
             .client
             .open_stream()
             .await
-            .map_err(|e| Error::FetchRowFailed(e.to_string()))?;
+            .map_err(|e| Error::ConnectionFailed(e.to_string()))?;
         stream
             .execute(stmt)
             .await

src/http.rs

@@ -121,7 +121,7 @@ impl Client {
                 pipeline::StreamRequest::Close,
             ],
         };
-        let body = serde_json::to_string(&msg).map_err(|e| Error::FetchRowFailed(e.to_string()))?;
+        let body = serde_json::to_string(&msg).map_err(|e| Error::ConnectionFailed(e.to_string()))?;
         let mut response: pipeline::ServerMsg = self
             .inner
             .send(self.url_for_queries.clone(), self.auth.clone(), body)
@@ -177,7 +177,7 @@ impl Client {
                 pipeline::StreamExecuteReq { stmt },
             )],
         };
-        let body = serde_json::to_string(&msg).map_err(|e| Error::FetchRowFailed(e.to_string()))?;
+        let body = serde_json::to_string(&msg).map_err(|e| Error::ConnectionFailed(e.to_string()))?;
         let url = cookie
             .base_url
             .unwrap_or_else(|| self.url_for_queries.clone());
@@ -205,13 +205,13 @@ impl Client {
         }
 
         if response.results.is_empty() {
-            return Err(Error::FetchRowFailed(format!(
+            return Err(Error::ConnectionFailed(format!(
                 "Unexpected empty response from server: {:?}",
                 response.results
             )));
         }
         if response.results.len() > 1 {
-            return Err(Error::FetchRowFailed(format!(
+            return Err(Error::ConnectionFailed(format!(
                 "Unexpected multiple responses from server: {:?}",
                 response.results
             )));
@@ -220,12 +220,12 @@ impl Client {
             pipeline::Response::Ok(pipeline::StreamResponseOk {
                 response: pipeline::StreamResponse::Execute(execute_result),
             }) => Ok(ResultSet::from(execute_result.result)),
-            pipeline::Response::Ok(_) => Err(Error::FetchRowFailed(format!(
+            pipeline::Response::Ok(_) => Err(Error::ConnectionFailed(format!(
                 "Unexpected response from server: {:?}",
                 response.results
             ))),
             pipeline::Response::Error(e) => {
-                Err(Error::FetchRowFailed(format!("Error from server: {:?}", e)))
+                Err(Error::ConnectionFailed(format!("Error from server: {e:?}")))
             }
         }
     }

src/local.rs

@@ -100,7 +100,7 @@ impl Client {
     ///     .raw_batch(["CREATE TABLE t(id)", "INSERT INTO t VALUES (42)"]);
     /// # }
     /// ```
-    pub fn raw_batch(
+    pub async fn raw_batch(
         &self,
         stmts: impl IntoIterator<Item = impl Into<Statement>>,
     ) -> Result<BatchResult> {
@@ -116,7 +116,7 @@ impl Client {
                 .map(libsql::Value::from)
                 .collect::<Vec<_>>()
                 .into();
-            let stmt = self.conn.prepare(sql_string)?;
+            let stmt = self.conn.prepare(sql_string).await?;
             let cols: Vec<Col> = stmt
                 .columns()
                 .into_iter()
@@ -125,7 +125,7 @@ impl Client {
                 })
                 .collect();
             let mut rows = Vec::new();
-            let input_rows = match stmt.query(&params) {
+            let mut input_rows = match stmt.query(&params).await {
                 Ok(rows) => rows,
                 Err(e) => {
                     step_results.push(None);
@@ -179,15 +179,15 @@ impl Client {
     ///
     /// # Arguments
     /// * `stmts` - SQL statements
-    pub fn batch(
+    pub async fn batch(
         &self,
         stmts: impl IntoIterator<Item = impl Into<Statement> + Send> + Send,
     ) -> Result<Vec<ResultSet>> {
         let batch_results = self.raw_batch(
             std::iter::once(Statement::new("BEGIN"))
                 .chain(stmts.into_iter().map(|s| s.into()))
                 .chain(std::iter::once(Statement::new("END"))),
-        )?;
+        ).await?;
         let step_error: Option<proto::Error> = batch_results
             .step_errors
             .into_iter()
@@ -214,24 +214,24 @@ impl Client {
 
     /// # Arguments
     /// * `stmt` - the SQL statement
-    pub fn execute(&self, stmt: impl Into<Statement> + Send) -> Result<ResultSet> {
-        let results = self.raw_batch(std::iter::once(stmt))?;
+    pub async fn execute(&self, stmt: impl Into<Statement> + Send) -> Result<ResultSet> {
+        let results = self.raw_batch(std::iter::once(stmt)).await?;
         match (results.step_results.first(), results.step_errors.first()) {
             (Some(Some(result)), Some(None)) => Ok(ResultSet::from(result.clone())),
             (Some(None), Some(Some(err))) => Err(Error::Misuse(err.message.clone())),
             _ => unreachable!(),
         }
     }
 
-    pub fn execute_in_transaction(&self, _tx_id: u64, stmt: Statement) -> Result<ResultSet> {
-        self.execute(stmt)
+    pub async fn execute_in_transaction(&self, _tx_id: u64, stmt: Statement) -> Result<ResultSet> {
+        self.execute(stmt).await
     }
 
-    pub fn commit_transaction(&self, _tx_id: u64) -> Result<()> {
-        self.execute("COMMIT").map(|_| ())
+    pub async fn commit_transaction(&self, _tx_id: u64) -> Result<()> {
+        self.execute("COMMIT").await.map(|_| ())
     }
 
-    pub fn rollback_transaction(&self, _tx_id: u64) -> Result<()> {
-        self.execute("ROLLBACK").map(|_| ())
+    pub async fn rollback_transaction(&self, _tx_id: u64) -> Result<()> {
+        self.execute("ROLLBACK").await.map(|_| ())
     }
 }

src/reqwest.rs

@@ -27,11 +27,11 @@ impl HttpClient {
             .header("Authorization", auth)
             .send()
             .await
-            .map_err(|e| Error::FetchRowFailed(e.to_string()))?;
+            .map_err(|e| Error::ConnectionFailed(e.to_string()))?;
         if response.status() != reqwest::StatusCode::OK {
             let status = response.status();
             let txt = response.text().await.unwrap_or_default();
-            return Err(Error::FetchRowFailed(format!("{status}: {txt}")));
+            return Err(Error::ConnectionFailed(format!("{status}: {txt}")));
         }
         let resp: String = response
             .text()

src/spin.rs

@@ -24,12 +24,12 @@ impl HttpClient {
             .map_err(|e| Error::ConnectionFailed(e.to_string()))?;
 
         let response = spin_sdk::outbound_http::send_request(req)
-            .map_err(|e| Error::FetchRowFailed(e.to_string()));
+            .map_err(|e| Error::ConnectionFailed(e.to_string()));
         let resp: String = std::str::from_utf8(&response?.into_body().unwrap_or_default())
-            .map_err(|e| Error::FetchRowFailed(e.to_string()))?
+            .map_err(|e| Error::ConnectionFailed(e.to_string()))?
             .to_string();
         let response: pipeline::ServerMsg =
-            serde_json::from_str(&resp).map_err(|e| Error::FetchRowFailed(e.to_string()))?;
+            serde_json::from_str(&resp).map_err(|e| Error::ConnectionFailed(e.to_string()))?;
         Ok(response)
     }
 }

src/workers.rs

@@ -45,7 +45,7 @@ impl HttpClient {
             .await
             .map_err(|e| Error::ConnectionFailed(e.to_string()))?;
         let response: pipeline::ServerMsg =
-            serde_json::from_str(&resp).map_err(|e| Error::FetchRowFailed(e.to_string()))?;
+            serde_json::from_str(&resp).map_err(|e| Error::ConnectionFailed(e.to_string()))?;
         Ok(response)
     }
 }