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    // Path types — check final segment ident
116    if let syn::Type::Path(type_path) = ty
117        && let Some(seg) = type_path.path.segments.last()
118    {
119        return match seg.ident.to_string().as_str() {
120            "String" | "str" => "z.string()".to_string(),
121            "i8" | "i16" | "i32" | "i64" | "i128" | "isize" | "u8" | "u16" | "u32" | "u64"
122            | "u128" | "usize" => "z.number().int()".to_string(),
123            "f32" | "f64" => "z.number()".to_string(),
124            "bool" => "z.boolean()".to_string(),
125            "Value" => "z.any()".to_string(),
126            other => format!("{}Schema", other),
127        };
128    }
129
130    // Unit type ()
131    if let syn::Type::Tuple(t) = ty
132        && t.elems.is_empty()
133    {
134        return "z.void()".to_string();
135    }
136
137    "z.unknown()".to_string()
138}
139
140// ---------------------------------------------------------------------------
141// Naming helpers
142// ---------------------------------------------------------------------------
143
144/// Convert `PascalCase` to `SCREAMING_SNAKE_CASE`.
145fn to_screaming_snake_case(name: &str) -> String {
146    let mut out = String::new();
147    let mut prev_lower = false;
148    for (i, ch) in name.chars().enumerate() {
149        if ch.is_uppercase() && i > 0 && prev_lower {
150            out.push('_');
151        }
152        out.push(ch.to_ascii_uppercase());
153        prev_lower = ch.is_ascii_lowercase();
154    }
155    out
156}
157
158// ---------------------------------------------------------------------------
159// Tests
160// ---------------------------------------------------------------------------
161
162#[cfg(test)]
163mod tests {
164    use super::*;
165
166    #[test]
167    fn screaming_snake_case() {
168        assert_eq!(to_screaming_snake_case("NotFound"), "NOT_FOUND");
169        assert_eq!(to_screaming_snake_case("DatabaseError"), "DATABASE_ERROR");
170        assert_eq!(
171            to_screaming_snake_case("RateLimitExceeded"),
172            "RATE_LIMIT_EXCEEDED"
173        );
174        assert_eq!(to_screaming_snake_case("OK"), "OK");
175        assert_eq!(to_screaming_snake_case("NotFoundError"), "NOT_FOUND_ERROR");
176    }
177
178    #[test]
179    fn zod_schema_primitives() {
180        let string_ty: syn::Type = syn::parse_str("String").unwrap();
181        assert_eq!(zod_schema_for_type(&string_ty), "z.string()");
182
183        let i32_ty: syn::Type = syn::parse_str("i32").unwrap();
184        assert_eq!(zod_schema_for_type(&i32_ty), "z.number().int()");
185
186        let f64_ty: syn::Type = syn::parse_str("f64").unwrap();
187        assert_eq!(zod_schema_for_type(&f64_ty), "z.number()");
188
189        let bool_ty: syn::Type = syn::parse_str("bool").unwrap();
190        assert_eq!(zod_schema_for_type(&bool_ty), "z.boolean()");
191    }
192
193    #[test]
194    fn zod_schema_option() {
195        let ty: syn::Type = syn::parse_str("Option<String>").unwrap();
196        assert_eq!(zod_schema_for_type(&ty), "z.string().optional()");
197    }
198
199    #[test]
200    fn zod_schema_qualified_option() {
201        // core::option::Option — matches on final segment
202        let ty: syn::Type = syn::parse_str("core::option::Option<i32>").unwrap();
203        assert_eq!(zod_schema_for_type(&ty), "z.number().int().optional()");
204    }
205
206    #[test]
207    fn zod_schema_vec() {
208        let ty: syn::Type = syn::parse_str("Vec<String>").unwrap();
209        assert_eq!(zod_schema_for_type(&ty), "z.array(z.string())");
210    }
211
212    #[test]
213    fn zod_schema_custom_type() {
214        let ty: syn::Type = syn::parse_str("Planet").unwrap();
215        assert_eq!(zod_schema_for_type(&ty), "PlanetSchema");
216    }
217
218    #[test]
219    fn zod_schema_value() {
220        let ty: syn::Type = syn::parse_str("serde_json::Value").unwrap();
221        assert_eq!(zod_schema_for_type(&ty), "z.any()");
222    }
223
224    #[test]
225    fn expand_unit_enum() {
226        let input: DeriveInput = syn::parse_quote! {
227            enum AppError { NotFound, Conflict }
228        };
229        let ts = expand_orpc_errors(input).unwrap();
230        let code = ts.to_string();
231        assert!(code.contains("NOT_FOUND"));
232        assert!(code.contains("CONFLICT"));
233        assert!(code.contains("None"));
234    }
235
236    #[test]
237    fn expand_rejects_struct() {
238        let input: DeriveInput = syn::parse_quote! {
239            struct NotAnEnum { field: String }
240        };
241        assert!(expand_orpc_errors(input).is_err());
242    }
243}
rorpc_parse/codegen/error_derive.rs

rorpc_parse/codegen/
error_derive.rs
