Architecture

What's Shared

• CRDT Engine: Automerge-based document merging (swirldb-core/src/core.rs)
• Storage Traits: DocumentStorage + ChangeLog definitions (swirldb-core/src/storage/mod.rs)
• Policy Engine: Path-based authorization logic (swirldb-core/src/policy.rs)
• Auth Providers: JWT, OAuth, ABAC interfaces (swirldb-core/src/auth.rs)
• In-Memory Storage: Reference implementations used for testing

What's Different

• Browser: Web APIs (localStorage, IndexedDB), WASM FFI, JavaScript interop
• Server: Native I/O (redb, filesystem), HTTP/WebSocket, multi-threading

Example: Storage Adapter Switching

// Browser: Start with memory, switch to localStorage later
let db = await SwirlDB.create();  // In-memory

// Later, migrate to persistent storage
const state = db.saveState();
db = await SwirlDB.withLocalStorage('my-app');
db.loadState(state);

// Or switch to IndexedDB for larger storage
db = await SwirlDB.withIndexedDB('my-app');
db.loadState(state);

Example: Server Adapter Composition

// Server: Start with memory for development
let storage = Arc::new(MemoryAdapter::new());
let db = SwirlDB::with_storage(storage, "db").await;

// Deploy with redb for production
let storage = Arc::new(RedbAdapter::new("./data")?);
let db = SwirlDB::with_storage(storage, "db").await;

// Same code. Same APIs. Just different adapter.

Policy-Based Access Control

// Define access rules in JSON
const policy = {
  rules: [
    {
      path: "/user/:userId/**",
      read: ["owner", "admin"],
      write: ["owner"]
    },
    {
      path: "/public/**",
      read: ["*"],
      write: ["authenticated"]
    }
  ]
};

// Apply policy to database instance
db.withPolicy(policy);

Example: Custom Redis Adapter

use redis::{Client, AsyncCommands};

pub struct RedisAdapter {
    client: Client,
}

impl RedisAdapter {
    pub fn new(url: &str) -> Result<Self> {
        Ok(RedisAdapter {
            client: Client::open(url)?,
        })
    }
}

impl DocumentStorageMarker for RedisAdapter {}

#[async_trait]
impl DocumentStorage for RedisAdapter {
    async fn save(&self, key: &str, data: &[u8]) -> Result<()> {
        let mut conn = self.client.get_async_connection().await?;
        conn.set(key, data).await?;
        Ok(())
    }

    async fn load(&self, key: &str) -> Result<Option<Vec<u8>>> {
        let mut conn = self.client.get_async_connection().await?;
        let result: Option<Vec<u8>> = conn.get(key).await?;
        Ok(result)
    }

    async fn delete(&self, key: &str) -> Result<()> {
        let mut conn = self.client.get_async_connection().await?;
        conn.del(key).await?;
        Ok(())
    }

    async fn list_keys(&self) -> Result<Vec<String>> {
        let mut conn = self.client.get_async_connection().await?;
        let keys: Vec<String> = conn.keys("*").await?;
        Ok(keys)
    }
}

// Now use it just like any other adapter!
let storage = Arc::new(RedisAdapter::new("redis://localhost")?);
let db = SwirlDB::with_storage(storage, "db").await;