add cloudsync extension

Signed-off-by: Yujong Lee <yujonglee.dev@gmail.com>

Author: yujonglee

Cargo.lock

@@ -64,10 +64,12 @@ hypr-cactus-model = { path = "crates/cactus-model", package = "cactus-model" }
 hypr-calendar-interface = { path = "crates/calendar-interface", package = "calendar-interface" }
 hypr-chatwoot = { path = "crates/chatwoot", package = "chatwoot" }
 hypr-cli-tui = { path = "crates/cli-tui", package = "cli-tui" }
+hypr-cloudsync = { path = "crates/cloudsync", package = "cloudsync" }
 hypr-data = { path = "crates/data", package = "data" }
 hypr-db-core = { path = "crates/db-core", package = "db-core" }
 hypr-db-parser = { path = "crates/db-parser", package = "db-parser" }
 hypr-db-user = { path = "crates/db-user", package = "db-user" }
+hypr-db3 = { path = "crates/db3", package = "db3" }
 hypr-denoise = { path = "crates/denoise", package = "denoise" }
 hypr-detect = { path = "crates/detect", package = "detect" }
 hypr-device-monitor = { path = "crates/device-monitor", package = "device-monitor" }

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "cloudsync"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+dirs = { workspace = true }
+sqlx = { workspace = true, features = ["runtime-tokio", "sqlite", "sqlite-unbundled"] }
+thiserror = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["macros", "rt"] }

crates/cloudsync/Cargo.toml

@@ -0,0 +1,131 @@
+use std::fs;
+use std::path::PathBuf;
+
+use crate::CLOUDSYNC_VERSION;
+use crate::error::Error;
+
+macro_rules! configure_cloudsync_target {
+    ($target:literal, $file_name:literal, $path:literal) => {
+        const CLOUDSYNC_TARGET: &str = $target;
+        const CLOUDSYNC_FILE_NAME: &str = $file_name;
+        const BUNDLED_CLOUDSYNC_BYTES: &[u8] = include_bytes!($path);
+    };
+}
+
+#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+configure_cloudsync_target!(
+    "macos/aarch64",
+    "cloudsync.dylib",
+    "../vendor/cloudsync/macos/aarch64/cloudsync.dylib"
+);
+
+#[cfg(all(target_os = "macos", target_arch = "x86_64"))]
+configure_cloudsync_target!(
+    "macos/x86_64",
+    "cloudsync.dylib",
+    "../vendor/cloudsync/macos/x86_64/cloudsync.dylib"
+);
+
+#[cfg(all(target_os = "linux", target_env = "gnu", target_arch = "aarch64"))]
+configure_cloudsync_target!(
+    "linux/gnu/aarch64",
+    "cloudsync.so",
+    "../vendor/cloudsync/linux/gnu/aarch64/cloudsync.so"
+);
+
+#[cfg(all(target_os = "linux", target_env = "gnu", target_arch = "x86_64"))]
+configure_cloudsync_target!(
+    "linux/gnu/x86_64",
+    "cloudsync.so",
+    "../vendor/cloudsync/linux/gnu/x86_64/cloudsync.so"
+);
+
+#[cfg(all(target_os = "linux", target_env = "musl", target_arch = "aarch64"))]
+configure_cloudsync_target!(
+    "linux/musl/aarch64",
+    "cloudsync.so",
+    "../vendor/cloudsync/linux/musl/aarch64/cloudsync.so"
+);
+
+#[cfg(all(target_os = "linux", target_env = "musl", target_arch = "x86_64"))]
+configure_cloudsync_target!(
+    "linux/musl/x86_64",
+    "cloudsync.so",
+    "../vendor/cloudsync/linux/musl/x86_64/cloudsync.so"
+);
+
+#[cfg(all(target_os = "windows", target_arch = "x86_64"))]
+configure_cloudsync_target!(
+    "windows/x86_64",
+    "cloudsync.dll",
+    "../vendor/cloudsync/windows/x86_64/cloudsync.dll"
+);
+
+pub fn bundled_extension_path() -> Result<PathBuf, Error> {
+    #[cfg(not(any(
+        all(target_os = "macos", target_arch = "aarch64"),
+        all(target_os = "macos", target_arch = "x86_64"),
+        all(target_os = "linux", target_env = "gnu", target_arch = "aarch64"),
+        all(target_os = "linux", target_env = "gnu", target_arch = "x86_64"),
+        all(target_os = "linux", target_env = "musl", target_arch = "aarch64"),
+        all(target_os = "linux", target_env = "musl", target_arch = "x86_64"),
+        all(target_os = "windows", target_arch = "x86_64"),
+    )))]
+    {
+        Err(Error::UnsupportedBundledCloudsync)
+    }
+
+    #[cfg(any(
+        all(target_os = "macos", target_arch = "aarch64"),
+        all(target_os = "macos", target_arch = "x86_64"),
+        all(target_os = "linux", target_env = "gnu", target_arch = "aarch64"),
+        all(target_os = "linux", target_env = "gnu", target_arch = "x86_64"),
+        all(target_os = "linux", target_env = "musl", target_arch = "aarch64"),
+        all(target_os = "linux", target_env = "musl", target_arch = "x86_64"),
+        all(target_os = "windows", target_arch = "x86_64"),
+    ))]
+    {
+        let base_dir = dirs::cache_dir()
+            .ok_or(Error::MissingCacheDir)?
+            .join("char")
+            .join("cloudsync")
+            .join(CLOUDSYNC_VERSION)
+            .join(CLOUDSYNC_TARGET);
+
+        fs::create_dir_all(&base_dir)?;
+
+        let extension_path = base_dir.join(CLOUDSYNC_FILE_NAME);
+        let needs_write = match fs::metadata(&extension_path) {
+            Ok(metadata) => metadata.len() != BUNDLED_CLOUDSYNC_BYTES.len() as u64,
+            Err(_) => true,
+        };
+
+        if needs_write {
+            let tmp_path =
+                base_dir.join(format!("{CLOUDSYNC_FILE_NAME}.{}.tmp", std::process::id()));
+            fs::write(&tmp_path, BUNDLED_CLOUDSYNC_BYTES)?;
+
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::PermissionsExt;
+
+                fs::set_permissions(&tmp_path, fs::Permissions::from_mode(0o755))?;
+            }
+
+            match fs::rename(&tmp_path, &extension_path) {
+                Ok(()) => {}
+                Err(error) if extension_path.exists() => {
+                    let _ = fs::remove_file(&tmp_path);
+
+                    if fs::metadata(&extension_path)?.len() != BUNDLED_CLOUDSYNC_BYTES.len() as u64
+                    {
+                        return Err(error.into());
+                    }
+                }
+                Err(error) => return Err(error.into()),
+            }
+        }
+
+        Ok(extension_path)
+    }
+}

crates/cloudsync/src/bundle.rs

@@ -0,0 +1,19 @@
+const SUPPORTED_CLOUDSYNC_TARGETS: &str = concat!(
+    "macos/{aarch64,x86_64}, ",
+    "linux/{gnu,musl}/{aarch64,x86_64}, ",
+    "windows/x86_64"
+);
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("sqlx error: {0}")]
+    Sqlx(#[from] sqlx::Error),
+    #[error("io error: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("no cache directory is available for the bundled cloudsync extension")]
+    MissingCacheDir,
+    #[error(
+        "the bundled cloudsync extension is not available for this target; supported targets: {SUPPORTED_CLOUDSYNC_TARGETS}"
+    )]
+    UnsupportedBundledCloudsync,
+}

crates/cloudsync/src/error.rs

@@ -0,0 +1,49 @@
+use sqlx::SqlitePool;
+
+use crate::error::Error;
+
+pub async fn version(pool: &SqlitePool) -> Result<String, Error> {
+    Ok(sqlx::query_scalar("SELECT cloudsync_version()")
+        .fetch_one(pool)
+        .await?)
+}
+
+pub async fn init(
+    pool: &SqlitePool,
+    table_name: &str,
+    crdt_algo: Option<&str>,
+    force: Option<bool>,
+) -> Result<(), Error> {
+    match (crdt_algo, force) {
+        (None, None) => {
+            sqlx::query("SELECT cloudsync_init(?)")
+                .bind(table_name)
+                .fetch_optional(pool)
+                .await?;
+        }
+        (Some(crdt_algo), None) => {
+            sqlx::query("SELECT cloudsync_init(?, ?)")
+                .bind(table_name)
+                .bind(crdt_algo)
+                .fetch_optional(pool)
+                .await?;
+        }
+        (None, Some(force)) => {
+            sqlx::query("SELECT cloudsync_init(?, NULL, ?)")
+                .bind(table_name)
+                .bind(force)
+                .fetch_optional(pool)
+                .await?;
+        }
+        (Some(crdt_algo), Some(force)) => {
+            sqlx::query("SELECT cloudsync_init(?, ?, ?)")
+                .bind(table_name)
+                .bind(crdt_algo)
+                .bind(force)
+                .fetch_optional(pool)
+                .await?;
+        }
+    }
+
+    Ok(())
+}

crates/cloudsync/src/init.rs

@@ -0,0 +1,60 @@
+#![forbid(unsafe_code)]
+
+mod bundle;
+mod error;
+mod init;
+mod network;
+
+use std::path::PathBuf;
+
+use sqlx::sqlite::SqliteConnectOptions;
+
+pub use bundle::bundled_extension_path;
+pub use error::Error;
+pub use init::{init, version};
+pub use network::{network_init, network_set_apikey, network_set_token, network_sync};
+
+pub const CLOUDSYNC_VERSION: &str = "0.8.68";
+
+pub fn apply(options: SqliteConnectOptions) -> Result<(SqliteConnectOptions, PathBuf), Error> {
+    let extension_path = bundled_extension_path()?;
+    let options = options.extension(extension_path.to_string_lossy().into_owned());
+
+    Ok((options, extension_path))
+}
+
+#[cfg(any(
+    all(test, target_os = "macos", target_arch = "aarch64"),
+    all(test, target_os = "macos", target_arch = "x86_64"),
+    all(test, target_os = "linux", target_env = "gnu", target_arch = "aarch64"),
+    all(test, target_os = "linux", target_env = "gnu", target_arch = "x86_64"),
+    all(
+        test,
+        target_os = "linux",
+        target_env = "musl",
+        target_arch = "aarch64"
+    ),
+    all(test, target_os = "linux", target_env = "musl", target_arch = "x86_64"),
+    all(test, target_os = "windows", target_arch = "x86_64"),
+))]
+mod tests {
+    use super::*;
+    use std::str::FromStr;
+
+    use sqlx::sqlite::SqlitePoolOptions;
+
+    #[tokio::test]
+    async fn loads_bundled_cloudsync() {
+        let options = SqliteConnectOptions::from_str("sqlite::memory:").unwrap();
+        let (options, _) = apply(options).unwrap();
+        let pool = SqlitePoolOptions::new()
+            .max_connections(1)
+            .connect_with(options)
+            .await
+            .unwrap();
+
+        let version = version(&pool).await.unwrap();
+
+        assert!(!version.is_empty());
+    }
+}

crates/cloudsync/src/lib.rs

@@ -0,0 +1,65 @@
+use sqlx::SqlitePool;
+
+use crate::error::Error;
+
+pub async fn network_init(pool: &SqlitePool, connection_string: &str) -> Result<(), Error> {
+    sqlx::query("SELECT cloudsync_network_init(?)")
+        .bind(connection_string)
+        .fetch_optional(pool)
+        .await?;
+
+    Ok(())
+}
+
+pub async fn network_set_apikey(pool: &SqlitePool, api_key: &str) -> Result<(), Error> {
+    sqlx::query("SELECT cloudsync_network_set_apikey(?)")
+        .bind(api_key)
+        .fetch_optional(pool)
+        .await?;
+
+    Ok(())
+}
+
+pub async fn network_set_token(pool: &SqlitePool, token: &str) -> Result<(), Error> {
+    sqlx::query("SELECT cloudsync_network_set_token(?)")
+        .bind(token)
+        .fetch_optional(pool)
+        .await?;
+
+    Ok(())
+}
+
+pub async fn network_sync(
+    pool: &SqlitePool,
+    wait_ms: Option<i64>,
+    max_retries: Option<i64>,
+) -> Result<(), Error> {
+    match (wait_ms, max_retries) {
+        (None, None) => {
+            sqlx::query("SELECT cloudsync_network_sync()")
+                .fetch_optional(pool)
+                .await?;
+        }
+        (Some(wait_ms), None) => {
+            sqlx::query("SELECT cloudsync_network_sync(?)")
+                .bind(wait_ms)
+                .fetch_optional(pool)
+                .await?;
+        }
+        (None, Some(max_retries)) => {
+            sqlx::query("SELECT cloudsync_network_sync(NULL, ?)")
+                .bind(max_retries)
+                .fetch_optional(pool)
+                .await?;
+        }
+        (Some(wait_ms), Some(max_retries)) => {
+            sqlx::query("SELECT cloudsync_network_sync(?, ?)")
+                .bind(wait_ms)
+                .bind(max_retries)
+                .fetch_optional(pool)
+                .await?;
+        }
+    }
+
+    Ok(())
+}