wip

Author: amomchilov

lib/graphql/execution/interpreter/runtime.rb

@@ -31,6 +31,16 @@ def initialize(result_name, parent_result)
           # @return [nil, true]
           attr_accessor :graphql_non_null_list_items
 
+          # @return [nil, true]
+          attr_accessor :graphql_skip_list_items_that_raise
+
+          def has_graphql_graph_parent_that_skips_list_items_that_raise
+            return @has_graphql_graph_parent_that_skips_list_items_that_raise if defined?(@has_graphql_graph_parent_that_skips_list_items_that_raise)
+
+            @has_graphql_graph_parent_that_skips_list_items_that_raise = graphql_skip_list_items_that_raise ||
+              !!graphql_parent&.has_graphql_graph_parent_that_skips_list_items_that_raise
+          end
+
           # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
           attr_accessor :graphql_result_data
         end
@@ -513,13 +523,18 @@ def evaluate_selection_with_args(arguments, field_defn, next_path, ast_node, fie
               rescue GraphQL::ExecutionError => err
                 err
               rescue StandardError => err
-                begin
-                  query.handle_or_reraise(err)
-                rescue GraphQL::ExecutionError => ex_err
-                  ex_err
+                if selection_result.has_graphql_graph_parent_that_skips_list_items_that_raise
+                  nil
+                else
+                  begin
+                    query.handle_or_reraise(err)
+                  rescue GraphQL::ExecutionError => ex_err
+                    ex_err
+                  end
                 end
               end
               after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
+                puts("return type: #{return_type.to_type_signature}, skip_nodes_on_raise: #{return_type.skip_nodes_on_raise?}")
                 continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
                 if HALT != continue_value
                   continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, resolved_arguments, result_name, selection_result)
@@ -545,7 +560,27 @@ def dead_result?(selection_result)
 
         def set_result(selection_result, result_name, value)
           if !dead_result?(selection_result)
-            if value.nil? &&
+            if value == GraphQL::Execution::SKIP
+              if selection_result.graphql_skip_list_items_that_raise
+                case selection_result
+                when GraphQLResultHash then selection_result.delete(result_name) # TODO: unify `#delete` interface with `#graphql_skip_at`
+                when GraphQLResultArray then selection_result.graphql_skip_at(result_name)
+                else raise "huh?"
+                end
+              else
+                # Propograte up to find the first list this item can be skiped from.
+                #
+                parent = selection_result.graphql_parent
+                name_in_parent = selection_result.graphql_result_name
+                if parent.nil? # This is a top-level result hash
+                  @response = nil
+                else
+                  set_result(parent, name_in_parent, GraphQL::Execution::SKIP)
+                  set_graphql_dead(selection_result)
+                end
+              end
+
+            elsif value.nil? &&
                 ( # there are two conditions under which `nil` is not allowed in the response:
                   (selection_result.graphql_non_null_list_items) || # this value would be written into a list that doesn't allow nils
                   ((nn = selection_result.graphql_non_null_field_names) && nn.include?(result_name)) # this value would be written into a field that doesn't allow nils
@@ -591,7 +626,11 @@ def set_graphql_dead(selection_result)
         def continue_value(path, value, parent_type, field, is_non_null, ast_node, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
           case value
           when nil
-            if is_non_null
+            if selection_result.has_graphql_graph_parent_that_skips_list_items_that_raise
+              # This writes the `nil` in, we need to patch it to skip instead.
+              print("skip!")
+              set_result(selection_result, result_name, GraphQL::Execution::SKIP)
+            elsif is_non_null
               set_result(selection_result, result_name, nil) do
                 # This block is called if `result_name` is not dead. (Maybe a previous invalid nil caused it be marked dead.)
                 err = parent_type::InvalidNullError.new(parent_type, field, value)
@@ -693,6 +732,8 @@ def continue_value(path, value, parent_type, field, is_non_null, ast_node, resul
         #
         # @return [Lazy, Array, Hash, Object] Lazy, Array, and Hash are all traversed to resolve lazy values later
         def continue_field(path, value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
+          # puts("current_type: #{current_type.to_type_signature}, skip_nodes_on_raise: #{current_type.skip_nodes_on_raise?} ")
+
           if current_type.non_null?
             current_type = current_type.of_type
             is_non_null = true
@@ -776,10 +817,13 @@ def continue_field(path, value, owner_type, field, current_type, ast_node, next_
             end
           when "LIST"
             inner_type = current_type.of_type
+            puts("LIST: #{current_type}, #{current_type.skip_nodes_on_raise?.inspect}")
+            puts("Item type: #{inner_type}, #{inner_type.skip_nodes_on_raise?.inspect}")
             # This is true for objects, unions, and interfaces
             use_dataloader_job = !inner_type.unwrap.kind.input?
             response_list = GraphQLResultArray.new(result_name, selection_result)
             response_list.graphql_non_null_list_items = inner_type.non_null?
+            response_list.graphql_skip_list_items_that_raise = current_type.skip_nodes_on_raise?
             set_result(selection_result, result_name, response_list)
             result_was_set = false
             idx = 0

lib/graphql/schema/addition.rb

@@ -132,6 +132,7 @@ def update_type_owner(owner, type)
               end
               orig_type = orig_type.of_type
             end
+            # This can't call to_list_type(skip_nodes_on_raise: ...), so I'll default the arg instead
             transforms.reverse_each { |t| type = type.public_send(t) }
           end
           owner.type = type

lib/graphql/schema/build_from_definition.rb

@@ -466,7 +466,7 @@ def build_resolve_type(lookup_hash, directives, missing_type_handler)
             when GraphQL::Language::Nodes::NonNullType
               resolve_type_proc.call(ast_node.of_type).to_non_null_type
             when GraphQL::Language::Nodes::ListType
-              resolve_type_proc.call(ast_node.of_type).to_list_type
+              resolve_type_proc.call(ast_node.of_type).to_list_type(skip_nodes_on_raise: false)
             when String
               directives[ast_node]
             else

lib/graphql/schema/field.rb

@@ -219,7 +219,7 @@ def method_conflict_warning?
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
       # @fallback_value [Object] A fallback value if the method is not defined
-      def initialize(type: nil, name: nil, owner: nil, null: nil, description: :not_given, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, default_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: :not_given, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, description: :not_given, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, default_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: :not_given, skip_nodes_on_raise: false, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -271,6 +271,7 @@ def initialize(type: nil, name: nil, owner: nil, null: nil, description: :not_gi
         else
           true
         end
+        @skip_nodes_on_raise = skip_nodes_on_raise
         @connection = connection
         @has_max_page_size = max_page_size != :not_given
         @max_page_size = max_page_size == :not_given ? nil : max_page_size
@@ -572,9 +573,10 @@ def type
             raise MissingReturnTypeError, "Can't determine the return type for #{self.path} (it has `resolver: #{@resolver_class}`, perhaps that class is missing a `type ...` declaration, or perhaps its type causes a cyclical loading issue)"
           end
           nullable = @return_type_null.nil? ? @resolver_class.null : @return_type_null
+          # TODO: Pull `skip_nodes_on_raise` from resolver class
           Member::BuildType.parse_type(return_type, null: nullable)
         else
-          @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+          @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null, skip_nodes_on_raise: @skip_nodes_on_raise)
         end
       rescue GraphQL::Schema::InvalidDocumentError, MissingReturnTypeError => err
         # Let this propagate up

lib/graphql/schema/list.rb

@@ -8,6 +8,11 @@ class Schema
     class List < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
+      def initialize(of_type, skip_nodes_on_raise: false)
+        super(of_type)
+        @skip_nodes_on_raise = skip_nodes_on_raise
+      end
+
       # @return [GraphQL::TypeKinds::LIST]
       def kind
         GraphQL::TypeKinds::LIST
@@ -18,6 +23,10 @@ def list?
         true
       end
 
+      def skip_nodes_on_raise?
+        @skip_nodes_on_raise
+      end
+
       def to_type_signature
         "[#{@of_type.to_type_signature}]"
       end

lib/graphql/schema/member/build_type.rb

@@ -9,7 +9,7 @@ module BuildType
         module_function
         # @param type_expr [String, Class, GraphQL::BaseType]
         # @return [GraphQL::BaseType]
-        def parse_type(type_expr, null:)
+        def parse_type(type_expr, null:, skip_nodes_on_raise: false)
           list_type = false
 
           return_type = case type_expr
@@ -85,7 +85,7 @@ def parse_type(type_expr, null:)
           # Apply list_type first, that way the
           # .to_non_null_type applies to the list type, not the inner type
           if list_type
-            return_type = return_type.to_list_type
+            return_type = return_type.to_list_type(skip_nodes_on_raise: skip_nodes_on_raise)
           end
 
           if !null

lib/graphql/schema/member/type_system_helpers.rb

@@ -17,15 +17,24 @@ def to_non_null_type
         end
 
         # @return [Schema::List] Make a list-type representation of this type
-        def to_list_type
-          @to_list_type ||= GraphQL::Schema::List.new(self)
+        def to_list_type(skip_nodes_on_raise: false)
+          if skip_nodes_on_raise
+            @to_skipping_list_type ||= GraphQL::Schema::List.new(self, skip_nodes_on_raise: true)
+          else
+            @to_list_type ||= GraphQL::Schema::List.new(self)
+          end
         end
 
         # @return [Boolean] true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.
         def non_null?
           false
         end
 
+        # @return [Boolean] true if this field's nodes should be skipped, if resolving them led to an error being raised.
+        def skip_nodes_on_raise?
+          false
+        end
+
         # @return [Boolean] true if this is a list type. A non-nullable list is considered a list.
         def list?
           false

lib/graphql/schema/non_null.rb

@@ -18,6 +18,11 @@ def non_null?
         true
       end
 
+      # @return [Boolean] true if this field's nodes should be skipped, if resolving them led to an error being raised.
+      def skip_nodes_on_raise?
+        @of_type.skip_nodes_on_raise?
+      end
+
       # @return [Boolean] True if this type wraps a list type
       def list?
         @of_type.list?
@@ -27,6 +32,8 @@ def to_type_signature
         "#{@of_type.to_type_signature}!"
       end
 
+      def to_s = inspect
+
       def inspect
         "#<#{self.class.name} @of_type=#{@of_type.inspect}>"
       end

lib/graphql/types/relay/connection_behaviors.rb

@@ -13,6 +13,7 @@ def self.included(child_class)
           child_class.default_relay(true)
           child_class.has_nodes_field(true)
           child_class.node_nullable(true)
+          child_class.skip_nodes_on_raise(false)
           child_class.edges_nullable(true)
           child_class.edge_nullable(true)
           add_page_info_field(child_class)
@@ -36,7 +37,7 @@ module ClassMethods
           # class name to set defaults. You can call it again in the class definition
           # to override the default (or provide a value, if the default lookup failed).
           # @param field_options [Hash] Any extra keyword arguments to pass to the `field :edges, ...` and `field :nodes, ...` configurations
-          def edge_type(edge_type_class, edge_class: GraphQL::Pagination::Connection::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)
+          def edge_type(edge_type_class, edge_class: GraphQL::Pagination::Connection::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, skip_nodes_on_raise: self.skip_nodes_on_raise, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)
             # Set this connection's graphql name
             node_type_name = node_type.graphql_name
 
@@ -60,7 +61,7 @@ def edge_type(edge_type_class, edge_class: GraphQL::Pagination::Connection::Edge
 
             field(**base_field_options)
 
-            define_nodes_field(node_nullable, field_options: field_options) if nodes_field
+            define_nodes_field(node_nullable, skip_nodes_on_raise, field_options: field_options) if nodes_field
 
             description("The connection type for #{node_type_name}.")
           end
@@ -88,12 +89,22 @@ def visible?(ctx)
           # Use `node_nullable(false)` in your base class to make non-null `node` and `nodes` fields.
           def node_nullable(new_value = nil)
             if new_value.nil?
+              # p([self, superclass, superclass.respond_to?(:node_nullable), superclass.try(:node_nullable)])
               defined?(@node_nullable) ? @node_nullable : superclass.node_nullable
             else
               @node_nullable = new_value
             end
           end
 
+          def skip_nodes_on_raise(new_value = nil)
+            if new_value.nil?
+              # p([self, superclass, superclass.respond_to?(:skip_nodes_on_raise), superclass.try(:skip_nodes_on_raise)])
+              defined?(@skip_nodes_on_raise) ? @skip_nodes_on_raise : superclass.skip_nodes_on_raise
+            else
+              @skip_nodes_on_raise = new_value
+            end
+          end
+
           # Set the default `edges_nullable` for this class and its child classes. (Defaults to `true`.)
           # Use `edges_nullable(false)` in your base class to make non-null `edges` fields.
           def edges_nullable(new_value = nil)
@@ -126,7 +137,7 @@ def has_nodes_field(new_value = nil)
 
           private
 
-          def define_nodes_field(nullable, field_options: nil)
+          def define_nodes_field(nullable, skip_nodes_on_raise, field_options: nil)
             base_field_options = {
               name: :nodes,
               type: [@node_type, null: nullable],
@@ -135,6 +146,7 @@ def define_nodes_field(nullable, field_options: nil)
               connection: false,
               # Assume that the connection was scoped before this step:
               scope: false,
+              skip_nodes_on_raise: skip_nodes_on_raise,
             }
             if field_options
               base_field_options.merge!(field_options)