apollo-router 2.14.0-rc.2

A configurable, high-performance routing runtime for Apollo Federation 🚀
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Tower layers wrapping the mis-named PersistedQueryLayer implementation into actual tower
//! layers.
//!
//! Long-term, we should move the actual implementation code into a service structure, but that is
//! more work especially to translate the tests.

use std::sync::Arc;

use futures::FutureExt as _;
use futures::future::BoxFuture;
use tower::BoxError;
use tower::Service;

use super::PersistedQueryLayer;
use crate::services::SupergraphRequest;
use crate::services::SupergraphResponse;

pub(crate) struct ExpandIdsLayer {
    wrapped: Arc<PersistedQueryLayer>,
}

impl ExpandIdsLayer {
    pub(crate) fn new(wrapped: Arc<PersistedQueryLayer>) -> Self {
        Self { wrapped }
    }
}

impl<S> tower::Layer<S> for ExpandIdsLayer {
    type Service = ExpandIdsService<S>;

    fn layer(&self, inner: S) -> Self::Service {
        ExpandIdsService {
            inner,
            wrapped: self.wrapped.clone(),
        }
    }
}

#[derive(Clone)]
pub(crate) struct ExpandIdsService<S> {
    inner: S,
    wrapped: Arc<PersistedQueryLayer>,
}

impl<S> Service<SupergraphRequest> for ExpandIdsService<S>
where
    S: Service<SupergraphRequest, Response = SupergraphResponse, Error = BoxError>
        + Clone
        + Send
        + 'static,
    S::Future: Send + 'static,
{
    type Response = SupergraphResponse;
    type Error = BoxError;
    // XXX(@goto-bus-stop): some reusable response future type that is either a call to an inner
    // service, or a short-circuited response would be useful
    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(
        &mut self,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, req: SupergraphRequest) -> Self::Future {
        match self.wrapped.supergraph_request(req) {
            Ok(req) => self.inner.call(req).boxed(),
            Err(res) => std::future::ready(Ok(res)).boxed(),
        }
    }
}

pub(crate) struct EnforceSafelistLayer {
    wrapped: Arc<PersistedQueryLayer>,
}

impl EnforceSafelistLayer {
    pub(crate) fn new(wrapped: Arc<PersistedQueryLayer>) -> Self {
        Self { wrapped }
    }
}

impl<S> tower::Layer<S> for EnforceSafelistLayer {
    type Service = EnforceSafelistService<S>;

    fn layer(&self, inner: S) -> Self::Service {
        EnforceSafelistService {
            inner,
            wrapped: self.wrapped.clone(),
        }
    }
}

#[derive(Clone)]
pub(crate) struct EnforceSafelistService<S> {
    inner: S,
    wrapped: Arc<PersistedQueryLayer>,
}

impl<S> Service<SupergraphRequest> for EnforceSafelistService<S>
where
    S: Service<SupergraphRequest, Response = SupergraphResponse, Error = BoxError>
        + Clone
        + Send
        + 'static,
    S::Future: Send + 'static,
{
    type Response = SupergraphResponse;
    type Error = BoxError;
    // XXX(@goto-bus-stop): some reusable response future type that is either a call to an inner
    // service, or a short-circuited response would be useful
    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(
        &mut self,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, req: SupergraphRequest) -> Self::Future {
        let inner = self.inner.clone();
        let mut inner = std::mem::replace(&mut self.inner, inner);

        let wrapped = self.wrapped.clone();
        Box::pin(async move {
            match wrapped.supergraph_request_with_analyzed_query(req).await {
                Ok(req) => inner.call(req).await,
                Err(res) => Ok(res),
            }
        })
    }
}