graphql: adapt "Validate a variable type" fron graphql.0

This patch is a port of
tarantool/graphql.0@38fc560

Author: olegrok

cartridge/graphql/execute.lua

@@ -3,6 +3,7 @@ local types = require(path .. '.types')
 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 getFieldResponseKey(field)
   return field.alias and field.alias.name.value or field.name.value
@@ -70,48 +71,69 @@ local function defaultResolver(object, arguments, info)
   return object[info.fieldASTs[1].name.value]
 end
 
-local function buildContext(schema, tree, rootValue, variables, operationName)
-  local context = {
-    schema = schema,
-    rootValue = rootValue,
-    variables = variables,
-    operation = nil,
-    fragmentMap = {},
-    defaultValues = {},
-    request_cache = {},
-  }
+local function getOperation(tree, operationName)
+    local operation
 
-  for _, definition in ipairs(tree.definitions) do
-    if definition.kind == 'operation' then
-      if not operationName and context.operation then
-        error('Operation name must be specified if more than one operation exists.')
-      end
+    for _, definition in ipairs(tree.definitions) do
+        if definition.kind == 'operation' then
+            if not operationName and operation then
+                error('Operation name must be specified if more than one operation exists.')
+            end
 
-      if not operationName or definition.name.value == operationName then
-        context.operation = definition
-      end
+            if not operationName or definition.name.value == operationName then
+                operation = definition
+            end
+        end
+    end
 
-      for _, variableDefinition in ipairs(definition.variableDefinitions or {}) do
-          if variableDefinition.defaultValue ~= nil then
-              context.defaultValues[variableDefinition.variable.name.value] =
-                  variableDefinition.defaultValue.value
+    if not operation then
+        if operationName then
+            error('Unknown operation "' .. operationName .. '"')
+        else
+            error('Must provide an operation')
+        end
+    end
 
-          end
-      end
-    elseif definition.kind == 'fragmentDefinition' then
-      context.fragmentMap[definition.name.value] = definition
+    return operation
+end
+
+local function getFragmentDefinitions(tree)
+    local fragmentMap = {}
+
+    for _, definition in ipairs(tree.definitions) do
+        if definition.kind == 'fragmentDefinition' then
+            fragmentMap[definition.name.value] = definition
+        end
     end
-  end
 
-  if not context.operation then
-    if operationName then
-      error('Unknown operation "' .. operationName .. '"')
-    else
-      error('Must provide an operation')
+    return fragmentMap
+end
+
+-- Extract variableTypes from the operation.
+local function getVariableTypes(schema, operation)
+    local variableTypes = {}
+
+    for _, definition in ipairs(operation.variableDefinitions or {}) do
+        variableTypes[definition.variable.name.value] =
+            query_util.typeFromAST(definition.type, schema)
     end
-  end
 
-  return context
+    return variableTypes
+end
+
+local function buildContext(schema, tree, rootValue, variables, operationName)
+  local operation = getOperation(tree, operationName)
+  local fragmentMap = getFragmentDefinitions(tree)
+  local variableTypes = getVariableTypes(schema, operation)
+  return {
+      schema = schema,
+      rootValue = rootValue,
+      variables = variables,
+      operation = operation,
+      fragmentMap = fragmentMap,
+      variableTypes = variableTypes,
+      request_cache = {},
+  }
 end
 
 local function collectFields(objectType, selections, visitedFragments, result, context)
@@ -297,6 +319,8 @@ local function execute(schema, tree, rootValue, variables, operationName)
     error('Unsupported operation "' .. context.operation.operation .. '"')
   end
 
+  validate_variables.validate_variables(context)
+
   return evaluateSelections(rootType, rootValue, context.operation.selectionSet.selections, context)
 end
 

cartridge/graphql/types.lua

@@ -1,8 +1,9 @@
+local ffi = require('ffi')
+local checks = require('checks')
+local errors = require('errors')
 local util = require('cartridge.graphql.util')
 local vars = require('cartridge.vars').new('cartridge.graphql.types')
 local utils = require('cartridge.utils')
-local checks = require('checks')
-local errors = require('errors')
 
 local type_not_found = errors.new_class("type_not_found")
 local validation_error = errors.new_class("validation_error")
@@ -58,6 +59,15 @@ function types.list(kind)
   return instance
 end
 
+function types.nullable(kind)
+    assert(type(kind) == 'table', 'kind must be a table, got ' .. type(kind))
+
+    if kind.__type ~= 'NonNull' then return kind end
+
+    assert(kind.ofType ~= nil, 'kind.ofType must not be nil')
+    return types.nullable(kind.ofType)
+end
+
 function types.scalar(config)
   assert(type(config.name) == 'string', 'type name must be provided as a string')
   assert(type(config.serialize) == 'function', 'serialize must be a function')
@@ -74,7 +84,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)
@@ -216,28 +227,58 @@ function types.inputObject(config)
   return instance
 end
 
-local coerceInt = function(value)
-  value = tonumber(value)
-
-  if not value then return end
+-- 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 value == value and value < 2 ^ 32 and value >= -2 ^ 32 then
-    return value < 0 and math.ceil(value) or math.floor(value)
+  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
 
-local coerceLong = function(value)
-  value = tonumber64(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
-    return value
+    if ffi.istype('int64_t', value) then
+      return true
+    elseif ffi.istype('uint64_t', value) then
+      return value < 2^63
+    end
   end
 
-  if not value then return end
+  return false
+end
+
+local function coerceInt(value)
+  local value = tonumber(value)
 
-  if value == value and value < 2 ^ 52 and value >= -2 ^ 52 then
-      return value < 0 and math.ceil(value) or math.floor(value)
-  end
+  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({
@@ -249,7 +290,8 @@ types.int = types.scalar({
     if node.kind == 'int' then
       return coerceInt(node.value)
     end
-  end
+  end,
+  isValueOfTheType = isInt,
 })
 
 types.long = types.scalar({
@@ -261,7 +303,8 @@ types.long = types.scalar({
     if node.kind == 'long' or node.kind == 'int' then
       return coerceLong(node.value)
     end
-  end
+  end,
+  isValueOfTheType = isLong,
 })
 
 types.float = types.scalar({
@@ -272,7 +315,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.string = types.scalar({
@@ -284,7 +330,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)
@@ -302,7 +351,10 @@ types.boolean = types.scalar({
     else
       return nil
     end
-  end
+  end,
+  isValueOfTheType = function(value)
+    return type(value) == 'boolean'
+  end,
 })
 
 types.id = types.scalar({

cartridge/graphql/util.lua

@@ -148,6 +148,64 @@ local function coerceValue(node, schemaType, variables, opts)
   end
 end
 
+--- Check whether passed value has one of listed types.
+---
+--- @param obj value to check
+---
+--- @tparam string obj_name name of the value to form an error
+---
+--- @tparam string type_1
+--- @tparam[opt] string type_2
+--- @tparam[opt] string type_3
+---
+--- @return nothing
+local function check(obj, obj_name, type_1, type_2, type_3)
+    if type(obj) == type_1 or type(obj) == type_2 or type(obj) == type_3 then
+        return
+    end
+
+    if type_3 ~= nil then
+        error(('%s must be a %s or a % or a %s, got %s'):format(obj_name,
+            type_1, type_2, type_3, type(obj)))
+    elseif type_2 ~= nil then
+        error(('%s must be a %s or a %s, got %s'):format(obj_name, type_1,
+            type_2, type(obj)))
+    else
+        error(('%s must be a %s, got %s'):format(obj_name, type_1, type(obj)))
+    end
+end
+
+--- Check whether table is an array.
+---
+--- Based on [that][1] implementation.
+--- [1]: https://github.com/mpx/lua-cjson/blob/db122676/lua/cjson/util.lua
+---
+--- @tparam table table to check
+--- @return[1] `true` if passed table is an array (includes the empty table
+--- case)
+--- @return[2] `false` otherwise
+local function is_array(table)
+    check(table, 'table', 'table')
+
+    local max = 0
+    local count = 0
+    for k, _ in pairs(table) do
+        if type(k) == 'number' then
+            if k > max then
+                max = k
+            end
+            count = count + 1
+        else
+            return false
+        end
+    end
+    if max > count * 2 then
+        return false
+    end
+
+    return max >= 0
+end
+
 return {
   map = map,
   find = find,
@@ -158,4 +216,7 @@ return {
   trim = trim,
   getTypeName = getTypeName,
   coerceValue = coerceValue,
+
+  is_array = is_array,
+  check = check,
 }