apollo-router 1.61.13

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

use std::sync::Arc;

use ahash::HashMap;
use apollo_compiler::ExecutableDocument;

use crate::Context;
use crate::graphql;
use crate::plugins::demand_control::DemandControlConfig;
use crate::plugins::demand_control::DemandControlError;
use crate::plugins::demand_control::Mode;
use crate::plugins::demand_control::StrategyConfig;
use crate::plugins::demand_control::cost_calculator::schema::DemandControlledSchema;
use crate::plugins::demand_control::cost_calculator::static_cost::StaticCostCalculator;
use crate::plugins::demand_control::strategy::static_estimated::StaticEstimated;
use crate::services::execution;
use crate::services::subgraph;

mod static_estimated;
#[cfg(test)]
mod test;

/// Strategy for a demand control exists for an entire request. It is Send and Sync but may contain state
/// such as the amount of budget remaining.
/// It is also responsible for updating metrics on what was rejected.
#[derive(Clone)]
pub(crate) struct Strategy {
    inner: Arc<dyn StrategyImpl>,
    pub(crate) mode: Mode,
}

impl Strategy {
    pub(crate) fn on_execution_request(
        &self,
        request: &execution::Request,
    ) -> Result<(), DemandControlError> {
        match self.inner.on_execution_request(request) {
            Err(e) if self.mode == Mode::Enforce => Err(e),
            _ => Ok(()),
        }
    }
    pub(crate) fn on_subgraph_request(
        &self,
        request: &subgraph::Request,
    ) -> Result<(), DemandControlError> {
        match self.inner.on_subgraph_request(request) {
            Err(e) if self.mode == Mode::Enforce => Err(e),
            _ => Ok(()),
        }
    }

    pub(crate) fn on_subgraph_response(
        &self,
        request: &ExecutableDocument,
        response: &subgraph::Response,
    ) -> Result<(), DemandControlError> {
        match self.inner.on_subgraph_response(request, response) {
            Err(e) if self.mode == Mode::Enforce => Err(e),
            _ => Ok(()),
        }
    }
    pub(crate) fn on_execution_response(
        &self,
        context: &Context,
        request: &ExecutableDocument,
        response: &graphql::Response,
    ) -> Result<(), DemandControlError> {
        match self.inner.on_execution_response(context, request, response) {
            Err(e) if self.mode == Mode::Enforce => Err(e),
            _ => Ok(()),
        }
    }
}

pub(crate) struct StrategyFactory {
    config: DemandControlConfig,
    #[allow(dead_code)]
    supergraph_schema: Arc<DemandControlledSchema>,
    subgraph_schemas: Arc<HashMap<String, DemandControlledSchema>>,
}

impl StrategyFactory {
    pub(crate) fn new(
        config: DemandControlConfig,
        supergraph_schema: Arc<DemandControlledSchema>,
        subgraph_schemas: Arc<HashMap<String, DemandControlledSchema>>,
    ) -> Self {
        Self {
            config,
            supergraph_schema,
            subgraph_schemas,
        }
    }

    pub(crate) fn create(&self) -> Strategy {
        let strategy: Arc<dyn StrategyImpl> = match &self.config.strategy {
            StrategyConfig::StaticEstimated { list_size, max } => Arc::new(StaticEstimated {
                max: *max,
                cost_calculator: StaticCostCalculator::new(
                    self.supergraph_schema.clone(),
                    self.subgraph_schemas.clone(),
                    *list_size,
                ),
            }),
            #[cfg(test)]
            StrategyConfig::Test { stage, error } => Arc::new(test::Test {
                stage: stage.clone(),
                error: error.clone(),
            }),
        };
        Strategy {
            mode: self.config.mode,
            inner: strategy,
        }
    }
}

pub(crate) trait StrategyImpl: Send + Sync {
    fn on_execution_request(&self, request: &execution::Request) -> Result<(), DemandControlError>;
    fn on_subgraph_request(&self, request: &subgraph::Request) -> Result<(), DemandControlError>;

    fn on_subgraph_response(
        &self,
        request: &ExecutableDocument,
        response: &subgraph::Response,
    ) -> Result<(), DemandControlError>;
    fn on_execution_response(
        &self,
        context: &Context,
        request: &ExecutableDocument,
        response: &graphql::Response,
    ) -> Result<(), DemandControlError>;
}