rusty_gql/resolver/
list.rs

1use std::collections::{HashSet, LinkedList, VecDeque};
2
3use crate::{
4    CollectFields, Context, FieldResolver, GqlValue, ResolverResult, SelectionSetContext,
5    SelectionSetResolver,
6};
7
8#[async_trait::async_trait]
9impl<T: FieldResolver, const N: usize> FieldResolver for [T; N] {
10    async fn resolve_field(&self, ctx: &Context<'_>) -> ResolverResult<Option<GqlValue>> {
11        let mut result = Vec::new();
12        for value in self {
13            if let Some(v) = value.resolve_field(ctx).await? {
14                result.push(v);
15            }
16        }
17        Ok(Some(GqlValue::List(result)))
18    }
19
20    fn type_name() -> String {
21        format!("[{}]!", T::type_name())
22    }
23}
24
25impl<T: FieldResolver, const N: usize> CollectFields for [T; N] {}
26
27#[async_trait::async_trait]
28impl<T: SelectionSetResolver, const N: usize> SelectionSetResolver for [T; N] {
29    async fn resolve_selection_set(
30        &self,
31        ctx: &SelectionSetContext<'_>,
32    ) -> ResolverResult<GqlValue> {
33        let mut result = Vec::new();
34        for value in self {
35            let v = value.resolve_selection_set(ctx).await?;
36            result.push(v);
37        }
38        Ok(GqlValue::List(result))
39    }
40}
41
42#[async_trait::async_trait]
43impl<T: FieldResolver> FieldResolver for HashSet<T> {
44    async fn resolve_field(&self, ctx: &Context<'_>) -> ResolverResult<Option<GqlValue>> {
45        let mut result = Vec::new();
46        for value in self {
47            if let Some(v) = value.resolve_field(ctx).await? {
48                result.push(v);
49            }
50        }
51        Ok(Some(GqlValue::List(result)))
52    }
53    fn type_name() -> String {
54        format!("[{}]!", T::type_name())
55    }
56}
57
58impl<T: FieldResolver> CollectFields for HashSet<T> {}
59
60#[async_trait::async_trait]
61impl<T: SelectionSetResolver> SelectionSetResolver for HashSet<T> {
62    async fn resolve_selection_set(
63        &self,
64        ctx: &SelectionSetContext<'_>,
65    ) -> ResolverResult<GqlValue> {
66        let mut result = Vec::new();
67        for value in self {
68            let v = value.resolve_selection_set(ctx).await?;
69            result.push(v);
70        }
71        Ok(GqlValue::List(result))
72    }
73}
74
75#[async_trait::async_trait]
76impl<'a, T: FieldResolver + 'a> FieldResolver for &'a [T] {
77    async fn resolve_field(&self, ctx: &Context<'_>) -> ResolverResult<Option<GqlValue>> {
78        let mut result = Vec::new();
79        for value in self.iter() {
80            if let Some(v) = value.resolve_field(ctx).await? {
81                result.push(v);
82            }
83        }
84        Ok(Some(GqlValue::List(result)))
85    }
86    fn type_name() -> String {
87        format!("[{}]!", T::type_name())
88    }
89}
90
91impl<'a, T: FieldResolver + 'a> CollectFields for &'a [T] {}
92
93#[async_trait::async_trait]
94impl<'a, T: SelectionSetResolver + 'a> SelectionSetResolver for &'a [T] {
95    async fn resolve_selection_set(
96        &self,
97        ctx: &SelectionSetContext<'_>,
98    ) -> ResolverResult<GqlValue> {
99        let mut result = Vec::new();
100        for value in self.iter() {
101            let v = value.resolve_selection_set(ctx).await?;
102            result.push(v);
103        }
104        Ok(GqlValue::List(result))
105    }
106}
107
108#[async_trait::async_trait]
109impl<T: FieldResolver> FieldResolver for VecDeque<T> {
110    async fn resolve_field(&self, ctx: &Context<'_>) -> ResolverResult<Option<GqlValue>> {
111        let mut result = Vec::new();
112        for value in self.iter() {
113            if let Some(v) = value.resolve_field(ctx).await? {
114                result.push(v);
115            }
116        }
117        Ok(Some(GqlValue::List(result)))
118    }
119    fn type_name() -> String {
120        format!("[{}]!", T::type_name())
121    }
122}
123
124impl<T: FieldResolver> CollectFields for VecDeque<T> {}
125
126#[async_trait::async_trait]
127impl<T: SelectionSetResolver> SelectionSetResolver for VecDeque<T> {
128    async fn resolve_selection_set(
129        &self,
130        ctx: &SelectionSetContext<'_>,
131    ) -> ResolverResult<GqlValue> {
132        let mut result = Vec::new();
133        for value in self.iter() {
134            let v = value.resolve_selection_set(ctx).await?;
135            result.push(v);
136        }
137        Ok(GqlValue::List(result))
138    }
139}
140
141#[async_trait::async_trait]
142impl<T: FieldResolver> FieldResolver for LinkedList<T> {
143    async fn resolve_field(&self, ctx: &Context<'_>) -> ResolverResult<Option<GqlValue>> {
144        let mut result = Vec::new();
145        for value in self.iter() {
146            if let Some(v) = value.resolve_field(ctx).await? {
147                result.push(v);
148            }
149        }
150        Ok(Some(GqlValue::List(result)))
151    }
152    fn type_name() -> String {
153        format!("[{}]!", T::type_name())
154    }
155}
156
157impl<T: FieldResolver> CollectFields for LinkedList<T> {}
158
159#[async_trait::async_trait]
160impl<T: SelectionSetResolver> SelectionSetResolver for LinkedList<T> {
161    async fn resolve_selection_set(
162        &self,
163        ctx: &SelectionSetContext<'_>,
164    ) -> ResolverResult<GqlValue> {
165        let mut result = Vec::new();
166        for value in self.iter() {
167            let v = value.resolve_selection_set(ctx).await?;
168            result.push(v);
169        }
170        Ok(GqlValue::List(result))
171    }
172}
173
174#[async_trait::async_trait]
175impl<T: FieldResolver> FieldResolver for Vec<T> {
176    async fn resolve_field(&self, ctx: &Context<'_>) -> ResolverResult<Option<GqlValue>> {
177        let mut result = Vec::new();
178        for value in self.iter() {
179            if let Some(v) = value.resolve_field(ctx).await? {
180                result.push(v);
181            }
182        }
183        Ok(Some(GqlValue::List(result)))
184    }
185    fn type_name() -> String {
186        format!("[{}]!", T::type_name())
187    }
188}
189
190impl<T: FieldResolver> CollectFields for Vec<T> {}
191
192#[async_trait::async_trait]
193impl<T: SelectionSetResolver> SelectionSetResolver for Vec<T> {
194    async fn resolve_selection_set(
195        &self,
196        ctx: &SelectionSetContext<'_>,
197    ) -> ResolverResult<GqlValue> {
198        let mut result = Vec::new();
199        for value in self.iter() {
200            let v = value.resolve_selection_set(ctx).await?;
201            result.push(v);
202        }
203        Ok(GqlValue::List(result))
204    }
205}
rusty_gql/resolver/list.rs

rusty_gql/resolver/
list.rs
