xidl-parser 0.105.0

A IDL codegen.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! Canonical HTTP parameter bindings shared by projection and version facts.

use super::super::semantics::SourceBinding;
use super::super::semantics::{HttpStreamKind, has_annotation, has_optional_annotation};
use super::super::validate::{HttpParamDirection, default_param_source, param_direction};
use super::super::{HttpMethod, HttpParam, HttpParamKind, HttpRoute, RestHirResult};
use crate::hir;
use std::collections::HashSet;

/// Resolves parameter sources with the exact REST projection rules.
#[derive(Debug, Clone, PartialEq)]
pub(crate) struct ParameterSources {
    default_source: HttpParamKind,
    pub(super) route_path_names: Vec<HashSet<String>>,
    route_query_names: Vec<HashSet<String>>,
}

impl ParameterSources {
    /// Builds a binding context from normalized HTTP routes.
    pub(crate) fn new(
        method: HttpMethod,
        stream_kind: Option<HttpStreamKind>,
        routes: &[HttpRoute],
    ) -> Self {
        Self {
            default_source: if matches!(stream_kind, Some(HttpStreamKind::Bidi)) {
                HttpParamKind::Body
            } else {
                default_param_source(method)
            },
            route_path_names: routes
                .iter()
                .map(|route| route.path_params.iter().cloned().collect())
                .collect(),
            route_query_names: routes
                .iter()
                .map(|route| route.query_params.iter().cloned().collect())
                .collect(),
        }
    }

    /// Projects a request parameter, excluding response-only declarations.
    pub(crate) fn request(&self, param: &hir::ParamDcl) -> RestHirResult<Option<HttpParam>> {
        if matches!(
            param_direction(param.attr.as_ref()),
            HttpParamDirection::Out
        ) {
            return Ok(None);
        }
        self.project(param).map(Some)
    }

    /// Projects a response parameter, excluding input-only declarations.
    pub(crate) fn response(&self, param: &hir::ParamDcl) -> RestHirResult<Option<HttpParam>> {
        if matches!(param_direction(param.attr.as_ref()), HttpParamDirection::In) {
            return Ok(None);
        }
        self.project(param).map(Some)
    }

    /// Projects a parameter without changing its direction.
    pub(crate) fn project(&self, param: &hir::ParamDcl) -> RestHirResult<HttpParam> {
        let binding = SourceBinding::read(&param.annotations, &param.declarator.0)?;
        let wire_name = binding.as_ref().map_or_else(
            || hir::field_rename(&param.annotations).unwrap_or_else(|| param.declarator.0.clone()),
            |binding| binding.wire_name(&param.declarator.0, &param.annotations, &[]),
        );
        let kind = match param_direction(param.attr.as_ref()) {
            HttpParamDirection::Out | HttpParamDirection::InOut => binding
                .map(|value| value.source)
                .unwrap_or(HttpParamKind::Body),
            HttpParamDirection::In => binding.map(|value| value.source).unwrap_or_else(|| {
                if self
                    .route_path_names
                    .iter()
                    .all(|set| set.contains(&param.declarator.0))
                {
                    HttpParamKind::Path
                } else if self
                    .route_query_names
                    .iter()
                    .any(|set| set.contains(&param.declarator.0))
                {
                    HttpParamKind::Query
                } else {
                    self.default_source
                }
            }),
        };
        Ok(HttpParam {
            name: param.declarator.0.clone(),
            wire_name,
            ty: param.ty.clone(),
            kind,
            optional: has_optional_annotation(&param.annotations),
            flatten: has_annotation(&param.annotations, "flatten"),
        })
    }
}