enable calling tarantool_graphql.new() with {auto_cfg = true} to generate configs

Author: SudoBobo

graphql/accessor_general.lua

@@ -827,7 +827,7 @@ local function process_tuple(state, tuple, opts)
 
     -- convert tuple -> object
     local obj = opts.unflatten_tuple(collection_name, tuple,
-        opts.default_unflatten_tuple)
+        opts.default_unflatten_tuple, opts.is_collection_formatted)
 
     -- skip all items before pivot (the item pointed by offset)
     if not state.pivot_found and pivot_filter then
@@ -975,6 +975,7 @@ local function select_internal(self, collection_name, from, filter, args, extra)
         fetched_object_cnt_max = self.settings.fetched_object_cnt_max,
         collection_name = collection_name,
         unflatten_tuple = self.funcs.unflatten_tuple,
+        is_collection_formatted = self.formatted_collections[collection_name] or false,
         default_unflatten_tuple = default_unflatten_tuple,
         pcre = args.pcre,
         resolveField = extra.resolveField,
@@ -1179,6 +1180,7 @@ local function get_pcre_argument_type(self, collection_name)
     return pcre_type
 end
 
+--todo add comments about opts.formatted_collections (also assertions)
 --- Create a new data accessor.
 ---
 --- Provided `funcs` argument determines certain functions for retrieving
@@ -1231,6 +1233,7 @@ function accessor_general.new(opts, funcs)
     assert(type(funcs) == 'table',
         'funcs must be a table, got ' .. type(funcs))
 
+    --todo assertions for opt.formatted_collections
     local schemas = opts.schemas
     local collections = opts.collections
     local service_fields = opts.service_fields
@@ -1285,6 +1288,7 @@ function accessor_general.new(opts, funcs)
         indexes = indexes,
         models = models,
         default_unflatten_tuple = default_unflatten_tuple,
+        formatted_collections = opts.formatted_collections,
         index_cache = index_cache,
         funcs = funcs,
         settings = {

graphql/accessor_space.lua

@@ -31,7 +31,10 @@ end
 --- ```
 --- return default(collection_name, tuple)
 --- ```
-local function unflatten_tuple(collection_name, tuple, default)
+local function unflatten_tuple(collection_name, tuple, default, is_collection_formatted)
+    if is_collection_formatted then
+        return tuple:tomap()
+    end
     return default(collection_name, tuple)
 end
 
@@ -48,6 +51,8 @@ function accessor_space.new(opts, funcs)
             'funcs values must be functions, got ' .. type(v))
     end
 
+    -- todo add some note in comments that funcs.unflatten_tuple must
+    -- manage our tuple:tomap or unflatten issue
     local res_funcs = {
         is_collection_exists = funcs.is_collection_exists or
             is_collection_exists,

graphql/config_complement.lua

@@ -0,0 +1,167 @@
+local utils = require('graphql.utils')
+local at = utils.assert_type
+
+local config_complement = {}
+
+--- The function determines connection type by fully qualified connection.parts
+--- and source collection space format
+--- Items in parts must be sorted by destination_field to match field order
+--- in connection's index
+local function determine_connection_type(connection_parts, index, source_format)
+    local type
+
+    if #connection_parts < #(index.fields) then
+        type = '1:N'
+    end
+
+    if #connection_parts == #(index.fields) then
+        if index.unique then
+            type = '1:1'
+        else
+            type = '1:N'
+        end
+    end
+
+    -- todo still not clear how to handle nullables
+    return type
+end
+
+--- XXX Currently if connections_parts have destination_fields that do not
+--- exist in connection's index the assertion is raised. Maybe it is not a
+--- desirable behavior. Consider the following case: you have working
+--- tarantool_graphql, then you try to change configuration a bit and
+--- tarantool_graphql crushes.
+local function sort_parts(connection_parts, index_fields)
+    local sorted_parts = {}
+    for _, part in pairs(connection_parts) do
+        local is_found = false
+        for i, index_field in ipairs(index_fields) do
+            if part.destination_field == index_field then
+                sorted_parts[i] = part
+                is_found = true
+            end
+        end
+        assert(is_found, ('part.destination_field %s was not found in ' ..
+            'connection index'):format(part.destination_field))
+    end
+    return sorted_parts;
+end
+
+--- The functions determines fully qualified connection's parts based on
+--- connection's index and incompletely qualified connection's part given by user
+--- @tparam table parts incompletely qualified connection's part given by user
+--- @tparam table index connection index (cfg.indexes[collection][index_name]
+--- order of items in index.fields must be the same as in index format
+local function determine_connection_parts(parts, index)
+    at(parts, 'parts', 'nil', 'number', 'table')
+    local result_parts = {}
+
+    -- full index case
+    if type(parts) == 'nil' then
+        for i, v in ipairs(index.fields) do
+            result_parts[i] = {source_field = v, destination_field = v}
+        end
+    end
+
+    -- index prefix case
+    if type(parts) == 'number' then
+        for i = 1, parts do
+            local v = index.fields[i]
+            result_parts[i] = {source_field = v, destination_field = v}
+        end
+    end
+
+    -- fully qualified parts case
+    if type(parts) == 'table' then
+        local sorted_parts = sort_parts(parts, index.fields)
+        for i, v in ipairs(sorted_parts) do
+            result_parts[i] = {source_field = v, destination_field = v}
+        end
+    end
+
+    return result_parts
+end
+
+---
+--- The function complements collections' connections, described in simplified
+--- format, to connections in a fully specified format. Connection's
+--- collection determined on source_collection. Type determined on index type.
+--- Notice an example:
+---
+--- "connections" : [
+---     {
+---         "name": "order_connection",
+---         "source_collection": "user_collection",
+---         "destination_collection": "order_collection"
+---         "index_name": "user_id_index",
+---         "parts" : nil | number | table (destination fields can be omitted)
+---     },
+---    ...
+--- ]
+--- will produce following complement in 'user_collection' :
+---
+--- "user_collection": {
+---    "schema_name": "user",
+---    "connections": [
+---    {
+---        "type": "1:N",
+---        "name": "order_connection",
+---        "destination_collection":  "order_collection",
+---        "parts": [
+---        { "source_field": "user_id", "destination_field": "user_id" }
+---        ],
+---        "index_name": "user_id_index"
+---    },
+---
+---    ]
+--- }
+---
+--- @tparam table collections cfg.collections
+--- @tparam table connections cfg.connections - user-defined collections
+--- @tparam table indexes cfg.indexes - {collection_name = collection_indexes}
+local function complement_connections(collections, connections, indexes, schemas)
+    if connections == nil then
+        return collections
+    end
+
+    at(collections, 'collections', 'table')
+    at(connections, 'connections', 'table')
+
+    for _, c in pairs(connections) do
+        at(c.name, 'connection.name', 'string')
+        at(c.source_collection, 'connection.source_collection', 'string')
+        at(c.destination_collection, 'connection.destination_collection',
+        'string')
+        at(c.index_name, 'connection.index_name', 'string')
+        at(c.parts, 'connection.parts', 'string', 'table', 'nil')
+
+        local index = indexes[c.source_collection][c.index_name]
+        assert(index.unique ~= nil, 'index.unique must not be nil ' ..
+            'during connections complementing')
+
+        local result_c = {}
+        result_c.parts = determine_connection_parts(c.parts, index)
+        result_c.type = determine_connection_type(result_c.parts, index)
+        result_c.index_name = c.index_name
+        result_c.destination_collection = c.destination_collection
+        result_c.name = c.name
+
+        local collection_connections = collections[c.source_collection].
+            connections
+        if collection_connections == nil then
+            collection_connections = {}
+        end
+        collection_connections[#collection_connections + 1] = result_c
+    end
+
+    return collections
+end
+
+--- The function complements
+function config_complement.complement_cfg(cfg)
+    cfg.collections = complement_connections(cfg.collections, cfg.connections,
+        cfg.indexes)
+    return cfg
+end
+
+return config_complement