Struct Response 

#[non_exhaustive]
pub struct Response {
    pub response: Response<ResponseStream>,
    pub context: Context,
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

response: Response<ResponseStream>

context: Context

Implementations

impl Response

pub fn builder() -> NewResponseBuilder

This is the constructor (or builder) to use when constructing a real Response..

Required parameters are required in non-testing code to create a Response..

impl Response

pub fn fake_builder() -> FakeNewResponseBuilder

This is the constructor (or builder) to use when constructing a “fake” Response.

This does not enforce the provision of the data that is required for a fully functional Response. It’s usually enough for testing, when a fully constructed Response is difficult to construct and not required for the purposes of the test.

In addition, fake responses are expected to be valid, and will panic if given invalid values.

impl Response

pub fn fake_stream_builder() -> FakeStreamNewResponseBuilder

This is the constructor (or builder) to use when constructing a “fake” Response stream.

This does not enforce the provision of the data that is required for a fully functional Response. It’s usually enough for testing, when a fully constructed Response is difficult to construct and not required for the purposes of the test.

In addition, fake responses are expected to be valid, and will panic if given invalid values.

impl Response

pub fn error_builder() -> ErrorNewResponseBuilder

This is the constructor (or builder) to use when constructing a Response that represents a global error. It has no path and no response data. This is useful for things such as authentication errors.

impl Response

pub async fn next_response(&mut self) -> Option<Response>

pub fn map<F>(self, f: F) -> Response

where F: FnOnce(ResponseStream) -> ResponseStream,

pub fn map_stream<F>(self, f: F) -> Self

where F: 'static + Send + FnMut(Response) -> Response,

Returns a new supergraph response where each graphql::Response is mapped through f.

In supergraph and execution services, the service response contains not just one GraphQL response but a stream of them, in order to support features such as @defer. This method uses futures::stream::StreamExt::map to map over each item in the stream.

Example

use apollo_router::services::supergraph;
use apollo_router::layers::ServiceExt as _;
use tower::ServiceExt as _;

struct ExamplePlugin;

#[async_trait::async_trait]
impl apollo_router::plugin::Plugin for ExamplePlugin {
    // …
    fn supergraph_service(&self, inner: supergraph::BoxService) -> supergraph::BoxService {
        inner
            .map_response(|supergraph_response| {
                supergraph_response.map_stream(|graphql_response| {
                    // Something interesting here
                    graphql_response
                })
            })
            .boxed()
    }
}

Trait Implementations

impl Debug for Response

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.