WIP: Validate a nested variable by an argument type

Author: Totktonada

graphql/core/rules.lua

@@ -4,6 +4,7 @@ local util = require(path .. '.util')
 local schema = require(path .. '.schema')
 local introspection = require(path .. '.introspection')
 local query_util = require(path .. '.query_util')
+local graphql_utils = require('graphql.utils')
 
 local function getParentField(context, name, count)
   if introspection.fieldMap[name] then return introspection.fieldMap[name] end
@@ -484,66 +485,100 @@ function rules.variableUsageAllowed(node, context)
       local parentField = getParentField(context, field)
       for i = 1, #arguments[field] do
         local argument = arguments[field][i]
-        if argument.value.kind == 'variable' then
-          local argumentType = parentField.arguments[argument.name.value]
+        local argumentType = parentField.arguments[argument.name.value]
+        local function recursiveValidateVariableType(argument, argumentType)
+          if argument.value.kind == 'variable' then
+            local variableName = argument.value.name.value
+            local variableDefinition = variableMap[variableName]
+            local hasDefault = variableDefinition.defaultValue ~= nil
+
+            local variableType = query_util.typeFromAST(variableDefinition.type,
+              context.schema)
+
+            if hasDefault and variableType.__type ~= 'NonNull' then
+              variableType = types.nonNull(variableType)
+            end
 
-          local variableName = argument.value.name.value
-          local variableDefinition = variableMap[variableName]
-          local hasDefault = variableDefinition.defaultValue ~= nil
+            local function isTypeSubTypeOf(subType, superType)
+              if subType == superType then return true end
 
-          local variableType = query_util.typeFromAST(variableDefinition.type,
-            context.schema)
+              if superType.__type == 'NonNull' then
+                if subType.__type == 'NonNull' then
+                  return isTypeSubTypeOf(subType.ofType, superType.ofType)
+                end
 
-          if hasDefault and variableType.__type ~= 'NonNull' then
-            variableType = types.nonNull(variableType)
-          end
+                return false
+              elseif subType.__type == 'NonNull' then
+                return isTypeSubTypeOf(subType.ofType, superType)
+              end
+
+              if superType.__type == 'List' then
+                if subType.__type == 'List' then
+                  return isTypeSubTypeOf(subType.ofType, superType.ofType)
+                end
 
-          local function isTypeSubTypeOf(subType, superType)
-            if subType == superType then return true end
+                return false
+              elseif subType.__type == 'List' then
+                return false
+              end
 
-            if superType.__type == 'NonNull' then
-              if subType.__type == 'NonNull' then
-                return isTypeSubTypeOf(subType.ofType, superType.ofType)
+              -- XXX: InputMap, ...; all named types must be allowed
+              if subType.__type ~= 'Object' and
+                  subType.__type ~= 'InputObject' then
+                return false
               end
 
-              return false
-            elseif subType.__type == 'NonNull' then
-              return isTypeSubTypeOf(subType.ofType, superType)
-            end
+              if superType.__type == 'Interface' then
+                local implementors = context.schema:getImplementors(superType.name)
+                return implementors and implementors[context.schema:getType(subType.name)]
+              elseif superType.__type == 'Union' or
+                  (superType.__type == 'Scalar' and
+                  superType.subtype == 'InputUnion') then
+                  --false then
+                local types = superType.types
+                for i = 1, #types do
+                  if types[i] == subType then
+                    return true
+                  end
+                end
 
-            if superType.__type == 'List' then
-              if subType.__type == 'List' then
-                return isTypeSubTypeOf(subType.ofType, superType.ofType)
+                return false
               end
 
-              return false
-            elseif subType.__type == 'List' then
               return false
             end
 
-            if subType.__type ~= 'Object' then return false end
-
-            if superType.__type == 'Interface' then
-              local implementors = context.schema:getImplementors(superType.name)
-              return implementors and implementors[context.schema:getType(subType.name)]
-            elseif superType.__type == 'Union' then
-              local types = superType.types
-              for i = 1, #types do
-                if types[i] == subType then
-                  return true
+            if not isTypeSubTypeOf(variableType, argumentType) then
+              error('Variable type mismatch')
+            end
+          elseif argument.value.kind == 'inputObject' then
+            for _, child in ipairs(argument.value.values) do
+              if argumentType.__type == 'InputObject' then
+                local childArgumentType = argumentType.fields[child.name].kind
+                recursiveValidateVariableType(child, childArgumentType)
+              elseif argumentType.__type == 'Scalar' and
+                  argumentType.subtype == 'InputMap' then
+                local childArgumentType = argumentType.values
+                recursiveValidateVariableType(child, childArgumentType)
+              elseif argumentType.__type == 'Scalar' and
+                  argumentType.subtype == 'InputUnion' then
+                local has_ok
+                local first_err
+                for _, childArgumentType in ipairs(argumentType.types) do
+                  local ok, err = pcall(recursiveValidateVariableType, child,
+                    childArgumentType)
+                  has_ok = has_ok or ok
+                  first_err = first_err or graphql_utils.strip_error(err)
+                  if ok then break end
+                end
+                if not has_ok then
+                  error(first_err)
                 end
               end
-
-              return false
             end
-
-            return false
-          end
-
-          if not isTypeSubTypeOf(variableType, argumentType) then
-            error('Variable type mismatch')
           end
         end
+        recursiveValidateVariableType(argument, argumentType)
       end
     end
   end

graphql/core/schema.lua

@@ -50,7 +50,8 @@ function schema:generateTypeMap(node)
   node.fields = type(node.fields) == 'function' and node.fields() or node.fields
   self.typeMap[node.name] = node
 
-  if node.__type == 'Union' then
+  if node.__type == 'Union' or (node.__type == 'Scalar' and
+      node.subtype == 'InputUnion') then
     for _, type in ipairs(node.types) do
       self:generateTypeMap(type)
     end
@@ -77,6 +78,10 @@ function schema:generateTypeMap(node)
       self:generateTypeMap(field.kind)
     end
   end
+
+  if node.type == 'Scalar' and node.subtype == 'InputMap' then
+    self:generateTypeMap(node.values)
+  end
 end
 
 function schema:generateDirectiveMap()

graphql/core/types.lua

@@ -249,6 +249,7 @@ function types.inputUnion(config)
     __type = 'Scalar',
     subtype = 'InputUnion',
     name = config.name,
+    types = config.types,
     serialize = function(value) return value end,
     parseValue = function(value) return value end,
     parseLiteral = function(node)

test/testdata/common_testdata.lua

@@ -360,7 +360,7 @@ end
 
 function common_testdata.run_queries(gql_wrapper)
     local test = tap.test('common')
-    test:plan(41)
+    test:plan(47)
 
     local query_1 = [[
         query user_by_order($order_id: String) {
@@ -1423,6 +1423,9 @@ function common_testdata.run_queries(gql_wrapper)
 
     -- }}}
 
+    -- {{{ InputUnion -- XXX
+    -- }}}
+
     local query_14 = [[
         mutation($order_metainfo: order_metainfo_collection_insert) {
             order_metainfo_collection(insert: $order_metainfo) {
@@ -1472,6 +1475,102 @@ function common_testdata.run_queries(gql_wrapper)
     -- }}}
     -- }}}
 
+    -- {{{ check variable type againts argument type
+
+    local query_15 = [[
+        mutation($tags: [Int!]) {
+            order_metainfo_collection(
+                update: {store: {tags: $tags}}
+                limit: 1
+            ) {
+                order_metainfo_id
+                store { tags }
+            }
+        }
+    ]]
+    local ok, err = pcall(gql_wrapper.compile, gql_wrapper, query_15)
+    local err_exp = 'Variable type mismatch'
+    test:is_deeply({ok, utils.strip_error(err)}, {false, err_exp},
+        'variable usage inside InputObject')
+
+    local query_16 = [[
+        mutation($tag_value: Int) {
+            order_metainfo_collection(
+                update: {store: {parametrized_tags: {foo: $tag_value}}}
+                limit: 1
+            ) {
+                order_metainfo_id
+            }
+        }
+    ]]
+    local ok, err = pcall(gql_wrapper.compile, gql_wrapper, query_16)
+    local err_exp = 'Variable type mismatch'
+    test:is_deeply({ok, utils.strip_error(err)}, {false, err_exp},
+        'variable usage inside InputMap')
+
+    local query_17 = [[
+        mutation($map_value: Int) {
+            order_metainfo_collection(
+                update: {store: {parametrized_tags: $map_value}}
+                limit: 1
+            ) {
+                order_metainfo_id
+            }
+        }
+    ]]
+    local ok, err = pcall(gql_wrapper.compile, gql_wrapper, query_17)
+    local err_exp = 'Variable type mismatch'
+    test:is_deeply({ok, utils.strip_error(err)}, {false, err_exp},
+        'variable usage as InputMap')
+
+    local query_18 = [[
+        mutation($id_value: Float!) {
+            order_metainfo_collection(
+                update: {store: {external_id: {int: $id_value}}}
+                limit: 1
+            ) {
+                order_metainfo_id
+            }
+        }
+    ]]
+    local ok, err = pcall(gql_wrapper.compile, gql_wrapper, query_18)
+    local err_exp = 'Variable type mismatch'
+    test:is_deeply({ok, utils.strip_error(err)}, {false, err_exp},
+        'variable usage inside InputUnion')
+
+    local query_19 = [[
+        mutation($id_box_value: Int) {
+            order_metainfo_collection(
+                update: {store: {external_id: $id_box_value}}
+                limit: 1
+            ) {
+                order_metainfo_id
+            }
+        }
+    ]]
+    local ok, err = pcall(gql_wrapper.compile, gql_wrapper, query_19)
+    local err_exp = 'Variable type mismatch'
+    test:is_deeply({ok, utils.strip_error(err)}, {false, err_exp},
+        'variable usage as InputUnion')
+
+    local box_t = 'arguments___order_metainfo_collection___update___' ..
+        'order_metainfo_collection_update___store___store___external_id___' ..
+        'external_id___Int_box'
+    local query_20 = [[
+        mutation($id_box_value: ]] .. box_t .. [[) {
+            order_metainfo_collection(
+                update: {store: {external_id: $id_box_value}}
+                limit: 1
+            ) {
+                order_metainfo_id
+            }
+        }
+    ]]
+    local ok, err = pcall(gql_wrapper.compile, gql_wrapper, query_20)
+    test:is(ok, true, 'correct variable usage as InputUnion')
+
+    -- }}}
+
     assert(test:check(), 'check plan')
 end