graphql 2.6.13 → 2.6.14

data/lib/graphql/pagination/relation_connection.rb

@@ -7,6 +7,10 @@ module GraphQL
   module Pagination
     # A generic class for working with database query objects.
     class RelationConnection < Pagination::Connection
+      # Database limits and offsets must fit in a signed 64-bit integer.
+      MAX_OFFSET = (2**63) - 1
+      private_constant :MAX_OFFSET
+
       def nodes
         load_nodes
         @nodes
@@ -87,7 +91,11 @@ module GraphQL
       # :call-seq:
       #   relation_larger_than(Object relation, Integer _initial_offset, Integer size) -> bool
       def relation_larger_than(relation, _initial_offset, size)
-        relation_count(set_limit(relation, size + 1)) == size + 1
+        if (limit = relation_limit(relation)) && limit <= size
+          false
+        else
+          relation_count(set_limit(relation, size + 1)) == size + 1
+        end
       end
 
       # **Parameters**
@@ -154,7 +162,8 @@ module GraphQL
       #   offset_from_cursor(cursor) -> Integer
       def offset_from_cursor(cursor)
         offset = Integer(decode(cursor), 10, exception: false) #: Integer?
-        if offset.nil? || offset <= 0
+        if offset.nil? || offset <= 0 || offset > MAX_OFFSET ||
+            offset + (relation_offset(items) || 0) > MAX_OFFSET
           raise GraphQL::ExecutionError, "Invalid cursor: #{cursor.inspect}"
         end
         offset
@@ -191,20 +200,21 @@ module GraphQL
 
           if after_offset
             next_offset += after_offset
+            relation_limit = [relation_limit - after_offset, 0].max if relation_limit
           end
 
           if before_offset && after_offset
             if after_offset < before_offset
               # Get the number of items between the two cursors
               space_between = before_offset - after_offset - 1
-              relation_limit = space_between
+              relation_limit = [relation_limit, space_between].compact.min
             else
               # The cursors overextend one another to an empty set
               @sliced_nodes_null_relation = true
             end
           elsif before_offset
             # Use limit to cut off the tail of the relation
-            relation_limit = before_offset - 1
+            relation_limit = [relation_limit, before_offset - 1].compact.min
           end
 
           @sliced_nodes_limit = relation_limit
@@ -222,13 +232,13 @@ module GraphQL
           if @sliced_nodes_null_relation
             paginated_nodes = null_relation(paginated_nodes)
           else
-            if @sliced_nodes_limit
-              paginated_nodes = set_limit(paginated_nodes, @sliced_nodes_limit)
-            end
-
             if @sliced_nodes_offset
               paginated_nodes = set_offset(paginated_nodes, @sliced_nodes_offset)
             end
+
+            if @sliced_nodes_limit
+              paginated_nodes = set_limit(paginated_nodes, @sliced_nodes_limit)
+            end
           end
 
           paginated_nodes
@@ -330,10 +340,11 @@ module GraphQL
       end
 
       # Fetch one row past `first` so `has_next_page` needs no extra query.
-      # Skips arrays (no query to save) and relations limited below `first` (no next page).
+      # Skips arrays (no query to save) and slices limited to `first` or fewer rows (no next page).
       def load_page
         page = limited_nodes
-        return page.to_a if page.is_a?(Array) || !peek_next_page? || relation_limit(page) != first
+        return page.to_a if page.is_a?(Array) || !peek_next_page? || relation_limit(page) != first ||
+          (@sliced_nodes_limit && @sliced_nodes_limit <= first)
 
         rows = set_limit(page, first + 1).to_a
         @has_next_page = rows.size > first

data/lib/graphql/query/partial.rb

@@ -179,8 +179,7 @@ module GraphQL
                   next_selections << sel
                 end
               else
-                raise "Unexpected selection in partial path: #{sel.class}, #{sel.inspect}"
-                sel #: absurd
+                raise "Unexpected selection in partial path: #{sel.class}, #{sel.inspect}" #: absurd(sel)
               end
             end
           end

data/lib/graphql/schema/addition.rb

@@ -11,9 +11,10 @@ module GraphQL
         @own_types = own_types
         @directives = Set.new
         @possible_types = {}
+        @possible_types_sets = {}
         @types = {}
         @union_memberships = {}
-        @references = Hash.new { |h, k| h[k] = Set.new }
+        @references = {}.compare_by_identity
         @arguments_with_default_values = []
         add_type_and_traverse(new_types)
       end
@@ -21,7 +22,8 @@ module GraphQL
       private
 
       def references_to(thing, from:)
-        @references[thing].add(from)
+        refs = @references[thing] ||= {}.compare_by_identity
+        refs[from] = true
       end
 
       def get_type(name)
@@ -42,19 +44,25 @@ module GraphQL
 
       def add_directives_from(owner)
         if !(dir_instances = owner.directives).empty?
-          dirs = dir_instances.map(&:class)
-          @directives.merge(dirs)
-          add_type_and_traverse(dirs)
+          new_dirs = nil #: Array[singleton(GraphQL::Schema::Directive)]?
+          dir_instances.each do |dir|
+            dir_class = dir.class
+            if !@directives.include?(dir_class)
+              new_dirs ||= []
+              new_dirs << dir_class
+            end
+          end
+          if new_dirs
+            @directives.merge(new_dirs)
+            add_type_and_traverse(new_dirs)
+          end
         end
       end
 
       def add_type_and_traverse(new_types)
         late_types = []
-        path = []
         new_types.each do |t|
-          path.push(t.graphql_name)
-          add_type(t, owner: nil, late_types: late_types, path: path)
-          path.pop
+          add_type(t, owner: nil, late_types: late_types)
         end
         missed_late_types = 0
         while (late_type_vals = late_types.shift)
@@ -64,13 +72,13 @@ module GraphQL
             # Reset the counter, since we might succeed next go-round
             missed_late_types = 0
             update_type_owner(type_owner, type)
-            add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
+            add_type(type, owner: type_owner, late_types: late_types)
           elsif lt.is_a?(LateBoundType)
             if (type = get_type(lt.name))
               # Reset the counter, since we might succeed next go-round
               missed_late_types = 0
               update_type_owner(type_owner, type)
-              add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
+              add_type(type, owner: type_owner, late_types: late_types)
             else
               missed_late_types += 1
               # Add it back to the list, maybe we'll be able to resolve it later.
@@ -89,6 +97,15 @@ module GraphQL
         nil
       end
 
+      # The Set makes this fast for interfaces with many possible types. The Array keeps their order.
+      def add_possible_type(interface_type, object_type)
+        types_set = @possible_types_sets[interface_type] ||= Set.new
+        if types_set.add?(object_type)
+          pt = @possible_types[interface_type] ||= []
+          pt << object_type
+        end
+      end
+
       def update_type_owner(owner, type)
         case owner
         when Module
@@ -114,9 +131,8 @@ module GraphQL
             end
             implementing_type.implements(*new_interfaces)
             new_interfaces.each do |int|
-              pt = @possible_types[int] ||= []
-              if !pt.include?(owner) && owner.is_a?(Class)
-                pt << owner
+              if owner.is_a?(Class)
+                add_possible_type(int, owner)
               end
               int.interfaces.each do |indirect_int|
                 if indirect_int.is_a?(LateBoundType)
@@ -125,10 +141,7 @@ module GraphQL
                   end
                 elsif owner.is_a?(Class)
                   # `implements` added this one, too, because `int` implements it
-                  indirect_pt = @possible_types[indirect_int] ||= []
-                  if !indirect_pt.include?(owner)
-                    indirect_pt << owner
-                  end
+                  add_possible_type(indirect_int, owner)
                 end
               end
             end
@@ -161,7 +174,7 @@ module GraphQL
         end
       end
 
-      def add_type(type, owner:, late_types:, path:)
+      def add_type(type, owner:, late_types:)
         if type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
           late_types << [owner, type]
           return
@@ -181,9 +194,7 @@ module GraphQL
             if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
               references_to(arg_type, from: arg)
             end
-            path.push(arg.graphql_name)
-            add_type(arg_type, owner: arg, late_types: late_types, path: path)
-            path.pop
+            add_type(arg_type, owner: arg, late_types: late_types)
             if arg.default_value?
               @arguments_with_default_values << arg
             end
@@ -202,40 +213,45 @@ module GraphQL
           if type.kind.fields?
             type.all_field_definitions.each do |field|
               field.ensure_loaded
-              name = field.graphql_name
               field_type = field.type.unwrap
-              if !field_type.is_a?(GraphQL::Schema::LateBoundType)
+              if field_type.is_a?(GraphQL::Schema::LateBoundType)
+                add_type(field_type, owner: field, late_types: late_types)
+              else
                 references_to(field_type, from: field)
+                if !@types[field_type.graphql_name].equal?(field_type)
+                  add_type(field_type, owner: field, late_types: late_types)
+                end
               end
-              path.push(name)
-              add_type(field_type, owner: field, late_types: late_types, path: path)
               add_directives_from(field)
               field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
-                if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                if arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                  add_type(arg_type, owner: arg, late_types: late_types)
+                else
                   references_to(arg_type, from: arg)
+                  if !@types[arg_type.graphql_name].equal?(arg_type)
+                    add_type(arg_type, owner: arg, late_types: late_types)
+                  end
                 end
-                path.push(arg.graphql_name)
-                add_type(arg_type, owner: arg, late_types: late_types, path: path)
-                path.pop
                 if arg.default_value?
                   @arguments_with_default_values << arg
                 end
               end
-              path.pop
             end
           end
           if type.kind.input_object?
             type.all_argument_definitions.each do |arg|
               add_directives_from(arg)
               arg_type = arg.type.unwrap
-              if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+              if arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                add_type(arg_type, owner: arg, late_types: late_types)
+              else
                 references_to(arg_type, from: arg)
+                if !@types[arg_type.graphql_name].equal?(arg_type)
+                  add_type(arg_type, owner: arg, late_types: late_types)
+                end
               end
-              path.push(arg.graphql_name)
-              add_type(arg_type, owner: arg, late_types: late_types, path: path)
-              path.pop
               if arg.default_value?
                 @arguments_with_default_values << arg
               end
@@ -243,18 +259,14 @@ module GraphQL
           end
           if type.kind.union?
             @possible_types[type] = type.all_possible_types
-            path.push("possible_types")
             type.all_possible_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path)
+              add_type(t, owner: type, late_types: late_types)
             end
-            path.pop
           end
           if type.kind.interface?
-            path.push("orphan_types")
             type.orphan_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path)
+              add_type(t, owner: type, late_types: late_types)
             end
-            path.pop
           end
           if type.kind.object?
             possible_types_for_this_name = @possible_types[type] ||= []
@@ -262,26 +274,21 @@ module GraphQL
           end
 
           if type.kind.object? || type.kind.interface?
-            path.push("implements")
             type.interface_type_memberships.each do |interface_type_membership|
               case interface_type_membership
               when Schema::TypeMembership
                 interface_type = interface_type_membership.abstract_type
                 # We can get these now; we'll have to get late-bound types later
                 if interface_type.is_a?(Module) && type.is_a?(Class)
-                  implementers = @possible_types[interface_type] ||= []
-                  if !implementers.include?(type)
-                    implementers << type
-                  end
+                  add_possible_type(interface_type, type)
                 end
               when String, Schema::LateBoundType
                 interface_type = interface_type_membership
               else
                 raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
               end
-              add_type(interface_type, owner: type, late_types: late_types, path: path)
+              add_type(interface_type, owner: type, late_types: late_types)
             end
-            path.pop
           end
 
           if type.kind.enum?

data/lib/graphql/schema/argument.rb

@@ -515,7 +515,7 @@ module GraphQL
         coerced_value = begin
           type.coerce_input(value, context)
         rescue StandardError => err
-          context.schema.handle_or_reraise(context, err)
+          handle_or_reraise_arg_error(context, err)
         end
 
         # If this isn't lazy, then the block returns eagerly and assigns the result here
@@ -525,14 +525,14 @@ module GraphQL
           prepared_value = begin
             prepare_value(parent_object, resolved_coerced_value, context: context)
           rescue StandardError => err
-            context.schema.handle_or_reraise(context, err)
+            handle_or_reraise_arg_error(context, err)
           end
 
           if loads && !from_resolver?
             loaded_value = begin
               load_and_authorize_value(owner, prepared_value, context)
             rescue StandardError => err
-              context.schema.handle_or_reraise(context, err)
+              handle_or_reraise_arg_error(context, err)
             end
           end
 
@@ -549,6 +549,17 @@ module GraphQL
         end
       end
 
+      # When a `rescue_from` handler *returns* an error object instead of raising,
+      # it must not be used as this argument's value — raise it so that
+      # `coerce_arguments` short-circuits resolution with it.
+      def handle_or_reraise_arg_error(context, err) # :nodoc:
+        handled_err = context.schema.handle_or_reraise(context, err)
+        if handled_err.is_a?(GraphQL::ExecutionError) || handled_err.is_a?(GraphQL::UnauthorizedError)
+          raise handled_err
+        end
+        handled_err
+      end
+
       def load_and_authorize_value(load_method_owner, coerced_value, context)
         if coerced_value.nil?
           return nil