ops-rs 1.64.597

A Rust ops framework with composable wrappers and batch execution
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use ops_rs::prelude::*;
use ops_rs::{
    dry_get, dry_put, dry_require, dry_result, wet_get_ref, wet_put_arc, wet_put_ref,
    wet_require_ref,
};
use std::sync::Arc;

// Example service for wet context
struct DataService {
    name: String,
}

impl DataService {
    fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
        }
    }

    fn process(&self, data: &str) -> String {
        format!("{} processed by {}", data, self.name)
    }
}

// Example op that uses the macros
struct ProcessDataOp;

#[async_trait]
impl Op<String> for ProcessDataOp {
    async fn perform(&self, dry: &mut DryContext, wet: &mut WetContext) -> OpResult<String> {
        // Using dry_require for dry context
        let input_data: String = dry_require!(dry, input_data)?;
        let process_count: i32 = dry_require!(dry, process_count)?;

        // Using wet_require_ref for wet context
        let data_service: Arc<DataService> = wet_require_ref!(wet, data_service)?;

        // Process the data
        let mut result = input_data;
        for _ in 0..process_count {
            result = data_service.process(&result);
        }

        Ok(result)
    }

    fn metadata(&self) -> OpMetadata {
        OpMetadata::builder("ProcessDataOp")
            .description("Processes data using a service with iteration count")
            .input_schema(serde_json::json!({
                "type": "object",
                "properties": {
                    "input_data": {
                        "type": "string",
                        "minLength": 1,
                        "description": "The data to process"
                    },
                    "process_count": {
                        "type": "integer",
                        "minimum": 1,
                        "maximum": 10,
                        "description": "Number of times to process the data"
                    }
                },
                "required": ["input_data", "process_count"],
                "additionalProperties": false
            }))
            .reference_schema(serde_json::json!({
                "type": "object",
                "properties": {
                    "data_service": {
                        "type": "DataService",
                        "description": "Service for processing data"
                    }
                },
                "required": ["data_service"],
                "additionalProperties": false
            }))
            .output_schema(serde_json::json!({
                "type": "string",
                "description": "The processed result after all iterations"
            }))
            .build()
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Context Macros Demo ===\n");

    // Create dry context and use ctx_put
    let mut dry = DryContext::new();
    let input_data = "Hello World".to_string();
    let process_count = 3;

    // Using dry_put macro for dry context
    dry_put!(dry, input_data);
    dry_put!(dry, process_count);

    // Verify with dry_get
    let retrieved_data: Option<String> = dry_get!(dry, input_data);
    println!("Retrieved data: {:?}", retrieved_data);

    // Create wet context
    let mut wet = WetContext::new();
    let data_service = DataService::new("MainProcessor");

    // Using wet_put_ref macro for wet context
    wet_put_ref!(wet, data_service);

    // Example with Arc
    let shared_service = Arc::new(DataService::new("SharedProcessor"));
    wet_put_arc!(wet, shared_service);

    // Execute the op
    let op = ProcessDataOp;
    let result = op.perform(&mut dry, &mut wet).await?;
    println!("\nProcessed result: {}", result);

    // Demonstrate dry_result macro
    let mut result_dry = DryContext::new();
    let final_result = "Final processed data".to_string();
    dry_result!(result_dry, "ProcessDataOp", final_result);

    // Verify result storage
    let stored_result: Option<String> = dry_get!(result_dry, result);
    let op_result: Option<String> = result_dry.get("ProcessDataOp");

    println!("\nResult stored under 'result': {:?}", stored_result);
    println!("Result stored under op name: {:?}", op_result);

    // Also demonstrate the explicitly named macros
    println!("\n=== Using explicitly named macros ===");

    let mut dry2 = DryContext::new();
    let test_value = 42;
    dry_put!(dry2, test_value);

    let retrieved: Option<i32> = dry_get!(dry2, test_value);
    println!("Retrieved using dry_get: {:?}", retrieved);

    let mut wet2 = WetContext::new();
    let service2 = DataService::new("SecondaryProcessor");
    wet_put_ref!(wet2, service2);

    let service_ref: Option<Arc<DataService>> = wet_get_ref!(wet2, service2);
    println!("Retrieved service ref: {}", service_ref.is_some());

    Ok(())
}