Validate a variable type

Fixed Int type to be between -2^31 and 2^31-1 instead of -2^32 and
2^32-1.

Forbid implicit fraction part removing from Int immediate value.

Fixed Long type to forbid variable value of 'number' Lua type that
cannot preciselly represent integral value (allow only ones inside -2^53
and 2^53 exclusivelly).

Related to #159.
Related to #160.

Author: Totktonada

Makefile

@@ -10,6 +10,7 @@ default:
 lint:
 	luacheck graphql/*.lua \
 		graphql/core/execute.lua \
+		graphql/core/validate_variables.lua \
 		graphql/convert_schema/*.lua \
 		graphql/server/*.lua \
 		test/bench/*.lua \

graphql/core/execute.lua

@@ -2,6 +2,7 @@ local path = (...):gsub('%.[^%.]+$', '')
 local util = require(path .. '.util')
 local introspection = require(path .. '.introspection')
 local query_util = require(path .. '.query_util')
+local validate_variables = require(path .. '.validate_variables')
 
 local function defaultResolver(object, arguments, info)
   return object[info.fieldASTs[1].name.value]
@@ -145,5 +146,7 @@ return function(schema, tree, rootValue, variables, operationName, opts)
     error('Unsupported operation "' .. context.operation.operation .. '"')
   end
 
+  validate_variables.validate_variables(context)
+
   return evaluateSelections(rootType, rootValue, context.operation.selectionSet.selections, context)
 end

graphql/core/query_util.lua

@@ -111,7 +111,8 @@ function query_util.buildContext(schema, tree, rootValue, variables, operationNa
         rootValue = rootValue,
         variables = variables,
         operation = nil,
-        fragmentMap = {}
+        fragmentMap = {},
+        variableTypes = {},
     }
 
     for _, definition in ipairs(tree.definitions) do
@@ -136,6 +137,12 @@ function query_util.buildContext(schema, tree, rootValue, variables, operationNa
         end
     end
 
+    -- Save variableTypes for the operation.
+    for _, definition in ipairs(context.operation.variableDefinitions or {}) do
+        context.variableTypes[definition.variable.name.value] =
+            query_util.typeFromAST(definition.type, context.schema)
+    end
+
     return context
 end
 

graphql/core/types.lua

@@ -1,3 +1,4 @@
+local ffi = require('ffi')
 local path = (...):gsub('%.[^%.]+$', '')
 local util = require(path .. '.util')
 
@@ -55,7 +56,8 @@ function types.scalar(config)
     description = config.description,
     serialize = config.serialize,
     parseValue = config.parseValue,
-    parseLiteral = config.parseLiteral
+    parseLiteral = config.parseLiteral,
+    isValueOfTheType = config.isValueOfTheType,
   }
 
   instance.nonNull = types.nonNull(instance)
@@ -253,6 +255,7 @@ function types.inputUnion(config)
       error('Literal parsing is implemented in util.coerceValue; ' ..
         'we should not go here')
     end,
+    resolveType = config.resolveType,
     resolveNodeType = config.resolveNodeType,
   }
 
@@ -261,14 +264,58 @@ function types.inputUnion(config)
   return instance
 end
 
-local coerceInt = function(value)
-  value = tonumber(value)
+-- Based on the code from tarantool/checks.
+local function isInt(value)
+  if type(value) == 'number' then
+    return value >= -2^31 and value < 2^31 and math.floor(value) == value
+  end
 
-  if not value then return end
+  if type(value) == 'cdata' then
+    if ffi.istype('int64_t', value) then
+      return value >= -2^31 and value < 2^31
+    elseif ffi.istype('uint64_t', value) then
+      return value < 2^31
+    end
+  end
+
+  return false
+end
 
-  if value == value and value < 2 ^ 32 and value >= -2 ^ 32 then
-    return value < 0 and math.ceil(value) or math.floor(value)
+-- The code from tarantool/checks.
+local function isLong(value)
+  if type(value) == 'number' then
+    -- Double floating point format has 52 fraction bits. If we want to keep
+    -- integer precision, the number must be less than 2^53.
+    return value > -2^53 and value < 2^53 and math.floor(value) == value
   end
+
+  if type(value) == 'cdata' then
+    if ffi.istype('int64_t', value) then
+      return true
+    elseif ffi.istype('uint64_t', value) then
+      return value < 2^63
+    end
+  end
+
+  return false
+end
+
+local function coerceInt(value)
+  local value = tonumber(value)
+
+  if value == nil then return end
+  if not isInt(value) then return end
+
+  return value
+end
+
+local function coerceLong(value)
+  local value = tonumber64(value)
+
+  if value == nil then return end
+  if not isLong(value) then return end
+
+  return value
 end
 
 types.int = types.scalar({
@@ -280,20 +327,22 @@ types.int = types.scalar({
     if node.kind == 'int' then
       return coerceInt(node.value)
     end
-  end
+  end,
+  isValueOfTheType = isInt,
 })
 
 types.long = types.scalar({
   name = 'Long',
-  description = 'Long is non-bounded integral type',
-  serialize = function(value) return tonumber(value) end,
-  parseValue = function(value) return tonumber(value) end,
+  description = "The `Long` scalar type represents non-fractional signed whole numeric values. Long can represent values between -(2^63) and 2^63 - 1.",
+  serialize = coerceLong,
+  parseValue = coerceLong,
   parseLiteral = function(node)
    -- 'int' is name of the immediate value type
    if node.kind == 'int' then
-     return tonumber(node.value)
+     return coerceLong(node.value)
    end
-  end
+  end,
+  isValueOfTheType = isLong,
 })
 
 types.float = types.scalar({
@@ -304,7 +353,10 @@ types.float = types.scalar({
     if node.kind == 'float' or node.kind == 'int' then
       return tonumber(node.value)
     end
-  end
+  end,
+  isValueOfTheType = function(value)
+    return type(value) == 'number'
+  end,
 })
 
 types.double = types.scalar({
@@ -316,7 +368,10 @@ types.double = types.scalar({
     if node.kind == 'float' or node.kind == 'int' then
       return tonumber(node.value)
     end
-  end
+  end,
+  isValueOfTheType = function(value)
+    return type(value) == 'number'
+  end,
 })
 
 types.string = types.scalar({
@@ -328,7 +383,10 @@ types.string = types.scalar({
     if node.kind == 'string' then
       return node.value
     end
-  end
+  end,
+  isValueOfTheType = function(value)
+    return type(value) == 'string'
+  end,
 })
 
 local function toboolean(x)
@@ -346,7 +404,10 @@ types.boolean = types.scalar({
     else
       return nil
     end
-  end
+  end,
+  isValueOfTheType = function(value)
+    return type(value) == 'boolean'
+  end,
 })
 
 types.id = types.scalar({
@@ -355,7 +416,10 @@ types.id = types.scalar({
   parseValue = tostring,
   parseLiteral = function(node)
     return node.kind == 'string' or node.kind == 'int' and node.value or nil
-  end
+  end,
+  isValueOfTheType = function(value)
+    error('NIY')
+  end,
 })
 
 function types.directive(config)

graphql/core/validate_variables.lua

@@ -0,0 +1,130 @@
+local types = require('graphql.core.types')
+local graphql_utils = require('graphql.utils')
+
+local check = graphql_utils.check
+
+local validate_variables = {}
+
+-- Traverse type more or less likewise util.coerceValue do.
+local function checkVariableValue(variableName, value, variableType)
+  check(variableName, 'variableName', 'string')
+  check(variableType, 'variableType', 'table')
+
+  local isNonNull = variableType.__type == 'NonNull'
+
+  if isNonNull then
+    variableType = types.nullable(variableType)
+    assert(value ~= nil,
+      ('Variable "%s" expected to be non-null'):format(variableName))
+  end
+
+  local isList = variableType.__type == 'List'
+  local isScalar = variableType.__type == 'Scalar'
+  local isInputObject = variableType.__type == 'InputObject'
+  local isInputMap = isScalar and variableType.subtype == 'InputMap'
+  local isInputUnion = isScalar and variableType.subtype == 'InputUnion'
+
+  -- Nullable variable type + null value case: value can be nil only when
+  -- isNonNull is false.
+  if value == nil then return end
+
+  if isList then
+    assert(type(value) == 'table',
+      ('Variable "%s" for a List must be a Lua table, got %s')
+      :format(variableName, type(value)))
+    assert(graphql_utils.is_array(value),
+      ('Variable "%s" for a List must be an array, got map')
+      :format(variableName))
+    assert(variableType.ofType ~= nil, 'variableType.ofType must not be nil')
+    for i, item in ipairs(value) do
+      local itemName = variableName .. '[' .. tostring(i) .. ']'
+      checkVariableValue(itemName, item, variableType.ofType)
+    end
+    return
+  end
+
+  if isInputObject then
+    assert(type(value) == 'table',
+      ('Variable "%s" for the InputObject "%s" must be a Lua table, ' ..
+      'got %s'):format(variableName, variableType.name, type(value)))
+
+    -- check all fields: as from value as well as from schema
+    local fieldNameSet = {}
+    for fieldName, _ in pairs(value) do
+        fieldNameSet[fieldName] = true
+    end
+    for fieldName, _ in pairs(variableType.fields) do
+        fieldNameSet[fieldName] = true
+    end
+
+    for fieldName, _ in pairs(fieldNameSet) do
+      local fieldValue = value[fieldName]
+      assert(type(fieldName) == 'string',
+        ('Field key of the variable "%s" for the InputObject "%s" ' ..
+        'must be a string, got %s'):format(variableName, variableType.name,
+        type(fieldName)))
+      assert(type(variableType.fields[fieldName]) ~= 'nil',
+        ('Unknown field "%s" of the variable "%s" for the ' ..
+        'InputObject "%s"'):format(fieldName, variableName, variableType.name))
+
+      local childType = variableType.fields[fieldName].kind
+      local childName = variableName .. '.' .. fieldName
+      checkVariableValue(childName, fieldValue, childType)
+    end
+
+    return
+  end
+
+  if isInputMap then
+    assert(type(value) == 'table',
+      ('Variable "%s" for the InputMap "%s" must be a Lua table, got %s')
+      :format(variableName, variableType.name, type(value)))
+
+    for fieldName, fieldValue in pairs(value) do
+      assert(type(fieldName) == 'string',
+        ('Field key of the variable "%s" for the InputMap "%s" must be a ' ..
+        'string, got %s'):format(variableName, variableType.name,
+        type(fieldName)))
+      local childType = variableType.values
+      local childName = variableName .. '.' .. fieldName
+      checkVariableValue(childName, fieldValue, childType)
+    end
+
+    return
+  end
+
+  -- XXX: Enum
+
+  if isInputUnion then
+    local childType = variableType.resolveType(value)
+    local childName = variableName .. '.' .. childType.name
+    checkVariableValue(childName, value, childType)
+    return
+  end
+
+  if isScalar then
+    check(variableType.isValueOfTheType, 'isValueOfTheType', 'function')
+    assert(variableType.isValueOfTheType(value),
+      ('Wrong variable "%s" for the Scalar "%s"'):format(
+      variableName, variableType.name))
+    return
+  end
+
+  error(('Unknown type of the variable "%s"'):format(variableName))
+end
+
+function validate_variables.validate_variables(context)
+  -- check that all variable values have corresponding variable declaration
+  for variableName, _ in pairs(context.variables or {}) do
+    assert(context.variableTypes[variableName] ~= nil,
+      ('There is no declaration for the variable "%s"'):format(variableName))
+  end
+
+  -- check that variable values have correct type
+  for variableName, variableType in pairs(context.variableTypes) do
+    local value = (context.variables or {})[variableName]
+    checkVariableValue(variableName, value, variableType)
+  end
+end
+
+return validate_variables