feat: add @oneOf support to introspection (#1177)

Author: obmarg

cynic-cli/README.md

@@ -88,6 +88,7 @@ Options:
           Possible values:
           - 2018: Run an introspection query compatible with the 2018 GraphQL specification
           - 2021: Run an introspection query compatible with the 2021 GraphQL specification
+          - 2025: Run an introspection query compatible with the 2025 GraphQL specification
           - auto: Run an additional query to determine what the GraphQL server supports
 
   -h, --help

cynic-cli/src/introspect.rs

@@ -12,6 +12,7 @@ pub(crate) fn introspect(args: IntrospectArgs) -> Result<(), IntrospectError> {
     let capabilities = match args.server_version {
         GraphQlVersion::TwentyEighteen => SpecificationVersion::June2018.capabilities(),
         GraphQlVersion::TwentyTwentyOne => SpecificationVersion::October2021.capabilities(),
+        GraphQlVersion::TwentyTwentyFive => SpecificationVersion::September2025.capabilities(),
         GraphQlVersion::AutoDetect => detect_capabilities(&client, &args)?,
     };
 

cynic-cli/src/main.rs

@@ -96,6 +96,9 @@ enum GraphQlVersion {
     /// Run an introspection query compatible with the 2021 GraphQL specification
     #[value(name = "2021")]
     TwentyTwentyOne,
+    /// Run an introspection query compatible with the 2025 GraphQL specification
+    #[value(name = "2025")]
+    TwentyTwentyFive,
     /// Run an additional query to determine what the GraphQL server supports
     #[value(name = "auto")]
     #[default]
@@ -107,6 +110,7 @@ impl std::fmt::Display for GraphQlVersion {
         match self {
             GraphQlVersion::TwentyEighteen => write!(f, "2018"),
             GraphQlVersion::TwentyTwentyOne => write!(f, "2021"),
+            GraphQlVersion::TwentyTwentyFive => write!(f, "2025"),
             GraphQlVersion::AutoDetect => write!(f, "auto"),
         }
     }

cynic-cli/tests/cases/help/introspect-help.stdout

@@ -29,6 +29,7 @@ Options:
           Possible values:
           - 2018: Run an introspection query compatible with the 2018 GraphQL specification
           - 2021: Run an introspection query compatible with the 2021 GraphQL specification
+          - 2025: Run an introspection query compatible with the 2025 GraphQL specification
           - auto: Run an additional query to determine what the GraphQL server supports
 
   -h, --help

cynic-introspection/src/detection.rs

@@ -59,9 +59,15 @@ impl CapabilitiesQuery {
             .iter()
             .find(|field| field.name == "specifiedByURL");
 
-        match specified_by_field {
-            Some(_) => SpecificationVersion::October2021,
-            None => SpecificationVersion::June2018,
+        let one_of_field = type_type
+            .fields
+            .iter()
+            .find(|field| field.name == "isOneOf");
+
+        match (one_of_field, specified_by_field) {
+            (Some(_), _) => SpecificationVersion::September2025,
+            (None, Some(_)) => SpecificationVersion::October2021,
+            _ => SpecificationVersion::June2018,
         }
     }
 }
@@ -78,6 +84,8 @@ pub enum SpecificationVersion {
     June2018,
     /// The GraphQL specification published in October 2021
     October2021,
+    /// The GraphQL specification published in September 2025
+    September2025,
 }
 
 #[derive(cynic::QueryFragment, Debug)]

cynic-introspection/src/query.rs

@@ -78,6 +78,12 @@ pub struct Type {
     /// A URL pointing to a specification for this scalar, if there is one
     #[cynic(rename = "specifiedByURL", feature = "2021")]
     pub specified_by_url: Option<String>,
+    /// Whether this type is a oneOf input object.
+    ///
+    /// This will be present on input objects from servers supporting `oneOf`
+    /// and null on other types
+    #[cynic(feature = "2025")]
+    pub is_one_of: Option<bool>,
 }
 
 #[derive(cynic::QueryFragment, Debug)]

cynic-introspection/src/query_builder.rs

@@ -9,6 +9,10 @@ impl IntrospectionQuery {
         match capabilities.specification_version {
             SpecificationVersion::Unknown | SpecificationVersion::June2018 => {}
             SpecificationVersion::October2021 => builder.enable_feature("2021"),
+            SpecificationVersion::September2025 => {
+                builder.enable_feature("2021");
+                builder.enable_feature("2025");
+            }
         }
         builder.build().expect("to succeed")
     }

cynic-introspection/src/schema.graphql

@@ -34,6 +34,8 @@ type __Type {
   ofType: __Type
   # may be non-null for custom SCALAR, otherwise null.
   specifiedByURL: String
+  # must be non-null for INPUT_OBJECT, otherwise null.
+  isOneOf: Boolean
 }
 
 enum __TypeKind {

cynic-introspection/src/schema/mod.rs

@@ -102,6 +102,8 @@ pub struct InputObjectType {
     pub description: Option<String>,
     /// The fields of the input object
     pub fields: Vec<InputValue>,
+    /// Whether this object is a oneOf input object or not
+    pub is_one_of: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -433,6 +435,7 @@ impl TryFrom<crate::query::Type> for Type {
                     .into_iter()
                     .map(InputValue::try_from)
                     .collect::<Result<Vec<_>, _>>()?,
+                is_one_of: ty.is_one_of.unwrap_or_default(),
             })),
             crate::query::TypeKind::List => Err(SchemaError::UnexpectedList),
             crate::query::TypeKind::NonNull => Err(SchemaError::UnexpectedNonNull),

cynic-introspection/src/schema/sdl.rs

@@ -126,17 +126,21 @@ impl std::fmt::Display for TypeDisplay<'_> {
                 name,
                 description,
                 fields,
+                is_one_of,
             }) => {
                 write!(f, "{}", DescriptionDisplay(description.as_deref()))?;
-                if fields.is_empty() {
-                    writeln!(f, "input {name}")
-                } else {
-                    writeln!(f, "input {name} {{")?;
+                write!(f, "input {name}")?;
+                if *is_one_of {
+                    write!(f, " @oneOf")?;
+                }
+                if !fields.is_empty() {
+                    writeln!(f, " {{")?;
                     for field in fields {
                         writeln!(indented(f), "{}", InputValueDisplay(field))?;
                     }
-                    writeln!(f, "}}\n")
+                    writeln!(f, "}}")?;
                 }
+                writeln!(f)
             }
             Type::Enum(EnumType {
                 name,