graph, graphql: Remove Subscription type from API schema

lutter · lutter · commit d1100e89909f · 2025-02-18T17:53:24.000-08:00
diff --git a/graph/src/data/graphql/ext.rs b/graph/src/data/graphql/ext.rs
@@ -52,8 +52,6 @@ pub trait DocumentExt {
 
     fn get_root_query_type(&self) -> Option<&ObjectType>;
 
-    fn get_root_subscription_type(&self) -> Option<&ObjectType>;
-
     fn object_or_interface(&self, name: &str) -> Option<ObjectOrInterface<'_>>;
 
     fn get_named_type(&self, name: &str) -> Option<&TypeDefinition>;
@@ -159,21 +157,6 @@ impl DocumentExt for Document {
             .next()
     }
 
-    fn get_root_subscription_type(&self) -> Option<&ObjectType> {
-        self.definitions
-            .iter()
-            .filter_map(|d| match d {
-                Definition::TypeDefinition(TypeDefinition::Object(t))
-                    if t.name == "Subscription" =>
-                {
-                    Some(t)
-                }
-                _ => None,
-            })
-            .peekable()
-            .next()
-    }
-
     fn object_or_interface(&self, name: &str) -> Option<ObjectOrInterface<'_>> {
         match self.get_named_type(name) {
             Some(TypeDefinition::Object(t)) => Some(t.into()),
diff --git a/graph/src/data/query/error.rs b/graph/src/data/query/error.rs
@@ -26,7 +26,6 @@ pub enum QueryExecutionError {
     OperationNameRequired,
     OperationNotFound(String),
     NotSupported(String),
-    NoRootSubscriptionObjectType,
     NonNullError(Pos, String),
     ListValueError(Pos, String),
     NamedTypeError(String),
@@ -42,7 +41,6 @@ pub enum QueryExecutionError {
     FilterNotSupportedError(String, String),
     UnknownField(Pos, String, String),
     EmptyQuery,
-    MultipleSubscriptionFields,
     SubgraphDeploymentIdError(String),
     RangeArgumentsError(&'static str, u32, i64),
     InvalidFilterError,
@@ -67,7 +65,6 @@ pub enum QueryExecutionError {
     Throttled,
     UndefinedFragment(String),
     Panic(String),
-    EventStreamError,
     FulltextQueryRequiresFilter,
     FulltextQueryInvalidSyntax(String),
     DeploymentReverted,
@@ -87,7 +84,6 @@ impl QueryExecutionError {
             OperationNameRequired
             | OperationNotFound(_)
             | NotSupported(_)
-            | NoRootSubscriptionObjectType
             | NonNullError(_, _)
             | NamedTypeError(_)
             | AbstractTypeError(_)
@@ -101,7 +97,6 @@ impl QueryExecutionError {
             | ChildFilterNestingNotSupportedError(_, _)
             | UnknownField(_, _, _)
             | EmptyQuery
-            | MultipleSubscriptionFields
             | SubgraphDeploymentIdError(_)
             | InvalidFilterError
             | EntityFieldError(_, _)
@@ -127,7 +122,6 @@ impl QueryExecutionError {
             | TooComplex(_, _)
             | TooDeep(_)
             | Panic(_)
-            | EventStreamError
             | TooExpensive
             | Throttled
             | DeploymentReverted
@@ -166,9 +160,6 @@ impl fmt::Display for QueryExecutionError {
                 write!(f, "{}", message)
             }
             NotSupported(s) => write!(f, "Not supported: {}", s),
-            NoRootSubscriptionObjectType => {
-                write!(f, "No root Subscription type defined in the schema")
-            }
             NonNullError(_, s) => {
                 write!(f, "Null value resolved for non-null field `{}`", s)
             }
@@ -212,10 +203,6 @@ impl fmt::Display for QueryExecutionError {
                 write!(f, "Type `{}` has no field `{}`", t, s)
             }
             EmptyQuery => write!(f, "The query is empty"),
-            MultipleSubscriptionFields => write!(
-                f,
-                "Only a single top-level field is allowed in subscriptions"
-            ),
             SubgraphDeploymentIdError(s) => {
                 write!(f, "Failed to get subgraph ID from type: `{}`", s)
             }
@@ -276,7 +263,6 @@ impl fmt::Display for QueryExecutionError {
             CyclicalFragment(name) =>write!(f, "query has fragment cycle including `{}`", name),
             UndefinedFragment(frag_name) => write!(f, "fragment `{}` is not defined", frag_name),
             Panic(msg) => write!(f, "panic processing query: {}", msg),
-            EventStreamError => write!(f, "error in the subscription event stream"),
             FulltextQueryRequiresFilter => write!(f, "fulltext search queries can only use EntityFilter::Equal"),
             FulltextQueryInvalidSyntax(msg) => write!(f, "Invalid fulltext search query syntax. Error: {}. Hint: Search terms with spaces need to be enclosed in single quotes", msg),
             TooExpensive => write!(f, "query is too expensive"),
diff --git a/graph/src/schema/api.rs b/graph/src/schema/api.rs
@@ -90,8 +90,8 @@ impl TryFrom<&r::Value> for ErrorPolicy {
 ///
 /// (2) By parsing an appropriate GraphQL schema from text and calling
 /// `from_graphql_schema`. In that case, it's the caller's responsibility to
-/// make sure that the schema has all the types needed for querying, like
-/// `Query` and `Subscription`
+/// make sure that the schema has all the types needed for querying, in
+/// particular `Query`
 ///
 /// Because of the second point, once constructed, it can not be assumed
 /// that an `ApiSchema` is based on an `InputSchema` and it can only be used
@@ -102,7 +102,6 @@ pub struct ApiSchema {
 
     // Root types for the api schema.
     pub query_type: Arc<s::ObjectType>,
-    pub subscription_type: Option<Arc<s::ObjectType>>,
     object_types: HashMap<String, Arc<s::ObjectType>>,
 }
 
@@ -121,11 +120,6 @@ impl ApiSchema {
             .get_root_query_type()
             .context("no root `Query` in the schema")?
             .clone();
-        let subscription_type = schema
-            .document
-            .get_root_subscription_type()
-            .cloned()
-            .map(Arc::new);
 
         let object_types = HashMap::from_iter(
             schema
@@ -138,7 +132,6 @@ impl ApiSchema {
         Ok(Self {
             schema,
             query_type: Arc::new(query_type),
-            subscription_type,
             object_types,
         })
     }
@@ -360,7 +353,6 @@ pub(in crate::schema) fn api_schema(
     add_types_for_interface_types(&mut api, input_schema)?;
     add_types_for_aggregation_types(&mut api, input_schema)?;
     add_query_type(&mut api.document, input_schema)?;
-    add_subscription_type(&mut api.document, input_schema)?;
     Ok(api.document)
 }
 
@@ -1135,44 +1127,6 @@ fn query_field_for_fulltext(fulltext: &s::Directive) -> Option<s::Field> {
     })
 }
 
-/// Adds a root `Subscription` object type to the schema.
-fn add_subscription_type(
-    api: &mut s::Document,
-    input_schema: &InputSchema,
-) -> Result<(), APISchemaError> {
-    let type_name = String::from("Subscription");
-
-    if api.get_named_type(&type_name).is_some() {
-        return Err(APISchemaError::TypeExists(type_name));
-    }
-
-    let mut fields: Vec<s::Field> = input_schema
-        .object_types()
-        .map(|(name, _)| name)
-        .chain(input_schema.interface_types().map(|(name, _)| name))
-        .flat_map(|name| query_fields_for_type(name, FilterOps::Object))
-        .collect();
-    let mut agg_fields = input_schema
-        .aggregation_types()
-        .map(|(name, _)| name)
-        .flat_map(query_fields_for_agg_type)
-        .collect::<Vec<s::Field>>();
-    fields.append(&mut agg_fields);
-    fields.push(meta_field());
-
-    let typedef = s::TypeDefinition::Object(s::ObjectType {
-        position: Pos::default(),
-        description: None,
-        name: type_name,
-        implements_interfaces: vec![],
-        directives: vec![],
-        fields,
-    });
-    let def = s::Definition::TypeDefinition(typedef);
-    api.definitions.push(def);
-    Ok(())
-}
-
 fn block_argument() -> s::InputValue {
     s::InputValue {
         position: Pos::default(),
diff --git a/graphql/src/execution/query.rs b/graphql/src/execution/query.rs
@@ -35,7 +35,6 @@ lazy_static! {
             vec![
                 Box::new(UniqueOperationNames::new()),
                 Box::new(LoneAnonymousOperation::new()),
-                Box::new(SingleFieldSubscriptions::new()),
                 Box::new(KnownTypeNames::new()),
                 Box::new(FragmentsOnCompositeTypes::new()),
                 Box::new(VariablesAreInputTypes::new()),
@@ -69,12 +68,6 @@ pub enum ComplexityError {
     CyclicalFragment(String),
 }
 
-#[derive(Copy, Clone)]
-enum Kind {
-    Query,
-    Subscription,
-}
-
 /// Helper to log the fields in a `SelectionSet` without cloning. Writes
 /// a list of field names from the selection set separated by ';'. Using
 /// ';' as a separator makes parsing the log a little easier since slog
@@ -130,8 +123,6 @@ pub struct Query {
 
     start: Instant,
 
-    kind: Kind,
-
     /// Used only for logging; if logging is configured off, these will
     /// have dummy values
     pub query_text: Arc<String>,
@@ -226,14 +217,14 @@ impl Query {
         let operation = operation.ok_or(QueryExecutionError::OperationNameRequired)?;
 
         let variables = coerce_variables(schema.as_ref(), &operation, query.variables)?;
-        let (kind, selection_set) = match operation {
-            q::OperationDefinition::Query(q::Query { selection_set, .. }) => {
-                (Kind::Query, selection_set)
-            }
+        let selection_set = match operation {
+            q::OperationDefinition::Query(q::Query { selection_set, .. }) => selection_set,
             // Queries can be run by just sending a selection set
-            q::OperationDefinition::SelectionSet(selection_set) => (Kind::Query, selection_set),
-            q::OperationDefinition::Subscription(q::Subscription { selection_set, .. }) => {
-                (Kind::Subscription, selection_set)
+            q::OperationDefinition::SelectionSet(selection_set) => selection_set,
+            q::OperationDefinition::Subscription(_) => {
+                return Err(vec![QueryExecutionError::NotSupported(
+                    "Subscriptions are not supported".to_owned(),
+                )])
             }
             q::OperationDefinition::Mutation(_) => {
                 return Err(vec![QueryExecutionError::NotSupported(
@@ -243,10 +234,8 @@ impl Query {
         };
 
         let start = Instant::now();
-        let root_type = match kind {
-            Kind::Query => schema.query_type.as_ref(),
-            Kind::Subscription => schema.subscription_type.as_ref().unwrap(),
-        };
+        let root_type = schema.query_type.as_ref();
+
         // Use an intermediate struct so we can modify the query before
         // enclosing it in an Arc
         let raw_query = RawQuery {
@@ -269,7 +258,6 @@ impl Query {
             schema,
             selection_set: Arc::new(selection_set),
             shape_hash: query.shape_hash,
-            kind,
             network,
             logger,
             start,
@@ -345,23 +333,6 @@ impl Query {
         Ok(bcs)
     }
 
-    /// Return `true` if this is a query, and not a subscription or
-    /// mutation
-    pub fn is_query(&self) -> bool {
-        match self.kind {
-            Kind::Query => true,
-            Kind::Subscription => false,
-        }
-    }
-
-    /// Return `true` if this is a subscription, not a query or a mutation
-    pub fn is_subscription(&self) -> bool {
-        match self.kind {
-            Kind::Subscription => true,
-            Kind::Query => false,
-        }
-    }
-
     /// Log details about the overall execution of the query
     pub fn log_execution(&self, block: BlockNumber) {
         if ENV_VARS.log_gql_timing() {
diff --git a/graphql/src/introspection/resolver.rs b/graphql/src/introspection/resolver.rs
@@ -332,10 +332,7 @@ impl IntrospectionResolver {
                 self.type_objects
                     .get(&String::from("Query"))
                     .cloned(),
-            subscriptionType:
-                self.type_objects
-                    .get(&String::from("Subscription"))
-                    .cloned(),
+            subscriptionType: r::Value::Null,
             mutationType: r::Value::Null,
             types: self.type_objects.values().cloned().collect::<Vec<_>>(),
             directives: self.directives.clone(),
diff --git a/graphql/src/query/mod.rs b/graphql/src/query/mod.rs
@@ -1,6 +1,6 @@
 use graph::{
     data::query::CacheStatus,
-    prelude::{BlockPtr, CheapClone, QueryExecutionError, QueryResult},
+    prelude::{BlockPtr, CheapClone, QueryResult},
 };
 use std::sync::Arc;
 use std::time::Instant;
@@ -54,14 +54,6 @@ where
         trace: options.trace,
     });
 
-    if !query.is_query() {
-        return (
-            Arc::new(
-                QueryExecutionError::NotSupported("Only queries are supported".to_string()).into(),
-            ),
-            CacheStatus::default(),
-        );
-    }
     let selection_set = selection_set
         .map(Arc::new)
         .unwrap_or_else(|| query.selection_set.cheap_clone());
diff --git a/store/test-store/tests/graphql/mock_introspection.json b/store/test-store/tests/graphql/mock_introspection.json
