Struct Graph 

pub struct Graph {
    pub def: GraphDef,
    pub context: Context,
}

Fields

def: GraphDef

context: Context

Implementations

impl Graph

pub fn new(def: GraphDef) -> Self

Examples found in repository

examples/parallel_execution.rs (line 308)

async fn analyze_and_execute(def: GraphDef) -> anyhow::Result<()> {
    // Create parallel executor
    let mut executor = ParallelExecutor::new(ParallelConfig {
        max_concurrent: 10,
        verbose: true,
    });

    // Register nodes
    for node_id in def.nodes.keys() {
        let node: Box<dyn Node> = Box::new(RuleNode::new(node_id, "true"));
        executor.register_node(node);
    }

    // Analyze parallelism
    let stats = executor.get_parallelism_stats(&def)?;
    stats.print_summary();

    // Execute the graph
    let mut graph = Graph::new(def);
    let start = Instant::now();
    executor.execute(&mut graph).await?;
    let duration = start.elapsed();

    println!("Execution completed in {:?}", duration);

    Ok(())
}

examples/simple_flow.rs (line 22)

async fn main() -> anyhow::Result<()> {
    // Initialize tracing
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .init();

    println!("=== Rust Logic Graph - Simple Flow Example ===\n");

    // Load graph definition from JSON
    let def = GraphIO::load_from_file("examples/simple_flow.json")?;
    println!("Loaded graph with {} nodes and {} edges\n",
        def.nodes.len(),
        def.edges.len()
    );

    // Create graph
    let mut graph = Graph::new(def);

    // Execute the graph
    println!("Starting graph execution...\n");
    Orchestrator::execute_graph(&mut graph).await?;

    // Display final context
    println!("\n=== Final Context ===");
    for (key, value) in &graph.context.data {
        println!("{}: {}", key, value);
    }

    println!("\n=== Execution Complete ===");
    Ok(())
}

examples/advanced_flow.rs (line 53)

async fn main() -> anyhow::Result<()> {
    // Initialize tracing
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::DEBUG)
        .init();

    println!("=== Rust Logic Graph - Advanced Flow Example ===");
    println!("Scenario: User Analytics Report Generation with Permission Checks\n");

    // Load graph definition
    let def = GraphIO::load_from_file("examples/advanced_flow.json")?;

    // Create custom executor with specific node configurations
    let mut executor = Executor::new();

    // Register nodes with custom logic
    executor.register_node(Box::new(RuleNode::new(
        "validate_input",
        "user_id > 0"
    )));

    executor.register_node(Box::new(DBNode::new(
        "fetch_user_data",
        "SELECT * FROM users WHERE id = ?"
    )));

    executor.register_node(Box::new(RuleNode::new(
        "check_permissions",
        "user_role == \"admin\""
    )));

    executor.register_node(Box::new(DBNode::new(
        "query_analytics",
        "SELECT * FROM analytics WHERE user_id = ?"
    )));

    executor.register_node(Box::new(AINode::new(
        "generate_report",
        "Generate comprehensive analytics report from data"
    )));

    executor.register_node(Box::new(AINode::new(
        "send_notification",
        "Send notification to user about report status"
    )));

    // Create graph and set initial context
    let mut graph = Graph::new(def);

    // Simulate input data
    graph.context.data.insert("user_id".to_string(), json!(1001));
    graph.context.data.insert("user_role".to_string(), json!("admin"));

    println!("Initial Context:");
    println!("  - user_id: 1001");
    println!("  - user_role: admin\n");

    // Execute the graph
    println!("Starting advanced flow execution...\n");
    executor.execute(&mut graph).await?;

    // Display results
    println!("\n=== Execution Results ===");
    println!("\nContext Data:");
    for (key, value) in &graph.context.data {
        if key.ends_with("_result") {
            println!("  {}: {}", key, serde_json::to_string_pretty(&value)?);
        }
    }

    println!("\n=== Flow Complete ===");
    Ok(())
}

examples/cache_flow.rs (line 114)

async fn demo_basic_caching() -> anyhow::Result<()> {
    println!("\n=== Demo 1: Basic Caching ===\n");

    // Create cache with default configuration
    let cache_config = CacheConfig {
        max_entries: 100,
        max_memory_bytes: 10 * 1024 * 1024, // 10MB
        default_ttl: None,                   // No expiration
        eviction_policy: EvictionPolicy::LRU,
        enable_background_cleanup: false,
    };

    let cache = CacheManager::new(cache_config).await?;

    // Create executor with cache
    let mut executor = Executor::with_cache(cache.clone());

    // Register expensive computation node
    executor.register_node(Box::new(ExpensiveComputeNode::new("compute", 1000)));

    // Create simple graph
    let graph_def = GraphDef {
        nodes: vec![("compute".to_string(), NodeType::RuleNode)]
            .into_iter()
            .collect(),
        edges: vec![],
    };

    // First execution - cache miss
    info!("First execution (cache miss):");
    let mut graph1 = Graph::new(graph_def.clone());
    graph1.context.set("input", json!(5))?;

    let start = std::time::Instant::now();
    executor.execute(&mut graph1).await?;
    let duration1 = start.elapsed();

    println!("First execution time: {:?}", duration1);
    println!("Cache stats: {:?}", cache.stats());

    // Second execution - cache hit
    info!("\nSecond execution (cache hit):");
    let mut graph2 = Graph::new(graph_def.clone());
    graph2.context.set("input", json!(5))?; // Same input

    let start = std::time::Instant::now();
    executor.execute(&mut graph2).await?;
    let duration2 = start.elapsed();

    println!("Second execution time: {:?}", duration2);
    println!("Cache stats: {:?}", cache.stats());
    println!("Speedup: {:.2}x", duration1.as_secs_f64() / duration2.as_secs_f64());

    // Third execution with different input - cache miss
    info!("\nThird execution with different input (cache miss):");
    let mut graph3 = Graph::new(graph_def);
    graph3.context.set("input", json!(10))?; // Different input

    let start = std::time::Instant::now();
    executor.execute(&mut graph3).await?;
    let duration3 = start.elapsed();

    println!("Third execution time: {:?}", duration3);
    println!("Final cache stats: {:?}", cache.stats());
    println!("Hit rate: {:.1}%", cache.stats().hit_rate());

    Ok(())
}

async fn demo_ttl_expiration() -> anyhow::Result<()> {
    println!("\n\n=== Demo 2: TTL Expiration ===\n");

    // Create cache with short TTL
    let cache_config = CacheConfig {
        max_entries: 100,
        max_memory_bytes: 10 * 1024 * 1024,
        default_ttl: Some(Duration::from_secs(2)), // 2 second TTL
        eviction_policy: EvictionPolicy::LRU,
        enable_background_cleanup: true,
    };

    let cache = CacheManager::new(cache_config).await?;
    let mut executor = Executor::with_cache(cache.clone());
    executor.register_node(Box::new(ExpensiveComputeNode::new("compute", 500)));

    let graph_def = GraphDef {
        nodes: vec![("compute".to_string(), NodeType::RuleNode)]
            .into_iter()
            .collect(),
        edges: vec![],
    };

    // First execution
    info!("First execution:");
    let mut graph1 = Graph::new(graph_def.clone());
    graph1.context.set("input", json!(7))?;
    executor.execute(&mut graph1).await?;
    println!("Cache stats after first execution: {:?}", cache.stats());

    // Immediate second execution - should hit cache
    info!("\nImmediate second execution (within TTL):");
    let mut graph2 = Graph::new(graph_def.clone());
    graph2.context.set("input", json!(7))?;
    executor.execute(&mut graph2).await?;
    println!("Cache stats: {:?}", cache.stats());

    // Wait for TTL to expire
    println!("\nWaiting for TTL to expire (3 seconds)...");
    tokio::time::sleep(Duration::from_secs(3)).await;

    // Third execution after TTL - should miss cache
    info!("\nThird execution (after TTL expiration):");
    let mut graph3 = Graph::new(graph_def);
    graph3.context.set("input", json!(7))?;
    executor.execute(&mut graph3).await?;
    println!("Cache stats after expiration: {:?}", cache.stats());

    Ok(())
}

async fn demo_eviction_policies() -> anyhow::Result<()> {
    println!("\n\n=== Demo 3: Eviction Policies ===\n");

    for policy in [EvictionPolicy::LRU, EvictionPolicy::FIFO, EvictionPolicy::LFU] {
        println!("\n--- Testing {:?} Policy ---", policy);

        let cache_config = CacheConfig {
            max_entries: 3, // Small limit to trigger eviction
            max_memory_bytes: 10 * 1024 * 1024,
            default_ttl: None,
            eviction_policy: policy,
            enable_background_cleanup: false,
        };

        let cache = CacheManager::new(cache_config).await?;
        let mut executor = Executor::with_cache(cache.clone());
        executor.register_node(Box::new(ExpensiveComputeNode::new("compute", 100)));

        let graph_def = GraphDef {
            nodes: vec![("compute".to_string(), NodeType::RuleNode)]
                .into_iter()
                .collect(),
            edges: vec![],
        };

        // Add 4 entries (should evict 1)
        for i in 1..=4 {
            let mut graph = Graph::new(graph_def.clone());
            graph.context.set("input", json!(i))?;
            executor.execute(&mut graph).await?;
            println!("Added entry {}, cache size: {}", i, cache.len());
        }

        let stats = cache.stats();
        println!("Final stats: entries={}, evictions={}", 
                 stats.current_entries, stats.evictions);
    }

    Ok(())
}

async fn demo_memory_limits() -> anyhow::Result<()> {
    println!("\n\n=== Demo 4: Memory Limits ===\n");

    // Create cache with small memory limit
    let cache_config = CacheConfig {
        max_entries: 1000,
        max_memory_bytes: 1024, // Only 1KB
        default_ttl: None,
        eviction_policy: EvictionPolicy::LRU,
        enable_background_cleanup: false,
    };

    let cache = CacheManager::new(cache_config).await?;
    let mut executor = Executor::with_cache(cache.clone());
    executor.register_node(Box::new(ExpensiveComputeNode::new("compute", 50)));

    let graph_def = GraphDef {
        nodes: vec![("compute".to_string(), NodeType::RuleNode)]
            .into_iter()
            .collect(),
        edges: vec![],
    };

    // Add entries until memory limit is reached
    for i in 1..=20 {
        let mut graph = Graph::new(graph_def.clone());
        graph.context.set("input", json!(i))?;
        graph.context.set("large_data", json!(vec![i; 100]))?; // Add some bulk
        executor.execute(&mut graph).await?;

        let stats = cache.stats();
        println!(
            "Entry {}: size={} entries, memory={} bytes, evictions={}",
            i, stats.current_entries, stats.current_memory_bytes, stats.evictions
        );
    }

    let stats = cache.stats();
    println!("\nFinal memory usage: {} bytes (limit: 1024 bytes)", 
             stats.current_memory_bytes);
    println!("Total evictions: {}", stats.evictions);

    Ok(())
}

async fn demo_cache_invalidation() -> anyhow::Result<()> {
    println!("\n\n=== Demo 5: Cache Invalidation ===\n");

    let cache = CacheManager::new(CacheConfig::default()).await?;
    let mut executor = Executor::with_cache(cache.clone());
    executor.register_node(Box::new(ExpensiveComputeNode::new("compute", 200)));

    let graph_def = GraphDef {
        nodes: vec![("compute".to_string(), NodeType::RuleNode)]
            .into_iter()
            .collect(),
        edges: vec![],
    };

    // Execute multiple times with different inputs
    for i in 1..=5 {
        let mut graph = Graph::new(graph_def.clone());
        graph.context.set("input", json!(i))?;
        executor.execute(&mut graph).await?;
    }

    println!("Cache populated with {} entries", cache.len());
    println!("Cache stats: {:?}", cache.stats());

    // Invalidate specific node
    println!("\nInvalidating all entries for node 'compute'...");
    let invalidated = cache.invalidate_node("compute");
    println!("Invalidated {} entries", invalidated);
    println!("Cache size after invalidation: {}", cache.len());

    // Re-execute - should be cache miss
    info!("\nRe-executing after invalidation:");
    let mut graph = Graph::new(graph_def);
    graph.context.set("input", json!(1))?;
    executor.execute(&mut graph).await?;
    println!("Final cache stats: {:?}", cache.stats());

    Ok(())
}

examples/grl_graph_flow.rs (line 58)

async fn main() -> anyhow::Result<()> {
    // Initialize tracing
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .init();

    println!("=== Rust Logic Graph - GRL Integration Example ===");
    println!("Scenario: Loan Application with Advanced GRL Rules\n");

    // Load graph definition
    let def = GraphIO::load_from_file("examples/grl_graph_flow.json")?;

    // Create custom executor with GRL-powered nodes
    let mut executor = Executor::new();

    // Input validation with GRL
    executor.register_node(Box::new(RuleNode::new(
        "input_validation",
        "loan_amount > 0 && loan_amount <= 1000000"
    )));

    // Fetch customer data
    executor.register_node(Box::new(DBNode::new(
        "fetch_customer",
        "SELECT * FROM customers WHERE id = ?"
    )));

    // Risk assessment with complex GRL rules
    executor.register_node(Box::new(RuleNode::new(
        "risk_assessment",
        "credit_score >= 600 && income >= loan_amount * 3"
    )));

    // Fraud detection AI
    executor.register_node(Box::new(AINode::new(
        "fraud_detection",
        "Analyze transaction patterns for fraud indicators"
    )));

    // Final approval decision
    executor.register_node(Box::new(RuleNode::new(
        "approval_decision",
        "risk_score < 50 && fraud_score < 30"
    )));

    // Notification
    executor.register_node(Box::new(AINode::new(
        "notification",
        "Generate approval/rejection notification email"
    )));

    // Create graph with initial context
    let mut graph = Graph::new(def);

    // Set application data
    graph.context.data.insert("loan_amount".to_string(), json!(50000));
    graph.context.data.insert("credit_score".to_string(), json!(720));
    graph.context.data.insert("income".to_string(), json!(180000));
    graph.context.data.insert("customer_id".to_string(), json!(12345));

    println!("Application Data:");
    println!("  Loan Amount: $50,000");
    println!("  Credit Score: 720");
    println!("  Annual Income: $180,000");
    println!("  Customer ID: 12345\n");

    // Execute the graph
    println!("Processing loan application through GRL-powered workflow...\n");
    executor.execute(&mut graph).await?;

    // Display results
    println!("\n=== Application Results ===\n");

    if let Some(validation) = graph.context.data.get("input_validation_result") {
        println!("✓ Input Validation: {}", validation);
    }

    if let Some(customer) = graph.context.data.get("fetch_customer_result") {
        println!("✓ Customer Data Retrieved");
    }

    if let Some(risk) = graph.context.data.get("risk_assessment_result") {
        println!("✓ Risk Assessment: {}", risk);
    }

    if let Some(fraud) = graph.context.data.get("fraud_detection_result") {
        println!("✓ Fraud Detection Completed");
    }

    if let Some(decision) = graph.context.data.get("approval_decision_result") {
        println!("✓ Approval Decision: {}", decision);
    }

    println!("\n=== GRL-Powered Workflow Complete ===");

    // Demonstrate standalone GRL engine
    println!("\n=== Bonus: Advanced GRL Rules ===\n");

    let mut grl_engine = RuleEngine::new();

    let advanced_rules = r#"
rule "HighValueLoan" salience 100 {
    when
        loan_amount > 100000 && credit_score < 750
    then
        requires_manual_review = true;
        approval_tier = "senior";
}

rule "StandardApproval" salience 50 {
    when
        loan_amount <= 100000 && credit_score >= 650
    then
        auto_approve = true;
        approval_tier = "standard";
}

rule "RiskMitigation" salience 25 {
    when
        debt_to_income_ratio > 0.4
    then
        requires_collateral = true;
        interest_rate_adjustment = 1.5;
}
"#;

    grl_engine.add_grl_rule(advanced_rules)?;

    println!("Advanced GRL rules loaded:");
    println!("  - High Value Loan Review");
    println!("  - Standard Approval Process");
    println!("  - Risk Mitigation Measures");

    println!("\n✅ All systems operational with rust-rule-engine integration!");

    Ok(())
}