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

//! Test to verify the Element/ElementDefinition nested struct fix
//!
//! This test generates Element and ElementDefinition structures to ensure
//! that nested structs are correctly assigned to their parent files.

use anyhow::Result;
use rh_codegen::{CodeGenerator, CodegenConfig};
use std::path::Path;

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

    // Create test structures that mimic Element and ElementDefinition
    let element_structure = create_element_structure_definition();
    let element_definition_structure = create_element_definition_structure_definition();

    let output_dir = Path::new("./test-nested-struct-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 nested struct assignment fix...");

    // Generate Element - this should only contain Element and its direct children
    generator.generate_to_organized_directories(&element_structure, &src_dir)?;

    // Generate ElementDefinition - this should only contain ElementDefinition and its direct children
    generator.generate_to_organized_directories(&element_definition_structure, &src_dir)?;

    println!("✅ Generated test files to verify nested struct fix");
    println!("📁 Check files in: {}/datatypes/", src_dir.display());
    println!("🔍 element.rs should only contain Element and Element* structs");
    println!("🔍 element_definition.rs should only contain ElementDefinition and ElementDefinition* structs");

    Ok(())
}

fn create_element_structure_definition() -> rh_codegen::fhir_types::StructureDefinition {
    use rh_codegen::fhir_types::*;

    StructureDefinition {
        resource_type: "StructureDefinition".to_string(),
        id: "Element".to_string(),
        url: "http://hl7.org/fhir/StructureDefinition/Element".to_string(),
        name: "Element".to_string(),
        title: Some("Element".to_string()),
        status: "active".to_string(),
        description: Some("Base definition for all elements in a resource.".to_string()),
        purpose: None,
        kind: "complex-type".to_string(),
        is_abstract: false,
        base_type: "Element".to_string(),
        base_definition: None,
        version: Some("4.0.1".to_string()),
        differential: None,
        snapshot: None,
    }
}

fn create_element_definition_structure_definition() -> rh_codegen::fhir_types::StructureDefinition {
    use rh_codegen::fhir_types::*;

    StructureDefinition {
        resource_type: "StructureDefinition".to_string(),
        id: "ElementDefinition".to_string(),
        url: "http://hl7.org/fhir/StructureDefinition/ElementDefinition".to_string(),
        name: "ElementDefinition".to_string(),
        title: Some("ElementDefinition".to_string()),
        status: "active".to_string(),
        description: Some(
            "Captures constraints on each element within the resource, profile, or extension."
                .to_string(),
        ),
        purpose: None,
        kind: "complex-type".to_string(),
        is_abstract: false,
        base_type: "BackboneElement".to_string(),
        base_definition: Some(
            "http://hl7.org/fhir/StructureDefinition/BackboneElement".to_string(),
        ),
        version: Some("4.0.1".to_string()),
        differential: None,
        snapshot: None,
    }
}