vika-cli 1.4.0

Generate TypeScript types, Zod schemas, and Fetch-based API clients from OpenAPI/Swagger specifications
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

use crate::error::{Result, TemplateError};
use crate::templates::registry::TemplateId;
use crate::templates::resolver::TemplateResolver;
use serde::Serialize;
use std::path::Path;
use tera::{Context, Tera};

/// Template engine wrapper around Tera.
pub struct TemplateEngine {
    tera: Tera,
    resolver: TemplateResolver,
}

impl TemplateEngine {
    /// Create a new template engine.
    ///
    /// Loads all templates (built-in and user overrides) and compiles them.
    pub fn new(project_root: Option<&Path>) -> Result<Self> {
        let resolver = TemplateResolver::new(project_root);
        let mut tera = Tera::default();

        // Load all templates into Tera
        for template_id in TemplateId::all() {
            let template_content = resolver.resolve(template_id)?;
            let template_name = template_id.filename();

            tera.add_raw_template(&template_name, &template_content)
                .map_err(|e| {
                    crate::error::GenerationError::Template(TemplateError::InvalidSyntax {
                        name: template_name.to_string(),
                        message: e.to_string(),
                    })
                })?;
        }

        Ok(Self { tera, resolver })
    }

    /// Render a template with the given context.
    pub fn render<T: Serialize>(&self, template_id: TemplateId, context: &T) -> Result<String> {
        let template_name = template_id.filename();

        let json_value = serde_json::to_value(context).map_err(|e| {
            crate::error::GenerationError::Template(TemplateError::RenderFailed {
                name: template_name.to_string(),
                message: format!("Failed to serialize context: {}", e),
            })
        })?;
        let tera_context = Context::from_serialize(&json_value).map_err(|e| {
            crate::error::GenerationError::Template(TemplateError::RenderFailed {
                name: template_name.to_string(),
                message: format!("Failed to create Tera context: {}", e),
            })
        })?;

        self.tera
            .render(&template_name, &tera_context)
            .map_err(|e| {
                crate::error::GenerationError::Template(TemplateError::RenderFailed {
                    name: template_name.to_string(),
                    message: e.to_string(),
                })
            })
            .map_err(Into::into)
    }

    /// Check if a template is overridden by user.
    pub fn is_overridden(&self, template_id: TemplateId) -> bool {
        self.resolver.is_overridden(template_id)
    }

    /// List all templates with their override status.
    pub fn list_templates(&self) -> Result<Vec<(String, bool)>> {
        self.resolver.list_templates()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::templates::context::TypeContext;

    #[test]
    fn test_template_engine_new() {
        let engine = TemplateEngine::new(None);
        assert!(engine.is_ok());
    }

    #[test]
    fn test_template_engine_render_enum() {
        let engine = TemplateEngine::new(None).unwrap();
        let context = TypeContext::enum_type(
            "TestEnum".to_string(),
            vec!["A".to_string(), "B".to_string()],
            None,
        );
        let result = engine.render(TemplateId::TypeEnum, &context);
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.contains("TestEnum"));
        assert!(output.contains("A"));
        assert!(output.contains("B"));
    }
}