rorpc_parse/codegen/
error_derive.rs

1//! Code generation for `#[derive(OrpcError)]`.
2//!
3//! Registers error enum variants with rorpc via `inventory::submit!` so
4//! `generate_contract()` can emit TypeScript `.errors({...})` entries.
5
6use proc_macro2::TokenStream;
7use quote::quote;
8use syn::{Data, DeriveInput, Fields};
9
10use crate::{
11    errors::Result,
12    types::{OPTION, VEC, try_extract_wrapper},
13};
14
15// ---------------------------------------------------------------------------
16// Public entry point
17// ---------------------------------------------------------------------------
18
19/// Generate the `#[derive(OrpcError)]` expansion.
20pub fn expand_orpc_errors(input: DeriveInput) -> Result<TokenStream> {
21    let enum_name = &input.ident;
22    let enum_name_str = enum_name.to_string();
23
24    let variants = match &input.data {
25        Data::Enum(data) => &data.variants,
26        _ => {
27            return Err(syn::Error::new_spanned(
28                &input.ident,
29                "#[derive(OrpcError)] can only be used on enums",
30            )
31            .into());
32        }
33    };
34
35    let mut variant_tokens: Vec<TokenStream> = Vec::new();
36
37    for variant in variants {
38        let variant_name_screaming = to_screaming_snake_case(&variant.ident.to_string());
39
40        let data_schema = match &variant.fields {
41            Fields::Unit => quote! { None },
42            Fields::Unnamed(fields) => {
43                let schemas: Vec<String> = fields
44                    .unnamed
45                    .iter()
46                    .map(|f| zod_schema_for_type(&f.ty))
47                    .collect();
48                let schema = if schemas.len() == 1 {
49                    schemas.into_iter().next().unwrap()
50                } else {
51                    format!("z.tuple([{}])", schemas.join(", "))
52                };
53                quote! { Some(#schema) }
54            }
55            Fields::Named(fields) => {
56                let field_schemas: Vec<String> = fields
57                    .named
58                    .iter()
59                    .map(|f| {
60                        let name = f.ident.as_ref().unwrap().to_string();
61                        let schema = zod_schema_for_type(&f.ty);
62                        format!("{}: {}", name, schema)
63                    })
64                    .collect();
65                let schema = format!("z.object({{ {} }})", field_schemas.join(", "));
66                quote! { Some(#schema) }
67            }
68        };
69
70        variant_tokens.push(quote! {
71            ::rorpc::ErrorVariant {
72                name: #variant_name_screaming,
73                data_schema: #data_schema,
74            }
75        });
76    }
77
78    Ok(quote! {
79        const _: () = {
80            ::rorpc::inventory::submit! {
81                ::rorpc::ErrorRegistration {
82                    type_name: #enum_name_str,
83                    variants: &[
84                        #(#variant_tokens),*
85                    ],
86                }
87            }
88        };
89    })
90}
91
92// ---------------------------------------------------------------------------
93// Type → Zod schema string
94//
95// Uses AST-based wrapper detection for Option<T> and Vec<T>.
96// ---------------------------------------------------------------------------
97
98fn zod_schema_for_type(ty: &syn::Type) -> String {
99    // Option<T>
100    if let Some(m) = try_extract_wrapper(ty, OPTION) {
101        if let Some(inner) = m.first_type() {
102            return format!("{}.optional()", zod_schema_for_type(inner));
103        }
104        return "z.unknown().optional()".to_string();
105    }
106
107    // Vec<T>
108    if let Some(m) = try_extract_wrapper(ty, VEC) {
109        if let Some(inner) = m.first_type() {
110            return format!("z.array({})", zod_schema_for_type(inner));
111        }
112        return "z.array(z.unknown())".to_string();
113    }
114
115    // HashMap<K, V>
116    if let Some(m) = try_extract_wrapper(ty, crate::types::HASHMAP) {
117        let types = m.all_types();
118        if types.len() == 2 {
119            let key_schema = zod_schema_for_type(&types[0]);
120            let value_schema = zod_schema_for_type(&types[1]);
121            return format!("z.record({}, {})", key_schema, value_schema);
122        }
123        return "z.record(z.string(), z.unknown())".to_string();
124    }
125
126    // Path types — check final segment ident
127    if let syn::Type::Path(type_path) = ty
128        && let Some(seg) = type_path.path.segments.last()
129    {
130        return match seg.ident.to_string().as_str() {
131            "String" | "str" => "z.string()".to_string(),
132            "i8" | "i16" | "i32" | "i64" | "i128" | "isize" | "u8" | "u16" | "u32" | "u64"
133            | "u128" | "usize" => "z.number().int()".to_string(),
134            "f32" | "f64" => "z.number()".to_string(),
135            "bool" => "z.boolean()".to_string(),
136            "Value" => "z.record(z.string(), z.unknown())".to_string(),
137            // Custom types without #[derive(ZodTs)] cannot be introspected here —
138            // the macro only sees the field's type name, not its internal fields.
139            // Emit z.unknown() so the contract is always valid TypeScript.
140            // To get a precise schema, add #[derive(ZodTs)] to the inner type.
141            _other => "z.unknown()".to_string(),
142        };
143    }
144
145    // Unit type ()
146    if let syn::Type::Tuple(t) = ty
147        && t.elems.is_empty()
148    {
149        return "z.void()".to_string();
150    }
151
152    "z.unknown()".to_string()
153}
154
155// ---------------------------------------------------------------------------
156// Naming helpers
157// ---------------------------------------------------------------------------
158
159/// Convert `PascalCase` to `SCREAMING_SNAKE_CASE`.
160fn to_screaming_snake_case(name: &str) -> String {
161    let mut out = String::new();
162    let mut prev_lower = false;
163    for (i, ch) in name.chars().enumerate() {
164        if ch.is_uppercase() && i > 0 && prev_lower {
165            out.push('_');
166        }
167        out.push(ch.to_ascii_uppercase());
168        prev_lower = ch.is_ascii_lowercase();
169    }
170    out
171}
172
173// ---------------------------------------------------------------------------
174// Tests
175// ---------------------------------------------------------------------------
176
177#[cfg(test)]
178mod tests {
179    use super::*;
180
181    #[test]
182    fn screaming_snake_case() {
183        assert_eq!(to_screaming_snake_case("NotFound"), "NOT_FOUND");
184        assert_eq!(to_screaming_snake_case("DatabaseError"), "DATABASE_ERROR");
185        assert_eq!(
186            to_screaming_snake_case("RateLimitExceeded"),
187            "RATE_LIMIT_EXCEEDED"
188        );
189        assert_eq!(to_screaming_snake_case("OK"), "OK");
190        assert_eq!(to_screaming_snake_case("NotFoundError"), "NOT_FOUND_ERROR");
191    }
192
193    #[test]
194    fn zod_schema_primitives() {
195        let string_ty: syn::Type = syn::parse_str("String").unwrap();
196        assert_eq!(zod_schema_for_type(&string_ty), "z.string()");
197
198        let i32_ty: syn::Type = syn::parse_str("i32").unwrap();
199        assert_eq!(zod_schema_for_type(&i32_ty), "z.number().int()");
200
201        let f64_ty: syn::Type = syn::parse_str("f64").unwrap();
202        assert_eq!(zod_schema_for_type(&f64_ty), "z.number()");
203
204        let bool_ty: syn::Type = syn::parse_str("bool").unwrap();
205        assert_eq!(zod_schema_for_type(&bool_ty), "z.boolean()");
206    }
207
208    #[test]
209    fn zod_schema_option() {
210        let ty: syn::Type = syn::parse_str("Option<String>").unwrap();
211        assert_eq!(zod_schema_for_type(&ty), "z.string().optional()");
212    }
213
214    #[test]
215    fn zod_schema_qualified_option() {
216        // core::option::Option — matches on final segment
217        let ty: syn::Type = syn::parse_str("core::option::Option<i32>").unwrap();
218        assert_eq!(zod_schema_for_type(&ty), "z.number().int().optional()");
219    }
220
221    #[test]
222    fn zod_schema_vec() {
223        let ty: syn::Type = syn::parse_str("Vec<String>").unwrap();
224        assert_eq!(zod_schema_for_type(&ty), "z.array(z.string())");
225    }
226
227    #[test]
228    fn zod_schema_hashmap() {
229        let ty: syn::Type = syn::parse_str("HashMap<String, String>").unwrap();
230        assert_eq!(zod_schema_for_type(&ty), "z.record(z.string(), z.string())");
231    }
232
233    #[test]
234    fn zod_schema_hashmap_with_int_value() {
235        let ty: syn::Type = syn::parse_str("HashMap<String, i32>").unwrap();
236        assert_eq!(zod_schema_for_type(&ty), "z.record(z.string(), z.number().int())");
237    }
238
239    #[test]
240    fn zod_schema_custom_type() {
241        // Custom types without #[derive(ZodTs)] cannot be introspected at macro time —
242        // the macro only sees the type name, not its internal fields.
243        // Falls back to z.unknown() so generated contracts always compile.
244        let ty: syn::Type = syn::parse_str("Planet").unwrap();
245        assert_eq!(zod_schema_for_type(&ty), "z.unknown()");
246    }
247
248    #[test]
249    fn zod_schema_value() {
250        let ty: syn::Type = syn::parse_str("serde_json::Value").unwrap();
251        assert_eq!(
252            zod_schema_for_type(&ty),
253            "z.record(z.string(), z.unknown())"
254        );
255    }
256
257    #[test]
258    fn expand_unit_enum() {
259        let input: DeriveInput = syn::parse_quote! {
260            enum AppError { NotFound, Conflict }
261        };
262        let ts = expand_orpc_errors(input).unwrap();
263        let code = ts.to_string();
264        assert!(code.contains("NOT_FOUND"));
265        assert!(code.contains("CONFLICT"));
266        assert!(code.contains("None"));
267    }
268
269    #[test]
270    fn expand_rejects_struct() {
271        let input: DeriveInput = syn::parse_quote! {
272            struct NotAnEnum { field: String }
273        };
274        assert!(expand_orpc_errors(input).is_err());
275    }
276}
rorpc_parse/codegen/error_derive.rs

rorpc_parse/codegen/
error_derive.rs
