graphql 1.10.2 → 2.0.21

data/lib/graphql/language.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 require "graphql/language/block_string"
 require "graphql/language/printer"
+require "graphql/language/sanitized_printer"
 require "graphql/language/document_from_schema_definition"
 require "graphql/language/generation"
 require "graphql/language/lexer"
 require "graphql/language/nodes"
+require "graphql/language/cache"
 require "graphql/language/parser"
 require "graphql/language/token"
 require "graphql/language/visitor"

data/lib/graphql/name_validator.rb

@@ -4,13 +4,8 @@ module GraphQL
     VALID_NAME_REGEX = /^[_a-zA-Z][_a-zA-Z0-9]*$/
 
     def self.validate!(name)
-      raise GraphQL::InvalidNameError.new(name, VALID_NAME_REGEX) unless valid?(name)
-    end
-
-    private
-
-    def self.valid?(name)
-      name =~ VALID_NAME_REGEX
+      name = name.is_a?(String) ? name : name.to_s
+      raise GraphQL::InvalidNameError.new(name, VALID_NAME_REGEX) unless name.match?(VALID_NAME_REGEX)
     end
   end
 end

data/lib/graphql/pagination/active_record_relation_connection.rb

@@ -5,21 +5,39 @@ module GraphQL
   module Pagination
     # Customizes `RelationConnection` to work with `ActiveRecord::Relation`s.
     class ActiveRecordRelationConnection < Pagination::RelationConnection
+      private
+
       def relation_count(relation)
-        if relation.respond_to?(:unscope)
+        int_or_hash = if already_loaded?(relation)
+          relation.size
+        elsif relation.respond_to?(:unscope)
           relation.unscope(:order).count(:all)
         else
           # Rails 3
           relation.count
         end
+        if int_or_hash.is_a?(Integer)
+          int_or_hash
+        else
+          # Grouped relations return count-by-group hashes
+          int_or_hash.length
+        end
       end
 
       def relation_limit(relation)
-        relation.limit_value
+        if relation.is_a?(Array)
+          nil
+        else
+          relation.limit_value
+        end
       end
 
       def relation_offset(relation)
-        relation.offset_value
+        if relation.is_a?(Array)
+          nil
+        else
+          relation.offset_value
+        end
       end
 
       def null_relation(relation)
@@ -30,6 +48,30 @@ module GraphQL
           relation.where("1=2")
         end
       end
+
+      def set_limit(nodes, limit)
+        if already_loaded?(nodes)
+          nodes.take(limit)
+        else
+          super
+        end
+      end
+
+      def set_offset(nodes, offset)
+        if already_loaded?(nodes)
+          # If the client sent a bogus cursor beyond the size of the relation,
+          # it might get `nil` from `#[...]`, so return an empty array in that case
+          nodes[offset..-1] || []
+        else
+          super
+        end
+      end
+
+      private
+
+      def already_loaded?(relation)
+        relation.is_a?(Array) || relation.loaded?
+      end
     end
   end
 end

data/lib/graphql/pagination/array_connection.rb

@@ -21,7 +21,7 @@ module GraphQL
 
       def cursor_for(item)
         idx = items.find_index(item) + 1
-        context.schema.cursor_encoder.encode(idx.to_s)
+        encode(idx.to_s)
       end
 
       private
@@ -35,9 +35,11 @@ module GraphQL
       def load_nodes
         @nodes ||= begin
           sliced_nodes = if before && after
-            items[index_from_cursor(after)..index_from_cursor(before)-1] || []
+            end_idx = index_from_cursor(before)-1
+            end_idx < 0 ? [] : items[index_from_cursor(after)..end_idx] || []
           elsif before
-            items[0..index_from_cursor(before)-2] || []
+            end_idx = index_from_cursor(before)-2
+            end_idx < 0 ? [] : items[0..end_idx] || []
           elsif after
             items[index_from_cursor(after)..-1] || []
           else
@@ -59,7 +61,7 @@ module GraphQL
             sliced_nodes.count > first
           elsif before
             # The original array is longer than the `before` index
-            index_from_cursor(before) < items.length
+            index_from_cursor(before) < items.length + 1
           else
             false
           end

data/lib/graphql/pagination/connection.rb

@@ -15,67 +15,137 @@ module GraphQL
       class PaginationImplementationMissingError < GraphQL::Error
       end
 
-      # @return [Class] The class to use for wrapping items as `edges { ... }`. Defaults to `Connection::Edge`
-      def self.edge_class
-        self::Edge
-      end
-
       # @return [Object] A list object, from the application. This is the unpaginated value passed into the connection.
       attr_reader :items
 
       # @return [GraphQL::Query::Context]
       attr_accessor :context
 
+      # @return [Object] the object this collection belongs to
+      attr_accessor :parent
+
       # Raw access to client-provided values. (`max_page_size` not applied to first or last.)
       attr_accessor :before_value, :after_value, :first_value, :last_value
 
-      # @return [String, nil] the client-provided cursor
+      # @return [String, nil] the client-provided cursor. `""` is treated as `nil`.
       def before
-        @before_value
+        if defined?(@before)
+          @before
+        else
+          @before = @before_value == "" ? nil : @before_value
+        end
       end
 
-      # @return [String, nil] the client-provided cursor
+      # @return [String, nil] the client-provided cursor. `""` is treated as `nil`.
       def after
-        @after_value
+        if defined?(@after)
+          @after
+        else
+          @after = @after_value == "" ? nil : @after_value
+        end
       end
 
+      # @return [Hash<Symbol => Object>] The field arguments from the field that returned this connection
+      attr_accessor :arguments
+
       # @param items [Object] some unpaginated collection item, like an `Array` or `ActiveRecord::Relation`
       # @param context [Query::Context]
+      # @param parent [Object] The object this collection belongs to
       # @param first [Integer, nil] The limit parameter from the client, if it provided one
       # @param after [String, nil] A cursor for pagination, if the client provided one
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
-      # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
-      def initialize(items, context: nil, first: nil, after: nil, max_page_size: nil, last: nil, before: nil)
+      # @param arguments [Hash] The arguments to the field that returned the collection wrapped by this connection
+      # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given and no `default_page_size` is set.
+      # @param default_page_size [Integer, nil] A configured value to determine the result size when neither first or last are given.
+      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, last: nil, before: nil, edge_class: nil, arguments: nil)
         @items = items
+        @parent = parent
         @context = context
+        @field = field
         @first_value = first
         @after_value = after
         @last_value = last
         @before_value = before
-        @max_page_size = max_page_size
+        @arguments = arguments
+        @edge_class = edge_class || self.class::Edge
+        # This is only true if the object was _initialized_ with an override
+        # or if one is assigned later.
+        @has_max_page_size_override = max_page_size != NOT_CONFIGURED
+        @max_page_size = if max_page_size == NOT_CONFIGURED
+          nil
+        else
+          max_page_size
+        end
+        @has_default_page_size_override = default_page_size != NOT_CONFIGURED
+        @default_page_size = if default_page_size == NOT_CONFIGURED
+          nil
+        else
+          default_page_size
+        end
+      end
+
+      def max_page_size=(new_value)
+        @has_max_page_size_override = true
+        @max_page_size = new_value
       end
 
-      attr_writer :max_page_size
       def max_page_size
-        @max_page_size ||= context.schema.default_max_page_size
+        if @has_max_page_size_override
+          @max_page_size
+        else
+          context.schema.default_max_page_size
+        end
+      end
+
+      def has_max_page_size_override?
+        @has_max_page_size_override
+      end
+
+      def default_page_size=(new_value)
+        @has_default_page_size_override = true
+        @default_page_size = new_value
+      end
+
+      def default_page_size
+        if @has_default_page_size_override
+          @default_page_size
+        else
+          context.schema.default_page_size
+        end
+      end
+
+      def has_default_page_size_override?
+        @has_default_page_size_override
       end
 
       attr_writer :first
       # @return [Integer, nil]
       #   A clamped `first` value.
       #   (The underlying instance variable doesn't have limits on it.)
-      #   If neither `first` nor `last` is given, but `max_page_size` is present, max_page_size is used for first.
+      #   If neither `first` nor `last` is given, but `default_page_size` is
+      #   present, default_page_size is used for first. If `default_page_size`
+      #   is greater than `max_page_size``, it'll be clamped down to
+      #   `max_page_size`. If `default_page_size` is nil, use `max_page_size`.
       def first
         @first ||= begin
           capped = limit_pagination_argument(@first_value, max_page_size)
           if capped.nil? && last.nil?
-            capped = max_page_size
+            capped = limit_pagination_argument(default_page_size, max_page_size) || max_page_size
           end
           capped
         end
       end
 
+      # This is called by `Relay::RangeAdd` -- it can be overridden
+      # when `item` needs some modifications based on this connection's state.
+      #
+      # @param item [Object] An item newly added to `items`
+      # @return [Edge]
+      def range_add_edge(item)
+        edge_class.new(item, self)
+      end
+
       attr_writer :last
       # @return [Integer, nil] A clamped `last` value. (The underlying instance variable doesn't have limits on it)
       def last
@@ -84,9 +154,15 @@ module GraphQL
 
       # @return [Array<Edge>] {nodes}, but wrapped with Edge instances
       def edges
-        @edges ||= nodes.map { |n| self.class.edge_class.new(n, self) }
+        @edges ||= nodes.map { |n| @edge_class.new(n, self) }
       end
 
+      # @return [Class] A wrapper class for edges of this connection
+      attr_accessor :edge_class
+
+      # @return [GraphQL::Schema::Field] The field this connection was returned by
+      attr_accessor :field
+
       # @return [Array<Object>] A slice of {items}, constrained by {@first_value}/{@after_value}/{@last_value}/{@before_value}
       def nodes
         raise PaginationImplementationMissingError, "Implement #{self.class}#nodes to paginate `@items`"
@@ -147,23 +223,29 @@ module GraphQL
       end
 
       def decode(cursor)
-        context.schema.cursor_encoder.decode(cursor)
+        context.schema.cursor_encoder.decode(cursor, nonce: true)
+      end
+
+      def encode(cursor)
+        context.schema.cursor_encoder.encode(cursor, nonce: true)
       end
 
       # A wrapper around paginated items. It includes a {cursor} for pagination
       # and could be extended with custom relationship-level data.
       class Edge
-        def initialize(item, connection)
+        attr_reader :node
+
+        def initialize(node, connection)
           @connection = connection
-          @item = item
+          @node = node
         end
 
-        def node
-          @item
+        def parent
+          @connection.parent
         end
 
         def cursor
-          @connection.cursor_for(@item)
+          @cursor ||= @connection.cursor_for(@node)
         end
       end
     end

data/lib/graphql/pagination/connections.rb

@@ -6,20 +6,13 @@ module GraphQL
     #
     # Attach as a plugin.
     #
-    # @example Using new default connections
-    #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Pagination::Connections
-    #   end
-    #
     # @example Adding a custom wrapper
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Pagination::Connections
     #     connections.add(MyApp::SearchResults, MyApp::SearchResultsConnection)
     #   end
     #
     # @example Removing default connection support for arrays (they can still be manually wrapped)
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Pagination::Connections
     #     connections.delete(Array)
     #   end
     #
@@ -28,18 +21,8 @@ module GraphQL
       class ImplementationMissingError < GraphQL::Error
       end
 
-      def self.use(schema_defn)
-        if schema_defn.is_a?(Class)
-          schema_defn.connections = self.new
-        else
-          # Unwrap a `.define` object
-          schema_defn = schema_defn.target
-          schema_defn.connections = self.new
-          schema_defn.class.connections = schema_defn.connections
-        end
-      end
-
-      def initialize
+      def initialize(schema:)
+        @schema = schema
         @wrappers = {}
         add_default
       end
@@ -52,29 +35,68 @@ module GraphQL
         @wrappers.delete(nodes_class)
       end
 
-      # Used by the runtime to wrap values in connection wrappers.
-      # @api Private
-      def wrap(field, object, arguments, context)
+      def all_wrappers
+        all_wrappers = {}
+        @schema.ancestors.reverse_each do |schema_class|
+          if schema_class.respond_to?(:connections) && (c = schema_class.connections)
+            all_wrappers.merge!(c.wrappers)
+          end
+        end
+        all_wrappers
+      end
+
+      def wrapper_for(items, wrappers: all_wrappers)
         impl = nil
-        object.class.ancestors.each { |cls|
-          impl = @wrappers[cls]
+
+        items.class.ancestors.each { |cls|
+          impl = wrappers[cls]
           break if impl
         }
 
-        if impl.nil?
-          raise ImplementationMissingError, "Couldn't find a connection wrapper for #{object.class} during #{field.path} (#{object.inspect})"
+        impl
+      end
+
+      # Used by the runtime to wrap values in connection wrappers.
+      # @api Private
+      def wrap(field, parent, items, arguments, context)
+        return items if GraphQL::Execution::Interpreter::RawValue === items
+        wrappers = context ? context.namespace(:connections)[:all_wrappers] : all_wrappers
+        impl = wrapper_for(items, wrappers: wrappers)
+
+        if impl
+          impl.new(
+            items,
+            context: context,
+            parent: parent,
+            field: field,
+            max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
+            default_page_size: field.has_default_page_size? ? field.default_page_size : context.schema.default_page_size,
+            first: arguments[:first],
+            after: arguments[:after],
+            last: arguments[:last],
+            before: arguments[:before],
+            arguments: arguments,
+            edge_class: edge_class_for_field(field),
+          )
+        else
+          raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
         end
+      end
 
-        impl.new(
-          object,
-          context: context,
-          max_page_size: field.max_page_size || context.schema.default_max_page_size,
-          first: arguments[:first],
-          after: arguments[:after],
-          last: arguments[:last],
-          before: arguments[:before],
-        )
+      # use an override if there is one
+      # @api private
+      def edge_class_for_field(field)
+        conn_type = field.type.unwrap
+        conn_type_edge_type = conn_type.respond_to?(:edge_class) && conn_type.edge_class
+        if conn_type_edge_type && conn_type_edge_type != Pagination::Connection::Edge
+          conn_type_edge_type
+        else
+          nil
+        end
       end
+      protected
+
+      attr_reader :wrappers
 
       private
 
@@ -102,6 +124,11 @@ module GraphQL
         if defined?(Mongoid::Association::Referenced::HasMany::Targets::Enumerable)
           add(Mongoid::Association::Referenced::HasMany::Targets::Enumerable, Pagination::MongoidRelationConnection)
         end
+
+        # Mongoid 7.3+
+        if defined?(Mongoid::Association::Referenced::HasMany::Enumerable)
+          add(Mongoid::Association::Referenced::HasMany::Enumerable, Pagination::MongoidRelationConnection)
+        end
       end
     end
   end

data/lib/graphql/pagination/relation_connection.rb

@@ -12,7 +12,7 @@ module GraphQL
 
       def has_previous_page
         if @has_previous_page.nil?
-          @has_previous_page = if @after_offset && @after_offset > 0
+          @has_previous_page = if after_offset && after_offset > 0
             true
           elsif last
             # See whether there are any nodes _before_ the current offset.
@@ -29,10 +29,14 @@ module GraphQL
 
       def has_next_page
         if @has_next_page.nil?
-          @has_next_page = if @before_offset && @before_offset > 0
+          @has_next_page = if before_offset && before_offset > 0
             true
           elsif first
-            relation_count(set_limit(sliced_nodes, first + 1)) == first + 1
+            if @nodes && @nodes.count < first
+              false
+            else
+              relation_larger_than(sliced_nodes, @sliced_nodes_offset, first)
+            end
           else
             false
           end
@@ -43,12 +47,20 @@ module GraphQL
       def cursor_for(item)
         load_nodes
         # index in nodes + existing offset + 1 (because it's offset, not index)
-        offset = nodes.index(item) + 1 + (@paged_nodes_offset || 0) + (relation_offset(items) || 0)
-        context.schema.cursor_encoder.encode(offset.to_s)
+        offset = nodes.index(item) + 1 + (@paged_nodes_offset || 0) - (relation_offset(items) || 0)
+        encode(offset.to_s)
       end
 
       private
 
+      # @param relation [Object] A database query object
+      # @param _initial_offset [Integer] The number of items already excluded from the relation
+      # @param size [Integer] The value against which we check the relation size
+      # @return [Boolean] True if the number of items in this relation is larger than `size`
+      def relation_larger_than(relation, _initial_offset, size)
+        relation_count(set_limit(relation, size + 1)) == size + 1
+      end
+
       # @param relation [Object] A database query object
       # @return [Integer, nil] The offset value, or nil if there isn't one
       def relation_offset(relation)
@@ -100,67 +112,107 @@ module GraphQL
         end
       end
 
-      # Apply `before` and `after` to the underlying `items`,
-      # returning a new relation.
-      def sliced_nodes
-        @sliced_nodes ||= begin
-          paginated_nodes = items
-          @after_offset = after && offset_from_cursor(after)
-          @before_offset = before && offset_from_cursor(before)
+      def calculate_sliced_nodes_parameters
+        if defined?(@sliced_nodes_limit)
+          return
+        else
+          next_offset = relation_offset(items) || 0
+          relation_limit = relation_limit(items)
 
-          if @after_offset
-            previous_offset = relation_offset(items) || 0
-            paginated_nodes = set_offset(paginated_nodes, previous_offset + @after_offset)
+          if after_offset
+            next_offset += after_offset
           end
 
-          if @before_offset && @after_offset
-            if @after_offset < @before_offset
+          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
-              paginated_nodes = set_limit(paginated_nodes, space_between)
+              space_between = before_offset - after_offset - 1
+              relation_limit = space_between
             else
-              # TODO I think this is untested
               # The cursors overextend one another to an empty set
-              paginated_nodes = null_relation(paginated_nodes)
+              @sliced_nodes_null_relation = true
             end
-          elsif @before_offset
+          elsif before_offset
             # Use limit to cut off the tail of the relation
-            paginated_nodes = set_limit(paginated_nodes, @before_offset - 1)
+            relation_limit = before_offset - 1
+          end
+
+          @sliced_nodes_limit = relation_limit
+          @sliced_nodes_offset = next_offset
+        end
+      end
+
+      # Apply `before` and `after` to the underlying `items`,
+      # returning a new relation.
+      def sliced_nodes
+        @sliced_nodes ||= begin
+          calculate_sliced_nodes_parameters
+          paginated_nodes = items
+
+          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
           end
 
           paginated_nodes
         end
       end
 
+      # @return [Integer, nil]
+      def before_offset
+        @before_offset ||= before && offset_from_cursor(before)
+      end
+
+      # @return [Integer, nil]
+      def after_offset
+        @after_offset ||= after && offset_from_cursor(after)
+      end
+
       # Apply `first` and `last` to `sliced_nodes`,
       # returning a new relation
       def limited_nodes
         @limited_nodes ||= begin
-          paginated_nodes = sliced_nodes
+          calculate_sliced_nodes_parameters
+          if @sliced_nodes_null_relation
+            # it's an empty set
+            return sliced_nodes
+          end
+          relation_limit = @sliced_nodes_limit
+          relation_offset = @sliced_nodes_offset
 
-          if first && (relation_limit(paginated_nodes).nil? || relation_limit(paginated_nodes) > first) && last.nil?
+          if first && (relation_limit.nil? || relation_limit > first)
             # `first` would create a stricter limit that the one already applied, so add it
-            paginated_nodes = set_limit(paginated_nodes, first)
+            relation_limit = first
           end
 
           if last
-            if (lv = relation_limit(paginated_nodes))
-              if last <= lv
+            if relation_limit
+              if last <= relation_limit
                 # `last` is a smaller slice than the current limit, so apply it
-                offset = (relation_offset(paginated_nodes) || 0) + (lv - last)
-                paginated_nodes = set_offset(paginated_nodes, offset)
-                paginated_nodes = set_limit(paginated_nodes, last)
+                relation_offset += (relation_limit - last)
+                relation_limit = last
               end
             else
               # No limit, so get the last items
-              sliced_nodes_count = relation_count(@sliced_nodes)
-              offset = (relation_offset(paginated_nodes) || 0) + sliced_nodes_count - [last, sliced_nodes_count].min
-              paginated_nodes = set_offset(paginated_nodes, offset)
-              paginated_nodes = set_limit(paginated_nodes, last)
+              sliced_nodes_count = relation_count(sliced_nodes)
+              relation_offset += (sliced_nodes_count - [last, sliced_nodes_count].min)
+              relation_limit = last
             end
           end
 
-          @paged_nodes_offset = relation_offset(paginated_nodes)
+          @paged_nodes_offset = relation_offset
+          paginated_nodes = items
+          paginated_nodes = set_offset(paginated_nodes, relation_offset)
+          if relation_limit
+            paginated_nodes = set_limit(paginated_nodes, relation_limit)
+          end
           paginated_nodes
         end
       end

data/lib/graphql/parse_error.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: language/parser.rb
 module GraphQL
   class ParseError < GraphQL::Error
     attr_reader :line, :col, :query