Feature: convert graphql query to avro schema

Extend query object: add `avro_schema` method, which produces Avro
schema which can be used to verify or flatten any `query_exequte`
result.

Closes #7

Author: Khatskevich

graphql/query_to_avro.lua

@@ -0,0 +1,130 @@
+--- Module for convertion GraphQl query to Avro schema.
+---
+--- Random notes:
+---
+--- * The best way to use this module is to just call `avro_schema` methon on
+---   compiled query object.
+local path = "graphql.core"
+local introspection = require(path .. '.introspection')
+local query_util = require(path .. '.query_util')
+
+-- module functions
+local query_to_avro = {}
+
+-- use long types, to avoid overflow problems
+local gql_scalar_to_avro_index = {
+    String = "string",
+    Int = "long",
+    Long = "long",
+    Float = "double",
+    Boolean = "boolean"
+}
+local function gql_scalar_to_avro(fieldType)
+    assert(fieldType.__type == "Scalar", "GraphQL scalar field expected")
+    local result = gql_scalar_to_avro_index[fieldType.name]
+    assert(result ~= nil, "Unexpected scalar type: " .. fieldType.name)
+    return result
+end
+
+local collection_to_avro
+
+local function complete_field_to_avro(fieldType, result, subSelections, context)
+    local fieldTypeName = fieldType.__type
+
+    if fieldTypeName == 'List' then
+        local innerType = fieldType.ofType
+        local type = {
+            type = "array",
+            items = complete_field_to_avro(innerType, {}, subSelections,
+                                           context).type
+        }
+        result.type = type
+        return result
+    end
+
+    if fieldTypeName == 'Scalar' or fieldTypeName == 'Enum' then
+        return fieldType.serialize(result)
+    end
+
+    if fieldTypeName == 'Object' then
+        --result.name = "lol"
+        result.type = collection_to_avro(fieldType, result,
+                                         subSelections, context)
+        return result
+        --return collection_to_avro(fieldType, result, subSelections, context)
+    elseif fieldTypeName == 'Interface' or fieldTypeName == 'Union' then
+        local objectType = fieldType.resolveType(result)
+        result.type = collection_to_avro(objectType, result,
+                                         subSelections, context)
+        return result
+    end
+    error('Unknown type "' .. fieldTypeName .. '" for field "' ..
+            field.name .. '"')
+end
+
+local function field_to_avro(objectType, object, fields, context)
+    local firstField = fields[1]
+    local fieldName = firstField.name.value
+    local fieldType = introspection.fieldMap[fieldName] or
+                        objectType.fields[fieldName]
+    assert(fieldType ~= nil)
+    local subSelections = query_util.mergeSelectionSets(fields)
+    local fieldTypeName = fieldType.kind.__type
+    local innerType = fieldType.kind
+    local nullable = true
+    -- In case the field is nullable, the real type is in ofType attibute.
+    if fieldTypeName == 'NonNull' then
+        innerType = innerType.ofType
+        nullable = false
+    end
+    local result = {}
+    result.name = fieldName
+    if fieldType.resolve ~= nil then
+        -- not scalar
+        return complete_field_to_avro(innerType, result, subSelections, context)
+    end
+    -- scalar type
+    result.type = gql_scalar_to_avro(innerType)
+    result.type = nullable and result.type .. "*" or result.type
+    return result
+end
+
+collection_to_avro = function(objectType, object, selections, context)
+    local groupedFieldSet = query_util.collectFields(objectType, selections,
+                                                     {}, {}, context)
+    local result= {
+        type = 'record',
+        name = objectType.name,
+        fields = {}
+    }
+    if #context.namespace_parts ~= 0 then
+        result.namespace = table.concat(context.namespace_parts, ".")
+    end
+    table.insert(context.namespace_parts, result.name)
+    for _, fields in pairs(groupedFieldSet) do
+        table.insert(result.fields,
+                     field_to_avro(objectType, object, fields, context))
+    end
+    context.namespace_parts[#context.namespace_parts] = nil
+    return result
+end
+
+--- The function creates an Avro schema for a given query.
+---
+--- @tparam table query object which avro schema should be created for
+---
+--- @treturn table `avro_schema` avro schema for any `query:execute()` result.
+function query_to_avro.convert(query)
+    local state = query.state
+    local context = query_util.buildContext(state.schema, query.ast, {},
+                                            {}, query.operation_name)
+    -- The variable is necessary to avoid fullname interferention.
+    -- Each nested Avro record creates it's namespace.
+    context.namespace_parts = {}
+    local rootType = state.schema[context.operation.operation]
+    return collection_to_avro(rootType, {},
+                              context.operation.selectionSet.selections,
+                              context)
+end
+
+return query_to_avro

graphql/tarantool_graphql.lua

@@ -14,6 +14,7 @@ local schema = require('graphql.core.schema')
 local types = require('graphql.core.types')
 local validate = require('graphql.core.validate')
 local execute = require('graphql.core.execute')
+local query_to_avro = require('graphql.query_to_avro')
 
 local utils = require('graphql.utils')
 
@@ -466,6 +467,7 @@ local function gql_compile(state, query)
     local gql_query = setmetatable(qstate, {
         __index = {
             execute = gql_execute,
+            avro_schema = query_to_avro.convert
         }
     })
     return gql_query

test/extra/suite.ini

@@ -0,0 +1,4 @@
+[default]
+core = app
+description = tests on features which are not related to specific executor
+lua_libs = ../common/lua/test_data_user_order.lua