Add creation of avro-schema from query with

multi-head connections,
Unions, Maps and directives

Also changed GraphQL Map type: now it has
subType = Map and name = values.type .. '_Map'
(Example: 'String_Map') This is to avoid name
clash.
Closes #200, closes #198, closes #197, closes
#85, closes #85

Author: SudoBobo

README.md

@@ -368,6 +368,10 @@ git clone https://github.com/tarantool/graphql.git
 git submodule update --recursive --init
 make test
 ```
+To run specific test:
+```
+TEST_RUN_TESTS=common/mutation make test
+```
 
 ## Requirements
 

graphql/convert_schema/resolve.lua

@@ -190,6 +190,25 @@ function resolve.gen_resolve_function_multihead(collection_name, connection,
     end
 
     return function(parent, _, info)
+        -- If parent object does not have all source_fields (for any of
+        -- variants) non-nill then we do not resolve variant and just return
+        -- box.NULL
+        for _, variant in ipairs(c.variants) do
+            for _, p in ipairs(variant.parts) do
+                local found = false
+                for field_name, value in pairs(parent) do
+                    if field_name == p.source_field and value ~= nil then
+                        found = true
+                        break
+                    end
+                end
+
+                if not found then
+                    return box.NULL, nil
+                end
+            end
+        end
+
         local v, variant_num, box_field_name = resolve_variant(parent)
         local destination_type = union_types[variant_num]
 

graphql/convert_schema/types.lua

@@ -448,10 +448,16 @@ function types.convert(state, avro_schema, opts)
             'got %s (avro_schema %s)'):format(type(avro_schema.values),
             json.encode(avro_schema)))
 
-        -- validate avro schema format inside 'values'
-        types.convert(state, avro_schema.values, {context = context})
+        local converted_values = types.convert(state, avro_schema.values,
+            {context = context})
+
+        local true_values_type = converted_values
+        while true_values_type.__type == 'NonNull' do
+            true_values_type = true_values_type.ofType
+        end
+        local map_name = true_values_type.name .. "_Map"
 
-        local res = core_types.map
+        local res = core_types.map({values = converted_values, name = map_name })
         return avro_t == 'map' and core_types.nonNull(res) or res
     elseif avro_t == 'union' then
         return union.convert(avro_schema, {

graphql/convert_schema/union.lua

@@ -38,6 +38,9 @@ local function box_type(type_to_box, box_field_name, opts)
     -- for the argument type to avoid 'Encountered multiple types' error. See
     -- also the comment in @{types.box_collection_type}.
     local box_name = (gql_true_type.name or gql_true_type.__type) .. '_box'
+    if (gql_true_type.__type == "Scalar" and gql_true_type.subtype == 'Map') then
+        box_name = 'Map_box'
+    end
     if gen_argument then
         box_name = helpers.full_name(box_name, context)
     else

graphql/core/types.lua

@@ -191,17 +191,24 @@ function types.union(config)
   return instance
 end
 
-types.map = types.scalar({
-  name = 'Map',
-  description = 'Map is a dictionary with string keys and values of ' ..
-    'arbitrary but same among all values type',
-  serialize = function(value) return value end,
-  parseValue = function(value) return value end,
-  parseLiteral = function(node)
-    error('Literal parsing is implemented in util.coerceValue; ' ..
-      'we should not go here')
-  end,
-})
+function types.map(config)
+    local instance = {
+        __type = 'Scalar',
+        subtype = 'Map',
+        name = config.name,
+        description = 'Map is a dictionary with string keys and values of ' ..
+            'arbitrary but same among all values type',
+        serialize = function(value) return value end,
+        parseValue = function(value) return value end,
+        parseLiteral = function(node)
+            error('Literal parsing is implemented in util.coerceValue; ' ..
+                'we should not go here')
+        end,
+        values = config.values,
+    }
+
+    return instance
+end
 
 function types.inputObject(config)
   assert(type(config.name) == 'string', 'type name must be provided as a string')

graphql/impl.lua

@@ -73,8 +73,8 @@ end
 --- @treturn table result of the operation
 local function compile_and_execute(state, query, variables, operation_name,
         opts)
-    assert(type(state) == 'table', 'use :gql_execute(...) instead of ' ..
-        '.execute(...)')
+    assert(type(state) == 'table', 'use :compile_and_execute(...) ' ..
+        'instead of .compile_and_execute(...)')
     assert(state.schema ~= nil, 'have not compiled schema')
     check(query, 'query', 'string')
     check(variables, 'variables', 'table', 'nil')
@@ -103,7 +103,7 @@ end
 --- @treturn table compiled query with `execute` and `avro_schema` functions
 local function gql_compile(state, query, opts)
     assert(type(state) == 'table' and type(query) == 'string',
-        'use :validate(...) instead of .validate(...)')
+        'use :gql_compile(...) instead of .gql_compile(...)')
     assert(state.schema ~= nil, 'have not compiled schema')
     check(query, 'query', 'string')
     check(opts, 'opts', 'table', 'nil')

graphql/query_to_avro.lua

@@ -10,12 +10,16 @@ local introspection = require(path .. '.introspection')
 local query_util = require(path .. '.query_util')
 local avro_helpers = require('graphql.avro_helpers')
 local convert_schema_helpers = require('graphql.convert_schema.helpers')
+local utils = require('graphql.utils')
+local check = utils.check
 
 -- module functions
 local query_to_avro = {}
 
 -- forward declaration
 local object_to_avro
+local union_to_avro
+local map_to_avro
 
 local gql_scalar_to_avro_index = {
     String = "string",
@@ -29,7 +33,9 @@ local gql_scalar_to_avro_index = {
 
 local function gql_scalar_to_avro(fieldType)
     assert(fieldType.__type == "Scalar", "GraphQL scalar field expected")
-    assert(fieldType.name ~= "Map", "Map type is not supported")
+    if (fieldType.subtype == "Map") then
+        return map_to_avro(fieldType)
+    end
     local result = gql_scalar_to_avro_index[fieldType.name]
     assert(result ~= nil, "Unexpected scalar type: " .. fieldType.name)
     return result
@@ -45,8 +51,14 @@ end
 --- @tparam table context current traversal context, here it just falls to the
 --- called functions (internal graphql-lua format)
 ---
+--- @tparam table opts the following options:
+---
+--- * is_nullable (boolean) whether resulting type should be nullable or not.
+---   If passed, then the function will not care if original GraphQL type was
+---   nullable or not.
+---
 --- @treturn table `result` is the resulting avro-schema
-local function gql_type_to_avro(fieldType, subSelections, context)
+local function gql_type_to_avro(fieldType, subSelections, context, opts)
     local fieldTypeName = fieldType.__type
     local isNonNull = false
 
@@ -71,20 +83,115 @@ local function gql_type_to_avro(fieldType, subSelections, context)
         result = gql_scalar_to_avro(fieldType)
     elseif fieldTypeName == 'Object' then
         result = object_to_avro(fieldType, subSelections, context)
-    elseif fieldTypeName == 'Interface' or fieldTypeName == 'Union' then
-        error('Interfaces and Unions are not supported yet')
+    elseif fieldTypeName == 'Union' then
+        result = union_to_avro(fieldType, subSelections, context)
+    elseif fieldTypeName == 'Interface' then
+        error('Interfaces are not supported yet')
     else
         error(string.format('Unknown type "%s"', tostring(fieldTypeName)))
     end
 
-    if not isNonNull then
+    local opts = opts or {}
+    opts.is_nullable = opts.is_nullable or false
+    if not isNonNull or opts.is_nullable then
         result = avro_helpers.make_avro_type_nullable(result, {
             raise_on_nullable = true,
         })
     end
     return result
 end
 
+--- The function converts a GraphQL Map type to avro-schema map type.
+map_to_avro = function(mapType)
+    assert(mapType.values ~= nil, "GraphQL Map type must have 'values' field")
+    return  {
+        type = "map",
+        values =  gql_type_to_avro(mapType.values),
+    }
+end
+
+--- The function converts a GraphQL Union type to avro-schema type.
+---
+--- Currently we use GraphQL Unions to implement both multi-head connections
+--- and avro-schema unions. The function distinguishes between them relying on
+--- 'fieldType.resolveType'. GraphQL Union implementing multi-head
+--- connection does not have such field, as it has another mechanism of union
+--- type resolving.
+---
+--- We have to distinguish between these two types of GraphQL Unions because
+--- we want to create different avro-schemas for them.
+---
+--- GraphQL Unions implementing avro-schema unions are to be converted back
+--- to avro-schema unions.
+---
+--- GraphQL Unions implementing multi-head connections are to be converted to
+--- avro-schema records. Each field represents one union variant. Variant type
+--- name is taken as a field name. Such records must have all fields nullable.
+---
+--- We convert multi-head Unions to records instead of unions because in case
+--- of 1:N connections we would not have valid avro-schema (if use unions).
+--- This is because according to avro-schema standard unions may not contain
+--- more than one schema with the same type (in case of 1:N multi-head
+--- connections we would have more than one 'array' in union)
+union_to_avro = function(fieldType, subSelections, context)
+    assert(fieldType.types ~= nil, "GraphQL Union must have 'types' field")
+    check(fieldType.types, "fieldType.types", "table")
+    local is_multihead = (fieldType.resolveType == nil)
+    local result = {}
+
+    if is_multihead then
+        check(fieldType.name, "fieldType.name", "string")
+        result = {
+            type = 'record',
+            name = fieldType.name,
+            fields = {}
+        }
+    end
+
+    for _, box_type in ipairs(fieldType.types) do
+        -- In GraphQL schema all types in Unions are 'boxed'. Here we
+        -- 'Unbox' types and selectionSets. More info on 'boxing' can be
+        -- found at @{convert_schema.types.convert_multihead_connection}
+        -- and at @{convert_schema.union}.
+        check(box_type, "box_type", "table")
+        assert(box_type.__type == "Object", "Box type must be a GraphQL Object")
+        assert(utils.table_size(box_type.fields) == 1, 'Box Object must ' ..
+            'have exactly one field')
+        local type =
+            box_type.fields[utils.get_keys(box_type.fields)[1]]
+
+        local box_sub_selections
+        for _, s in pairs(subSelections) do
+            if s.typeCondition.name.value == box_type.name then
+                box_sub_selections = s
+                break
+            end
+        end
+
+        -- We have to extract subSelections from 'box' type.
+        local type_sub_selections
+        if box_sub_selections.selectionSet.selections[1].selectionSet ~= nil then
+            -- Object GraphQL type case.
+            type_sub_selections =
+            box_sub_selections.selectionSet.selections[1].selectionSet.selections
+        else
+            -- Scalar GraphQL type case.
+            type_sub_selections = box_sub_selections.selectionSet.selections[1]
+        end
+
+        if is_multihead then
+            local avro_type = gql_type_to_avro(type.kind,
+                type_sub_selections, context, {is_nullable = true})
+            table.insert(result.fields, {name = type.name, type = avro_type})
+        else
+            table.insert(result, gql_type_to_avro(type.kind,
+                type_sub_selections, context))
+        end
+    end
+
+    return result
+end
+
 --- The function converts a single Object field to avro format.
 local function field_to_avro(object_type, fields, context)
     local firstField = fields[1]
@@ -97,6 +204,46 @@ local function field_to_avro(object_type, fields, context)
 
     local fieldTypeAvro = gql_type_to_avro(fieldType.kind, subSelections,
         context)
+    -- Currently we support only 'include' and 'skip' directives. Both of them
+    -- affect resulting avro-schema the same way: field with directive becomes
+    -- nullable, if it's already not. Nullable field does not change.
+    --
+    -- If it is a 1:N connection then it's 'array' field becomes 'array*'.
+    -- If it is avro-schema union, then 'null' will be added to the union
+    -- types. If there are more then one directive on a field then all works
+    -- the same way, like it is only one directive. (But we still check all
+    -- directives to be 'include' or 'skip').
+    if firstField.directives ~= nil then
+        for _, d in ipairs(firstField.directives) do
+            check(d.name, "directive.name", "table")
+            check(d.arguments, "directive.arguments", "table")
+            check(d.kind, "directive.kind", "string")
+            assert(d.kind == "directive")
+            check(d.name.value, "directive.name.value", "string")
+            assert(d.name.value == "include" or d.name.value == "skip",
+                "Only 'include' and 'skip' directives are supported for now")
+        end
+        if type(fieldTypeAvro) == "string" then
+            if string.sub(fieldTypeAvro, -1) ~= '*' then
+                fieldTypeAvro = fieldTypeAvro .. '*'
+            end
+        end
+        if type(fieldTypeAvro) == "table" then
+            if utils.is_array(fieldTypeAvro) then
+                -- Union case.
+                if not utils.value_in("null", fieldTypeAvro) then
+                    table.insert(fieldTypeAvro, "null")
+                end
+            else
+                -- Record case.
+                check(fieldTypeAvro.type, "fieldTypeAvro.type", "string")
+                if string.sub(fieldTypeAvro.type, -1) ~= '*' then
+                    fieldTypeAvro.type = fieldTypeAvro.type .. '*'
+                end
+            end
+        end
+    end
+
     return {
         name = convert_schema_helpers.base_name(fieldName),
         type = fieldTypeAvro,