lenra_app/gen/
manifest.rs

1use serde::{Deserialize, Serialize};
2///Element of type view
3#[derive(Clone, Debug, Deserialize, Serialize)]
4#[serde(deny_unknown_fields)]
5pub struct ComponentsView {
6    ///The context projection. This field represents the projection of the context, allowing selective retrieval of specific elements. It is a map that specifies the desired elements to be included in the projection.
7    #[serde(default, skip_serializing_if = "serde_json::Map::is_empty")]
8    pub context: serde_json::Map<String, serde_json::Value>,
9    #[serde(default, skip_serializing_if = "Option::is_none")]
10    pub find: Option<ComponentsViewDefinitionsFind>,
11    ///The name of the view
12    pub name: String,
13    #[serde(default, skip_serializing_if = "Option::is_none")]
14    pub props: Option<DefsProps>,
15    ///The identifier of the component
16    #[serde(rename = "_type")]
17    pub type_: serde_json::Value,
18}
19impl From<&ComponentsView> for ComponentsView {
20    fn from(value: &ComponentsView) -> Self {
21        value.clone()
22    }
23}
24impl ComponentsView {
25    pub fn builder() -> builder::ComponentsView {
26        builder::ComponentsView::default()
27    }
28}
29///Find query for view components
30#[derive(Clone, Debug, Deserialize, Serialize)]
31#[serde(deny_unknown_fields)]
32pub struct ComponentsViewDefinitionsFind {
33    ///the collection where the query is applied
34    pub coll: String,
35    #[serde(default, skip_serializing_if = "Option::is_none")]
36    pub projection: Option<DataProjection>,
37    pub query: DataQuery,
38}
39impl From<&ComponentsViewDefinitionsFind> for ComponentsViewDefinitionsFind {
40    fn from(value: &ComponentsViewDefinitionsFind) -> Self {
41        value.clone()
42    }
43}
44impl ComponentsViewDefinitionsFind {
45    pub fn builder() -> builder::ComponentsViewDefinitionsFind {
46        builder::ComponentsViewDefinitionsFind::default()
47    }
48}
49///Mongo data query projection
50#[derive(Clone, Debug, Deserialize, Serialize)]
51pub struct DataProjection(pub serde_json::Map<String, serde_json::Value>);
52impl std::ops::Deref for DataProjection {
53    type Target = serde_json::Map<String, serde_json::Value>;
54    fn deref(&self) -> &serde_json::Map<String, serde_json::Value> {
55        &self.0
56    }
57}
58impl From<DataProjection> for serde_json::Map<String, serde_json::Value> {
59    fn from(value: DataProjection) -> Self {
60        value.0
61    }
62}
63impl From<&DataProjection> for DataProjection {
64    fn from(value: &DataProjection) -> Self {
65        value.clone()
66    }
67}
68impl From<serde_json::Map<String, serde_json::Value>> for DataProjection {
69    fn from(value: serde_json::Map<String, serde_json::Value>) -> Self {
70        Self(value)
71    }
72}
73///Mongo data query
74#[derive(Clone, Debug, Deserialize, Serialize)]
75pub struct DataQuery(pub serde_json::Map<String, serde_json::Value>);
76impl std::ops::Deref for DataQuery {
77    type Target = serde_json::Map<String, serde_json::Value>;
78    fn deref(&self) -> &serde_json::Map<String, serde_json::Value> {
79        &self.0
80    }
81}
82impl From<DataQuery> for serde_json::Map<String, serde_json::Value> {
83    fn from(value: DataQuery) -> Self {
84        value.0
85    }
86}
87impl From<&DataQuery> for DataQuery {
88    fn from(value: &DataQuery) -> Self {
89        value.clone()
90    }
91}
92impl From<serde_json::Map<String, serde_json::Value>> for DataQuery {
93    fn from(value: serde_json::Map<String, serde_json::Value>) -> Self {
94        Self(value)
95    }
96}
97///Parameters passed to the listener
98#[derive(Clone, Debug, Deserialize, Serialize)]
99pub struct DefsProps(pub serde_json::Map<String, serde_json::Value>);
100impl std::ops::Deref for DefsProps {
101    type Target = serde_json::Map<String, serde_json::Value>;
102    fn deref(&self) -> &serde_json::Map<String, serde_json::Value> {
103        &self.0
104    }
105}
106impl From<DefsProps> for serde_json::Map<String, serde_json::Value> {
107    fn from(value: DefsProps) -> Self {
108        value.0
109    }
110}
111impl From<&DefsProps> for DefsProps {
112    fn from(value: &DefsProps) -> Self {
113        value.clone()
114    }
115}
116impl From<serde_json::Map<String, serde_json::Value>> for DefsProps {
117    fn from(value: serde_json::Map<String, serde_json::Value>) -> Self {
118        Self(value)
119    }
120}
121#[derive(Clone, Debug, Deserialize, Serialize)]
122#[serde(deny_unknown_fields)]
123pub struct Exposer {
124    ///The routes of the application for this exposer
125    pub routes: Vec<Route>,
126    ///The exposer API version
127    #[serde(default, skip_serializing_if = "Option::is_none")]
128    pub version: Option<String>,
129}
130impl From<&Exposer> for Exposer {
131    fn from(value: &Exposer) -> Self {
132        value.clone()
133    }
134}
135impl Exposer {
136    pub fn builder() -> builder::Exposer {
137        builder::Exposer::default()
138    }
139}
140///The Lenra application manifest
141#[derive(Clone, Debug, Deserialize, Serialize)]
142#[serde(deny_unknown_fields)]
143pub struct Manifest {
144    ///The JSON exposer definition of the application
145    #[serde(default, skip_serializing_if = "Option::is_none")]
146    pub json: Option<Exposer>,
147    ///The Lenra exposer definition of the application
148    #[serde(default, skip_serializing_if = "Option::is_none")]
149    pub lenra: Option<Exposer>,
150}
151impl From<&Manifest> for Manifest {
152    fn from(value: &Manifest) -> Self {
153        value.clone()
154    }
155}
156impl Manifest {
157    pub fn builder() -> builder::Manifest {
158        builder::Manifest::default()
159    }
160}
161#[derive(Clone, Debug, Deserialize, Serialize)]
162#[serde(deny_unknown_fields)]
163pub struct Route {
164    pub path: String,
165    pub view: ComponentsView,
166}
167impl From<&Route> for Route {
168    fn from(value: &Route) -> Self {
169        value.clone()
170    }
171}
172impl Route {
173    pub fn builder() -> builder::Route {
174        builder::Route::default()
175    }
176}
177pub mod builder {
178    #[derive(Clone, Debug)]
179    pub struct ComponentsView {
180        context: Result<serde_json::Map<String, serde_json::Value>, String>,
181        find: Result<Option<super::ComponentsViewDefinitionsFind>, String>,
182        name: Result<String, String>,
183        props: Result<Option<super::DefsProps>, String>,
184        type_: Result<serde_json::Value, String>,
185    }
186    impl Default for ComponentsView {
187        fn default() -> Self {
188            Self {
189                context: Ok(Default::default()),
190                find: Ok(Default::default()),
191                name: Err("no value supplied for name".to_string()),
192                props: Ok(Default::default()),
193                type_: Err("no value supplied for type_".to_string()),
194            }
195        }
196    }
197    impl ComponentsView {
198        pub fn context<T>(mut self, value: T) -> Self
199        where
200            T: std::convert::TryInto<serde_json::Map<String, serde_json::Value>>,
201            T::Error: std::fmt::Display,
202        {
203            self
204                .context = value
205                .try_into()
206                .map_err(|e| {
207                    format!("error converting supplied value for context: {}", e)
208                });
209            self
210        }
211        pub fn find<T>(mut self, value: T) -> Self
212        where
213            T: std::convert::TryInto<Option<super::ComponentsViewDefinitionsFind>>,
214            T::Error: std::fmt::Display,
215        {
216            self
217                .find = value
218                .try_into()
219                .map_err(|e| format!("error converting supplied value for find: {}", e));
220            self
221        }
222        pub fn name<T>(mut self, value: T) -> Self
223        where
224            T: std::convert::TryInto<String>,
225            T::Error: std::fmt::Display,
226        {
227            self
228                .name = value
229                .try_into()
230                .map_err(|e| format!("error converting supplied value for name: {}", e));
231            self
232        }
233        pub fn props<T>(mut self, value: T) -> Self
234        where
235            T: std::convert::TryInto<Option<super::DefsProps>>,
236            T::Error: std::fmt::Display,
237        {
238            self
239                .props = value
240                .try_into()
241                .map_err(|e| {
242                    format!("error converting supplied value for props: {}", e)
243                });
244            self
245        }
246        pub fn type_<T>(mut self, value: T) -> Self
247        where
248            T: std::convert::TryInto<serde_json::Value>,
249            T::Error: std::fmt::Display,
250        {
251            self
252                .type_ = value
253                .try_into()
254                .map_err(|e| {
255                    format!("error converting supplied value for type_: {}", e)
256                });
257            self
258        }
259    }
260    impl std::convert::TryFrom<ComponentsView> for super::ComponentsView {
261        type Error = String;
262        fn try_from(value: ComponentsView) -> Result<Self, String> {
263            Ok(Self {
264                context: value.context?,
265                find: value.find?,
266                name: value.name?,
267                props: value.props?,
268                type_: value.type_?,
269            })
270        }
271    }
272    impl From<super::ComponentsView> for ComponentsView {
273        fn from(value: super::ComponentsView) -> Self {
274            Self {
275                context: Ok(value.context),
276                find: Ok(value.find),
277                name: Ok(value.name),
278                props: Ok(value.props),
279                type_: Ok(value.type_),
280            }
281        }
282    }
283    #[derive(Clone, Debug)]
284    pub struct ComponentsViewDefinitionsFind {
285        coll: Result<String, String>,
286        projection: Result<Option<super::DataProjection>, String>,
287        query: Result<super::DataQuery, String>,
288    }
289    impl Default for ComponentsViewDefinitionsFind {
290        fn default() -> Self {
291            Self {
292                coll: Err("no value supplied for coll".to_string()),
293                projection: Ok(Default::default()),
294                query: Err("no value supplied for query".to_string()),
295            }
296        }
297    }
298    impl ComponentsViewDefinitionsFind {
299        pub fn coll<T>(mut self, value: T) -> Self
300        where
301            T: std::convert::TryInto<String>,
302            T::Error: std::fmt::Display,
303        {
304            self
305                .coll = value
306                .try_into()
307                .map_err(|e| format!("error converting supplied value for coll: {}", e));
308            self
309        }
310        pub fn projection<T>(mut self, value: T) -> Self
311        where
312            T: std::convert::TryInto<Option<super::DataProjection>>,
313            T::Error: std::fmt::Display,
314        {
315            self
316                .projection = value
317                .try_into()
318                .map_err(|e| {
319                    format!("error converting supplied value for projection: {}", e)
320                });
321            self
322        }
323        pub fn query<T>(mut self, value: T) -> Self
324        where
325            T: std::convert::TryInto<super::DataQuery>,
326            T::Error: std::fmt::Display,
327        {
328            self
329                .query = value
330                .try_into()
331                .map_err(|e| {
332                    format!("error converting supplied value for query: {}", e)
333                });
334            self
335        }
336    }
337    impl std::convert::TryFrom<ComponentsViewDefinitionsFind>
338    for super::ComponentsViewDefinitionsFind {
339        type Error = String;
340        fn try_from(value: ComponentsViewDefinitionsFind) -> Result<Self, String> {
341            Ok(Self {
342                coll: value.coll?,
343                projection: value.projection?,
344                query: value.query?,
345            })
346        }
347    }
348    impl From<super::ComponentsViewDefinitionsFind> for ComponentsViewDefinitionsFind {
349        fn from(value: super::ComponentsViewDefinitionsFind) -> Self {
350            Self {
351                coll: Ok(value.coll),
352                projection: Ok(value.projection),
353                query: Ok(value.query),
354            }
355        }
356    }
357    #[derive(Clone, Debug)]
358    pub struct Exposer {
359        routes: Result<Vec<super::Route>, String>,
360        version: Result<Option<String>, String>,
361    }
362    impl Default for Exposer {
363        fn default() -> Self {
364            Self {
365                routes: Err("no value supplied for routes".to_string()),
366                version: Ok(Default::default()),
367            }
368        }
369    }
370    impl Exposer {
371        pub fn routes<T>(mut self, value: T) -> Self
372        where
373            T: std::convert::TryInto<Vec<super::Route>>,
374            T::Error: std::fmt::Display,
375        {
376            self
377                .routes = value
378                .try_into()
379                .map_err(|e| {
380                    format!("error converting supplied value for routes: {}", e)
381                });
382            self
383        }
384        pub fn version<T>(mut self, value: T) -> Self
385        where
386            T: std::convert::TryInto<Option<String>>,
387            T::Error: std::fmt::Display,
388        {
389            self
390                .version = value
391                .try_into()
392                .map_err(|e| {
393                    format!("error converting supplied value for version: {}", e)
394                });
395            self
396        }
397    }
398    impl std::convert::TryFrom<Exposer> for super::Exposer {
399        type Error = String;
400        fn try_from(value: Exposer) -> Result<Self, String> {
401            Ok(Self {
402                routes: value.routes?,
403                version: value.version?,
404            })
405        }
406    }
407    impl From<super::Exposer> for Exposer {
408        fn from(value: super::Exposer) -> Self {
409            Self {
410                routes: Ok(value.routes),
411                version: Ok(value.version),
412            }
413        }
414    }
415    #[derive(Clone, Debug)]
416    pub struct Manifest {
417        json: Result<Option<super::Exposer>, String>,
418        lenra: Result<Option<super::Exposer>, String>,
419    }
420    impl Default for Manifest {
421        fn default() -> Self {
422            Self {
423                json: Ok(Default::default()),
424                lenra: Ok(Default::default()),
425            }
426        }
427    }
428    impl Manifest {
429        pub fn json<T>(mut self, value: T) -> Self
430        where
431            T: std::convert::TryInto<Option<super::Exposer>>,
432            T::Error: std::fmt::Display,
433        {
434            self
435                .json = value
436                .try_into()
437                .map_err(|e| format!("error converting supplied value for json: {}", e));
438            self
439        }
440        pub fn lenra<T>(mut self, value: T) -> Self
441        where
442            T: std::convert::TryInto<Option<super::Exposer>>,
443            T::Error: std::fmt::Display,
444        {
445            self
446                .lenra = value
447                .try_into()
448                .map_err(|e| {
449                    format!("error converting supplied value for lenra: {}", e)
450                });
451            self
452        }
453    }
454    impl std::convert::TryFrom<Manifest> for super::Manifest {
455        type Error = String;
456        fn try_from(value: Manifest) -> Result<Self, String> {
457            Ok(Self {
458                json: value.json?,
459                lenra: value.lenra?,
460            })
461        }
462    }
463    impl From<super::Manifest> for Manifest {
464        fn from(value: super::Manifest) -> Self {
465            Self {
466                json: Ok(value.json),
467                lenra: Ok(value.lenra),
468            }
469        }
470    }
471    #[derive(Clone, Debug)]
472    pub struct Route {
473        path: Result<String, String>,
474        view: Result<super::ComponentsView, String>,
475    }
476    impl Default for Route {
477        fn default() -> Self {
478            Self {
479                path: Err("no value supplied for path".to_string()),
480                view: Err("no value supplied for view".to_string()),
481            }
482        }
483    }
484    impl Route {
485        pub fn path<T>(mut self, value: T) -> Self
486        where
487            T: std::convert::TryInto<String>,
488            T::Error: std::fmt::Display,
489        {
490            self
491                .path = value
492                .try_into()
493                .map_err(|e| format!("error converting supplied value for path: {}", e));
494            self
495        }
496        pub fn view<T>(mut self, value: T) -> Self
497        where
498            T: std::convert::TryInto<super::ComponentsView>,
499            T::Error: std::fmt::Display,
500        {
501            self
502                .view = value
503                .try_into()
504                .map_err(|e| format!("error converting supplied value for view: {}", e));
505            self
506        }
507    }
508    impl std::convert::TryFrom<Route> for super::Route {
509        type Error = String;
510        fn try_from(value: Route) -> Result<Self, String> {
511            Ok(Self {
512                path: value.path?,
513                view: value.view?,
514            })
515        }
516    }
517    impl From<super::Route> for Route {
518        fn from(value: super::Route) -> Self {
519            Self {
520                path: Ok(value.path),
521                view: Ok(value.view),
522            }
523        }
524    }
525}
lenra_app/gen/manifest.rs

lenra_app/gen/
manifest.rs
