Add TYPE_MISMATCH and WRONG_VALUE error codes

Part of #134.

Author: Totktonada

graphql/convert_schema/union.lua

@@ -2,9 +2,11 @@ local yaml = require('yaml')
 local core_types = require('graphql.core.types')
 local avro_helpers = require('graphql.avro_helpers')
 local helpers = require('graphql.convert_schema.helpers')
-
+local error_codes = require('graphql.error_codes')
 local utils = require('graphql.utils')
+
 local check = utils.check
+local e = error_codes
 
 local union = {}
 
@@ -303,28 +305,34 @@ function union.convert(avro_schema, opts)
         types = union_types,
         name = helpers.full_name(union_name, context),
         resolveType = function(result)
-            assert(type(result) == 'table',
-                'union value must be a map with one field, got ' ..
-                type(result))
-            assert(next(result) ~= nil and next(result, next(result)) == nil,
-                'union value must have only one field')
+            if type(result) ~= 'table' then
+                error(e.wrong_value('union value must be a map with one ' ..
+                    'field, got ' .. type(result)))
+            end
+            if next(result) == nil or next(result, next(result)) ~= nil then
+                error(e.wrong_value('union value must have only one field'))
+            end
             for determinant, type in pairs(determinant_to_type) do
                 if result[determinant] ~= nil then
                     return type
                 end
             end
             local field_name = tostring(next(result))
-            error(('unexpected union value field: %s'):format(field_name))
+            error(e.wrong_value(('unexpected union value field: %s'):format(
+                field_name)))
         end,
         resolveNodeType = function(node)
-            assert(#node.values == 1,
-                ('box object with more then one field: %d'):format(
-                #node.values))
+            if #node.values ~= 1 then
+                error(e.wrong_value('box object with more then one field: %d')
+                    :format(#node.values))
+            end
             local determinant = node.values[1].name
             check(determinant, 'determinant', 'string')
             local res = determinant_to_type[determinant]
-            assert(determinant ~= nil,
-                ('the union has no "%s" field'):format(determinant))
+            if res == nil then
+                error(e.wrong_value('the union has no "%s" field'):format(
+                    determinant))
+            end
             return res
         end,
     })

graphql/core/rules.lua

@@ -3,8 +3,11 @@ local types = require(path .. '.types')
 local util = require(path .. '.util')
 local introspection = require(path .. '.introspection')
 local query_util = require(path .. '.query_util')
+local graphql_error_codes = require('graphql.error_codes')
 local graphql_utils = require('graphql.utils')
 
+local e = graphql_error_codes
+
 local function getParentField(context, name, count)
   if introspection.fieldMap[name] then return introspection.fieldMap[name] end
 
@@ -593,7 +596,7 @@ function rules.variableUsageAllowed(node, context)
       local ok, err = isVariableTypesValid(argument, argumentType, context,
         variableMap)
       if not ok then
-        error(err)
+        error(e.type_mismatch(err))
       end
     end
   end

graphql/core/util.lua

@@ -1,4 +1,7 @@
 local yaml = require('yaml')
+local graphql_error_codes = require('graphql.error_codes')
+
+local e = graphql_error_codes
 
 local util = {}
 
@@ -79,8 +82,8 @@ function util.coerceValue(node, schemaType, variables, opts)
   if schemaType.__type == 'NonNull' then
     local res = util.coerceValue(node, schemaType.ofType, variables, opts)
     if strict_non_null and res == nil then
-      error(('Expected non-null for "%s", got null'):format(
-        util.getTypeName(schemaType)))
+      error(e.wrong_value(('Expected non-null for "%s", got null'):format(
+        util.getTypeName(schemaType))))
     end
     return res
   end
@@ -95,7 +98,7 @@ function util.coerceValue(node, schemaType, variables, opts)
 
   if schemaType.__type == 'List' then
     if node.kind ~= 'list' then
-      error('Expected a list')
+      error(e.wrong_value('Expected a list'))
     end
 
     return util.map(node.values, function(value)
@@ -111,7 +114,7 @@ function util.coerceValue(node, schemaType, variables, opts)
 
   if isInputObject then
     if node.kind ~= 'inputObject' then
-      error('Expected an input object')
+      error(e.wrong_value('Expected an input object'))
     end
 
     -- check all fields: as from value as well as from schema
@@ -128,7 +131,8 @@ function util.coerceValue(node, schemaType, variables, opts)
     local inputObjectValue = {}
     for fieldName, _ in pairs(fieldNameSet) do
       if not schemaType.fields[fieldName] then
-        error('Unknown input object field "' .. fieldName .. '"')
+        error(e.wrong_value(('Unknown input object field "%s"'):format(
+          fieldName)))
       end
 
       local childValue = fieldValues[fieldName]
@@ -142,7 +146,7 @@ function util.coerceValue(node, schemaType, variables, opts)
 
   if isInputMap then
     if node.kind ~= 'inputObject' then
-      error('Expected an input object')
+      error(e.wrong_value('Expected an input object'))
     end
 
     local inputMapValue = {}
@@ -156,11 +160,11 @@ function util.coerceValue(node, schemaType, variables, opts)
 
   if schemaType.__type == 'Enum' then
     if node.kind ~= 'enum' then
-      error('Expected enum value, got ' .. node.kind)
+      error(e.wrong_value('Expected enum value, got %s'):format(node.kind))
     end
 
     if not schemaType.values[node.value] then
-      error('Invalid enum value "' .. node.value .. '"')
+      error(e.wrong_value('Invalid enum value "%s"'):format(node.value))
     end
 
     return node.value
@@ -173,7 +177,8 @@ function util.coerceValue(node, schemaType, variables, opts)
 
   if schemaType.__type == 'Scalar' then
     if schemaType.parseLiteral(node) == nil then
-      error('Could not coerce "' .. tostring(node.value) .. '" to "' .. schemaType.name .. '"')
+      error(e.wrong_value('Could not coerce "%s" to "%s"'):format(
+        tostring(node.value), schemaType.name))
     end
 
     return schemaType.parseLiteral(node)

graphql/core/validate_variables.lua

@@ -1,7 +1,9 @@
 local types = require('graphql.core.types')
 local graphql_utils = require('graphql.utils')
+local graphql_error_codes = require('graphql.error_codes')
 
 local check = graphql_utils.check
+local e = graphql_error_codes
 
 local validate_variables = {}
 
@@ -14,8 +16,10 @@ local function checkVariableValue(variableName, value, variableType)
 
   if isNonNull then
     variableType = types.nullable(variableType)
-    assert(value ~= nil,
-      ('Variable "%s" expected to be non-null'):format(variableName))
+    if value == nil then
+      error(e.wrong_value(('Variable "%s" expected to be non-null'):format(
+        variableName)))
+    end
   end
 
   local isList = variableType.__type == 'List'
@@ -29,12 +33,14 @@ local function checkVariableValue(variableName, value, variableType)
   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))
+    if type(value) ~= 'table' then
+      error(e.wrong_value(('Variable "%s" for a List must be a Lua ' ..
+        'table, got %s'):format(variableName, type(value))))
+    end
+    if not graphql_utils.is_array(value) then
+      error(e.wrong_value(('Variable "%s" for a List must be an array, ' ..
+        'got map'):format(variableName)))
+    end
     assert(variableType.ofType ~= nil, 'variableType.ofType must not be nil')
     for i, item in ipairs(value) do
       local itemName = variableName .. '[' .. tostring(i) .. ']'
@@ -44,9 +50,11 @@ local function checkVariableValue(variableName, value, variableType)
   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)))
+    if type(value) ~= 'table' then
+      error(e.wrong_value(('Variable "%s" for the InputObject "%s" must ' ..
+        'be a Lua table, got %s'):format(variableName, variableType.name,
+        type(value))))
+    end
 
     -- check all fields: as from value as well as from schema
     local fieldNameSet = {}
@@ -59,13 +67,16 @@ local function checkVariableValue(variableName, value, variableType)
 
     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))
+      if type(fieldName) ~= 'string' then
+        error(e.wrong_value(('Field key of the variable "%s" for the ' ..
+          'InputObject "%s" must be a string, got %s'):format(variableName,
+          variableType.name, type(fieldName))))
+      end
+      if type(variableType.fields[fieldName]) == 'nil' then
+        error(e.wrong_value(('Unknown field "%s" of the variable "%s" ' ..
+          'for the InputObject "%s"'):format(fieldName, variableName,
+          variableType.name)))
+      end
 
       local childType = variableType.fields[fieldName].kind
       local childName = variableName .. '.' .. fieldName
@@ -76,15 +87,18 @@ local function checkVariableValue(variableName, value, variableType)
   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)))
+    if type(value) ~= 'table' then
+      error(e.wrong_value(('Variable "%s" for the InputMap "%s" must be a ' ..
+        'Lua table, got %s'):format(variableName, variableType.name,
+        type(value))))
+    end
 
     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)))
+      if type(fieldName) ~= 'string' then
+        error(e.wrong_value(('Field key of the variable "%s" for the ' ..
+          'InputMap "%s" must be a string, got %s'):format(variableName,
+          variableType.name, type(fieldName))))
+      end
       local childType = variableType.values
       local childName = variableName .. '.' .. fieldName
       checkVariableValue(childName, fieldValue, childType)
@@ -103,9 +117,10 @@ local function checkVariableValue(variableName, value, variableType)
 
   if isScalar then
     check(variableType.isValueOfTheType, 'isValueOfTheType', 'function')
-    assert(variableType.isValueOfTheType(value),
-      ('Wrong variable "%s" for the Scalar "%s"'):format(
-      variableName, variableType.name))
+    if not variableType.isValueOfTheType(value) then
+      error(e.wrong_value(('Wrong variable "%s" for the Scalar "%s"'):format(
+        variableName, variableType.name)))
+    end
     return
   end
 
@@ -115,8 +130,10 @@ 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))
+    if context.variableTypes[variableName] == nil then
+      error(e.wrong_value(('There is no declaration for the variable "%s"')
+        :format(variableName)))
+    end
   end
 
   -- check that variable values have correct type

graphql/error_codes.lua

@@ -0,0 +1,24 @@
+local error_codes = {}
+
+error_codes.TYPE_MISMATCH = 1
+error_codes.WRONG_VALUE = 2
+
+function error_codes.type_mismatch(message)
+    return {
+        message = message,
+        extensions = {
+            error_code = error_codes.TYPE_MISMATCH,
+        }
+    }
+end
+
+function error_codes.wrong_value(message)
+    return {
+        message = message,
+        extensions = {
+            error_code = error_codes.WRONG_VALUE,
+        }
+    }
+end
+
+return error_codes

graphql/init.lua

@@ -34,12 +34,21 @@ local accessor_general = require('graphql.accessor_general')
 local accessor_space = require('graphql.accessor_space')
 local accessor_shard = require('graphql.accessor_shard')
 local impl = require('graphql.impl')
+local error_codes = require('graphql.error_codes')
 
 local graphql = {}
 
 -- constants
 graphql.TIMEOUT_INFINITY = accessor_general.TIMEOUT_INFINITY
 
+-- error codes
+graphql.error_codes = {}
+for k, v in pairs(error_codes) do
+    if type(v) == 'number' then
+        graphql.error_codes[k] = v
+    end
+end
+
 -- for backward compatibility
 graphql.accessor_general = accessor_general
 graphql.accessor_space = accessor_space