guardian-db

GuardianDB v0.14.0
├── Core Database
│   ├── GuardianDB (guardian/mod.rs)         # Main database API facade
│   ├── BaseGuardianDB (guardian/core.rs)    # Core implementation
│   ├── Error Handling (guardian/error.rs)   # Error types
│   └── Serializer (guardian/serializer.rs)  # Data serialization
│
├── Store Implementations (stores/)
│   ├── EventLogStore                   # Immutable append-only logs
│   ├── KeyValueStore                   # Distributed key-value pairs  
│   ├── DocumentStore                   # JSON documents with queries
│   ├── BaseStore                       # Common store functionality
│   └── Operations                      # Store operations & parsing
│
├── Networking Layer (p2p/)
│   ├── IrohClient (network/client.rs)  # Native Iroh IPFS Client
│   ├── Network Core (network/core/)    # IrohBackend
│   │   ├── BatchProcessor              # Batch operation handling
│   │   ├── Blobs                       # Blob storage management
│   │   ├── ConnectionPool              # Connection pooling
│   │   ├── Docs                        # Document replication (Willow Protocol)
│   │   ├── Gossip                      # Gossipsub protocol
│   │   ├── KeySynchronizer             # Key distribution
│   │   ├── NetworkingMetrics           # Network telemetry
│   │   └── OptimizedCache              # Performance caching
│   ├── Messaging (messaging/)
│   │   ├── DirectChannel               # Peer-to-peer messaging
│   │   └── OneOnOneChannel             # Direct peer communication
│   ├── EventBus                        # Type-safe event system
│   └── Config (network/config.rs)      # Network configuration
│
├── Access Control Layer (access_control/)
│   ├── GuardianDBAccessController (acl_guardian.rs)   # Signature-based ACL
│   ├── IrohAccessController (acl_iroh.rs)             # Iroh-based ACL
│   ├── SimpleAccessController (acl_simple.rs)         # Open access (dev)
│   ├── Manifest (manifest.rs)                         # ACL configuration
│   └── Traits (traits.rs)                             # ACL traits
│
├── CRDT Log System (log/)
│   ├── Entry (entry.rs)                            # CRDT log entries
│   ├── Identity (identity.rs)                      # Peer identity
│   ├── IdentityProvider (identity_provider.rs)     # Identity management
│   ├── LamportClock (lamport_clock.rs)             # Distributed time ordering
│   ├── AccessControl (access_control.rs)           # Log-level ACL
│   └── Traits (traits.rs)                          # Log traits
│
├── Data & Storage Layer
│   ├── Cache (cache/)
│   │   └── LevelDown (level_down.rs)             # Sled-based storage
│   ├── DataStore (data_store.rs)                 # Pluggable storage interface
│   ├── Keystore (keystore.rs)                    # Ed25519 cryptographic keys
│   ├── MessageMarshaler (message_marshaler.rs)   # Message Serialization
│   ├── DBManifest (db_manifest.rs)               # Database configuration
│   └── Address (address.rs)                      # Address resolution
│
├── Reactive Systems
│   ├── ReactiveSynchronizer (reactive_synchronizer.rs)   # State sync
│   └── Events (events.rs)                                # Event emission system
│
└── Core Traits & Types
    └── Traits (traits.rs)    # Common traits & types

use guardian_db::{GuardianDB, NewGuardianDBOptions, CreateDBOptions};
use guardian_db::p2p::network::client::IrohClient;
use guardian_db::traits::{EventLogStore, Store};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create development Iroh Client and database
    let client = IrohClient::development().await?;

    // Create GuardianDB instance
    let options = NewGuardianDBOptions {
        directory: Some("./guardian_data".to_string()),
        ..Default::default()
    };
    let db = GuardianDB::new(client, Some(options)).await?;

    // Create an event log with options
    let log_options = CreateDBOptions {
        create: Some(true),
        store_type: Some("eventlog".to_string()),
        ..Default::default()
    };
    let log = db.log("my-event-log", Some(log_options)).await?;

    // Add events to the log (append-only, immutable)
    log.add("Hello, GuardianDB!".as_bytes().to_vec()).await?;
    log.add("This is a decentralized database".as_bytes().to_vec()).await?;
    log.add("Built with Rust and Iroh".as_bytes().to_vec()).await?;

    // List all operations in the log
    let operations = log.list(None).await?;
    println!("Total entries: {}", operations.len());

    // Iterate over operations
    for (i, op) in operations.iter().enumerate() {
        println!("Entry {}: {:?}", i + 1, String::from_utf8_lossy(op.value()));
    }

    Ok(())
}

use guardian_db::{GuardianDB, NewGuardianDBOptions, CreateDBOptions};
use guardian_db::p2p::network::client::IrohClient;
use guardian_db::traits::KeyValueStore;

#[tokio::main] 
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize Iroh Client and database
    let client = IrohClient::development().await?;
    
    let options = NewGuardianDBOptions {
        directory: Some("./guardian_data".to_string()),
        ..Default::default()
    };
    
    let db = GuardianDB::new(client, Some(options)).await?;

    // Create a key-value store with CRDT semantics
    let kv = db.key_value("my-kv-store", None).await?;

    // CRUD operations - all operations are automatically replicated
    kv.put("app_name", "GuardianDB".as_bytes().to_vec()).await?;
    kv.put("version", "0.14.0".as_bytes().to_vec()).await?;
    kv.put("language", "Rust".as_bytes().to_vec()).await?;

    // Get values - queries the local CRDT index
    if let Some(name_bytes) = kv.get("app_name").await? {
        let name = String::from_utf8(name_bytes)?;
        println!("App: {}", name);
    }

    if let Some(version_bytes) = kv.get("version").await? {
        let version = String::from_utf8(version_bytes)?;
        println!("Version: {}", version);
    }

    // List all key-value pairs
    let all_pairs = kv.all();
    println!("Total entries: {}", all_pairs.len());
    for (key, value) in all_pairs.iter() {
        let value_str = String::from_utf8_lossy(value);
        println!("  {}: {}", key, value_str);
    }

    // Delete a key - creates a DEL operation in the distributed log
    kv.delete("version").await?;
    println!("After deletion: {} keys remaining", kv.all().len());

    Ok(())
}

use guardian_db::{GuardianDB, NewGuardianDBOptions, CreateDBOptions};
use guardian_db::p2p::network::client::IrohClient;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize Iroh Client and database
    let client = IrohClient::development().await?;
    
    let options = NewGuardianDBOptions {
        directory: Some("./guardian_data".to_string()),
        ..Default::default()
    };
    
    let db = GuardianDB::new(client, Some(options)).await?;

    // Create a document store with options
    let doc_options = CreateDBOptions {
        create: Some(true),
        store_type: Some("document".to_string()),
        ..Default::default()
    };
    
    let mut docs = db.docs("my-document-store", Some(doc_options)).await?;

    // Add JSON documents (requires _id field)
    let project_doc = json!({
        "_id": "guardian-db",
        "name": "GuardianDB", 
        "type": "database",
        "version": "0.14.0",
        "language": "Rust",
        "features": ["decentralized", "peer-to-peer", "CRDT", "Iroh"]
    });

    let network_doc = json!({
        "_id": "iroh-network",
        "name": "Iroh Network",
        "type": "networking",
        "version": "0.92.0", 
        "protocols": ["gossip", "docs", "blobs"]
    });

    // Store documents
    docs.put(project_doc).await?;
    docs.put(network_doc).await?;

    // Query documents by type using closure filter
    let database_docs = docs.query(|doc| {
        Ok(doc.get("type").and_then(|v| v.as_str()) == Some("database"))
    })?;

    println!("Found {} database documents", database_docs.len());
    
    // Get specific document by ID
    let guardian_docs = docs.get("guardian-db", None).await?;
    println!("GuardianDB doc: {:?}", guardian_docs);

    // Delete a document
    docs.delete("iroh-network").await?;

    // Put multiple documents in batch
    let batch_docs = vec![
        json!({"_id": "doc1", "name": "Document 1"}),
        json!({"_id": "doc2", "name": "Document 2"}),
    ];
    docs.put_batch(batch_docs).await?;

    Ok(())
}

use guardian_db::p2p::network::client::IrohClient;
use guardian_db::p2p::network::config::ClientConfig;
use tokio::io::AsyncReadExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Quick development setup (Native Iroh with QUIC transport)
    let client = IrohClient::development().await?;
    println!("✓ Iroh Client initialized with native QUIC backend");

    // Advanced configuration with native Iroh
    let config = ClientConfig {
        enable_pubsub: true,                        // iroh-gossip support
        data_store_path: Some("./iroh_data".into()),
        port: 4001,                                 // Iroh endpoint port (0 = random)
        enable_discovery_n0: true,                  // Discovery via n0.computer (Pkarr/DNS)
        enable_discovery_mdns: true,                // Local mDNS discovery
        known_peers: vec![],                        // NodeIds of known peers
        network: Default::default(),                // Network tuning (timeout, buffer, etc.)
        storage: Default::default(),                // iroh-blobs storage config
        gossip: Default::default(),                 // iroh-gossip config
    };

    let client = IrohClient::new(config).await?;
    println!("✓ Advanced Iroh Client configured");

    // Add data using native Iroh backend (BLAKE3 hashing)
    let data = "Hello from GuardianDB! This is stored with Iroh.";
    let add_response = client.add_bytes(data.as_bytes().to_vec()).await?;

    println!("Added to Iroh: {}", add_response.hash);
    println!("Size: {} bytes", add_response.size);

    // Retrieve data from Iroh (with smart caching)
    let mut stream = client.backend().cat(&add_response.hash).await?;
    let mut buffer = Vec::new();
    stream.read_to_end(&mut buffer).await?;

    let retrieved_text = String::from_utf8(buffer)?;
    println!("Retrieved: {}", retrieved_text);

    // Pin the content (persistent tags prevent GC)
    client.backend().pin_add(&add_response.hash).await?;
    println!("Content pinned with persistent tag");

    // Get node info (Iroh NodeId)
    let node_info = client.id().await?;
    println!("Node ID: {}", node_info.id);
    println!("Protocol Version: {}", node_info.protocol_version);
    println!("Agent Version: {}", node_info.agent_version);

    Ok(())
}

use guardian_db::guardian::core::{GuardianDB, NewGuardianDBOptions};
use guardian_db::p2p::network::config::ClientConfig;
use tracing::{info, Level};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging/tracing
    tracing_subscriber::fmt()
        .with_max_level(Level::INFO)
        .init();

    // Configure Iroh client with native backend
    let config = ClientConfig::default();
    info!("Iroh Client config prepared");
    
    // Configure GuardianDB
    let options = NewGuardianDBOptions {
        directory: Some("./guardian_data".into()),
        ..Default::default()
    };
    
    let db = GuardianDB::new(Some(config), Some(options)).await?;
    info!("GuardianDB initialized successfully");

    // Database is ready for use
    let stores_info = format!(
        "Available store types: EventLog, KeyValue, Document"
    );
    info!("{}", stores_info);
    
    Ok(())
}

use guardian_db::guardian::core::{GuardianDB, NewGuardianDBOptions};
use guardian_db::p2p::network::config::{ClientConfig, NetworkConfig, StorageConfig, GossipConfig};
use tracing::{info, Level};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize comprehensive logging
    tracing_subscriber::fmt()
        .with_max_level(Level::DEBUG)
        .init();

    // Production Iroh configuration with native backend
    let config = ClientConfig {
        enable_pubsub: true,                        // iroh-gossip support
        data_store_path: Some("./production_iroh".into()),
        port: 4001,                                 // Fixed port for production
        enable_discovery_n0: true,                  // Discovery via n0.computer (Pkarr/DNS)
        enable_discovery_mdns: true,                // Local mDNS discovery
        known_peers: vec![],                        // Add known NodeIds here
        
        // Network configuration
        network: NetworkConfig {
            connection_timeout: Duration::from_secs(60),
            max_peers_per_session: 1000,
            io_buffer_size: 128 * 1024,             // 128KB
            keepalive_interval: Duration::from_secs(120),
        },
        
        // Storage configuration (iroh-blobs)
        storage: StorageConfig {
            enable_memory_cache: true,
            max_cache_size: 1024 * 1024 * 1024,     // 1GB cache
            max_blob_size: 100 * 1024 * 1024,       // 100MB per blob
            enable_gc: true,
            gc_interval: Duration::from_secs(1800), // 30 minutes
        },
        
        // Gossip configuration (iroh-gossip)
        gossip: GossipConfig {
            max_message_size: 10 * 1024 * 1024,     // 10MB
            message_buffer_size: 10000,
            operation_timeout: Duration::from_secs(60),
            heartbeat_interval: Duration::from_millis(500),
            max_topics: 1000,
        },
    };

    info!("Production Iroh Client configured");

    // Advanced GuardianDB configuration
    let db_options = NewGuardianDBOptions {
        directory: Some("./production_guardian".into()),
        ..Default::default()
    };

    let db = GuardianDB::new(Some(config), Some(db_options)).await?;
    info!("GuardianDB configured for production use");

    // Database is ready for use with advanced configuration
    info!("Advanced configuration applied successfully");

    Ok(())
}

# Run all tests (776 passing tests)
cargo test

# Run only unit tests (in src/)
cargo test --lib

# Run only integration tests (in tests/)
cargo test --test '*'

# Run specific test files
cargo test --test integration_lifecycle        # Lifecycle tests
cargo test --test integration_replication      # P2P replication tests
cargo test --test integration_access_control   # Access control tests
cargo test --test integration_persistence      # Persistence tests
cargo test --test test_determinism             # Determinism tests

# Run specific unit test modules
cargo test guardian_core_test               # Core GuardianDB tests
cargo test event_log_store_test             # Event log store tests
cargo test kv_store_test                    # Key-value store tests
cargo test document_store_test              # Document store tests
cargo test iroh_backend_test                # Iroh backend tests
cargo test connection_pool_test             # Connection pool tests
cargo test networking_metrics_test          # Networking metrics tests
cargo test access_control                   # Access control tests

# Run with detailed output
RUST_LOG=debug cargo test -- --nocapture

# Run with single thread (for P2P tests)
cargo test --test integration_replication -- --test-threads=1

# Run tests in release mode (faster)
cargo test --release

# Build with all features (default)
cargo build

# Build optimized release version
cargo build --release

# Check code quality and formatting
cargo clippy                   # Comprehensive linting
cargo fmt                      # Code formatting
cargo check                    # Fast compilation check

# Build documentation
cargo doc --open               # Generate and open docs

# Development tools
cargo watch -x check           # Auto-rebuild on changes  
cargo audit                    # Security audit