Merge branch 'main' into feat-add-list-namespaces-admin-endpoint

Author: Allypost

Cargo.lock

@@ -25,18 +25,18 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.9.12"
+version = "0.9.14"
 authors = ["the libSQL authors"]
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/tursodatabase/libsql"
 
 [workspace.dependencies]
-libsql-ffi = { path = "libsql-ffi", version = "0.9.12" }
-libsql-sys = { path = "libsql-sys", version = "0.9.12", default-features = false }
-libsql-hrana = { path = "libsql-hrana", version = "0.9.12" }
-libsql_replication = { path = "libsql-replication", version = "0.9.12" }
-rusqlite = { package = "libsql-rusqlite", path = "vendored/rusqlite", version = "0.9.12", default-features = false, features = [
+libsql-ffi = { path = "libsql-ffi", version = "0.9.14" }
+libsql-sys = { path = "libsql-sys", version = "0.9.14", default-features = false }
+libsql-hrana = { path = "libsql-hrana", version = "0.9.14" }
+libsql_replication = { path = "libsql-replication", version = "0.9.14" }
+rusqlite = { package = "libsql-rusqlite", path = "vendored/rusqlite", version = "0.9.14", default-features = false, features = [
     "libsql-experimental",
     "column_decltype",
     "load_extension",

Cargo.toml

@@ -25,8 +25,11 @@ async fn main() {
         None
     };
 
-    let db_builder =
-        Builder::new_synced_database(db_path, sync_url, auth_token).remote_encryption(encryption);
+    let mut db_builder = Builder::new_synced_database(db_path, sync_url, auth_token);
+
+    if let Some(enc) = encryption {
+        db_builder = db_builder.remote_encryption(enc);
+    }
 
     let db = match db_builder.build().await {
         Ok(db) => db,

libsql/examples/encryption_sync.rs

@@ -137,7 +137,7 @@ impl Connection {
     ///
     /// # Return
     ///
-    /// This returns a `BatchRows` currently only the `remote`  and `local` connection supports this feature and
+    /// This returns a `BatchRows` currently only the `remote` and `local` connection supports this feature and
     /// all other connection types will return an empty set always.
     pub async fn execute_batch(&self, sql: &str) -> Result<BatchRows> {
         tracing::trace!("executing batch `{}`", sql);
@@ -206,7 +206,7 @@ impl Connection {
         self.conn.busy_timeout(timeout)
     }
 
-    /// Check weather libsql is in `autocommit` or not.
+    /// Check whether libsql is in `autocommit` or not.
     pub fn is_autocommit(&self) -> bool {
         self.conn.is_autocommit()
     }

libsql/src/connection.rs

@@ -25,7 +25,7 @@ pub use crate::database::EncryptionContext;
 ///
 /// # Note
 ///
-/// Embedded replica's require a clean database (no database file) or a previously synced database or else it will
+/// Embedded replicas require a clean database (no database file) or a previously synced database or else it will
 /// throw an error to prevent any misuse. To work around this error a user can delete the database
 /// and let it resync and create the wal_index metadata file.
 pub struct Builder<T = ()> {
@@ -276,7 +276,7 @@ cfg_replication! {
             self
         }
 
-        /// Set weather you want writes to be visible locally before the write query returns. This
+        /// Set whether you want writes to be visible locally before the write query returns. This
         /// means that you will be able to read your own writes if this is set to `true`.
         ///
         /// # Default
@@ -306,8 +306,8 @@ cfg_replication! {
 
         /// Set the encryption context if the database is encrypted in remote server.
         #[cfg(feature = "sync")]
-        pub fn remote_encryption(mut self, encryption_context: Option<EncryptionContext>) -> Builder<RemoteReplica> {
-            self.inner.remote_encryption = encryption_context;
+        pub fn remote_encryption(mut self, encryption_context: EncryptionContext) -> Builder<RemoteReplica> {
+            self.inner.remote_encryption = Some(encryption_context);
             self
         }
 
@@ -333,7 +333,7 @@ cfg_replication! {
             self
         }
 
-        /// Skip the saftey assert used to ensure that sqlite3 is configured correctly for the way
+        /// Skip the safety assert used to ensure that sqlite3 is configured correctly for the way
         /// that libsql uses the ffi code. By default, libsql will try to use the SERIALIZED
         /// threadsafe mode for sqlite3. This allows us to implement Send/Sync for all the types to
         /// allow them to move between threads safely. Due to the fact that sqlite3 has a global
@@ -399,9 +399,14 @@ cfg_replication! {
                             url.to_string()
                         };
                         let req = http::Request::get(format!("{prefix}/info"))
-                            .header("Authorization", format!("Bearer {}", auth_token))
-                            .body(hyper::Body::empty())
-                            .unwrap();
+                            .header("Authorization", format!("Bearer {}", auth_token));
+
+                        let req = if let Some(ref remote_encryption) = remote_encryption {
+                            req.header("x-turso-encryption-key", remote_encryption.key.as_string())
+                        } else {
+                            req
+                        };
+                        let req = req.body(hyper::Body::empty()).unwrap();
 
                         let res = client
                             .request(req)
@@ -427,11 +432,14 @@ cfg_replication! {
 
                         if res.status().is_success() {
                             tracing::trace!("Using sync protocol v2 for {}", url);
-                            let builder = Builder::new_synced_database(path, url, auth_token)
+                            let mut builder = Builder::new_synced_database(path, url, auth_token)
                                 .connector(connector)
                                 .remote_writes(true)
-                                .read_your_writes(read_your_writes)
-                                .remote_encryption(remote_encryption);
+                                .read_your_writes(read_your_writes);
+
+                            if let Some(encryption) = remote_encryption {
+                                builder = builder.remote_encryption(encryption);
+                            }
 
                             let builder = if let Some(sync_interval) = sync_interval {
                                 builder.sync_interval(sync_interval)
@@ -616,8 +624,8 @@ cfg_sync! {
         }
 
          /// Set the encryption context if the database is encrypted in remote server.
-        pub fn remote_encryption(mut self, encryption_context: Option<EncryptionContext>) -> Builder<SyncedDatabase> {
-            self.inner.remote_encryption = encryption_context;
+        pub fn remote_encryption(mut self, encryption_context: EncryptionContext) -> Builder<SyncedDatabase> {
+            self.inner.remote_encryption = Some(encryption_context);
             self
         }
 
@@ -784,8 +792,8 @@ cfg_remote! {
         }
 
         /// Set the encryption context if the database is encrypted in remote server.
-        pub fn remote_encryption(mut self, encryption_context: Option<EncryptionContext>) -> Builder<Remote> {
-            self.inner.remote_encryption = encryption_context;
+        pub fn remote_encryption(mut self, encryption_context: EncryptionContext) -> Builder<Remote> {
+            self.inner.remote_encryption = Some(encryption_context);
             self
         }
 

libsql/src/database/builder.rs

@@ -1,7 +1,7 @@
 [package]
 name = "libsql-rusqlite"
 # Note: Update version in README.md when you change this.
-version = "0.9.12"
+version = "0.9.14"
 authors = ["The rusqlite developers"]
 edition = "2018"
 description = "Ergonomic wrapper for SQLite (libsql fork)"

vendored/rusqlite/Cargo.toml

@@ -76,7 +76,13 @@ fn build_wasm(_arg: &str) -> Result<()> {
 
 fn run_tests(arg: &str) -> Result<()> {
     println!("installing nextest");
-    run_cargo(&["install", "cargo-nextest"])?;
+    run_cargo(&[
+        "install",
+        "--locked",
+        "--version",
+        "0.9.98",
+        "cargo-nextest",
+    ])?;
     println!("running nextest run");
     run_cargo(&["nextest", "run", arg])?;
 
@@ -85,7 +91,14 @@ fn run_tests(arg: &str) -> Result<()> {
 
 fn run_tests_encryption(arg: &str) -> Result<()> {
     println!("installing nextest");
-    run_cargo(&["install", "--force", "cargo-nextest"])?;
+    run_cargo(&[
+        "install",
+        "--force",
+        "--locked",
+        "--version",
+        "0.9.98",
+        "cargo-nextest",
+    ])?;
     println!("running nextest run");
     run_cargo(&[
         "nextest",