Preserve large numbers in query transformations

In GraphQL source text, you can write an integer outside the int32 range
if a float is expected. apollo-rs parses these numbers as
`hir::Value::Int` because at that time, the expected type of the value is
not known, especially because it's possible to parse queries without
knowledge of the schema.

In the defer label transformation, any apollo-rs `hir::Value::Int` was
treated as an i32. This would cause an error if it's one such large integer.
The fully proper way to convert `hir::Value` to another type (ie. encoder or
serde_json, as is done elsewhere) would be to match on the actual
GraphQL type expected by the schema. But the simpler thing to do is to
just use a Float if the value is too big for an Int. This will
round-trip correctly.

apollo-router/src/query_planner/labeler.rs

@@ -116,3 +116,18 @@ pub(crate) fn directive(
 
     Ok(encoder_directive)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::add_defer_labels;
+    use apollo_compiler::ApolloCompiler;
+
+    #[test]
+    fn large_float_written_as_int() {
+        let mut compiler = ApolloCompiler::new();
+        compiler.add_type_system("type Query { field(id: Float): String! }", "schema.graphql");
+        let file_id = compiler.add_executable(r#"{ field(id: 1234567890123) }"#, "query.graphql");
+        let result = add_defer_labels(file_id, &compiler).unwrap();
+        insta::assert_snapshot!(result);
+    }
+}

apollo-router/src/query_planner/snapshots/apollo_router__query_planner__labeler__tests__large_float_written_as_int.snap

@@ -0,0 +1,8 @@
+---
+source: apollo-router/src/query_planner/labeler.rs
+expression: result
+---
+query {
+  field(id: 1234567890123)
+}
+

apollo-router/src/spec/query/transform.rs

@@ -369,9 +369,10 @@ pub(crate) fn ty(hir: &hir::Type) -> apollo_encoder::Type_ {
 pub(crate) fn value(hir: &hir::Value) -> Result<apollo_encoder::Value, BoxError> {
     Ok(match hir {
         hir::Value::Variable(val) => apollo_encoder::Value::Variable(val.name().into()),
-        hir::Value::Int { value, .. } => {
-            apollo_encoder::Value::Int(value.to_i32_checked().ok_or("Int value overflows i32")?)
-        }
+        hir::Value::Int { value, .. } => value
+            .to_i32_checked()
+            .map(apollo_encoder::Value::Int)
+            .unwrap_or_else(|| apollo_encoder::Value::Float(value.get())),
         hir::Value::Float { value, .. } => apollo_encoder::Value::Float(value.get()),
         hir::Value::String { value, .. } => apollo_encoder::Value::String(value.clone()),
         hir::Value::Boolean { value, .. } => apollo_encoder::Value::Boolean(*value),