[WIP] Sb/avro arr

graphql/tarantool_graphql.lua

@@ -30,6 +30,14 @@ local function avro_type(avro_schema)
             return 'record*'
         elseif utils.is_array(avro_schema) then
             return 'union'
+        elseif avro_schema.type == 'array' then
+            return 'array'
+        elseif avro_schema.type == 'array*' then
+            return 'array*'
+        elseif avro_schema.type == 'map' then
+            return 'map'
+        elseif avro_schema.type == 'map*' then
+            return 'map*'
         end
     elseif type(avro_schema) == 'string' then
         if avro_schema == 'int' then
@@ -49,16 +57,7 @@ local function avro_type(avro_schema)
     error('unrecognized avro-schema type: ' .. json.encode(avro_schema))
 end
 
--- XXX: recursive skip several NonNull's?
-local function nullable(gql_class)
-    assert(type(gql_class) == 'table', 'gql_class must be a table, got ' ..
-        type(gql_class))
-
-    if gql_class.__type ~= 'NonNull' then return gql_class end
-
-    assert(gql_class.ofType ~= nil, 'gql_class.ofType must not be nil')
-    return gql_class.ofType
-end
+local nullable = utils.nullable
 
 local types_long = types.scalar({
     name = 'Long',
@@ -96,15 +95,25 @@ local function convert_scalar_type(avro_schema, opts)
     elseif avro_t == 'string*' then
         return types.string
     end
+
+    if opts.is_items_type then
+        error('avro array items must have know scalar type, not: ' ..
+                json.encode(avro_schema))
+    end
+
     if raise then
         error('unrecognized avro-schema scalar type: ' ..
-            json.encode(avro_schema))
+        json.encode(avro_schema))
     end
+
+
     return nil
 end
 
 --- Non-recursive version of the @{gql_type} function that returns
 --- InputObject instead of Object.
+--- An error will be raised in case of fields that are not scalar types
+--- as there are no sense in non scalar arguments.
 local function gql_argument_type(state, avro_schema)
     assert(type(state) == 'table',
         'state must be a table, got ' .. type(state))
@@ -115,17 +124,21 @@ local function gql_argument_type(state, avro_schema)
         assert(type(avro_schema.name) == 'string',
             ('avro_schema.name must be a string, got %s (avro_schema %s)')
             :format(type(avro_schema.name), json.encode(avro_schema)))
+
         assert(type(avro_schema.fields) == 'table',
             ('avro_schema.fields must be a table, got %s (avro_schema %s)')
             :format(type(avro_schema.fields), json.encode(avro_schema)))
 
         local fields = {}
-        for _, field in ipairs(fields) do
+        for _, field in ipairs(avro_schema.fields) do
+
             assert(type(field.name) == 'string',
                 ('field.name must be a string, got %s (schema %s)')
                 :format(type(field.name), json.encode(field)))
+
             local gql_field_type = convert_scalar_type(
                 field.type, {raise = true})
+
             fields[field.name] = {
                 name = field.name,
                 kind = types.nonNull(gql_field_type),
@@ -149,44 +162,71 @@ local function gql_argument_type(state, avro_schema)
     end
 end
 
+
+--- Recursively convert each field of an avro-schema to a graphql type and
+--- corresponding argument for an upper graphql type.
+---
+--- @tparam table state
+--- @tparam table fields
 local function convert_record_fields_to_args(state, fields)
     local args = {}
     for _, field in ipairs(fields) do
+
         assert(type(field.name) == 'string',
             ('field.name must be a string, got %s (schema %s)')
             :format(type(field.name), json.encode(field)))
+
         local gql_class = gql_argument_type(state, field.type)
-        args[field.name] = nullable(gql_class)
+
+        -- arrays (gql lists) and maps can't be arguments
+        -- so these kinds are to be skipped
+
+        if (nullable(gql_class) ~= 'List'
+                            and nullable(gql_class) ~= 'Map') then
+            args[field.name] = nullable(gql_class)
+        end
     end
     return args
 end
 
---- Convert each field of an avro-schema to a graphql type and corresponding
---- argument for an upper graphql type.
+--- Recursively convert each field of an avro-schema to a graphql type and
+--- corresponding argument for an upper graphql type.
 ---
 --- @tparam table state for read state.accessor and previously filled
 --- state.types
 --- @tparam table fields fields part from an avro-schema
-local function convert_record_fields(state, fields)
+--- @tparam table opts include is_for_args flag to specify
+--- case when the function is used to collect arguments
+local function convert_record_fields(state, fields, opts)
     local res = {}
     local object_args = {}
+    local opts = opts or {}
+    local is_for_args = opts.is_for_args or false
+
     for _, field in ipairs(fields) do
         assert(type(field.name) == 'string',
             ('field.name must be a string, got %s (schema %s)')
             :format(type(field.name), json.encode(field)))
+
         res[field.name] = {
             name = field.name,
             kind = gql_type(state, field.type),
         }
-        object_args[field.name] = nullable(res[field.name].kind)
+
+
+        -- arrays (gql lists) and maps can't be arguments
+        if not is_for_args or (nullable(res[field.name].kind) ~= 'List'
+                            and nullable(res[field.name].kind) ~= 'Map') then
+            object_args[field.name] = nullable(res[field.name].kind)
+        end
     end
     return res, object_args
 end
 
---- The function recursively converts passed avro-schema to a graphql type.
+--- The function recursively converts passed avro-schema to a graphql type (kind).
 ---
 --- @tparam table state for read state.accessor and previously filled
---- state.types
+--- state.types (state.types are gql types)
 --- @tparam table avro_schema input avro-schema
 --- @tparam[opt] table collection table with schema_name, connections fields
 --- described a collection (e.g. tarantool's spaces)
@@ -212,12 +252,14 @@ gql_type = function(state, avro_schema, collection, collection_name)
         ('collection and collection_name must be nils or ' ..
         'non-nils simultaneously, got: %s and %s'):format(type(collection),
         type(collection_name)))
+
     local accessor = state.accessor
     assert(accessor ~= nil, 'state.accessor must not be nil')
     assert(accessor.select ~= nil, 'state.accessor.select must not be nil')
     assert(accessor.list_args ~= nil,
         'state.accessor.list_args must not be nil')
 
+    -- type of the top element in the avro schema
     local avro_t = avro_type(avro_schema)
 
     if avro_t == 'record' or avro_t == 'record*' then
@@ -230,6 +272,7 @@ gql_type = function(state, avro_schema, collection, collection_name)
 
         local fields, _ = convert_record_fields(state, avro_schema.fields)
 
+        -- if collection param is passed then go over all connections
         for _, c in ipairs((collection or {}).connections or {}) do
             assert(type(c.type) == 'string',
                 'connection.type must be a string, got ' .. type(c.type))
@@ -243,6 +286,7 @@ gql_type = function(state, avro_schema, collection, collection_name)
             assert(type(c.parts) == 'table',
                 'connection.parts must be a string, got ' .. type(c.parts))
 
+            -- gql type of connection field
             local destination_type =
                 state.types[c.destination_collection]
             assert(destination_type ~= nil,
@@ -261,20 +305,24 @@ gql_type = function(state, avro_schema, collection, collection_name)
 
             local c_list_args = state.list_arguments[c.destination_collection]
 
+            -- change fields that are represented by connections
             fields[c.name] = {
                 name = c.name,
                 kind = destination_type,
                 arguments = c_args,
                 resolve = function(parent, args_instance, info)
                     local destination_args_names = {}
                     local destination_args_values = {}
+
                     for _, part in ipairs(c.parts) do
+
                         assert(type(part.source_field) == 'string',
                             'part.source_field must be a string, got ' ..
                             type(part.destination_field))
                         assert(type(part.destination_field) == 'string',
                             'part.destination_field must be a string, got ' ..
                             type(part.destination_field))
+
                         destination_args_names[#destination_args_names + 1] =
                             part.destination_field
                         destination_args_values[#destination_args_values + 1] =
@@ -318,24 +366,50 @@ gql_type = function(state, avro_schema, collection, collection_name)
             }
         end
 
+        -- create gql schema
         local res = types.object({
             name = collection ~= nil and collection.name or avro_schema.name,
             description = 'generated from avro-schema for ' ..
                 avro_schema.name,
             fields = fields,
         })
         return avro_t == 'enum' and types.nonNull(res) or res
+
     elseif avro_t == 'enum' then
         error('enums not implemented yet') -- XXX
+
+    elseif avro_t == 'array' or avro_t == 'array*' then
+
+        assert(avro_schema.items ~= nil,
+            'items field must not be nil in array avro schema')
+        assert(type(avro_schema.items) == 'string',
+            'avro_schema.items must be a string, got ' .. type(avro_schema.item))
+
+        local gql_items_type = convert_scalar_type(avro_schema.items,
+            {is_items_type=true, raise=true})
+
+        local gql_array = types.list(gql_items_type)
+
+        if  avro_t == 'array*' then
+            return gql_array
+        end
+
+        if avro_t == 'array' then
+            return types.nonNull(gql_array)
+        end
+
     else
         local res = convert_scalar_type(avro_schema, {raise = false})
         if res == nil then
             error('unrecognized avro-schema type: ' .. json.encode(avro_schema))
         end
         return res
+
     end
+
 end
 
+
 local function parse_cfg(cfg)
     local state = {}
     state.types = utils.gen_booking_table({})
@@ -356,32 +430,41 @@ local function parse_cfg(cfg)
 
     local fields = {}
 
-    for name, collection in pairs(state.collections) do
-        collection.name = name
+    for collection_name, collection in pairs(state.collections) do
+        collection.name = collection_name
         assert(collection.schema_name ~= nil,
             'collection.schema_name must not be nil')
+
         local schema = cfg.schemas[collection.schema_name]
         assert(schema ~= nil, ('cfg.schemas[%s] must not be nil'):format(
             tostring(collection.schema_name)))
         assert(schema.name == nil or schema.name == collection.schema_name,
             ('top-level schema name does not match the name in ' ..
             'the schema itself: "%s" vs "%s"'):format(collection.schema_name,
             schema.name))
-        state.types[name] = gql_type(state, schema, collection, name)
 
+        -- recursively converts all avro types into gql types in the given schema
+        assert(schema.type == 'record',
+            'top-level schema must have record avro type, not' .. schema.type)
+        state.types[collection_name] = gql_type(state, schema, collection, collection_name)
+
+        -- prepare arguments (their kinds)
         local _, object_args = convert_record_fields(state,
-            schema.fields)
+            schema.fields, {is_for_args=true})
         local list_args = convert_record_fields_to_args(
-            state, accessor:list_args(name))
+            state, accessor:list_args(collection_name), {is_for_args=true})
         local args = utils.merge_tables(object_args, list_args)
-        state.object_arguments[name] = object_args
-        state.list_arguments[name] = list_args
-        state.all_arguments[name] = args
+
+        -- list and map (avro array and map) can't be arguments
+
+        state.object_arguments[collection_name] = object_args
+        state.list_arguments[collection_name] = list_args
+        state.all_arguments[collection_name] = args
 
         -- create entry points from collection names
-        fields[name] = {
-            kind = types.nonNull(types.list(state.types[name])),
-            arguments = state.all_arguments[name],
+        fields[collection_name] = {
+            kind = types.nonNull(types.list(state.types[collection_name])),
+            arguments = state.all_arguments[collection_name],
             resolve = function(rootValue, args_instance, info)
                 local object_args_instance = {} -- passed to 'filter'
                 local list_args_instance = {} -- passed to 'args'
@@ -397,7 +480,7 @@ local function parse_cfg(cfg)
                     end
                 end
                 local from = nil
-                return accessor:select(rootValue, name, from,
+                return accessor:select(rootValue, collection_name, from,
                     object_args_instance, list_args_instance)
             end,
         }
@@ -414,6 +497,8 @@ local function parse_cfg(cfg)
     return state
 end
 
+--- The function checks if given query has an appropriate type 'query'
+--- (mutations are not supported yet).
 local function assert_gql_query_ast(func_name, ast)
     assert(#ast.definitions == 1,
         func_name .. ': expected an one query')
@@ -425,6 +510,8 @@ local function assert_gql_query_ast(func_name, ast)
         type(operation_name))
 end
 
+--- The function just makes some reasonable assertions on input
+--- and then call graphql-lua execute.
 local function gql_execute(qstate, variables)
     assert(qstate.state)
     local state = qstate.state
@@ -442,6 +529,12 @@ local function gql_execute(qstate, variables)
         operation_name)
 end
 
+--- The function parses a raw query string, validate the resulting query
+--- and make it ready for execution.
+---
+--- @tparam table state current state of graphql-lib, including
+--- schemas, collections and accessor
+--- @tparam string query raw query string
 local function gql_compile(state, query)
     assert(type(state) == 'table' and type(query) == 'string',
         'use :validate(...) instead of .validate(...)')
@@ -458,6 +551,7 @@ local function gql_compile(state, query)
         ast = ast,
         operation_name = operation_name,
     }
+
     local gql_query = setmetatable(qstate, {
         __index = {
             execute = gql_execute,

graphql/utils.lua

@@ -132,4 +132,16 @@ function utils.gen_booking_table(data)
     })
 end
 
+-- XXX: recursive skip several NonNull's?
+function utils.nullable(gql_class)
+    assert(type(gql_class) == 'table', 'gql_class must be a table, got ' ..
+            type(gql_class))
+
+    if gql_class.__type ~= 'NonNull' then return gql_class end
+
+    assert(gql_class.ofType ~= nil, 'gql_class.ofType must not be nil')
+    return gql_class.ofType
+end
+
+
 return utils