execute_introspection_only_query + [email protected] + [email protected] (#906)

* Add execute_introspection_only_query bypassing SchemaIntrospectionSplit

* Prepare [email protected] and [email protected] releases

Author: SimonSapin

crates/apollo-compiler/CHANGELOG.md

@@ -17,7 +17,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ## Maintenance
 ## Documentation-->
 
-# [x.x.x] (unreleased) - 2024-mm-dd
+# [1.0.0-beta.21](https://crates.io/crates/apollo-compiler/1.0.0-beta.21) - 2024-08-03
 
 ## BREAKING
 

crates/apollo-compiler/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "apollo-compiler"
-version = "1.0.0-beta.20" # When bumping, also update README.md
+version = "1.0.0-beta.21" # When bumping, also update README.md
 authors = ["Irina Shestak <[email protected]>"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/apollographql/apollo-rs"

crates/apollo-compiler/README.md

@@ -40,7 +40,7 @@ Or add this to your `Cargo.toml` for a manual installation:
 # Just an example, change to the necessary package version.
 # Using an exact dependency is recommended for beta versions
 [dependencies]
-apollo-compiler = "=1.0.0-beta.20"
+apollo-compiler = "=1.0.0-beta.21"
 ```
 
 ## Rust versions

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

@@ -4,14 +4,14 @@ use crate::executable::OperationType;
 use crate::execution::engine::execute_selection_set;
 use crate::execution::engine::ExecutionMode;
 use crate::execution::resolver::ResolvedValue;
+use crate::execution::GraphQLError;
 use crate::execution::JsonMap;
 use crate::execution::Response;
 use crate::execution::SchemaIntrospectionError;
 use crate::execution::SchemaIntrospectionSplit;
 use crate::schema;
 use crate::schema::Implementers;
 use crate::schema::Name;
-use crate::validation::SuspectedValidationBug;
 use crate::validation::Valid;
 use crate::ExecutableDocument;
 use crate::Node;
@@ -47,13 +47,12 @@ impl SchemaIntrospectionQuery {
     /// Generally [`split`][SchemaIntrospectionSplit::split] should be used instead.
     ///
     /// [schema introspection]: https://spec.graphql.org/October2021/#sec-Schema-Introspection
-    #[doc(hidden)]
-    // Hidden to discourage usage, but pub to allow Router "both" mode to use legacy code
-    // for deciding what is or isn’t an introspection query.
-    pub fn assume_only_intropsection_fields(
+    pub(crate) fn assume_only_intropsection_fields(
         document: Valid<ExecutableDocument>,
     ) -> Result<Self, SchemaIntrospectionError> {
-        super::introspection_max_depth::check_document(&document)?;
+        let operation = document.operations.get(None).unwrap();
+        super::introspection_max_depth::check_introspection_max_depth(&document, operation)
+            .map_err(SchemaIntrospectionError::DeeplyNestedIntrospectionList)?;
         Ok(Self(document))
     }
 
@@ -72,19 +71,17 @@ impl SchemaIntrospectionQuery {
         execute_non_introspection_parts: impl FnOnce(&Valid<ExecutableDocument>) -> Response,
     ) -> Response {
         match SchemaIntrospectionSplit::split(schema, document, operation) {
-            Ok(SchemaIntrospectionSplit::Only(introspection_query)) => introspection_query
-                .execute(schema, variable_values)
-                .unwrap_or_else(|err| err.into_response(&document.sources)),
+            Ok(SchemaIntrospectionSplit::Only(introspection_query)) => {
+                introspection_query.execute(schema, variable_values)
+            }
             Ok(SchemaIntrospectionSplit::None) => execute_non_introspection_parts(document),
             Ok(SchemaIntrospectionSplit::Both {
                 introspection_query,
                 filtered_document: filtered_operation,
             }) => {
                 let non_introspection_response =
                     execute_non_introspection_parts(&filtered_operation);
-                let introspection_response = introspection_query
-                    .execute(schema, variable_values)
-                    .unwrap_or_else(|err| err.into_response(&document.sources));
+                let introspection_response = introspection_query.execute(schema, variable_values);
                 non_introspection_response.merge(introspection_response)
             }
             Err(err) => err.into_response(&document.sources),
@@ -95,49 +92,65 @@ impl SchemaIntrospectionQuery {
     /// that can also be converted with [`into_response`][SuspectedValidationBug::into_response].
     ///
     /// [request error]: https://spec.graphql.org/October2021/#sec-Errors.Request-errors
-    pub fn execute(
-        &self,
-        schema: &Valid<Schema>,
-        variable_values: &Valid<JsonMap>,
-    ) -> Result<Response, SuspectedValidationBug> {
+    pub fn execute(&self, schema: &Valid<Schema>, variable_values: &Valid<JsonMap>) -> Response {
         let operation = self.0.operations.get(None).unwrap();
-        debug_assert_eq!(operation.operation_type, OperationType::Query);
-
-        // https://spec.graphql.org/October2021/#sec-Query
-        let object_type_name = operation.object_type();
-        let object_type_def =
-            schema
-                .get_object(object_type_name)
-                .ok_or_else(|| SuspectedValidationBug {
-                    message: format!(
-                    "Root operation type {object_type_name} is undefined or not an object type."
-                ),
-                    location: None,
-                })?;
-        let implementers_map = &OnceLock::new();
-        let initial_value = &IntrospectionRootResolver(SchemaWithCache {
-            schema,
-            implementers_map,
-        });
+        execute_introspection_only_query(schema, &self.0, operation, variable_values)
+    }
+}
 
-        let mut errors = Vec::new();
-        let path = None;
-        let data = execute_selection_set(
-            schema,
-            &self.0,
-            variable_values,
-            &mut errors,
-            path,
-            ExecutionMode::Normal,
-            object_type_def,
-            initial_value,
-            &operation.selection_set.selections,
-        );
-        Ok(Response {
-            data: data.into(),
-            errors,
-            extensions: Default::default(),
-        })
+/// Execute a query whose [root fields][Operation::root_fields] are all intropsection meta-fields:
+/// `__schema`, `__type`, or `__typename`.
+///
+/// Returns an error if `operation_name` does not [correspond to a an operation definition](https://spec.graphql.org/October2021/#GetOperation())
+pub fn execute_introspection_only_query(
+    schema: &Valid<Schema>,
+    document: &Valid<ExecutableDocument>,
+    operation: &Node<Operation>,
+    variable_values: &Valid<JsonMap>,
+) -> Response {
+    if operation.operation_type != OperationType::Query {
+        return Response::from_request_error(GraphQLError::new(
+            format!(
+                "execute_introspection_only_query called with a {}",
+                operation.operation_type.name()
+            ),
+            operation.location(),
+            &document.sources,
+        ));
+    }
+
+    // https://spec.graphql.org/October2021/#sec-Query
+    let object_type_name = operation.object_type();
+    let Some(object_type_def) = schema.get_object(object_type_name) else {
+        return Response::from_request_error(GraphQLError::new(
+            "Undefined root operation type",
+            object_type_name.location(),
+            &document.sources,
+        ));
+    };
+    let implementers_map = &OnceLock::new();
+    let initial_value = &IntrospectionRootResolver(SchemaWithCache {
+        schema,
+        implementers_map,
+    });
+
+    let mut errors = Vec::new();
+    let path = None;
+    let data = execute_selection_set(
+        schema,
+        document,
+        variable_values,
+        &mut errors,
+        path,
+        ExecutionMode::Normal,
+        object_type_def,
+        initial_value,
+        &operation.selection_set.selections,
+    );
+    Response {
+        data: data.into(),
+        errors,
+        extensions: Default::default(),
     }
 }
 

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

@@ -1,36 +1,40 @@
+use crate::executable::Operation;
 use crate::executable::Selection;
 use crate::executable::SelectionSet;
-use crate::execution::introspection_split::get_fragment;
-use crate::execution::SchemaIntrospectionError;
+use crate::parser::SourceSpan;
 use crate::validation::Valid;
 use crate::ExecutableDocument;
 
 const MAX_LISTS_DEPTH: u32 = 3;
 
-pub(crate) fn check_document(
+#[derive(Debug)]
+pub struct DeeplyNestedIntrospectionListError {
+    pub location: Option<SourceSpan>,
+}
+
+pub fn check_introspection_max_depth(
     document: &Valid<ExecutableDocument>,
-) -> Result<(), SchemaIntrospectionError> {
-    for operation in document.operations.iter() {
-        let initial_depth = 0;
-        check_selection_set(document, initial_depth, &operation.selection_set)?;
-    }
-    Ok(())
+    operation: &Operation,
+) -> Result<(), DeeplyNestedIntrospectionListError> {
+    let initial_depth = 0;
+    check_selection_set(document, initial_depth, &operation.selection_set)
 }
 
 fn check_selection_set(
     document: &Valid<ExecutableDocument>,
     depth_so_far: u32,
     selection_set: &SelectionSet,
-) -> Result<(), SchemaIntrospectionError> {
+) -> Result<(), DeeplyNestedIntrospectionListError> {
     for selection in &selection_set.selections {
         match selection {
             Selection::InlineFragment(inline) => {
                 check_selection_set(document, depth_so_far, &inline.selection_set)?
             }
             Selection::FragmentSpread(spread) => {
                 // Validation ensures that `Valid<ExecutableDocument>` does not contain fragment cycles
-                let def = get_fragment(document, &spread.fragment_name)?;
-                check_selection_set(document, depth_so_far, &def.selection_set)?
+                if let Some(def) = document.fragments.get(&spread.fragment_name) {
+                    check_selection_set(document, depth_so_far, &def.selection_set)?
+                }
             }
             Selection::Field(field) => {
                 let mut depth = depth_so_far;
@@ -40,9 +44,9 @@ fn check_selection_set(
                 ) {
                     depth += 1;
                     if depth >= MAX_LISTS_DEPTH {
-                        return Err(SchemaIntrospectionError::DeeplyNestedIntrospectionList(
-                            field.name.location(),
-                        ));
+                        return Err(DeeplyNestedIntrospectionListError {
+                            location: field.name.location(),
+                        });
                     }
                 }
                 check_selection_set(document, depth, &field.selection_set)?

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

@@ -9,6 +9,7 @@ use crate::executable::Operation;
 use crate::executable::OperationType;
 use crate::executable::Selection;
 use crate::executable::SelectionSet;
+use crate::execution::introspection_max_depth::DeeplyNestedIntrospectionListError;
 use crate::execution::GraphQLError;
 use crate::execution::Response;
 use crate::execution::SchemaIntrospectionQuery;
@@ -65,7 +66,7 @@ pub enum SchemaIntrospectionSplit {
 #[derive(Debug)]
 pub enum SchemaIntrospectionError {
     SuspectedValidationBug(SuspectedValidationBug),
-    DeeplyNestedIntrospectionList(Option<SourceSpan>),
+    DeeplyNestedIntrospectionList(DeeplyNestedIntrospectionListError),
     Unsupported {
         message: String,
         location: Option<SourceSpan>,
@@ -597,8 +598,8 @@ impl SchemaIntrospectionError {
     pub fn into_graphql_error(self, sources: &SourceMap) -> GraphQLError {
         match self {
             Self::SuspectedValidationBug(s) => s.into_graphql_error(sources),
-            Self::DeeplyNestedIntrospectionList(location) => {
-                GraphQLError::new("Maximum introspection depth exceeded", location, sources)
+            Self::DeeplyNestedIntrospectionList(e) => {
+                GraphQLError::new("Maximum introspection depth exceeded", e.location, sources)
             }
             Self::Unsupported { message, location } => {
                 GraphQLError::new(message, location, sources)

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

@@ -16,7 +16,9 @@ mod result_coercion;
 
 pub use self::input_coercion::coerce_variable_values;
 pub use self::input_coercion::InputCoercionError;
+pub use self::introspection_execute::execute_introspection_only_query;
 pub use self::introspection_execute::SchemaIntrospectionQuery;
+pub use self::introspection_max_depth::check_introspection_max_depth;
 pub use self::introspection_split::SchemaIntrospectionError;
 pub use self::introspection_split::SchemaIntrospectionSplit;
 pub use self::response::GraphQLError;

crates/apollo-smith/CHANGELOG.md

@@ -18,6 +18,10 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ## Maintenance
 
 ## Documentation -->
+# [0.11.0](https://crates.io/crates/apollo-smith/0.10.0) - 2024-09-03
+
+- **Update apollo-compiler dependency to `=1.0.0-beta.21`**
+
 # [0.10.0](https://crates.io/crates/apollo-smith/0.10.0) - 2024-07-31
 
 - **Update apollo-parser dependency to `0.8.0`**

crates/apollo-smith/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "apollo-smith"
-version = "0.10.0" # When bumping, also update README.md
+version = "0.11.0" # When bumping, also update README.md
 edition = "2021"
 authors = ["Benjamin Coenen <[email protected]>"]
 license = "MIT OR Apache-2.0"
@@ -22,7 +22,7 @@ categories = [
 ]
 
 [dependencies]
-apollo-compiler = { path = "../apollo-compiler", version = "=1.0.0-beta.20" }
+apollo-compiler = { path = "../apollo-compiler", version = "=1.0.0-beta.21" }
 apollo-parser = { path = "../apollo-parser", version = "0.8.0" }
 arbitrary = { version = "1.3.0", features = ["derive"] }
 indexmap = "2.0.0"

crates/apollo-smith/README.md

@@ -49,7 +49,7 @@ and add `apollo-smith` to your Cargo.toml:
 ## fuzz/Cargo.toml
 
 [dependencies]
-apollo-smith = "0.10.0"
+apollo-smith = "0.11.0"
 ```
 
 It can then be used in a `fuzz_target` along with the [`arbitrary`] crate,