feat(compiler): Allow coercing Int variables to Float (#1011)

The GraphQL spec allows coercing Int values to Float in input positions (see [input coercion]). There are a couple things to note about this. 

1. Strings are not allowed to be coerced in this position, even if they are numeric.
2. Ints can only be converted to Float when they are "representable by finite IEEE 754" floating point numbers.

Since an IEEE 754 floating point double (f64) has 53 bits of precision, it can safely represent up to the value `2^53 - 1` as a finite value. Beyond that, the round trip from integer to float and back will lose information. I have represented this with a new `MAX_SAFE_INT` constant which is often included in other languages like JavaScript's `Number.MAX_SAFE_INT`. When, we encounter an Int variable in a Float position, we ensure that its value is finitely representable.

There is some nuance in that the spec does not say _all_ floats have to be within this range. So, this implementation allows explicitly passed floats which are greater than that bound, only applying the integer conversion limit when coercing a value.

[input coercion]: https://spec.graphql.org/September2025/#sec-Float.Input-Coercion

Author: tninesling

crates/apollo-compiler/CHANGELOG.md

@@ -70,6 +70,29 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
         .expect("schema parsed successfully");
   ```
 
+- **Allow coercing Int variables to Float - [tninesling], [pull/1011]**
+
+  The GraphQL spec allows coercing Int values to Float in input positions (see
+  [input coercion]). There are a couple things to note about this.
+
+  - Strings are not allowed to be coerced in this position, even if they are
+    numeric.
+  - Ints can only be converted to Float when they are "representable by finite
+    IEEE 754" floating point numbers.
+
+  Since an IEEE 754 floating point double (f64) has 53 bits of precision, it can
+  safely represent up to the value 2^53 - 1 as a finite value. Beyond that, the
+  round trip from integer to float and back will lose information. This is
+  represented with a new `MAX_SAFE_INT` constant which is often included in
+  other languages like JavaScript's `Number.MAX_SAFE_INT`. When, we encounter an
+  Int variable in a Float position, we ensure that its value is finitely
+  representable.
+
+  There is some nuance in that the spec does not say all floats have to be
+  within this range. So, this implementation allows explicitly passed floats
+  which are greater than that bound, only applying the integer conversion limit
+  when coercing a value.
+
 ## Fixes
 
 - **Fix handling of orphan root type extensions - [dariuszkuc], [pull/993](#993)**
@@ -106,12 +129,15 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
   Previously added `::iter_origins()` methods on Schema and Type Definitions was not made `pub`.
 
 [dariuszkuc]: https://github.com/dariuszkuc
-[duckki]: https://github.com/duckki 
+[duckki]: https://github.com/duckki
+[tninesling]: https://github.com/tninesling
+[input coercion]: https://spec.graphql.org/September2025/#sec-Float.Input-Coercion
 [pull/994]: https://github.com/apollographql/apollo-rs/pull/994
 [pull/993]: https://github.com/apollographql/apollo-rs/pull/993
 [pull/990]: https://github.com/apollographql/apollo-rs/pull/990
 [pull/989]: https://github.com/apollographql/apollo-rs/pull/989
 [pull/987]: https://github.com/apollographql/apollo-rs/pull/987
+[pull/1011]: https://github.com/apollographql/apollo-rs/pull/1011
 
 
 # [1.29.0](https://crates.io/crates/apollo-compiler/1.29.0) - 2025-08-08

crates/apollo-compiler/src/resolvers/input_coercion.rs

@@ -18,6 +18,9 @@ use crate::validation::Valid;
 use crate::Node;
 use crate::Schema;
 
+/// The maximum integer safely representable as an IEEE 754 double-precision float.
+const MAX_SAFE_INT: i64 = (1_i64 << 53) - 1;
+
 #[derive(Debug, Clone)]
 pub(crate) enum InputCoercionError {
     SuspectedValidationBug(SuspectedValidationBug),
@@ -120,7 +123,11 @@ fn coerce_variable_value(
             }
             "Float" => {
                 // https://spec.graphql.org/October2021/#sec-Float.Input-Coercion
-                if value.is_f64() {
+                if value.is_f64()
+                    || value
+                        .as_f64()
+                        .is_some_and(|f| f.abs() < MAX_SAFE_INT as f64)
+                {
                     return Ok(value.clone());
                 }
             }
@@ -479,3 +486,115 @@ impl InputCoercionError {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::validation::Valid;
+    use crate::ExecutableDocument;
+    use crate::Schema;
+
+    fn schema_and_doc_with_float_arg() -> (Valid<Schema>, Valid<ExecutableDocument>) {
+        let schema = Schema::parse_and_validate(
+            r#"
+                type Query {
+                    foo(bar: Float!): Float!
+                }
+            "#,
+            "sdl",
+        )
+        .unwrap();
+        let doc = ExecutableDocument::parse_and_validate(
+            &schema,
+            "query ($bar: Float!) { foo(bar: $bar) }",
+            "op.graphql",
+        )
+        .unwrap();
+        (schema, doc)
+    }
+
+    #[test]
+    fn coerces_float_to_float() {
+        let float_beyond_integer_max = (MAX_SAFE_INT as f64) + 0.5;
+        let variables = serde_json_bytes::json!({ "bar": float_beyond_integer_max });
+        let (schema, doc) = schema_and_doc_with_float_arg();
+
+        // When a float greater than MAX_SAFE_INT is provided, it should be accepted as a float.
+        let _ = coerce_variable_values(
+            &schema,
+            doc.operations.anonymous.as_ref().unwrap(),
+            variables.as_object().unwrap(),
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn coerces_int_to_float() {
+        let variables = serde_json_bytes::json!({ "bar": 14 });
+        let (schema, doc) = schema_and_doc_with_float_arg();
+
+        // When an integer within the safe bounds is provided, it should be accepted as a float.
+        let _ = coerce_variable_values(
+            &schema,
+            doc.operations.anonymous.as_ref().unwrap(),
+            variables.as_object().unwrap(),
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn fails_to_coerce_int_to_float_beyond_precision_bound() {
+        let variables = serde_json_bytes::json!({ "bar": i64::MAX });
+        let (schema, doc) = schema_and_doc_with_float_arg();
+
+        // When an integer cannot be finitely represented as a float, it should be rejected.
+        let _ = coerce_variable_values(
+            &schema,
+            doc.operations.anonymous.as_ref().unwrap(),
+            variables.as_object().unwrap(),
+        )
+        .unwrap_err();
+    }
+
+    #[test]
+    fn fails_to_numeric_string_to_float() {
+        let variables = serde_json_bytes::json!({ "bar": "14" });
+        let (schema, doc) = schema_and_doc_with_float_arg();
+
+        // Strings (even numeric ones) should not be coerced to Float in input positions.
+        let _ = coerce_variable_values(
+            &schema,
+            doc.operations.anonymous.as_ref().unwrap(),
+            variables.as_object().unwrap(),
+        )
+        .unwrap_err();
+    }
+
+    #[test]
+    fn fails_to_coerce_inf_to_float() {
+        let variables = serde_json_bytes::json!({ "bar": f64::INFINITY });
+        let (schema, doc) = schema_and_doc_with_float_arg();
+
+        // Infinity should not be accepted as a Float input value.
+        let _ = coerce_variable_values(
+            &schema,
+            doc.operations.anonymous.as_ref().unwrap(),
+            variables.as_object().unwrap(),
+        )
+        .unwrap_err();
+    }
+
+    #[test]
+    fn fails_to_coerce_nan_to_float() {
+        let variables = serde_json_bytes::json!({ "bar": f64::NAN });
+        let (schema, doc) = schema_and_doc_with_float_arg();
+
+        // NaN should not be accepted as a Float input value.
+        let _ = coerce_variable_values(
+            &schema,
+            doc.operations.anonymous.as_ref().unwrap(),
+            variables.as_object().unwrap(),
+        )
+        .unwrap_err();
+    }
+}