graph, graphql: Encapsulate access to the underlying schema in ApiSchema

This just shuffles some code around, but doesn't change anything else, in
preparation for representing the schema in a way that's more useful to us.

Author: lutter

graph/src/data/schema.rs

@@ -23,6 +23,8 @@ use std::iter::FromIterator;
 use std::str::FromStr;
 use std::sync::Arc;
 
+use super::graphql::ObjectOrInterface;
+
 pub const SCHEMA_TYPE_NAME: &str = "_Schema_";
 
 pub const META_FIELD_TYPE: &str = "_Meta_";
@@ -349,7 +351,7 @@ impl SchemaReference {
 
 #[derive(Debug)]
 pub struct ApiSchema {
-    pub schema: Schema,
+    schema: Schema,
 
     // Root types for the api schema.
     pub query_type: Arc<ObjectType>,
@@ -394,10 +396,6 @@ impl ApiSchema {
         })
     }
 
-    pub fn document(&self) -> &s::Document {
-        &self.schema.document
-    }
-
     pub fn id(&self) -> &DeploymentHash {
         &self.schema.id
     }
@@ -425,16 +423,87 @@ impl ApiSchema {
             .expect("ApiSchema.object_type is only used with existing types")
             .cheap_clone()
     }
-}
 
-fn add_introspection_schema(schema: &mut Document) {
-    lazy_static! {
-        static ref INTROSPECTION_SCHEMA: Document = {
-            let schema = include_str!("introspection.graphql");
-            parse_schema(schema).expect("the schema `introspection.graphql` is invalid")
-        };
+    pub fn get_named_type(&self, name: &str) -> Option<&TypeDefinition> {
+        self.schema.document.get_named_type(name)
+    }
+
+    /// Returns true if the given type is an input type.
+    ///
+    /// Uses the algorithm outlined on
+    /// https://facebook.github.io/graphql/draft/#IsInputType().
+    pub fn is_input_type(&self, t: &s::Type) -> bool {
+        match t {
+            s::Type::NamedType(name) => {
+                let named_type = self.get_named_type(name);
+                named_type.map_or(false, |type_def| match type_def {
+                    s::TypeDefinition::Scalar(_)
+                    | s::TypeDefinition::Enum(_)
+                    | s::TypeDefinition::InputObject(_) => true,
+                    _ => false,
+                })
+            }
+            s::Type::ListType(inner) => self.is_input_type(inner),
+            s::Type::NonNullType(inner) => self.is_input_type(inner),
+        }
     }
 
+    pub fn get_root_query_type_def(&self) -> Option<&s::TypeDefinition> {
+        self.schema
+            .document
+            .definitions
+            .iter()
+            .find_map(|d| match d {
+                s::Definition::TypeDefinition(def @ s::TypeDefinition::Object(_)) => match def {
+                    s::TypeDefinition::Object(t) if t.name == "Query" => Some(def),
+                    _ => None,
+                },
+                _ => None,
+            })
+    }
+
+    pub fn object_or_interface(&self, name: &str) -> Option<ObjectOrInterface<'_>> {
+        if name.starts_with("__") {
+            INTROSPECTION_SCHEMA.object_or_interface(name)
+        } else {
+            self.schema.document.object_or_interface(name)
+        }
+    }
+
+    /// Returns the type definition that a field type corresponds to.
+    pub fn get_type_definition_from_field<'a>(
+        &'a self,
+        field: &s::Field,
+    ) -> Option<&'a s::TypeDefinition> {
+        self.get_type_definition_from_type(&field.field_type)
+    }
+
+    /// Returns the type definition for a type.
+    pub fn get_type_definition_from_type<'a>(
+        &'a self,
+        t: &s::Type,
+    ) -> Option<&'a s::TypeDefinition> {
+        match t {
+            s::Type::NamedType(name) => self.get_named_type(name),
+            s::Type::ListType(inner) => self.get_type_definition_from_type(inner),
+            s::Type::NonNullType(inner) => self.get_type_definition_from_type(inner),
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn definitions(&self) -> impl Iterator<Item = &s::Definition<'static, String>> {
+        self.schema.document.definitions.iter()
+    }
+}
+
+lazy_static! {
+    static ref INTROSPECTION_SCHEMA: Document = {
+        let schema = include_str!("introspection.graphql");
+        parse_schema(schema).expect("the schema `introspection.graphql` is invalid")
+    };
+}
+
+fn add_introspection_schema(schema: &mut Document) {
     fn introspection_fields() -> Vec<Field> {
         // Generate fields for the root query fields in an introspection schema,
         // the equivalent of the fields of the `Query` type:

graphql/src/execution/ast.rs

@@ -2,7 +2,7 @@ use std::{collections::HashSet, ops::Deref};
 
 use graph::{
     components::store::EntityType,
-    data::graphql::{DocumentExt, ObjectOrInterface},
+    data::graphql::ObjectOrInterface,
     prelude::{anyhow, q, r, s, ApiSchema, QueryExecutionError, ValueMap},
 };
 use graphql_parser::Pos;
@@ -318,8 +318,6 @@ pub(crate) fn resolve_object_types(
 ) -> Result<HashSet<ObjectType>, QueryExecutionError> {
     let mut set = HashSet::new();
     match schema
-        .schema
-        .document
         .get_named_type(name)
         .ok_or_else(|| QueryExecutionError::AbstractTypeError(name.to_string()))?
     {

graphql/src/execution/execution.rs

@@ -19,9 +19,7 @@ use graph::util::lfu_cache::LfuCache;
 
 use super::QueryHash;
 use crate::execution::ast as a;
-use crate::introspection::{
-    is_introspection_field, INTROSPECTION_DOCUMENT, INTROSPECTION_QUERY_TYPE,
-};
+use crate::introspection::{is_introspection_field, INTROSPECTION_QUERY_TYPE};
 use crate::prelude::*;
 use crate::schema::ast as sast;
 
@@ -208,15 +206,6 @@ where
     pub(crate) cache_status: AtomicCell<CacheStatus>,
 }
 
-// Helpers to look for types and fields on both the introspection and regular schemas.
-pub(crate) fn get_named_type(schema: &s::Document, name: &str) -> Option<s::TypeDefinition> {
-    if name.starts_with("__") {
-        INTROSPECTION_DOCUMENT.get_named_type(name).cloned()
-    } else {
-        schema.get_named_type(name).cloned()
-    }
-}
-
 pub(crate) fn get_field<'a>(
     object_type: impl Into<ObjectOrInterface<'a>>,
     name: &str,
@@ -229,17 +218,6 @@ pub(crate) fn get_field<'a>(
     }
 }
 
-pub(crate) fn object_or_interface<'a>(
-    schema: &'a s::Document,
-    name: &str,
-) -> Option<ObjectOrInterface<'a>> {
-    if name.starts_with("__") {
-        INTROSPECTION_DOCUMENT.object_or_interface(name)
-    } else {
-        schema.object_or_interface(name)
-    }
-}
-
 impl<R> ExecutionContext<R>
 where
     R: Resolver,
@@ -615,7 +593,6 @@ fn resolve_field_value_for_named_type(
     let named_type = ctx
         .query
         .schema
-        .document()
         .get_named_type(type_name)
         .ok_or_else(|| QueryExecutionError::NamedTypeError(type_name.to_string()))?;
     match named_type {
@@ -671,7 +648,6 @@ fn resolve_field_value_for_list_type(
             let named_type = ctx
                 .query
                 .schema
-                .document()
                 .get_named_type(type_name)
                 .ok_or_else(|| QueryExecutionError::NamedTypeError(type_name.to_string()))?;
 
@@ -773,7 +749,7 @@ fn complete_value(
         }
 
         s::Type::NamedType(name) => {
-            let named_type = ctx.query.schema.document().get_named_type(name).unwrap();
+            let named_type = ctx.query.schema.get_named_type(name).unwrap();
 
             match named_type {
                 // Complete scalar values
@@ -858,7 +834,7 @@ fn resolve_abstract_type<'a>(
     // yields nothing
     let obj_type = ctx
         .resolver
-        .resolve_abstract_type(ctx.query.schema.document(), abstract_type, object_value)
+        .resolve_abstract_type(&ctx.query.schema, abstract_type, object_value)
         .ok_or_else(|| {
             vec![QueryExecutionError::AbstractTypeError(
                 sast::get_type_name(abstract_type).to_string(),

graphql/src/execution/query.rs

@@ -7,10 +7,7 @@ use std::sync::Arc;
 use std::time::Instant;
 use std::{collections::hash_map::DefaultHasher, convert::TryFrom};
 
-use graph::data::graphql::{
-    ext::{DocumentExt, TypeExt},
-    ObjectOrInterface,
-};
+use graph::data::graphql::{ext::TypeExt, ObjectOrInterface};
 use graph::data::query::{Query as GraphDataQuery, QueryVariables};
 use graph::data::schema::ApiSchema;
 use graph::prelude::{
@@ -21,10 +18,7 @@ use crate::execution::ast as a;
 use crate::query::{ast as qast, ext::BlockConstraint};
 use crate::schema::ast as sast;
 use crate::values::coercion;
-use crate::{
-    execution::{get_field, get_named_type, object_or_interface},
-    schema::api::ErrorPolicy,
-};
+use crate::{execution::get_field, schema::api::ErrorPolicy};
 
 #[derive(Clone, Debug)]
 pub enum ComplexityError {
@@ -157,8 +151,8 @@ impl Query {
 
         let start = Instant::now();
         let root_type = match kind {
-            Kind::Query => schema.document().get_root_query_type().unwrap(),
-            Kind::Subscription => schema.document().get_root_subscription_type().unwrap(),
+            Kind::Query => schema.query_type.as_ref(),
+            Kind::Subscription => schema.subscription_type.as_ref().unwrap(),
         };
         // Use an intermediate struct so we can modify the query before
         // enclosing it in an Arc
@@ -316,7 +310,7 @@ pub fn coerce_variables(
         .flatten()
     {
         // Skip variable if it has an invalid type
-        if !sast::is_input_type(schema.document(), &variable_def.var_type) {
+        if !schema.is_input_type(&variable_def.var_type) {
             errors.push(QueryExecutionError::InvalidVariableTypeError(
                 variable_def.position,
                 variable_def.name.to_owned(),
@@ -371,7 +365,7 @@ fn coerce_variable(
 ) -> Result<r::Value, Vec<QueryExecutionError>> {
     use crate::values::coercion::coerce_value;
 
-    let resolver = |name: &str| schema.document().get_named_type(name);
+    let resolver = |name: &str| schema.get_named_type(name);
 
     coerce_value(value, &variable_def.var_type, &resolver).map_err(|value| {
         vec![QueryExecutionError::InvalidArgumentError(
@@ -430,7 +424,6 @@ impl<'s> RawQuery<'s> {
             .items
             .iter()
             .try_fold(0, |total_complexity, selection| {
-                let schema = self.schema.document();
                 match selection {
                     q::Selection::Field(field) => {
                         // Empty selection sets are the base case.
@@ -454,7 +447,8 @@ impl<'s> RawQuery<'s> {
                         .ok_or(Invalid)?;
 
                         let field_complexity = self.complexity_inner(
-                            &get_named_type(schema, s_field.field_type.get_base_type())
+                            self.schema
+                                .get_named_type(s_field.field_type.get_base_type())
                                 .ok_or(Invalid)?,
                             &field.selection_set,
                             max_depth,
@@ -483,7 +477,7 @@ impl<'s> RawQuery<'s> {
                     q::Selection::FragmentSpread(fragment) => {
                         let def = self.fragments.get(&fragment.fragment_name).unwrap();
                         let q::TypeCondition::On(type_name) = &def.type_condition;
-                        let ty = get_named_type(schema, &type_name).ok_or(Invalid)?;
+                        let ty = self.schema.get_named_type(&type_name).ok_or(Invalid)?;
 
                         // Copy `visited_fragments` on write.
                         let mut visited_fragments = visited_fragments.clone();
@@ -501,12 +495,12 @@ impl<'s> RawQuery<'s> {
                     q::Selection::InlineFragment(fragment) => {
                         let ty = match &fragment.type_condition {
                             Some(q::TypeCondition::On(type_name)) => {
-                                get_named_type(schema, &type_name).ok_or(Invalid)?
+                                self.schema.get_named_type(type_name).ok_or(Invalid)?
                             }
-                            _ => ty.clone(),
+                            _ => ty,
                         };
                         self.complexity_inner(
-                            &ty,
+                            ty,
                             &fragment.selection_set,
                             max_depth,
                             depth + 1,
@@ -523,7 +517,7 @@ impl<'s> RawQuery<'s> {
     /// If the query is invalid, returns `Ok(0)` so that execution proceeds and
     /// gives a proper error.
     fn complexity(&self, max_depth: u8) -> Result<u64, QueryExecutionError> {
-        let root_type = sast::get_root_query_type_def(self.schema.document()).unwrap();
+        let root_type = self.schema.get_root_query_type_def().unwrap();
 
         match self.complexity_inner(
             root_type,
@@ -545,7 +539,7 @@ impl<'s> RawQuery<'s> {
     }
 
     fn validate_fields(&self) -> Result<(), Vec<QueryExecutionError>> {
-        let root_type = self.schema.document().get_root_query_type().unwrap();
+        let root_type = self.schema.query_type.as_ref();
 
         let errors =
             self.validate_fields_inner(&"Query".to_owned(), root_type.into(), &self.selection_set);
@@ -563,8 +557,6 @@ impl<'s> RawQuery<'s> {
         ty: ObjectOrInterface<'_>,
         selection_set: &q::SelectionSet,
     ) -> Vec<QueryExecutionError> {
-        let schema = self.schema.document();
-
         selection_set
             .items
             .iter()
@@ -573,9 +565,9 @@ impl<'s> RawQuery<'s> {
                     q::Selection::Field(field) => match get_field(ty, &field.name) {
                         Some(s_field) => {
                             let base_type = s_field.field_type.get_base_type();
-                            if get_named_type(schema, base_type).is_none() {
+                            if self.schema.get_named_type(base_type).is_none() {
                                 errors.push(QueryExecutionError::NamedTypeError(base_type.into()));
-                            } else if let Some(ty) = object_or_interface(schema, base_type) {
+                            } else if let Some(ty) = self.schema.object_or_interface(base_type) {
                                 errors.extend(self.validate_fields_inner(
                                     base_type,
                                     ty,
@@ -593,7 +585,7 @@ impl<'s> RawQuery<'s> {
                         match self.fragments.get(&fragment.fragment_name) {
                             Some(frag) => {
                                 let q::TypeCondition::On(type_name) = &frag.type_condition;
-                                match object_or_interface(schema, type_name) {
+                                match self.schema.object_or_interface(type_name) {
                                     Some(ty) => errors.extend(self.validate_fields_inner(
                                         type_name,
                                         ty,
@@ -611,7 +603,7 @@ impl<'s> RawQuery<'s> {
                     }
                     q::Selection::InlineFragment(fragment) => match &fragment.type_condition {
                         Some(q::TypeCondition::On(type_name)) => {
-                            match object_or_interface(schema, type_name) {
+                            match self.schema.object_or_interface(type_name) {
                                 Some(ty) => errors.extend(self.validate_fields_inner(
                                     type_name,
                                     ty,
@@ -745,7 +737,7 @@ impl Transform {
     ) -> Result<(), Vec<QueryExecutionError>> {
         let mut errors = vec![];
 
-        let resolver = |name: &str| self.schema.document().get_named_type(name);
+        let resolver = |name: &str| self.schema.get_named_type(name);
 
         for argument_def in sast::get_argument_definitions(ty, field_name)
             .into_iter()
@@ -812,7 +804,7 @@ impl Transform {
             let field_type = parent_type.field(&name).expect("field names are valid");
             let ty = field_type.field_type.get_base_type();
             let type_set = a::ObjectTypeSet::from_name(&self.schema, ty)?;
-            let ty = self.schema.document().object_or_interface(ty).unwrap();
+            let ty = self.schema.object_or_interface(ty).unwrap();
             self.expand_selection_set(selection_set, &type_set, ty)?
         };
 
@@ -914,7 +906,6 @@ impl Transform {
         let ty = match frag_cond {
             Some(q::TypeCondition::On(name)) => self
                 .schema
-                .document()
                 .object_or_interface(name)
                 .expect("type names on fragment spreads are valid"),
             None => ty,