graphql: Mix the introspection schema into the API schema

That makes it possible to use the same schema for data nad for
introspection queries

Author: lutter

graph/src/data/graphql/ext.rs

@@ -307,6 +307,41 @@ impl DirectiveFinder for Vec<Directive> {
     }
 }
 
+pub trait TypeDefinitionExt {
+    fn name(&self) -> &str;
+
+    // Return `true` if this is the definition of a type from the
+    // introspection schema
+    fn is_introspection(&self) -> bool {
+        self.name().starts_with("__")
+    }
+}
+
+impl TypeDefinitionExt for TypeDefinition {
+    fn name(&self) -> &str {
+        match self {
+            TypeDefinition::Scalar(t) => &t.name,
+            TypeDefinition::Object(t) => &t.name,
+            TypeDefinition::Interface(t) => &t.name,
+            TypeDefinition::Union(t) => &t.name,
+            TypeDefinition::Enum(t) => &t.name,
+            TypeDefinition::InputObject(t) => &t.name,
+        }
+    }
+}
+
+pub trait FieldExt {
+    // Return `true` if this is the name of one of the query fields from the
+    // introspection schema
+    fn is_introspection(&self) -> bool;
+}
+
+impl FieldExt for Field {
+    fn is_introspection(&self) -> bool {
+        &self.name == "__schema" || &self.name == "__type"
+    }
+}
+
 #[cfg(test)]
 mod directive_finder_tests {
     use graphql_parser::parse_schema;

graph/src/data/introspection.graphql

@@ -0,0 +1,98 @@
+# A GraphQL introspection schema for inclusion in a subgraph's API schema.
+# The schema differs from the 'standard' introspection schema in that it
+# doesn't have a Query type nor scalar declarations as they come from the
+# API schema.
+
+type __Schema {
+  types: [__Type!]!
+  queryType: __Type!
+  mutationType: __Type
+  subscriptionType: __Type
+  directives: [__Directive!]!
+}
+
+type __Type {
+  kind: __TypeKind!
+  name: String
+  description: String
+
+  # OBJECT and INTERFACE only
+  fields(includeDeprecated: Boolean = false): [__Field!]
+
+  # OBJECT only
+  interfaces: [__Type!]
+
+  # INTERFACE and UNION only
+  possibleTypes: [__Type!]
+
+  # ENUM only
+  enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
+
+  # INPUT_OBJECT only
+  inputFields: [__InputValue!]
+
+  # NON_NULL and LIST only
+  ofType: __Type
+}
+
+type __Field {
+  name: String!
+  description: String
+  args: [__InputValue!]!
+  type: __Type!
+  isDeprecated: Boolean!
+  deprecationReason: String
+}
+
+type __InputValue {
+  name: String!
+  description: String
+  type: __Type!
+  defaultValue: String
+}
+
+type __EnumValue {
+  name: String!
+  description: String
+  isDeprecated: Boolean!
+  deprecationReason: String
+}
+
+enum __TypeKind {
+  SCALAR
+  OBJECT
+  INTERFACE
+  UNION
+  ENUM
+  INPUT_OBJECT
+  LIST
+  NON_NULL
+}
+
+type __Directive {
+  name: String!
+  description: String
+  locations: [__DirectiveLocation!]!
+  args: [__InputValue!]!
+}
+
+enum __DirectiveLocation {
+  QUERY
+  MUTATION
+  SUBSCRIPTION
+  FIELD
+  FRAGMENT_DEFINITION
+  FRAGMENT_SPREAD
+  INLINE_FRAGMENT
+  SCHEMA
+  SCALAR
+  OBJECT
+  FIELD_DEFINITION
+  ARGUMENT_DEFINITION
+  INTERFACE
+  UNION
+  ENUM
+  ENUM_VALUE
+  INPUT_OBJECT
+  INPUT_FIELD_DEFINITION
+}

graph/src/data/schema.rs

@@ -3,6 +3,7 @@ use crate::data::graphql::ext::{DirectiveExt, DirectiveFinder, DocumentExt, Type
 use crate::data::store::ValueType;
 use crate::data::subgraph::{DeploymentHash, SubgraphName};
 use crate::prelude::{
+    lazy_static,
     q::Value,
     s::{self, Definition, InterfaceType, ObjectType, TypeDefinition, *},
 };
@@ -355,8 +356,15 @@ pub struct ApiSchema {
 }
 
 impl ApiSchema {
-    /// `api_schema` will typically come from `fn api_schema` in the graphql crate.
-    pub fn from_api_schema(api_schema: Schema) -> Result<Self, anyhow::Error> {
+    /// `api_schema` will typically come from `fn api_schema` in the graphql
+    /// crate.
+    ///
+    /// In addition, the API schema has an introspection schema mixed into
+    /// `api_schema`. In particular, the `Query` type has fields called
+    /// `__schema` and `__type`
+    pub fn from_api_schema(mut api_schema: Schema) -> Result<Self, anyhow::Error> {
+        add_introspection_schema(&mut api_schema.document);
+
         let query_type = api_schema
             .document
             .get_root_query_type()
@@ -397,6 +405,69 @@ impl ApiSchema {
     }
 }
 
+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")
+        };
+    }
+
+    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:
+        //
+        // type Query {
+        //   __schema: __Schema!
+        //   __type(name: String!): __Type
+        // }
+
+        let type_args = vec![InputValue {
+            position: Pos::default(),
+            description: None,
+            name: "name".to_string(),
+            value_type: Type::NonNullType(Box::new(Type::NamedType("String".to_string()))),
+            default_value: None,
+            directives: vec![],
+        }];
+
+        vec![
+            Field {
+                position: Pos::default(),
+                description: None,
+                name: "__schema".to_string(),
+                arguments: vec![],
+                field_type: Type::NonNullType(Box::new(Type::NamedType("__Schema".to_string()))),
+                directives: vec![],
+            },
+            Field {
+                position: Pos::default(),
+                description: None,
+                name: "__type".to_string(),
+                arguments: type_args,
+                field_type: Type::NamedType("__Type".to_string()),
+                directives: vec![],
+            },
+        ]
+    }
+
+    schema
+        .definitions
+        .extend(INTROSPECTION_SCHEMA.definitions.iter().cloned());
+
+    let query_type = schema
+        .definitions
+        .iter_mut()
+        .filter_map(|d| match d {
+            Definition::TypeDefinition(TypeDefinition::Object(t)) if t.name == "Query" => Some(t),
+            _ => None,
+        })
+        .peekable()
+        .next()
+        .expect("no root `Query` in the schema");
+    query_type.fields.append(&mut introspection_fields());
+}
+
 /// A validated and preprocessed GraphQL schema for a subgraph.
 #[derive(Clone, Debug, PartialEq)]
 pub struct Schema {

graphql/src/introspection/resolver.rs

@@ -1,3 +1,4 @@
+use graph::data::graphql::ext::{FieldExt, TypeDefinitionExt};
 use graphql_parser::Pos;
 use std::collections::{BTreeMap, HashMap};
 
@@ -10,18 +11,21 @@ use crate::schema::ast as sast;
 
 type TypeObjectsMap = BTreeMap<String, r::Value>;
 
+/// Our Schema has the introspection schema mixed in. When we build the
+/// `TypeObjectsMap`, suppress types and fields that belong to the
+/// introspection schema
 fn schema_type_objects(schema: &Schema) -> TypeObjectsMap {
-    sast::get_type_definitions(&schema.document).iter().fold(
-        BTreeMap::new(),
-        |mut type_objects, typedef| {
+    sast::get_type_definitions(&schema.document)
+        .iter()
+        .filter(|def| !def.is_introspection())
+        .fold(BTreeMap::new(), |mut type_objects, typedef| {
             let type_name = sast::get_type_name(typedef);
             if !type_objects.contains_key(type_name) {
                 let type_object = type_definition_object(schema, &mut type_objects, typedef);
                 type_objects.insert(type_name.to_owned(), type_object);
             }
             type_objects
-        },
-    )
+        })
 }
 
 fn type_object(schema: &Schema, type_objects: &mut TypeObjectsMap, t: &s::Type) -> r::Value {
@@ -167,6 +171,7 @@ fn field_objects(
     r::Value::List(
         fields
             .iter()
+            .filter(|field| !field.is_introspection())
             .map(|field| field_object(schema, type_objects, field))
             .collect(),
     )

graphql/src/schema/api.rs

@@ -73,9 +73,8 @@ impl TryFrom<&r::Value> for ErrorPolicy {
 /// Derives a full-fledged GraphQL API schema from an input schema.
 ///
 /// The input schema should only have type/enum/interface/union definitions
-/// and must not include a root Query type. This Query type is derived,
-/// with all its fields and their input arguments, based on the existing
-/// types.
+/// and must not include a root Query type. This Query type is derived, with
+/// all its fields and their input arguments, based on the existing types.
 pub fn api_schema(input_schema: &Document) -> Result<Document, APISchemaError> {
     // Refactor: Take `input_schema` by value.
     let object_types = input_schema.get_object_type_definitions();
@@ -528,9 +527,9 @@ fn add_query_type(
 
     let mut fields = object_types
         .iter()
-        .map(|t| &t.name)
+        .map(|t| t.name.as_str())
         .filter(|name| !name.eq(&SCHEMA_TYPE_NAME))
-        .chain(interface_types.iter().map(|t| &t.name))
+        .chain(interface_types.iter().map(|t| t.name.as_str()))
         .flat_map(|name| query_fields_for_type(name))
         .collect::<Vec<Field>>();
     let mut fulltext_fields = schema

store/postgres/tests/store.rs

@@ -1,3 +1,4 @@
+use graph::data::graphql::ext::TypeDefinitionExt;
 use graph_chain_ethereum::{Mapping, MappingABI};
 use graph_mock::MockMetricsRegistry;
 use hex_literal::hex;
@@ -1480,6 +1481,7 @@ fn subgraph_schema_types_have_subgraph_id_directive() {
                 s::Definition::TypeDefinition(typedef) => Some(typedef),
                 _ => None,
             })
+            .filter(|typedef| !typedef.is_introspection())
         {
             // Verify that all types have a @subgraphId directive on them
             let directive = match typedef {