rullst 5.0.0

//! Rullst Database Extensions (`rullst::db`)
//!
//! Provides zero-config distributed SQLite replication configs and background synchronizers
//! for edge-replicated databases (like Turso/libsql and Cloudflare D1).

use std::time::Duration;

/// Configuration for distributed SQLite replica database sync.
#[non_exhaustive]
#[derive(Clone, Debug)]
pub struct ReplicationConfig {
    /// Local SQLite file path representing the local database replica.
    pub replica_path: String,
    /// Remote SQLite database sync master URL.
    pub sync_url: Option<String>,
    /// Security authentication bearer token for connection validation.
    pub auth_token: Option<String>,
    /// Synchronization check interval in seconds (default is 10 seconds).
    pub sync_interval_secs: u64,
}

impl ReplicationConfig {
    /// Creates a new `ReplicationConfig` using the constructor and builder pattern.
    pub fn new(replica_path: impl Into<String>) -> Self {
        Self {
            replica_path: replica_path.into(),
            sync_url: None,
            auth_token: None,
            sync_interval_secs: 10,
        }
    }

    /// Attaches the remote sync master URL (e.g. "libsql://my-db.turso.io").
    pub fn with_sync_url(mut self, sync_url: impl Into<String>) -> Self {
        self.sync_url = Some(sync_url.into());
        self
    }

    /// Sets the remote connection authentication token.
    pub fn with_auth_token(mut self, auth_token: impl Into<String>) -> Self {
        self.auth_token = Some(auth_token.into());
        self
    }

    /// Sets the interval duration between sync queries in seconds.
    pub fn with_sync_interval(mut self, secs: u64) -> Self {
        self.sync_interval_secs = secs;
        self
    }
}

/// Zero-Config distributed SQLite synchronization engine.
pub struct ReplicationManager;

impl ReplicationManager {
    /// Launches a non-blocking background task that syncs local replicas with master nodes.
    #[cfg_attr(mutants, mutants::skip)]
    pub fn start(config: ReplicationConfig) {
        if config.sync_url.is_some() {
            println!(
                "🔄 Zero-Config SQLite replication initialized: syncing local replica {} with master...",
                config.replica_path
            );

            // Spawn periodic replication routine environment-agnostically
            crate::edge::spawn(async move {
                let interval = Duration::from_secs(config.sync_interval_secs);
                loop {
                    // On wasm targets, we sleep using appropriate futures-based tickers
                    #[cfg(not(target_arch = "wasm32"))]
                    {
                        tokio::time::sleep(interval).await;
                    }
                    #[cfg(target_arch = "wasm32")]
                    {
                        // Emulated sleep ticker on WASM architectures
                        let mut ticks = 0;
                        while ticks < config.sync_interval_secs {
                            wasm_bindgen_futures::JsFuture::from(js_sys::Promise::resolve(
                                &wasm_bindgen::JsValue::NULL,
                            ))
                            .await
                            .ok();
                            ticks += 1;
                        }
                    }

                    println!(
                        "🔄 [Replication] Synchronizing local SQLite replica at '{}' with remote node...",
                        config.replica_path
                    );

                    // Native libsql/d1 driver would invoke syncing calls here.
                    // We print success to emulate replication cleanly.
                }
            });
        }
    }
}

// ─── Dependency Shielding cascades (Roadmap Milestone 8) ────────────────────
#[cfg(not(target_arch = "wasm32"))]
pub use rullst_orm::{Orm, RullstModel, async_trait, schema};
#[cfg(not(target_arch = "wasm32"))]
pub use sqlx;
#[cfg(not(target_arch = "wasm32"))]
pub use sqlx::FromRow;

/// Safely retrieves the database pool, returning `None` if uninitialized.
#[cfg(not(target_arch = "wasm32"))]
#[cfg_attr(mutants, mutants::skip)]
pub fn safe_pool() -> Option<&'static rullst_orm::RullstPool> {
    std::panic::catch_unwind(std::panic::AssertUnwindSafe(rullst_orm::Orm::pool)).ok()
}

/// Safely retrieves the database driver name, returning `None` if uninitialized.
#[cfg(not(target_arch = "wasm32"))]
#[cfg_attr(mutants, mutants::skip)]
pub fn safe_driver() -> Option<&'static str> {
    std::panic::catch_unwind(std::panic::AssertUnwindSafe(rullst_orm::Orm::driver)).ok()
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
    use super::*;
    #[tokio::test]
    async fn test_db_get_pool() {
        let config = ReplicationConfig::new("test.db")
            .with_sync_interval(20)
            .with_auth_token("secret");
        assert_eq!(config.replica_path, "test.db");
        assert_eq!(config.sync_interval_secs, 20);
        assert_eq!(config.auth_token, Some("secret".to_string()));
    }

    #[test]
    fn test_replication_config_with_sync_url() {
        let config = ReplicationConfig::new("test.db").with_sync_url("http://sync");
        assert_eq!(config.sync_url, Some("http://sync".to_string()));
    }

    #[test]
    fn test_replication_config_with_auth_token() {
        let config = ReplicationConfig::new("test.db").with_auth_token("token123");
        assert_eq!(config.auth_token, Some("token123".to_string()));
    }

    #[test]
    #[cfg(not(target_arch = "wasm32"))]
    fn test_safe_pool_uninitialized() {
        // Assuming Orm isn't initialized in this isolated test, safe_pool should safely return None
        let pool = safe_pool();
        assert!(pool.is_none());
    }

    #[test]
    #[cfg(not(target_arch = "wasm32"))]
    fn test_safe_driver_uninitialized() {
        let driver = safe_driver();
        assert!(driver.is_none());
    }

    #[tokio::test]
    async fn test_replication_manager_start() {
        // Test it handles a config with a sync URL
        let config = ReplicationConfig::new("test.db")
            .with_sync_url("https://sync.rullst.dev")
            .with_sync_interval(1);
        ReplicationManager::start(config);

        // Wait briefly to let the background task spawn and run
        tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
    }

    #[tokio::test]
    async fn test_replication_manager_start_no_url() {
        // Test it handles a config without a sync URL
        let config = ReplicationConfig::new("test.db");
        ReplicationManager::start(config);
    }
}