Fix connection wrappers on lazy lists

Author: rmosolgo

lib/graphql/schema/field/connection_extension.rb

@@ -22,43 +22,49 @@ def resolve(object:, arguments:, context:)
         end
 
         def after_resolve(value:, object:, arguments:, context:, memo:)
-          if value.is_a? GraphQL::ExecutionError
-            # This isn't even going to work because context doesn't have ast_node anymore
-            context.add_error(value)
-            nil
-          elsif value.nil?
-            nil
-          elsif value.is_a?(GraphQL::Pagination::Connection)
-            # update the connection with some things that may not have been provided
-            value.context ||= context
-            value.parent ||= object.object
-            value.first_value ||= arguments[:first]
-            value.after_value ||= arguments[:after]
-            value.last_value ||= arguments[:last]
-            value.before_value ||= arguments[:before]
-            if field.has_max_page_size? && !value.has_max_page_size_override?
-              value.max_page_size = field.max_page_size
+          # rename some inputs to avoid conflicts inside the block
+          maybe_lazy = value
+          value = nil
+          context.schema.after_lazy(maybe_lazy) do |resolved_value|
+            value = resolved_value
+            if value.is_a? GraphQL::ExecutionError
+              # This isn't even going to work because context doesn't have ast_node anymore
+              context.add_error(value)
+              nil
+            elsif value.nil?
+              nil
+            elsif value.is_a?(GraphQL::Pagination::Connection)
+              # update the connection with some things that may not have been provided
+              value.context ||= context
+              value.parent ||= object.object
+              value.first_value ||= arguments[:first]
+              value.after_value ||= arguments[:after]
+              value.last_value ||= arguments[:last]
+              value.before_value ||= arguments[:before]
+              if field.has_max_page_size? && !value.has_max_page_size_override?
+                value.max_page_size = field.max_page_size
+              end
+              if (custom_t = context.schema.connections.edge_class_for_field(@field))
+                value.edge_class = custom_t
+              end
+              value
+            elsif context.schema.new_connections?
+              wrappers = context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
+              context.schema.connections.wrap(field, object.object, value, arguments, context, wrappers: wrappers)
+            else
+              if object.is_a?(GraphQL::Schema::Object)
+                object = object.object
+              end
+              connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(value)
+              connection_class.new(
+                value,
+                arguments,
+                field: field,
+                max_page_size: field.max_page_size,
+                parent: object,
+                context: context,
+              )
             end
-            if (custom_t = context.schema.connections.edge_class_for_field(@field))
-              value.edge_class = custom_t
-            end
-            value
-          elsif context.schema.new_connections?
-            wrappers = context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
-            context.schema.connections.wrap(field, object.object, value, arguments, context, wrappers: wrappers)
-          else
-            if object.is_a?(GraphQL::Schema::Object)
-              object = object.object
-            end
-            connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(value)
-            connection_class.new(
-              value,
-              arguments,
-              field: field,
-              max_page_size: field.max_page_size,
-              parent: object,
-              context: context,
-            )
           end
         end
       end

spec/graphql/schema/member/scoped_spec.rb

@@ -12,6 +12,13 @@ def self.scope_items(items, context)
           items.select { |i| i.name == "Trombone" }
         elsif context[:english]
           items.select { |i| i.name == "Paperclip" }
+        elsif context[:lazy]
+          # return everything, but make the runtime wait for it,
+          # and add a flag for confirming it was called
+          ->() {
+            context[:proc_called] = true
+            items
+          }
         else
           # boot everything
           items.reject { true }
@@ -105,6 +112,7 @@ def things
       use GraphQL::Execution::Interpreter
       use GraphQL::Analysis::AST
     end
+    lazy_resolve(Proc, :call)
   end
 
   describe ".scope_items(items, ctx)" do
@@ -177,6 +185,25 @@ def get_item_names_with_context(ctx, field_name: "items")
       assert_equal ["Paperclip"], names
     end
 
+    it "works for lazy connection values" do
+      ctx = { lazy: true }
+      query_str = "
+      {
+        itemsConnection {
+          edges {
+            node {
+              name
+            }
+          }
+        }
+      }
+      "
+      res = ScopeSchema.execute(query_str, context: ctx)
+      names = res["data"]["itemsConnection"]["edges"].map { |e| e["node"]["name"] }
+      assert_equal ["Trombone", "Paperclip"], names
+      assert_equal true, ctx[:proc_called]
+    end
+
     it "is called for abstract types" do
       query_str = "
       {
@@ -194,6 +221,12 @@ def get_item_names_with_context(ctx, field_name: "items")
       things = res["data"]["things"]
       assert_equal [{ "name" => "Trombone" }, {"designation" => "Turbine"}], things
     end
+
+    it "works with lazy values" do
+      ctx = {lazy: true}
+      assert_equal ["Trombone", "Paperclip"], get_item_names_with_context(ctx)
+      assert_equal true, ctx[:proc_called]
+    end
   end
 
   describe "Schema::Field.scoped?" do