WIP

src/link/argument.rs

@@ -1,4 +1,5 @@
 use crate::error::{FederationError, SingleFederationError};
+use crate::link::graphql_definition::BooleanOrVariable;
 use apollo_compiler::ast::Value;
 use apollo_compiler::schema::{Directive, Name};
 use apollo_compiler::{Node, NodeStr};
@@ -141,3 +142,21 @@ pub(crate) fn directive_required_boolean_argument(
         .into()
     })
 }
+
+pub(crate) fn directive_optional_variable_boolean_argument(
+    application: &Node<Directive>,
+    name: &Name,
+) -> Result<Option<BooleanOrVariable>, FederationError> {
+    match application.argument_by_name(name) {
+        Some(value) => match value.deref() {
+            Value::Variable(name) => Ok(Some(BooleanOrVariable::Variable(name.clone()))),
+            Value::Boolean(value) => Ok(Some(BooleanOrVariable::Boolean(*value))),
+            Value::Null => Ok(None),
+            _ => Err(FederationError::internal(format!(
+                "Argument \"{}\" of directive \"@{}\" must be a boolean.",
+                name, application.name
+            ))),
+        },
+        None => Ok(None),
+    }
+}

src/link/graphql_definition.rs

@@ -1,12 +1,25 @@
-use apollo_compiler::executable::Name;
-use apollo_compiler::NodeStr;
+use crate::error::FederationError;
+use crate::link::argument::{
+    directive_optional_string_argument, directive_optional_variable_boolean_argument,
+};
+use apollo_compiler::executable::{Directive, Name};
+use apollo_compiler::{name, Node, NodeStr};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct DeferDirectiveArguments {
     label: Option<NodeStr>,
     if_: Option<BooleanOrVariable>,
 }
 
+pub(crate) fn defer_directive_arguments(
+    application: &Node<Directive>,
+) -> Result<DeferDirectiveArguments, FederationError> {
+    Ok(DeferDirectiveArguments {
+        label: directive_optional_string_argument(application, &name!("label"))?,
+        if_: directive_optional_variable_boolean_argument(application, &name!("if"))?,
+    })
+}
+
 /// This struct is meant for recording the original structure/intent of `@skip`/`@include`
 /// applications within the elements of a `GraphPath`. Accordingly, the order of them matters within
 /// a `Vec`, and superfluous struct instances aren't elided; `Conditions` is the more appropriate

src/query_graph/condition_resolver.rs

@@ -1,41 +1,68 @@
+use crate::error::FederationError;
 use crate::query_graph::graph_path::{
     ExcludedConditions, ExcludedDestinations, OpGraphPathContext,
 };
 use crate::query_graph::path_tree::OpPathTree;
 use crate::query_plan::QueryPlanCost;
 use petgraph::graph::EdgeIndex;
+use std::sync::Arc;
 
 /// Note that `ConditionResolver`s are guaranteed to be only called for edge with conditions.
 pub(crate) trait ConditionResolver {
     fn resolve(
+        &mut self,
         edge: EdgeIndex,
-        context: OpGraphPathContext,
-        excluded_destinations: ExcludedDestinations,
-        excluded_conditions: ExcludedConditions,
-    ) -> ConditionResolution;
+        context: &OpGraphPathContext,
+        excluded_destinations: &ExcludedDestinations,
+        excluded_conditions: &ExcludedConditions,
+    ) -> Result<ConditionResolution, FederationError>;
 }
 
+// TODO: This could probably be refactored into an enum.
+#[derive(Debug, Clone)]
 pub(crate) struct ConditionResolution {
-    satisfied: bool,
-    cost: QueryPlanCost,
-    path_tree: Option<OpPathTree>,
-    // Note that this is not guaranteed to be set even if satistied === false.
-    unsatisfied_condition_reason: Option<UnsatisfiedConditionReason>,
+    pub(crate) satisfied: bool,
+    pub(crate) cost: QueryPlanCost,
+    pub(crate) path_tree: Option<Arc<OpPathTree>>,
+    // Note that this is not guaranteed to be set even if satisfied is false.
+    pub(crate) unsatisfied_condition_reason: Option<UnsatisfiedConditionReason>,
 }
 
+#[derive(Debug, Clone)]
 pub(crate) enum UnsatisfiedConditionReason {
     NoPostRequireKey,
 }
 
+impl ConditionResolution {
+    pub(crate) fn no_conditions() -> Self {
+        Self {
+            satisfied: true,
+            cost: 0,
+            path_tree: None,
+            unsatisfied_condition_reason: None,
+        }
+    }
+
+    pub(crate) fn unsatisfied_conditions() -> Self {
+        Self {
+            satisfied: false,
+            cost: -1,
+            path_tree: None,
+            unsatisfied_condition_reason: None,
+        }
+    }
+}
+
 pub(crate) struct CachingConditionResolver;
 
 impl ConditionResolver for CachingConditionResolver {
     fn resolve(
+        &mut self,
         _edge: EdgeIndex,
-        _context: OpGraphPathContext,
-        _excluded_destinations: ExcludedDestinations,
-        _excluded_conditions: ExcludedConditions,
-    ) -> ConditionResolution {
+        _context: &OpGraphPathContext,
+        _excluded_destinations: &ExcludedDestinations,
+        _excluded_conditions: &ExcludedConditions,
+    ) -> Result<ConditionResolution, FederationError> {
         todo!()
     }
 }