Skip to main content

gqlrs_derive/
lib.rs

1#![allow(clippy::cognitive_complexity)]
2#![allow(clippy::vec_init_then_push)]
3#![allow(clippy::uninlined_format_args)]
4#![forbid(unsafe_code)]
5
6extern crate proc_macro;
7
8mod args;
9mod complex_interface;
10mod complex_object;
11mod description;
12mod directive;
13mod r#enum;
14mod input_object;
15mod interface;
16mod merged_object;
17mod merged_subscription;
18mod newtype;
19mod object;
20mod oneof_object;
21mod output_type;
22mod scalar;
23mod simple_object;
24mod subscription;
25mod type_directive;
26mod union;
27mod utils;
28mod validators;
29
30use darling::{FromDeriveInput, FromMeta};
31use proc_macro::TokenStream;
32use syn::{DeriveInput, ItemFn, ItemImpl, parse_macro_input};
33
34macro_rules! parse_nested_meta {
35    ($ty:ty, $args:expr) => {{
36        let meta = match darling::ast::NestedMeta::parse_meta_list(proc_macro2::TokenStream::from(
37            $args,
38        )) {
39            Ok(v) => v,
40            Err(e) => {
41                return TokenStream::from(darling::Error::from(e).write_errors());
42            }
43        };
44
45        match <$ty>::from_list(&meta) {
46            Ok(object_args) => object_args,
47            Err(err) => return TokenStream::from(err.write_errors()),
48        }
49    }};
50}
51
52#[proc_macro_attribute]
53#[allow(non_snake_case)]
54pub fn Object(args: TokenStream, input: TokenStream) -> TokenStream {
55    let object_args = parse_nested_meta!(args::Object, args);
56    let mut item_impl = parse_macro_input!(input as ItemImpl);
57    match object::generate(&object_args, &mut item_impl) {
58        Ok(expanded) => expanded,
59        Err(err) => err.write_errors().into(),
60    }
61}
62
63#[proc_macro_derive(SimpleObject, attributes(graphql))]
64pub fn derive_simple_object(input: TokenStream) -> TokenStream {
65    let object_args =
66        match args::SimpleObject::from_derive_input(&parse_macro_input!(input as DeriveInput)) {
67            Ok(object_args) => object_args,
68            Err(err) => return TokenStream::from(err.write_errors()),
69        };
70    match simple_object::generate(&object_args) {
71        Ok(expanded) => expanded,
72        Err(err) => err.write_errors().into(),
73    }
74}
75
76#[proc_macro_attribute]
77#[allow(non_snake_case)]
78pub fn ComplexObject(args: TokenStream, input: TokenStream) -> TokenStream {
79    let object_args = parse_nested_meta!(args::ComplexObject, args);
80    let mut item_impl = parse_macro_input!(input as ItemImpl);
81    match complex_object::generate(&object_args, &mut item_impl) {
82        Ok(expanded) => expanded,
83        Err(err) => err.write_errors().into(),
84    }
85}
86
87#[proc_macro_attribute]
88#[allow(non_snake_case)]
89pub fn ComplexInterface(args: TokenStream, input: TokenStream) -> TokenStream {
90    let interface_args = parse_nested_meta!(args::ComplexInterface, args);
91    let mut item_impl = parse_macro_input!(input as ItemImpl);
92    match complex_interface::generate(&interface_args, &mut item_impl) {
93        Ok(expanded) => expanded,
94        Err(err) => err.write_errors().into(),
95    }
96}
97
98#[proc_macro_derive(Enum, attributes(graphql))]
99pub fn derive_enum(input: TokenStream) -> TokenStream {
100    let enum_args = match args::Enum::from_derive_input(&parse_macro_input!(input as DeriveInput)) {
101        Ok(enum_args) => enum_args,
102        Err(err) => return TokenStream::from(err.write_errors()),
103    };
104    match r#enum::generate(&enum_args) {
105        Ok(expanded) => expanded,
106        Err(err) => err.write_errors().into(),
107    }
108}
109
110#[proc_macro_derive(InputObject, attributes(graphql))]
111pub fn derive_input_object(input: TokenStream) -> TokenStream {
112    let object_args =
113        match args::InputObject::from_derive_input(&parse_macro_input!(input as DeriveInput)) {
114            Ok(object_args) => object_args,
115            Err(err) => return TokenStream::from(err.write_errors()),
116        };
117    match input_object::generate(&object_args) {
118        Ok(expanded) => expanded,
119        Err(err) => err.write_errors().into(),
120    }
121}
122
123#[proc_macro_derive(Interface, attributes(graphql))]
124pub fn derive_interface(input: TokenStream) -> TokenStream {
125    let interface_args =
126        match args::Interface::from_derive_input(&parse_macro_input!(input as DeriveInput)) {
127            Ok(interface_args) => interface_args,
128            Err(err) => return TokenStream::from(err.write_errors()),
129        };
130    match interface::generate(&interface_args) {
131        Ok(expanded) => expanded,
132        Err(err) => err.write_errors().into(),
133    }
134}
135
136#[proc_macro_derive(Union, attributes(graphql))]
137pub fn derive_union(input: TokenStream) -> TokenStream {
138    let union_args = match args::Union::from_derive_input(&parse_macro_input!(input as DeriveInput))
139    {
140        Ok(union_args) => union_args,
141        Err(err) => return TokenStream::from(err.write_errors()),
142    };
143    match union::generate(&union_args) {
144        Ok(expanded) => expanded,
145        Err(err) => err.write_errors().into(),
146    }
147}
148
149#[proc_macro_attribute]
150#[allow(non_snake_case)]
151pub fn Subscription(args: TokenStream, input: TokenStream) -> TokenStream {
152    let object_args = parse_nested_meta!(args::Subscription, args);
153    let mut item_impl = parse_macro_input!(input as ItemImpl);
154    match subscription::generate(&object_args, &mut item_impl) {
155        Ok(expanded) => expanded,
156        Err(err) => err.write_errors().into(),
157    }
158}
159
160#[proc_macro_attribute]
161#[allow(non_snake_case)]
162pub fn Scalar(args: TokenStream, input: TokenStream) -> TokenStream {
163    let scalar_args = parse_nested_meta!(args::Scalar, args);
164    let mut item_impl = parse_macro_input!(input as ItemImpl);
165    match scalar::generate(&scalar_args, &mut item_impl) {
166        Ok(expanded) => expanded,
167        Err(err) => err.write_errors().into(),
168    }
169}
170
171#[proc_macro_derive(MergedObject, attributes(graphql))]
172pub fn derive_merged_object(input: TokenStream) -> TokenStream {
173    let object_args =
174        match args::MergedObject::from_derive_input(&parse_macro_input!(input as DeriveInput)) {
175            Ok(object_args) => object_args,
176            Err(err) => return TokenStream::from(err.write_errors()),
177        };
178    match merged_object::generate(&object_args) {
179        Ok(expanded) => expanded,
180        Err(err) => err.write_errors().into(),
181    }
182}
183
184#[proc_macro_derive(MergedSubscription, attributes(graphql))]
185pub fn derive_merged_subscription(input: TokenStream) -> TokenStream {
186    let object_args = match args::MergedSubscription::from_derive_input(&parse_macro_input!(
187        input as DeriveInput
188    )) {
189        Ok(object_args) => object_args,
190        Err(err) => return TokenStream::from(err.write_errors()),
191    };
192    match merged_subscription::generate(&object_args) {
193        Ok(expanded) => expanded,
194        Err(err) => err.write_errors().into(),
195    }
196}
197
198#[proc_macro_derive(Description, attributes(graphql))]
199pub fn derive_description(input: TokenStream) -> TokenStream {
200    let desc_args =
201        match args::Description::from_derive_input(&parse_macro_input!(input as DeriveInput)) {
202            Ok(desc_args) => desc_args,
203            Err(err) => return TokenStream::from(err.write_errors()),
204        };
205    match description::generate(&desc_args) {
206        Ok(expanded) => expanded,
207        Err(err) => err.write_errors().into(),
208    }
209}
210
211#[proc_macro_derive(NewType, attributes(graphql))]
212pub fn derive_newtype(input: TokenStream) -> TokenStream {
213    let newtype_args =
214        match args::NewType::from_derive_input(&parse_macro_input!(input as DeriveInput)) {
215            Ok(newtype_args) => newtype_args,
216            Err(err) => return TokenStream::from(err.write_errors()),
217        };
218    match newtype::generate(&newtype_args) {
219        Ok(expanded) => expanded,
220        Err(err) => err.write_errors().into(),
221    }
222}
223
224#[proc_macro_attribute]
225#[allow(non_snake_case)]
226pub fn Directive(args: TokenStream, input: TokenStream) -> TokenStream {
227    let directive_args = parse_nested_meta!(args::Directive, args);
228    let mut item_fn = parse_macro_input!(input as ItemFn);
229    match directive::generate(&directive_args, &mut item_fn) {
230        Ok(expanded) => expanded,
231        Err(err) => err.write_errors().into(),
232    }
233}
234
235#[proc_macro_attribute]
236#[allow(non_snake_case)]
237pub fn TypeDirective(args: TokenStream, input: TokenStream) -> TokenStream {
238    let directive_args = parse_nested_meta!(args::TypeDirective, args);
239    let mut item_fn = parse_macro_input!(input as ItemFn);
240    match type_directive::generate(&directive_args, &mut item_fn) {
241        Ok(expanded) => expanded,
242        Err(err) => err.write_errors().into(),
243    }
244}
245
246#[proc_macro_derive(OneofObject, attributes(graphql))]
247pub fn derive_oneof_object(input: TokenStream) -> TokenStream {
248    let object_args =
249        match args::OneofObject::from_derive_input(&parse_macro_input!(input as DeriveInput)) {
250            Ok(object_args) => object_args,
251            Err(err) => return TokenStream::from(err.write_errors()),
252        };
253    match oneof_object::generate(&object_args) {
254        Ok(expanded) => expanded,
255        Err(err) => err.write_errors().into(),
256    }
257}