Hold collection-local arguments in cache requests

It is primarily for filters over 1:N connection borders (#94).

Author: Totktonada

graphql/accessor_shard_cache.lua

@@ -52,7 +52,7 @@ function accessor_shard_cache.fetch(batches)
         if next(ids) == nil then
             goto continue
         end
-        --print('fetch ids: ' .. require('yaml').encode(ids))
+        -- print('fetch ids: ' .. require('yaml').encode(ids))
         -- local buffers = {}
         local results = {}
 
@@ -101,6 +101,7 @@ function accessor_shard_cache.fetch(batches)
         assert(#results == #ids, 'XXX') -- XXX
         for i = 1, #ids do
             if cache[ids[i]] == nil then
+                -- print('fetch: ' .. require('json').encode(ids[i]))
                 cache[ids[i]] = {
                     result = results[i],
                     fetch_ids = {fetch_id}

graphql/bfs_executor.lua

@@ -1,4 +1,7 @@
---- XXX
+--- Breadth-first executor with support of batching similar requests.
+---
+--- The main data structure of this module is the list of requests to be
+--- processed:
 ---
 ---    open_set = {
 ---        prepared_object_list = <...>,
@@ -51,7 +54,8 @@
 ---                                    value = <...>,
 ---                                },
 ---                                ...
----                            }
+---                            },
+---                            coerced_arguments = <...>,
 ---                        },
 ---                        ...
 ---                    }
@@ -63,6 +67,7 @@
 
 local utils = require('graphql.utils')
 local core_util = require('graphql.core.util')
+local core_types = require('graphql.core.types')
 local core_query_util = require('graphql.core.query_util')
 local core_validate_variables = require('graphql.core.validate_variables')
 local core_introspection = require('graphql.core.introspection')
@@ -73,22 +78,17 @@ local accessor_shard_cache = require('graphql.accessor_shard_cache')
 
 local bfs_executor = {}
 
---- XXX
-local function get_argument_type(field_type, argument_name)
-    for name, argument_type in pairs(field_type.arguments) do
-        if name == argument_name then
-            return argument_type
-        end
-    end
-    error(('cannot find argument "%s"'):format(argument_name))
-end
-
 local function get_argument_values(field_type, selection, variables)
     local args = {}
+    for argument_name, value in pairs(selection.coerced_arguments or {}) do
+        args[argument_name] = value
+    end
     for _, argument in ipairs(selection.arguments or {}) do
         local argument_name = argument.name.value
-        assert(argument_name ~= nil)
-        local argument_type = get_argument_type(field_type, argument_name)
+        assert(argument_name ~= nil, 'argument_name must not be nil')
+        local argument_type = field_type.arguments[argument_name]
+        assert(argument_type ~= nil,
+            ('cannot find argument "%s"'):format(argument_name))
         local value = core_util.coerceValue(argument.value, argument_type,
             variables, {strict_non_null = true})
         args[argument_name] = value
@@ -207,33 +207,65 @@ local function filter_object(object, object_type, selections, opts)
                 selections = child_selections,
             }
 
-            local function filters_to_selections(connection_filters)
-                -- XXX: add arguments (important for offset, limit and so on)
-                local res = {}
-                for k, v in pairs(connection_filters) do
-                    table.insert(res, {
-                        name = {
-                            value = k
-                        },
-                        kind = 'field',
-                        selectionSet = {
-                            selections = {},
+            local function filters_to_selections(object_type, filters)
+                local selections = {}
+                for k, v in pairs(filters) do
+                    local field_type = object_type.fields[k]
+                    assert(field_type ~= nil, 'fild_type must not be nil')
+                    if field_type.prepare_resolve ~= nil then
+                        -- per-connection field
+                        assert(type(v) == 'table',
+                            'per-connection field filter must be a table, ' ..
+                            'got ' .. type(v))
+
+                        local new_selection = {
+                            name = {
+                                value = k
+                            },
+                            kind = 'field',
+                            -- selectionSet is nil
+                            -- coerced_arguments is nil
                         }
-                    })
-                    if type(v) == 'table' then
-                        res[#res].selectionSet.selections =
-                            filters_to_selections(v)
+                        table.insert(selections, new_selection)
+
+                        local inner_type = core_types.bare(field_type.kind)
+                        local child_selections = filters_to_selections(
+                            inner_type, v)
+                        if next(child_selections) ~= nil then
+                            new_selection.selectionSet = {}
+                            new_selection.selectionSet.selections =
+                                child_selections
+                        end
+
+                        -- add arguments on local collection fields
+                        for child_k, child_v in pairs(v) do
+                            local is_sel_found = false
+                            for _, sel in ipairs(child_selections) do
+                                if sel.name.value == child_k then
+                                    is_sel_found = true
+                                end
+                            end
+                            if not is_sel_found then
+                                if new_selection.coerced_arguments == nil then
+                                    new_selection.coerced_arguments = {}
+                                end
+                                assert(new_selection
+                                    .coerced_arguments[child_k] == nil,
+                                    'found two selections with the same name')
+                                new_selection.coerced_arguments[child_k] = child_v
+                            end
+                        end
                     end
                 end
                 --require('yaml').cfg{encode_use_tostring = true}
                 --print('selections')
-                --print(require('yaml').encode(res))
-                return res
+                --print(require('yaml').encode(selections))
+                return selections
             end
 
             if not prepared_resolve.is_calculated then
                 local connection_filters = {}
-                local local_filters = {}
+                local local_args = {}
 
                 local filter = prepared_resolve.prepared_select.filter
                 for k, v in pairs(filter) do
@@ -249,19 +281,23 @@ local function filter_object(object, object_type, selections, opts)
 
                 for k, v in pairs(args) do
                     if connection_filters[k] == nil then
-                        local_filters[k] = v
+                        local_args[k] = v
                     end
                 end
 
-                if next(connection_filters) ~= nil then
+                -- create cache only requests for requests with 'by connection'
+                -- filters and without extra arguments (like mutation arguments)
+                local extra_args = prepared_resolve.prepared_select.extra
+                    .extra_args or {}
+                if next(connection_filters) ~= nil and
+                        next(extra_args) == nil then
                     -- cache_only_prepared_resolve is the same as
                     -- prepared_resolve, but it does not require fetching
                     -- connected objects to fetch and return this one
                     local cache_only_prepared_resolve = field_type.prepare_resolve(
-                        object, local_filters, info)
+                        object, local_args, info)
                     local cache_only_selections = filters_to_selections(
-                        connection_filters)
-                    -- XXX: arguments
+                        inner_type, filter)
                     cache_only_fields_info[field_name] = {
                         is_list = is_list,
                         kind = inner_type,
@@ -336,7 +372,6 @@ local function invoke_resolve(prepared_object, variables, opts)
     local open_set = {}
 
     for field_name, field_info in pairs(prepared_object.fields_info) do
-        -- XXX: don't call :invoke() for is_item_cache_only
         local object_or_list
         if field_info.prepared_resolve.is_calculated then
             object_or_list = field_info.prepared_resolve.objs