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            cache: None,
177            auth: None,
178            storage: None,
179            logging: None,
180            events: None,
181        }
182    }
183
184    fn sample_resource() -> ResourceDefinition {
185        let mut schema = IndexMap::new();
186        schema.insert(
187            "id".to_string(),
188            FieldSchema {
189                field_type: FieldType::Uuid,
190                primary: true,
191                generated: true,
192                required: false,
193                unique: false,
194                nullable: false,
195                reference: None,
196                min: None,
197                max: None,
198                format: None,
199                values: None,
200                default: None,
201                sensitive: false,
202                search: false,
203                items: None,
204            },
205        );
206        schema.insert(
207            "name".to_string(),
208            FieldSchema {
209                field_type: FieldType::String,
210                primary: false,
211                generated: false,
212                required: true,
213                unique: false,
214                nullable: false,
215                reference: None,
216                min: None,
217                max: None,
218                format: None,
219                values: None,
220                default: None,
221                sensitive: false,
222                search: false,
223                items: None,
224            },
225        );
226        schema.insert(
227            "active".to_string(),
228            FieldSchema {
229                field_type: FieldType::Boolean,
230                primary: false,
231                generated: false,
232                required: false,
233                unique: false,
234                nullable: true,
235                reference: None,
236                min: None,
237                max: None,
238                format: None,
239                values: None,
240                default: None,
241                sensitive: false,
242                search: false,
243                items: None,
244            },
245        );
246
247        let mut endpoints = IndexMap::new();
248        endpoints.insert(
249            "list".to_string(),
250            EndpointSpec {
251                method: HttpMethod::Get,
252                path: "/items".to_string(),
253                auth: Some(AuthRule::Roles(vec!["member".to_string()])),
254                input: None,
255                filters: None,
256                search: None,
257                pagination: Some(PaginationStyle::Cursor),
258                sort: None,
259                cache: Some(CacheSpec {
260                    ttl: 60,
261                    invalidate_on: None,
262                }),
263                controller: None,
264                events: None,
265                jobs: None,
266                upload: None,
267                soft_delete: false,
268            },
269        );
270        endpoints.insert(
271            "create".to_string(),
272            EndpointSpec {
273                method: HttpMethod::Post,
274                path: "/items".to_string(),
275                auth: Some(AuthRule::Roles(vec!["admin".to_string()])),
276                input: Some(vec!["name".to_string(), "active".to_string()]),
277                filters: None,
278                search: None,
279                pagination: None,
280                sort: None,
281                cache: None,
282                controller: None,
283                events: None,
284                jobs: None,
285                upload: None,
286                soft_delete: false,
287            },
288        );
289
290        ResourceDefinition {
291            resource: "items".to_string(),
292            version: 1,
293            schema,
294            endpoints: Some(endpoints),
295            relations: None,
296            indexes: None,
297        }
298    }
299
300    #[test]
301    fn generates_ts_from_openapi_spec() {
302        let config = test_config();
303        let resources = vec![sample_resource()];
304        let spec = crate::openapi::generate(&config, &resources);
305        let files = generate_from_spec(&spec);
306
307        assert!(files.contains_key("items.ts"), "items.ts generated");
308        assert!(files.contains_key("index.ts"), "index.ts generated");
309    }
310
311    #[test]
312    fn ts_contains_interfaces() {
313        let config = test_config();
314        let resources = vec![sample_resource()];
315        let spec = crate::openapi::generate(&config, &resources);
316        let files = generate_from_spec(&spec);
317
318        let items_ts = &files["items.ts"];
319        assert!(
320            items_ts.contains("export interface Items"),
321            "main interface"
322        );
323        assert!(
324            items_ts.contains("export interface ItemsCreateInput"),
325            "input interface"
326        );
327    }
328
329    #[test]
330    fn ts_field_types_correct() {
331        let config = test_config();
332        let resources = vec![sample_resource()];
333        let spec = crate::openapi::generate(&config, &resources);
334        let files = generate_from_spec(&spec);
335
336        let items_ts = &files["items.ts"];
337        assert!(items_ts.contains("id?: string;"), "uuid → optional string");
338        assert!(items_ts.contains("name: string;"), "required string");
339        assert!(
340            items_ts.contains("active?: boolean;"),
341            "nullable boolean optional"
342        );
343    }
344
345    #[test]
346    fn ts_index_reexports() {
347        let config = test_config();
348        let resources = vec![sample_resource()];
349        let spec = crate::openapi::generate(&config, &resources);
350        let files = generate_from_spec(&spec);
351
352        let index = &files["index.ts"];
353        assert!(index.contains("export * from './items';"));
354    }
355
356    #[test]
357    fn deterministic_ts_output() {
358        let config = test_config();
359        let resources = vec![sample_resource()];
360        let spec = crate::openapi::generate(&config, &resources);
361
362        let files1 = generate_from_spec(&spec);
363        let files2 = generate_from_spec(&spec);
364
365        assert_eq!(files1, files2, "TS SDK output must be deterministic");
366    }
367}
shaperail_codegen/typescript.rs

shaperail_codegen/
typescript.rs
