compiler: Refactor execution code to prepare for giving it a public API (#979)

Author: SimonSapin

crates/apollo-compiler/src/execution/engine.rs

@@ -1,12 +1,16 @@
 use crate::ast::Value;
+use crate::collections::HashMap;
 use crate::collections::HashSet;
 use crate::collections::IndexMap;
 use crate::executable::Field;
 use crate::executable::Selection;
 use crate::execution::input_coercion::coerce_argument_values;
 use crate::execution::resolver::ObjectValue;
-use crate::execution::resolver::ResolverError;
+use crate::execution::resolver::ResolveError;
+use crate::execution::resolver::ResolvedValue;
 use crate::execution::result_coercion::complete_value;
+use crate::introspection::resolvers::MaybeLazy;
+use crate::introspection::resolvers::SchemaWithImplementersMap;
 use crate::parser::SourceMap;
 use crate::parser::SourceSpan;
 use crate::response::GraphQLError;
@@ -15,6 +19,7 @@ use crate::response::JsonValue;
 use crate::response::ResponseDataPathSegment;
 use crate::schema::ExtendedType;
 use crate::schema::FieldDefinition;
+use crate::schema::Implementers;
 use crate::schema::ObjectType;
 use crate::schema::Type;
 use crate::validation::SuspectedValidationBug;
@@ -26,7 +31,7 @@ use crate::Schema;
 /// <https://spec.graphql.org/October2021/#sec-Normal-and-Serial-Execution>
 #[derive(Debug, Copy, Clone)]
 pub(crate) enum ExecutionMode {
-    /// Allowed to resolve fields in any order, including in parellel
+    /// Allowed to resolve fields in any order, including in parallel
     Normal,
     /// Top-level fields of a mutation operation must be executed in order
     #[allow(unused)]
@@ -46,134 +51,118 @@ pub(crate) struct LinkedPathElement<'a> {
     pub(crate) next: LinkedPath<'a>,
 }
 
+pub(crate) struct ExecutionContext<'a> {
+    pub(crate) schema: &'a Valid<Schema>,
+    pub(crate) document: &'a Valid<ExecutableDocument>,
+    pub(crate) variable_values: &'a Valid<JsonMap>,
+    pub(crate) errors: &'a mut Vec<GraphQLError>,
+    pub(crate) implementers_map: MaybeLazy<'a, HashMap<Name, Implementers>>,
+}
+
 /// <https://spec.graphql.org/October2021/#ExecuteSelectionSet()>
-#[allow(clippy::too_many_arguments)] // yes it’s not a nice API but it’s internal
+///
+/// `object_value: None` is a special case for top-level of `introspection::partial_execute`
 pub(crate) fn execute_selection_set<'a>(
-    schema: &Valid<Schema>,
-    document: &'a Valid<ExecutableDocument>,
-    variable_values: &Valid<JsonMap>,
-    errors: &mut Vec<GraphQLError>,
+    ctx: &mut ExecutionContext<'a>,
     path: LinkedPath<'_>,
     mode: ExecutionMode,
     object_type: &ObjectType,
-    object_value: &ObjectValue<'_>,
+    object_value: Option<&dyn ObjectValue>,
     selections: impl IntoIterator<Item = &'a Selection>,
 ) -> Result<JsonMap, PropagateNull> {
     let mut grouped_field_set = IndexMap::default();
     collect_fields(
-        schema,
-        document,
-        variable_values,
+        ctx,
         object_type,
-        object_value,
         selections,
         &mut HashSet::default(),
         &mut grouped_field_set,
     );
 
     match mode {
-        ExecutionMode::Normal => {}
-        ExecutionMode::Sequential => {
-            // If we want parallelism, use `futures::future::join_all` (async)
+        ExecutionMode::Normal => {
+            // If we want parallelism, use `StreamExt::buffer_unordered` (async)
             // or Rayon’s `par_iter` (sync) here.
         }
+        ExecutionMode::Sequential => {}
     }
 
     let mut response_map = JsonMap::with_capacity(grouped_field_set.len());
     for (&response_key, fields) in &grouped_field_set {
         // Indexing should not panic: `collect_fields` only creates a `Vec` to push to it
         let field_name = &fields[0].name;
-        let Ok(field_def) = schema.type_field(&object_type.name, field_name) else {
+        let Ok(field_def) = ctx.schema.type_field(&object_type.name, field_name) else {
             // TODO: Return a `validation_bug`` field error here?
             // The spec specifically has a “If fieldType is defined” condition,
             // but it being undefined would make the request invalid, right?
             continue;
         };
-        let value = if field_name == "__typename" {
-            JsonValue::from(object_type.name.as_str())
-        } else {
-            let field_path = LinkedPathElement {
-                element: ResponseDataPathSegment::Field(response_key.clone()),
-                next: path,
-            };
-            execute_field(
-                schema,
-                document,
-                variable_values,
-                errors,
-                Some(&field_path),
-                mode,
-                object_value,
-                field_def,
-                fields,
-            )?
+        let field_path = LinkedPathElement {
+            element: ResponseDataPathSegment::Field(response_key.clone()),
+            next: path,
         };
-        response_map.insert(response_key.as_str(), value);
+        if let Some(value) = execute_field(
+            ctx,
+            Some(&field_path),
+            mode,
+            object_type,
+            object_value,
+            field_def,
+            fields,
+        )? {
+            response_map.insert(response_key.as_str(), value);
+        }
     }
     Ok(response_map)
 }
 
 /// <https://spec.graphql.org/October2021/#CollectFields()>
-#[allow(clippy::too_many_arguments)] // yes it’s not a nice API but it’s internal
 fn collect_fields<'a>(
-    schema: &Schema,
-    document: &'a ExecutableDocument,
-    variable_values: &Valid<JsonMap>,
+    ctx: &mut ExecutionContext<'a>,
     object_type: &ObjectType,
-    object_value: &ObjectValue<'_>,
     selections: impl IntoIterator<Item = &'a Selection>,
     visited_fragments: &mut HashSet<&'a Name>,
     grouped_fields: &mut IndexMap<&'a Name, Vec<&'a Field>>,
 ) {
     for selection in selections {
-        if eval_if_arg(selection, "skip", variable_values).unwrap_or(false)
-            || !eval_if_arg(selection, "include", variable_values).unwrap_or(true)
+        if eval_if_arg(selection, "skip", ctx.variable_values).unwrap_or(false)
+            || !eval_if_arg(selection, "include", ctx.variable_values).unwrap_or(true)
         {
             continue;
         }
         match selection {
-            Selection::Field(field) => {
-                if !object_value.skip_field(&field.name) {
-                    grouped_fields
-                        .entry(field.response_key())
-                        .or_default()
-                        .push(field.as_ref())
-                }
-            }
+            Selection::Field(field) => grouped_fields
+                .entry(field.response_key())
+                .or_default()
+                .push(field.as_ref()),
             Selection::FragmentSpread(spread) => {
                 let new = visited_fragments.insert(&spread.fragment_name);
                 if !new {
                     continue;
                 }
-                let Some(fragment) = document.fragments.get(&spread.fragment_name) else {
+                let Some(fragment) = ctx.document.fragments.get(&spread.fragment_name) else {
                     continue;
                 };
-                if !does_fragment_type_apply(schema, object_type, fragment.type_condition()) {
+                if !does_fragment_type_apply(ctx.schema, object_type, fragment.type_condition()) {
                     continue;
                 }
                 collect_fields(
-                    schema,
-                    document,
-                    variable_values,
+                    ctx,
                     object_type,
-                    object_value,
                     &fragment.selection_set.selections,
                     visited_fragments,
                     grouped_fields,
                 )
             }
             Selection::InlineFragment(inline) => {
                 if let Some(condition) = &inline.type_condition {
-                    if !does_fragment_type_apply(schema, object_type, condition) {
+                    if !does_fragment_type_apply(ctx.schema, object_type, condition) {
                         continue;
                     }
                 }
                 collect_fields(
-                    schema,
-                    document,
-                    variable_values,
+                    ctx,
                     object_type,
-                    object_value,
                     &inline.selection_set.selections,
                     visited_fragments,
                     grouped_fields,
@@ -218,55 +207,79 @@ fn eval_if_arg(
 }
 
 /// <https://spec.graphql.org/October2021/#ExecuteField()>
-#[allow(clippy::too_many_arguments)] // yes it’s not a nice API but it’s internal
-fn execute_field(
-    schema: &Valid<Schema>,
-    document: &Valid<ExecutableDocument>,
-    variable_values: &Valid<JsonMap>,
-    errors: &mut Vec<GraphQLError>,
+///
+/// `object_value: None` is a special case for top-level of `introspection::partial_execute`
+///
+/// Return `Ok(None)` for silently skipping that field.
+fn execute_field<'a>(
+    ctx: &mut ExecutionContext<'a>,
     path: LinkedPath<'_>,
     mode: ExecutionMode,
-    object_value: &ObjectValue<'_>,
+    object_type: &ObjectType,
+    object_value: Option<&dyn ObjectValue>,
     field_def: &FieldDefinition,
-    fields: &[&Field],
-) -> Result<JsonValue, PropagateNull> {
+    fields: &[&'a Field],
+) -> Result<Option<JsonValue>, PropagateNull> {
     let field = fields[0];
-    let argument_values = match coerce_argument_values(
-        schema,
-        document,
-        variable_values,
-        errors,
-        path,
-        field_def,
-        field,
-    ) {
+    let argument_values = match coerce_argument_values(ctx, path, field_def, field) {
         Ok(argument_values) => argument_values,
-        Err(PropagateNull) => return try_nullify(&field_def.ty, Err(PropagateNull)),
+        Err(PropagateNull) if field_def.ty.is_non_null() => return Err(PropagateNull),
+        Err(PropagateNull) => return Ok(Some(JsonValue::Null)),
+    };
+    let is_field_of_root_query = || {
+        ctx.schema
+            .schema_definition
+            .query
+            .as_ref()
+            .is_some_and(|q| q.name == object_type.name)
+    };
+    let resolved_result = match field.name.as_str() {
+        "__typename" => Ok(ResolvedValue::leaf(object_type.name.as_str())),
+        "__schema" if is_field_of_root_query() => {
+            let schema = SchemaWithImplementersMap {
+                schema: ctx.schema,
+                implementers_map: ctx.implementers_map,
+            };
+            Ok(ResolvedValue::object(schema))
+        }
+        "__type" if is_field_of_root_query() => {
+            let schema = SchemaWithImplementersMap {
+                schema: ctx.schema,
+                implementers_map: ctx.implementers_map,
+            };
+            if let Some(name) = argument_values.get("name").and_then(|v| v.as_str()) {
+                Ok(crate::introspection::resolvers::type_def(schema, name))
+            } else {
+                // This should never happen: `coerce_argument_values()` returns a map that conforms
+                // to the `__type(name: String!): __Type` definition
+                // Still, in case of a bug prefer returning an error than panicking
+                Err(ResolveError {
+                    message: "expected string argument `name`".into(),
+                })
+            }
+        }
+        _ => {
+            if let Some(obj) = object_value {
+                obj.resolve_field(field, &argument_values)
+            } else {
+                // Skip non-introspection root fields for `introspection::partial_execute`
+                return Ok(None);
+            }
+        }
     };
-    let resolved_result = object_value.resolve_field(&field.name, &argument_values);
     let completed_result = match resolved_result {
-        Ok(resolved) => complete_value(
-            schema,
-            document,
-            variable_values,
-            errors,
-            path,
-            mode,
-            field.ty(),
-            resolved,
-            fields,
-        ),
-        Err(ResolverError { message }) => {
-            errors.push(GraphQLError::field_error(
+        Ok(resolved) => complete_value(ctx, path, mode, field.ty(), resolved, fields),
+        Err(ResolveError { message }) => {
+            ctx.errors.push(GraphQLError::field_error(
                 format!("resolver error: {message}"),
                 path,
                 field.name.location(),
-                &document.sources,
+                &ctx.document.sources,
             ));
             Err(PropagateNull)
         }
     };
-    try_nullify(&field_def.ty, completed_result)
+    try_nullify(&field_def.ty, completed_result).map(Some)
 }
 
 /// Try to insert a propagated null if possible, or keep propagating it.