rh-codegen 0.1.0-beta.1

Code generation library for creating Rust types from FHIR StructureDefinitions
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

use rh_codegen::StructureDefinition;
use serde_json::json;

/// Test to validate that trait implementations correctly use nested types for BackboneElement fields
fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Testing trait implementation BackboneElement type handling...");

    // Create a test Account-like structure with coverage field
    let test_structure = json!({
        "resourceType": "StructureDefinition",
        "id": "account",
        "url": "http://hl7.org/fhir/StructureDefinition/Account",
        "version": "4.0.1",
        "name": "Account",
        "title": "Account",
        "status": "active",
        "kind": "resource",
        "abstract": false,
        "type": "Account",
        "baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
        "derivation": "specialization",
        "differential": {
            "element": [
                {
                    "id": "Account",
                    "path": "Account",
                    "definition": "A financial tool for tracking value",
                    "min": 0,
                    "max": "*"
                },
                {
                    "id": "Account.coverage",
                    "path": "Account.coverage",
                    "definition": "The party(s) that are responsible for covering the payment",
                    "min": 0,
                    "max": "*",
                    "type": [{"code": "BackboneElement"}]
                },
                {
                    "id": "Account.guarantor",
                    "path": "Account.guarantor",
                    "definition": "The parties ultimately responsible for balancing the Account",
                    "min": 0,
                    "max": "*",
                    "type": [{"code": "BackboneElement"}]
                }
            ]
        }
    });

    // Parse the structure definition
    let structure_def: StructureDefinition = serde_json::from_value(test_structure)?;

    // Create generator and generate trait implementations

    // Generate the trait implementation using the internal trait impl generator
    let trait_impl_generator = rh_codegen::generators::TraitImplGenerator::new();
    let trait_impls = trait_impl_generator.generate_trait_impls(&structure_def)?;

    println!("Generated {} trait implementations", trait_impls.len());

    // Find the specific Account trait implementation
    if let Some(account_impl) = trait_impls
        .iter()
        .find(|impl_| impl_.trait_name.contains("AccountAccessors"))
    {
        println!(
            "Found AccountAccessors implementation with {} methods",
            account_impl.methods.len()
        );

        // Check coverage method
        if let Some(coverage_method) = account_impl.methods.iter().find(|m| m.name == "coverage") {
            println!("coverage() return type: {}", coverage_method.return_type);
            println!("coverage() body: {}", coverage_method.body);

            // Should return &[AccountCoverage], not &[BackboneElement]
            if coverage_method.return_type.contains("AccountCoverage") {
                println!("✅ Coverage method correctly returns &[AccountCoverage]!");
            } else if coverage_method.return_type.contains("BackboneElement") {
                println!("❌ Coverage method incorrectly returns &[BackboneElement]");
                println!("   Expected: &[AccountCoverage]");
                println!("   Got: {}", coverage_method.return_type);
            } else {
                println!(
                    "⚠️  Unexpected return type: {}",
                    coverage_method.return_type
                );
            }
        } else {
            println!("❌ No coverage method found in trait implementation");
        }

        // Check guarantor method
        if let Some(guarantor_method) = account_impl.methods.iter().find(|m| m.name == "guarantor")
        {
            println!("guarantor() return type: {}", guarantor_method.return_type);
            println!("guarantor() body: {}", guarantor_method.body);

            // Should return &[AccountGuarantor], not &[BackboneElement]
            if guarantor_method.return_type.contains("AccountGuarantor") {
                println!("✅ Guarantor method correctly returns &[AccountGuarantor]!");
            } else if guarantor_method.return_type.contains("BackboneElement") {
                println!("❌ Guarantor method incorrectly returns &[BackboneElement]");
                println!("   Expected: &[AccountGuarantor]");
                println!("   Got: {}", guarantor_method.return_type);
            } else {
                println!(
                    "⚠️  Unexpected return type: {}",
                    guarantor_method.return_type
                );
            }
        } else {
            println!("❌ No guarantor method found in trait implementation");
        }
    } else {
        println!("❌ No AccountAccessors trait implementation found");
        println!("Available trait implementations:");
        for impl_ in &trait_impls {
            println!(
                "  - {} (with {} methods)",
                impl_.trait_name,
                impl_.methods.len()
            );
        }
    }

    println!("🎯 Trait implementation nested BackboneElement type handling test completed!");

    Ok(())
}