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}