shaperail_codegen/
typescript.rs

1use std::collections::BTreeMap;
2
3/// Generate TypeScript type definitions from an OpenAPI 3.1 spec.
4///
5/// Reads the `components.schemas` section and produces one interface per schema.
6/// This generates types that match what `openapi-typescript` would produce from
7/// the same spec — the spec JSON is also written alongside so users can run
8/// `npx openapi-typescript openapi.json -o types.ts` if they prefer.
9pub fn generate_from_spec(spec: &serde_json::Value) -> BTreeMap<String, String> {
10    let mut files: BTreeMap<String, String> = BTreeMap::new();
11
12    let schemas = match spec
13        .get("components")
14        .and_then(|c| c.get("schemas"))
15        .and_then(|s| s.as_object())
16    {
17        Some(s) => s,
18        None => return files,
19    };
20
21    let mut all_interfaces = Vec::new();
22
23    // Sort schema names for deterministic output
24    let mut schema_names: Vec<&String> = schemas.keys().collect();
25    schema_names.sort();
26
27    for name in &schema_names {
28        let schema = &schemas[*name];
29        if let Some(interface) = schema_to_interface(name, schema) {
30            all_interfaces.push(interface);
31        }
32    }
33
34    // Generate per-resource files by grouping schemas
35    // Collect resource names from paths tags
36    let mut resource_schemas: BTreeMap<String, Vec<String>> = BTreeMap::new();
37
38    if let Some(paths) = spec.get("paths").and_then(|p| p.as_object()) {
39        for (_path, methods) in paths {
40            if let Some(methods_obj) = methods.as_object() {
41                for (_method, operation) in methods_obj {
42                    if let Some(tags) = operation.get("tags").and_then(|t| t.as_array()) {
43                        if let Some(tag) = tags.first().and_then(|t| t.as_str()) {
44                            let pascal = to_pascal_case(tag);
45                            // Add the main schema and any input schemas
46                            for schema_name in &schema_names {
47                                if schema_name.starts_with(&pascal) {
48                                    resource_schemas
49                                        .entry(tag.to_string())
50                                        .or_default()
51                                        .push((*schema_name).clone());
52                                }
53                            }
54                        }
55                    }
56                }
57            }
58        }
59    }
60
61    // Deduplicate schema lists
62    for schemas_list in resource_schemas.values_mut() {
63        schemas_list.sort();
64        schemas_list.dedup();
65    }
66
67    // Generate per-resource .ts files
68    for (resource_name, schema_list) in &resource_schemas {
69        let mut content = String::new();
70        for schema_name in schema_list {
71            if let Some(schema) = schemas.get(schema_name) {
72                if let Some(interface) = schema_to_interface(schema_name, schema) {
73                    content.push_str(&interface);
74                    content.push('\n');
75                }
76            }
77        }
78        if !content.is_empty() {
79            files.insert(format!("{resource_name}.ts"), content);
80        }
81    }
82
83    // Generate index.ts that re-exports everything
84    let index: String = resource_schemas
85        .keys()
86        .map(|r| format!("export * from './{r}';"))
87        .collect::<Vec<_>>()
88        .join("\n");
89    if !index.is_empty() {
90        files.insert("index.ts".to_string(), format!("{index}\n"));
91    }
92
93    files
94}
95
96fn schema_to_interface(name: &str, schema: &serde_json::Value) -> Option<String> {
97    let properties = schema.get("properties")?.as_object()?;
98    let required_fields: Vec<&str> = schema
99        .get("required")
100        .and_then(|r| r.as_array())
101        .map(|arr| arr.iter().filter_map(|v| v.as_str()).collect())
102        .unwrap_or_default();
103
104    let mut fields = Vec::new();
105
106    // Sort property names for deterministic output
107    let mut prop_names: Vec<&String> = properties.keys().collect();
108    prop_names.sort();
109
110    for prop_name in prop_names {
111        let prop = &properties[prop_name];
112        let ts_type = openapi_type_to_ts(prop);
113        let optional = if required_fields.contains(&prop_name.as_str()) {
114            ""
115        } else {
116            "?"
117        };
118        fields.push(format!("  {prop_name}{optional}: {ts_type};"));
119    }
120
121    Some(format!(
122        "export interface {name} {{\n{}\n}}\n",
123        fields.join("\n")
124    ))
125}
126
127fn openapi_type_to_ts(schema: &serde_json::Value) -> &'static str {
128    // Check for $ref — treat as unknown
129    if schema.get("$ref").is_some() {
130        return "unknown";
131    }
132
133    let type_val = schema.get("type").and_then(|t| t.as_str());
134    let format_val = schema.get("format").and_then(|f| f.as_str());
135
136    match (type_val, format_val) {
137        (Some("string"), _) => "string",
138        (Some("integer"), _) | (Some("number"), _) => "number",
139        (Some("boolean"), _) => "boolean",
140        (Some("array"), _) => "unknown[]",
141        (Some("object"), _) => "Record<string, unknown>",
142        _ => "unknown",
143    }
144}
145
146fn to_pascal_case(s: &str) -> String {
147    s.split('_')
148        .map(|word| {
149            let mut chars = word.chars();
150            match chars.next() {
151                None => String::new(),
152                Some(c) => {
153                    let upper: String = c.to_uppercase().collect();
154                    upper + &chars.as_str().to_lowercase()
155                }
156            }
157        })
158        .collect()
159}
160
161#[cfg(test)]
162mod tests {
163    use super::*;
164    use indexmap::IndexMap;
165    use shaperail_core::{
166        AuthRule, CacheSpec, EndpointSpec, FieldSchema, FieldType, HttpMethod, PaginationStyle,
167        ResourceDefinition,
168    };
169
170    fn test_config() -> shaperail_core::ProjectConfig {
171        shaperail_core::ProjectConfig {
172            project: "test-api".to_string(),
173            port: 3000,
174            workers: shaperail_core::WorkerCount::Auto,
175            database: None,
176            databases: None,
177            cache: None,
178            auth: None,
179            storage: None,
180            logging: None,
181            events: None,
182        }
183    }
184
185    fn sample_resource() -> ResourceDefinition {
186        let mut schema = IndexMap::new();
187        schema.insert(
188            "id".to_string(),
189            FieldSchema {
190                field_type: FieldType::Uuid,
191                primary: true,
192                generated: true,
193                required: false,
194                unique: false,
195                nullable: false,
196                reference: None,
197                min: None,
198                max: None,
199                format: None,
200                values: None,
201                default: None,
202                sensitive: false,
203                search: false,
204                items: None,
205            },
206        );
207        schema.insert(
208            "name".to_string(),
209            FieldSchema {
210                field_type: FieldType::String,
211                primary: false,
212                generated: false,
213                required: true,
214                unique: false,
215                nullable: false,
216                reference: None,
217                min: None,
218                max: None,
219                format: None,
220                values: None,
221                default: None,
222                sensitive: false,
223                search: false,
224                items: None,
225            },
226        );
227        schema.insert(
228            "active".to_string(),
229            FieldSchema {
230                field_type: FieldType::Boolean,
231                primary: false,
232                generated: false,
233                required: false,
234                unique: false,
235                nullable: true,
236                reference: None,
237                min: None,
238                max: None,
239                format: None,
240                values: None,
241                default: None,
242                sensitive: false,
243                search: false,
244                items: None,
245            },
246        );
247
248        let mut endpoints = IndexMap::new();
249        endpoints.insert(
250            "list".to_string(),
251            EndpointSpec {
252                method: HttpMethod::Get,
253                path: "/items".to_string(),
254                auth: Some(AuthRule::Roles(vec!["member".to_string()])),
255                input: None,
256                filters: None,
257                search: None,
258                pagination: Some(PaginationStyle::Cursor),
259                sort: None,
260                cache: Some(CacheSpec {
261                    ttl: 60,
262                    invalidate_on: None,
263                }),
264                controller: None,
265                events: None,
266                jobs: None,
267                upload: None,
268                soft_delete: false,
269            },
270        );
271        endpoints.insert(
272            "create".to_string(),
273            EndpointSpec {
274                method: HttpMethod::Post,
275                path: "/items".to_string(),
276                auth: Some(AuthRule::Roles(vec!["admin".to_string()])),
277                input: Some(vec!["name".to_string(), "active".to_string()]),
278                filters: None,
279                search: None,
280                pagination: None,
281                sort: None,
282                cache: None,
283                controller: None,
284                events: None,
285                jobs: None,
286                upload: None,
287                soft_delete: false,
288            },
289        );
290
291        ResourceDefinition {
292            resource: "items".to_string(),
293            version: 1,
294            db: None,
295            schema,
296            endpoints: Some(endpoints),
297            relations: None,
298            indexes: None,
299        }
300    }
301
302    #[test]
303    fn generates_ts_from_openapi_spec() {
304        let config = test_config();
305        let resources = vec![sample_resource()];
306        let spec = crate::openapi::generate(&config, &resources);
307        let files = generate_from_spec(&spec);
308
309        assert!(files.contains_key("items.ts"), "items.ts generated");
310        assert!(files.contains_key("index.ts"), "index.ts generated");
311    }
312
313    #[test]
314    fn ts_contains_interfaces() {
315        let config = test_config();
316        let resources = vec![sample_resource()];
317        let spec = crate::openapi::generate(&config, &resources);
318        let files = generate_from_spec(&spec);
319
320        let items_ts = &files["items.ts"];
321        assert!(
322            items_ts.contains("export interface Items"),
323            "main interface"
324        );
325        assert!(
326            items_ts.contains("export interface ItemsCreateInput"),
327            "input interface"
328        );
329    }
330
331    #[test]
332    fn ts_field_types_correct() {
333        let config = test_config();
334        let resources = vec![sample_resource()];
335        let spec = crate::openapi::generate(&config, &resources);
336        let files = generate_from_spec(&spec);
337
338        let items_ts = &files["items.ts"];
339        assert!(items_ts.contains("id?: string;"), "uuid → optional string");
340        assert!(items_ts.contains("name: string;"), "required string");
341        assert!(
342            items_ts.contains("active?: boolean;"),
343            "nullable boolean optional"
344        );
345    }
346
347    #[test]
348    fn ts_index_reexports() {
349        let config = test_config();
350        let resources = vec![sample_resource()];
351        let spec = crate::openapi::generate(&config, &resources);
352        let files = generate_from_spec(&spec);
353
354        let index = &files["index.ts"];
355        assert!(index.contains("export * from './items';"));
356    }
357
358    #[test]
359    fn deterministic_ts_output() {
360        let config = test_config();
361        let resources = vec![sample_resource()];
362        let spec = crate::openapi::generate(&config, &resources);
363
364        let files1 = generate_from_spec(&spec);
365        let files2 = generate_from_spec(&spec);
366
367        assert_eq!(files1, files2, "TS SDK output must be deterministic");
368    }
369}
shaperail_codegen/typescript.rs

shaperail_codegen/
typescript.rs
