Split code to modules

Moves are mostly done w/o changes. There are APIs (parameters and return
values) that are subject to further refactoring.

Removed duplicate code in resolve the function for multihead
connections.

Part of #166.

Author: Totktonada

graphql/accessor_general.lua

@@ -1,8 +1,11 @@
---- The module us collection of helpers to simplify avro-schema related tasks.
+--- The module is collection of helpers to simplify avro-schema related tasks.
 
 local json = require('json')
 local avro_schema = require('avro_schema')
 
+local utils = require('graphql.utils')
+local check = utils.check
+
 local avro_helpers = {}
 
 --- The function converts avro type to the corresponding nullable type in
@@ -83,4 +86,81 @@ function avro_helpers.major_avro_schema_version()
     return model.get_types == nil and 2 or 3
 end
 
+function avro_helpers.is_scalar_type(avro_schema_type)
+    check(avro_schema_type, 'avro_schema_type', 'string')
+
+    local scalar_types = {
+        ['int'] = true,
+        ['int*'] = true,
+        ['long'] = true,
+        ['long*'] = true,
+        ['float'] = true,
+        ['float*'] = true,
+        ['double'] = true,
+        ['double*'] = true,
+        ['boolean'] = true,
+        ['boolean*'] = true,
+        ['string'] = true,
+        ['string*'] = true,
+        ['null'] = true,
+    }
+
+    return scalar_types[avro_schema_type] or false
+end
+
+function avro_helpers.is_comparable_scalar_type(avro_schema_type)
+    check(avro_schema_type, 'avro_schema_type', 'string')
+
+    local scalar_types = {
+        ['int'] = true,
+        ['int*'] = true,
+        ['long'] = true,
+        ['long*'] = true,
+        ['boolean'] = true,
+        ['boolean*'] = true,
+        ['string'] = true,
+        ['string*'] = true,
+        ['null'] = true,
+    }
+
+    return scalar_types[avro_schema_type] or false
+end
+
+function avro_helpers.is_compound_type(avro_schema_type)
+    check(avro_schema_type, 'avro_schema_type', 'string')
+
+    local compound_types = {
+        ['record'] = true,
+        ['record*'] = true,
+        ['array'] = true,
+        ['array*'] = true,
+        ['map'] = true,
+        ['map*'] = true,
+    }
+
+    return compound_types[avro_schema_type] or false
+end
+
+function avro_helpers.avro_type(avro_schema, opts)
+    local opts = opts or {}
+    local allow_references = opts.allow_references or false
+
+    if type(avro_schema) == 'table' then
+        if utils.is_array(avro_schema) then
+            return 'union'
+        elseif avro_helpers.is_compound_type(avro_schema.type) then
+            return avro_schema.type
+        elseif allow_references then
+            return avro_schema
+        end
+    elseif type(avro_schema) == 'string' then
+        if avro_helpers.is_scalar_type(avro_schema) then
+            return avro_schema
+        elseif allow_references then
+            return avro_schema
+        end
+    end
+    error('unrecognized avro-schema type: ' .. json.encode(avro_schema))
+end
+
 return avro_helpers

graphql/avro_helpers.lua

@@ -0,0 +1,134 @@
+--- Convert avro-schema fields to GraphQL arguments (scalars and InputObjects).
+
+local json = require('json')
+local log = require('log')
+local core_types = require('graphql.core.types')
+local avro_helpers = require('graphql.avro_helpers')
+local core_types_helpers = require('graphql.convert_schema.core_types_helpers')
+local scalar_types = require('graphql.convert_schema.scalar_types')
+
+local utils = require('graphql.utils')
+local check = utils.check
+
+local arguments = {}
+
+--- Convert each field of an avro-schema to a scalar graphql type or an input
+--- object.
+---
+--- It uses the @{arguments.convert} function to convert each field, then skips
+--- fields of record, array and map types and gives the resulting list of
+--- converted fields.
+---
+--- @tparam table fields list of fields of the avro-schema record fields format
+---
+--- @tparam[opt] table opts optional options:
+---
+--- * `skip_compound` -- do not add fields of record type to the arguments;
+--- default: false.
+---
+--- * `dont_skip` -- do not skip any fields; default: false.
+---
+--- @treturn table `args` -- map with type names as keys and graphql types as
+--- values
+function arguments.convert_record_fields(fields, opts)
+    assert(type(fields) == 'table',
+        'fields must be a table, got ' .. type(fields))
+
+    local opts = opts or {}
+    assert(type(opts) == 'table',
+        'opts must be a table, got ' .. type(opts))
+
+    local skip_compound = opts.skip_compound or false
+    assert(type(skip_compound) == 'boolean',
+        'skip_compound must be a boolean, got ' .. type(skip_compound))
+
+    local dont_skip = opts.dont_skip or false
+    check(dont_skip, 'dont_skip', 'boolean')
+
+    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)))
+        -- records, arrays (gql lists), maps and unions can't be arguments, so
+        -- these graphql types are to be skipped;
+        -- skip_compound == false is the trick for accessor_general-provided
+        -- record; we don't expect map, array or union here as well as we don't
+        -- expect avro-schema reference.
+        local avro_t = avro_helpers.avro_type(field.type,
+            {allow_references = true})
+        local add_field = dont_skip or
+            avro_helpers.is_comparable_scalar_type(avro_t) or
+            (not skip_compound and not avro_helpers.is_scalar_type(avro_t))
+        if add_field then
+            local ok, gql_class = pcall(arguments.convert, field.type)
+            -- XXX: we need better avro-schema -> graphql types converter to
+            -- handle the following cases:
+            -- * scalar arguments that can be checked for equality (object
+            --   args): skip any other
+            -- * pcre / limit / offset (nothing special here I guess)
+            -- * auxiliary schemas for insert / update: don't skip anything
+            if ok then
+                args[field.name] = core_types_helpers.nullable(gql_class)
+            else
+                log.warn(('Cannot add argument "%s": %s'):format(
+                    field.name, tostring(gql_class)))
+            end
+        end
+    end
+    return args
+end
+
+--- Convert avro-schema type to GraphQL scalar or InputObject.
+---
+--- An error will be raised if avro_schema type is 'record'
+--- and its' fields have non-scalar types. So triple nesting level is not
+--- supported (record with record as a field - ok, record with record which
+--- has inside an another level - not ok).
+function arguments.convert(avro_schema)
+    assert(avro_schema ~= nil,
+        'avro_schema must not be nil')
+
+    if avro_helpers.avro_type(avro_schema) == 'record' then
+        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(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 = scalar_types.convert(field.type,
+                {raise = true})
+
+            fields[field.name] = {
+                name = field.name,
+                kind = gql_field_type,
+            }
+        end
+
+        local res = core_types.nonNull(core_types.inputObject({
+            name = avro_schema.name,
+            description = 'generated from avro-schema for ' ..
+                avro_schema.name,
+            fields = fields,
+        }))
+
+        return res
+    else
+        local res = scalar_types.convert(avro_schema, {raise = false})
+        if res == nil then
+            error('unrecognized avro-schema type: ' ..
+                json.encode(avro_schema))
+        end
+        return res
+    end
+end
+
+return arguments

graphql/convert_schema/arguments.lua

@@ -0,0 +1,26 @@
+--- Collection of helpers to work with GraphQL types.
+
+local utils = require('graphql.utils')
+local check = utils.check
+
+local core_types_helpers = {}
+
+function core_types_helpers.nullable(gql_class)
+    check(gql_class, 'gql_class', 'table')
+
+    if gql_class.__type ~= 'NonNull' then return gql_class end
+
+    assert(gql_class.ofType ~= nil, 'gql_class.ofType must not be nil')
+    return core_types_helpers.nullable(gql_class.ofType)
+end
+
+function core_types_helpers.raw_gql_type(gql_class)
+    check(gql_class, 'gql_class', 'table')
+
+    if gql_class.ofType == nil then return gql_class end
+
+    assert(gql_class.ofType ~= nil, 'gql_class.ofType must not be nil')
+    return core_types_helpers.raw_gql_type(gql_class.ofType)
+end
+
+return core_types_helpers

graphql/convert_schema/core_types_helpers.lua

@@ -0,0 +1,7 @@
+local schema = require('graphql.convert_schema.schema')
+
+local convert_schema = {}
+
+convert_schema.convert = schema.convert
+
+return convert_schema