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

use anyhow::Result;
use rh_codegen::fhir_types::{
    ElementDefinition, ElementType, StructureDefinition, StructureDefinitionDifferential,
};
use rh_codegen::{CodeGenerator, CodegenConfig};
use std::path::Path;

/// Create a test structure definition with array fields to test array handling
fn create_test_structure_with_arrays() -> StructureDefinition {
    StructureDefinition {
        resource_type: "StructureDefinition".to_string(),
        id: "TestArrayResource".to_string(),
        url: "http://example.org/fhir/StructureDefinition/TestArrayResource".to_string(),
        name: "TestArrayResource".to_string(),
        status: "active".to_string(),
        kind: "resource".to_string(),
        is_abstract: false,
        base_type: "TestArrayResource".to_string(),
        base_definition: Some("http://hl7.org/fhir/StructureDefinition/DomainResource".to_string()),
        differential: Some(StructureDefinitionDifferential {
            element: vec![
                ElementDefinition {
                    id: Some("TestArrayResource".to_string()),
                    path: "TestArrayResource".to_string(),
                    short: None,
                    definition: None,
                    min: Some(0),
                    max: Some("*".to_string()),
                    element_type: Some(vec![ElementType {
                        code: Some("TestArrayResource".to_string()),
                        target_profile: None,
                    }]),
                    fixed: None,
                    pattern: None,
                    binding: None,
                    constraint: None,
                },
                ElementDefinition {
                    id: Some("TestArrayResource.stringArray".to_string()),
                    path: "TestArrayResource.stringArray".to_string(),
                    short: None,
                    definition: None,
                    min: Some(0),
                    max: Some("*".to_string()),
                    element_type: Some(vec![ElementType {
                        code: Some("string".to_string()),
                        target_profile: None,
                    }]),
                    fixed: None,
                    pattern: None,
                    binding: None,
                    constraint: None,
                },
                ElementDefinition {
                    id: Some("TestArrayResource.requiredArray".to_string()),
                    path: "TestArrayResource.requiredArray".to_string(),
                    short: None,
                    definition: None,
                    min: Some(1),
                    max: Some("*".to_string()),
                    element_type: Some(vec![ElementType {
                        code: Some("CodeableConcept".to_string()),
                        target_profile: None,
                    }]),
                    fixed: None,
                    pattern: None,
                    binding: None,
                    constraint: None,
                },
            ],
        }),
        snapshot: None,
        version: None,
        title: None,
        description: None,
        purpose: None,
    }
}

fn main() -> Result<()> {
    let config = CodegenConfig::default();
    let mut generator = CodeGenerator::new(config);

    let output_dir = Path::new("./test_array_fix");
    let src_dir = output_dir.join("src");

    // Clean up any existing output
    if output_dir.exists() {
        std::fs::remove_dir_all(output_dir)?;
    }
    std::fs::create_dir_all(&src_dir)?;

    println!("Testing array handling fix...");

    // Create a test structure with arrays
    let test_structure = create_test_structure_with_arrays();

    // Generate the struct to test array handling
    generator.generate_to_organized_directories(&test_structure, &src_dir)?;

    println!("✅ Generated test files for array handling verification");
    println!("📁 Files generated in: ./test_array_fix/");

    Ok(())
}