helios-sof 0.1.47

This crate provides a complete implementation of the SQL-on-FHIR specification for Rust, enabling the transformation of FHIR resources into tabular data using declarative ViewDefinitions. It supports all major FHIR versions (R4, R4B, R5, R6) through a version-agnostic abstraction layer.
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

#[cfg(test)]
mod tests {
    use helios_fhir::{FhirResource, r4::Patient};
    use helios_fhirpath::{EvaluationContext, evaluate_expression};

    #[test]
    fn debug_boolean_constant_test() {
        // Create a test patient with deceasedBoolean = true
        let patient_json = r#"
        {
            "resourceType": "Patient",
            "id": "pt2",
            "deceasedBoolean": true,
            "name": [{
                "family": "Johnson",
                "use": "usual"
            }]
        }
        "#;

        let patient: Patient = serde_json::from_str(patient_json).unwrap();
        println!("Patient: {:#?}", patient);

        // Check what the deceased field contains
        if let Some(deceased) = &patient.deceased {
            println!("Deceased: {:#?}", deceased);
        } else {
            println!("No deceased field");
        }

        // Convert patient to FhirResource and EvaluationContext
        let fhir_resource = FhirResource::R4(Box::new(helios_fhir::r4::Resource::Patient(
            Box::new(patient),
        )));
        let mut context = EvaluationContext::new(vec![fhir_resource]);

        // Add the boolean constant
        let is_deceased_constant = helios_fhirpath_support::EvaluationResult::Boolean(
            true,
            Some(helios_fhirpath_support::TypeInfoResult::new(
                "FHIR", "boolean",
            )),
        );
        context.set_variable_result("is_deceased", is_deceased_constant);

        // Test the individual parts of the expression
        println!("\n=== Testing FHIRPath expressions ===");

        // Test: deceased
        match evaluate_expression("deceased", &context) {
            Ok(result) => println!("deceased = {:#?}", result),
            Err(e) => println!("deceased error: {:?}", e),
        }

        // Test: deceased.ofType(boolean)
        match evaluate_expression("deceased.ofType(boolean)", &context) {
            Ok(result) => println!("deceased.ofType(boolean) = {:#?}", result),
            Err(e) => println!("deceased.ofType(boolean) error: {:?}", e),
        }

        // Test: deceased.ofType(boolean).exists()
        match evaluate_expression("deceased.ofType(boolean).exists()", &context) {
            Ok(result) => println!("deceased.ofType(boolean).exists() = {:#?}", result),
            Err(e) => println!("deceased.ofType(boolean).exists() error: {:?}", e),
        }

        // Test: %is_deceased
        match evaluate_expression("%is_deceased", &context) {
            Ok(result) => println!("%is_deceased = {:#?}", result),
            Err(e) => println!("%is_deceased error: {:?}", e),
        }

        // Test: deceased.ofType(boolean) = %is_deceased
        match evaluate_expression("deceased.ofType(boolean) = %is_deceased", &context) {
            Ok(result) => println!("deceased.ofType(boolean) = %is_deceased = {:#?}", result),
            Err(e) => println!("deceased.ofType(boolean) = %is_deceased error: {:?}", e),
        }

        // Test: the full expression
        match evaluate_expression(
            "deceased.ofType(boolean).exists() and deceased.ofType(boolean) = %is_deceased",
            &context,
        ) {
            Ok(result) => println!("Full expression = {:#?}", result),
            Err(e) => println!("Full expression error: {:?}", e),
        }

        // This test always passes - we just want to see the debug output
    }
}