cronus_generator 0.3.0

The generators for cronus API spec.
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



use anyhow::{Ok, Result};
use convert_case::{Casing, Case};
use cronus_spec::{RawUsecase, RawSchema};
use tracing::{span, Level};

use crate::{Generator, Ctxt, utils::{get_request_name, get_usecase_name, get_response_name}};



pub struct TypescriptGenerator {
}

impl TypescriptGenerator {
    pub fn new() -> Self {
        Self {
           
        }
    }
}

impl Generator for TypescriptGenerator {
    fn name(&self) -> &'static str {
        return "typescript"
    }

    fn generate_schema(&self, ctx: &Ctxt, schema_name:&str, schema: &RawSchema)-> Result<()> {
        self.generate_schema(ctx, Some(schema_name.to_owned()),  schema);
        Ok(())
    }

    fn generate_usecase(&self, ctx: &Ctxt, name: &str, usecase: &RawUsecase) -> Result<()> {
        let span = span!(Level::TRACE, "generate_usecase", "usecase" = name);
        // Enter the span, returning a guard object.
        let _enter = span.enter();
        
        let usecase_name = get_usecase_name(ctx, name);
    
        let mut result = format!("export interface {} {{\n", usecase_name);
    
        for (method_name, method) in &usecase.methods {
            let method_name_camel = method_name.to_case(Case::Camel);

            let request_type = match &method.req {
                Some(req) => {
                    let request_type = get_request_name(ctx, &method_name_camel);
                    self.generate_schema(ctx, Some(request_type.clone()), req, );
                    request_type
                },
                None => String::new(),
            };
    
            let response_type = match &method.res {
                Some(res) => {
                    let response_type = get_response_name(ctx,  &method_name_camel);
                    self.generate_schema(ctx, Some(response_type.clone()), res, );
                    response_type
                },
                None => "Promise<void>".to_string(),
            };
    
            let method_signature = if request_type.is_empty() {
                format!("  {}(): {};\n", method_name_camel, response_type)
            } else {
                format!("  {}(request: {}): {};\n", method_name_camel, request_type, response_type)
            };

            result += &method_signature;
        }
    
        result += "}\n";
        ctx.append_file(self.name(), &self.dst(ctx), &result);

        Ok(())
    }

    
}


impl TypescriptGenerator {


    fn dst(&self, ctx: &Ctxt) -> String {
        if let Some(gen_config) = &ctx.spec.option.as_ref().unwrap().generator {
            if let Some(ts_gen_config) = &gen_config.typescript {
                if let Some(file) = &ts_gen_config.file {
                    return file.clone()
                }
                
            }
        }

        return "types.ts".to_string();
    }

    pub fn generate_schema(&self,
        ctx: &Ctxt,
        override_name: Option<String>,
        schema: &RawSchema,
    ) {
        let interface_name: String;
        if let Some(ty) = override_name {
            interface_name = ty.to_case(Case::UpperCamel);
        } else {
            interface_name = schema.ty.as_ref().unwrap().clone();
        }

        let span = span!(Level::TRACE, "generate_inteface", "interface" = interface_name);
        // Enter the span, returning a guard object.
        let _enter = span.enter();

        let ts_type = schema_to_ts_type(&schema);

        let result = format!("export interface {} {}\n", interface_name, ts_type);

        ctx.append_file(self.name(), &self.dst(ctx), &result);

    }
}


// Helper function to generate TypeScript type from RawSchema
fn schema_to_ts_type(schema: &RawSchema) -> String {
    if let Some(ref ty) = schema.ty {
        ty.clone()
    } else if let Some(ref items) = schema.items {
        format!("Array<{}>", schema_to_ts_type(items))
    } else if let Some(ref properties) = schema.properties {
        let mut props = String::new();
        for (key, value) in properties {
            props += &format!("  {}: {};\n", key, schema_to_ts_type(value));
        }
        format!("{{\n{}}}", props)
    } else {
        "any".to_string() // Fallback to 'any' type if no other information is available
    }
}