Accept a cdata number as value of a Float variable

It is quite usual that a floating point number is encoded using JSON,
goes over HTTP, received on tarantool server, decoded from JSON and
passed as a variable into the GraphQL executor.

A number out of the [-10^14+1; 10^14-1] range is decoded into Lua as
cdata number[^1] to don't loss the precision. A JSON decoder don't know
that we intend to use this value as the floating point one and chooses
the conservative option: decode the value into cdata number to don't
loss the precision.

In GraphQL we know that it is actually the floating point value
(disregarding its representation in Lua). So it looks correct to accept
a cdata number as value of a Float variable.

The similar idea was expressed in [1] against tarantool itself: let it
accept a number without fractional part as a value suitable for the
`float` field type.

[1]: tarantool/tarantool#5933

[^1]: `cdata<int64_t>` or `cdata<uint64_t>`

Fixes #47

Author: Totktonada

graphql/types.lua

@@ -318,7 +318,15 @@ types.long = types.scalar({
 })
 
 local function isFloat(value)
-  return type(value) == 'number'
+  if type(value) == 'number' then
+    return true
+  end
+
+  if type(value) == 'cdata' then
+    return ffi.istype('int64_t', value) or ffi.istype('uint64_t', value)
+  end
+
+  return false
 end
 
 local function coerceFloat(value)

test/integration/graphql_test.lua

@@ -2051,3 +2051,64 @@ g.test_propagate_defaults_to_callback = function()
     t.assert_equals(errors, nil)
     t.assert_items_equals(json.decode(data.prefix.test_mutation), result)
 end
+
+-- gh-47: accept a cdata number as a value of a Float variable.
+function g.test_cdata_number_as_float()
+     local query = [[
+        query ($x: Float!) { test(arg: $x) }
+    ]]
+
+    local function callback(_, args)
+        return args[1].value
+    end
+
+    local query_schema = {
+        ['test'] = {
+            kind = types.float.nonNull,
+            arguments = {
+                arg = types.float.nonNull,
+            },
+            resolve = callback,
+        }
+    }
+
+    -- 2^64-1
+    local variables = {x = 18446744073709551615ULL}
+    local res = check_request(query, query_schema, nil, nil, {variables = variables})
+    t.assert_type(res, 'table')
+    t.assert_almost_equals(res.test, 18446744073709551615)
+end
+
+-- Accept a large number in a Float argument.
+--
+-- The test is created in the scope of gh-47, but it is not
+-- strictly related to it: the issue is about interpreting
+-- a cdata number in a **variable** as a `Float` value.
+--
+-- Here we check a large number, which is written verbatim as
+-- an argument in a query. Despite that it is not what is
+-- described in gh-47, it worth to have such a test.
+function g.test_large_float_argument()
+    -- 2^64-1
+     local query = [[
+        { test(arg: 18446744073709551615) }
+    ]]
+
+    local function callback(_, args)
+        return args[1].value
+    end
+
+    local query_schema = {
+        ['test'] = {
+            kind = types.float.nonNull,
+            arguments = {
+                arg = types.float.nonNull,
+            },
+            resolve = callback,
+        }
+    }
+
+    local res = check_request(query, query_schema)
+    t.assert_type(res, 'table')
+    t.assert_almost_equals(res.test, 18446744073709551615)
+end