Give an empty multihead connection as null

This commit changes behaviour in the following cases:

1. When a union variant to which a connected object belongs is not appear
   in a query, the library returns box.NULL w/o any wrappers.

2. When no connected object is found, the library returns box.NULL as
   well even if all-nulls check before fails (typically because of
   disable_dangling_check option, but also it is possible because of
   using different source fields across multihead connection variants).

The first case is tested with to_avro_multihead.test.lua. The latter one
does not tested.

In these cases we could receive `{"collection_name": null}` as a result
instead of just `null`. Only `null` is valid result for a avro-schema
union.

Both variant however are valid by our avro-schema generated for a query,
because a multi-head connection represented as an object with nullable
fields. There is a reason for that, see the comment for the
union_to_avro() function in graphql/query_to_avro.lua.

Fixes #253.

Author: Totktonada

graphql/bfs_executor.lua

@@ -575,6 +575,7 @@ local function filter_object(object, object_type, selections, context, opts)
                 qcontext = qcontext,
                 schema = context.schema,
                 parentObject = object_type,
+                fieldASTs = {selection},
             }
         end
 

graphql/convert_schema/resolve.lua

@@ -254,9 +254,8 @@ function resolve.gen_resolve_function_multihead(collection_name, connection,
         local is_hidden = opts.is_hidden or false
         check(is_hidden, 'is_hidden', 'boolean')
 
-        -- If a parent object does not have all source fields (for any of
-        -- variants) non-null then we do not resolve variant and just return
-        -- box.NULL.
+        -- If a parent object has all source fields null (for all variants)
+        -- then we do not resolve variant and just return box.NULL.
         local is_source_fields_found = false
         for _, variant in ipairs(c.variants) do
             is_source_fields_found =
@@ -280,6 +279,29 @@ function resolve.gen_resolve_function_multihead(collection_name, connection,
         local v, variant_num, box_field_name = resolve_variant(parent)
         local destination_type = union_types[variant_num]
 
+        -- check whether destination type is in requested types
+        local is_variant_requested = false
+        for _, s in ipairs(info.fieldASTs[1].selectionSet.selections) do
+            local requested_type_name = s.typeCondition.name.value
+            if destination_type.name == requested_type_name then
+                is_variant_requested = true
+                break
+            end
+        end
+
+        -- If the variant the object match is not requested in a query, just
+        -- return box.NULL, w/o the wrapper.
+        if not is_variant_requested then
+            if gen_prepare then
+                return {
+                    is_calculated = true,
+                    objs = box.NULL,
+                }
+            else
+                return box.NULL, nil
+            end
+        end
+
         local quazi_connection = {
             type = c.type,
             parts = v.parts,
@@ -300,14 +322,20 @@ function resolve.gen_resolve_function_multihead(collection_name, connection,
             result.connection = quazi_connection
             result.invoke = function(prepared_resolve)
                 local result = invoke_resolve(prepared_resolve)
-                -- see comment below
+                -- see comments below
+                if result == nil then return box.NULL, nil end
                 return {[box_field_name] = result}, destination_type
             end
             return result
         else
             local result = resolve.gen_resolve_function(collection_name,
                 quazi_connection, destination_type, {}, accessor, gen_opts)(
                 parent, {}, info, opts)
+            -- If a connected object was not found, return just box.NULL w/o
+            -- wrapping. It is possible here when different source fields are
+            -- set for variants or when the disable_dangling_check options is
+            -- set.
+            if result == nil then return box.NULL, nil end
             -- This 'wrapping' is needed because we use 'select' on 'collection'
             -- GraphQL type and the result of the resolve function must be in
             -- {'collection_name': {result}} format to be avro-valid.

test/extra/to_avro_multihead.test.lua

@@ -268,9 +268,6 @@ local ok, err = avro.validate(compiled_schema_heroes, result_1.data)
 test:ok(ok, 'query 1 response validation (obtainHeroes)', {err = err})
 
 -- humans
-result_expected_1.hero_collection[1].hero_connection.starship_collection = nil
-result_expected_1.hero_collection[1].hero_banking_connection
-    .dublon_account_collection = nil
 local result_1 = gql_query:execute(variables_1, 'obtainHumans')
 test:is_deeply(result_1.data, result_expected_1,
     'query 1 response (obtainHumans)')
@@ -307,11 +304,9 @@ local ok, err = avro.validate(compiled_schema_heroes, result_2.data)
 test:ok(ok, 'query 2 response validation (obtainHeroes)', {err = err})
 
 -- humans
-result_expected_2.hero_collection[1].hero_connection.starship_collection = nil
-result_expected_2.hero_collection[1].hero_banking_connection
-    .dublon_account_collection = nil
+result_expected_2.hero_collection[1].hero_connection = nil
+result_expected_2.hero_collection[1].hero_banking_connection = nil
 local result_2 = gql_query:execute(variables_2, 'obtainHumans')
-print(yaml.encode(result_2.data))
 test:is_deeply(result_2.data, result_expected_2,
     'query 2 response (obtainHumans)')
 local ok, err = avro.validate(compiled_schema_humans, result_2.data)