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

Makefile

@@ -3,8 +3,11 @@ default:
 
 .PHONY: lint
 lint:
-	luacheck graphql/*.lua test/local/*.lua test/testdata/*.lua \
+	luacheck graphql/*.lua \
+		test/local/*.lua \
+		test/testdata/*.lua \
 		test/common/*.test.lua test/common/lua/*.lua \
+		test/extra/*.test.lua \
 		--no-redefined --no-unused-args
 
 .PHONY: test

graphql/query_to_avro.lua

@@ -0,0 +1,131 @@
+--- 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 object_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 items = complete_field_to_avro(innerType, {}, subSelections,
+                context).type
+        result.type = {
+            type = "array",
+            items = items
+        }
+        return result
+    end
+
+    if fieldTypeName == 'Object' then
+        result.type = object_to_avro(fieldType, subSelections, context)
+        return result
+    elseif fieldTypeName == 'Interface' or fieldTypeName == 'Union' then
+        error('Interfases and Utions are not supported yet')
+    end
+    error(string.format('Unknown type "%s"', fieldTypeName))
+end
+
+--- The function converts a single Object field to avro format
+local function field_to_avro(object_type, fields, context)
+    local firstField = fields[1]
+    local fieldName = firstField.name.value
+    local fieldType = introspection.fieldMap[fieldName] or
+        object_type.fields[fieldName]
+    assert(fieldType ~= nil)
+    local subSelections = query_util.mergeSelectionSets(fields)
+    local innerType = fieldType.kind
+    local fieldTypeName = innerType.__type
+    local nullable = true
+    -- In case the field is NonNull, 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
+
+--- Convert GraphQL object to avro record.
+---
+--- @tparam table object_type GraphQL type object to be converted to Avro schema
+---
+--- @tparam table selections GraphQL representations of fields which should be
+--- in the output of the query
+---
+--- @tparam table context additional information for Avro schema generation; one
+--- of the fields is `namespace_parts` -- table of names of records from the
+--- root to the current object
+---
+--- @treturn table corresponding Avro schema
+object_to_avro = function(object_type, selections, context)
+    local groupedFieldSet = query_util.collectFields(object_type, selections,
+        {}, {}, context)
+    local result = {
+        type = 'record',
+        name = object_type.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
+        local avro_field = field_to_avro(object_type, fields, context)
+        table.insert(result.fields, avro_field)
+    end
+    context.namespace_parts[#context.namespace_parts] = nil
+    return result
+end
+
+--- Create 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]
+    local selections = context.operation.selectionSet.selections
+    return object_to_avro(rootType, 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')
 
@@ -595,6 +596,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