graphql 2.6.11 → 2.6.13

data/lib/graphql/pagination/connection.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Pagination
@@ -10,15 +11,33 @@ module GraphQL
     #
     # Unlike the previous connection implementation, these default to bidirectional pagination.
     #
-    # Pagination arguments and context may be provided at initialization or assigned later (see {Schema::Field::ConnectionExtension}).
+    # Pagination arguments and context may be provided at initialization or assigned later (see [Schema::Field::ConnectionExtension](rdoc-ref:Schema::Field::ConnectionExtension)).
     class Connection
       class PaginationImplementationMissingError < GraphQL::Error
       end
 
-      # @return [Object] A list object, from the application. This is the unpaginated value passed into the connection.
+      class << self
+        # Subclasses may override `cursor_for` to build their own cursors (for example, value-based cursors).
+        # In that case, position-based cursors from the parent class would be wrong, so `cursor_for_position`
+        # should call the overridden `cursor_for` instead.
+        #
+        # The result is cached on each class, since it's the same for every instance.
+        def custom_cursor_for?(default_owner) # :nodoc:
+          if !defined?(@custom_cursor_for)
+            @custom_cursor_for = instance_method(:cursor_for).owner != default_owner
+          end
+          @custom_cursor_for
+        end
+      end
+
+      # **Returns**
+      #
+      # - `Object` — A list object, from the application. This is the unpaginated value passed into the connection.
       attr_reader :items
 
-      # @return [GraphQL::Query::Context]
+      # **Returns**
+      #
+      # - `GraphQL::Query::Context`
       attr_reader :context
 
       def context=(new_ctx)
@@ -29,13 +48,20 @@ module GraphQL
         @context
       end
 
-      # @return [Object] the object this collection belongs to
+      # **Returns**
+      #
+      # - `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. `""` is treated as `nil`.
+      # **Returns**
+      #
+      # - `String, nil` — the client-provided cursor. `""` is treated as `nil`.
+      #
+      # :call-seq:
+      #   before() -> String | nil
       def before
         if defined?(@before)
           @before
@@ -44,7 +70,12 @@ module GraphQL
         end
       end
 
-      # @return [String, nil] the client-provided cursor. `""` is treated as `nil`.
+      # **Returns**
+      #
+      # - `String, nil` — the client-provided cursor. `""` is treated as `nil`.
+      #
+      # :call-seq:
+      #   after() -> String | nil
       def after
         if defined?(@after)
           @after
@@ -53,19 +84,26 @@ module GraphQL
         end
       end
 
-      # @return [Hash<Symbol => Object>] The field arguments from the field that returned this connection
+      # **Returns**
+      #
+      # - `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 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.
+      # **Parameters**
+      #
+      # - `items` (`Object`) — some unpaginated collection item, like an `Array` or `ActiveRecord::Relation`
+      # - `context` (`Query::Context`)
+      # - `parent` (`Object`) — The object this collection belongs to
+      # - `first` (`Integer, nil`) — The limit parameter from the client, if it provided one
+      # - `after` (`String, nil`) — A cursor for pagination, if the client provided one
+      # - `last` (`Integer, nil`) — Limit parameter from the client, if provided
+      # - `before` (`String, nil`) — A cursor for pagination, if the client provided one.
+      # - `arguments` (`Hash`) — The arguments to the field that returned the collection wrapped by this connection
+      # - `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.
+      # - `default_page_size` (`Integer, nil`) — A configured value to determine the result size when neither first or last are given.
+      #
+      # :call-seq:
+      #   initialize(Object items, Object parent:, field:, Query::Context context:, Integer | nil first:, String | nil after:, Integer | nil max_page_size:, Integer | nil default_page_size:, Integer | nil last:, String | nil before:, edge_class:, Hash arguments:)
       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
@@ -76,7 +114,7 @@ module GraphQL
         @last_value = last
         @before_value = before
         @arguments = arguments
-        @edge_class = edge_class || self.class::Edge
+        @edge_class = edge_class || self.class.const_get(: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
@@ -135,13 +173,12 @@ module GraphQL
       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 `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`.
+      # **Returns**
+      #
+      # - `Integer, nil` — A clamped `first` value. (The underlying instance variable doesn't have limits on it.) 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`.
+      #
+      # :call-seq:
+      #   first() -> Integer | nil
       def first
         @first ||= begin
           capped = limit_pagination_argument(@first_value, max_page_size)
@@ -155,36 +192,72 @@ module GraphQL
       # 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]
+      # **Parameters**
+      #
+      # - `item` (`Object`) — An item newly added to `items`
+      #
+      # **Returns**
+      #
+      # - `Edge`
+      #
+      # :call-seq:
+      #   range_add_edge(Object item) -> 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)
+      # **Returns**
+      #
+      # - `Integer, nil` — A clamped `last` value. (The underlying instance variable doesn't have limits on it)
+      #
+      # :call-seq:
+      #   last() -> Integer | nil
       def last
         @last ||= limit_pagination_argument(@last_value, max_page_size)
       end
 
-      # @return [Array<Edge>] {nodes}, but wrapped with Edge instances
+      # **Returns**
+      #
+      # - `Array<Edge>` — [nodes](rdoc-ref:nodes), but wrapped with Edge instances
+      #
+      # :call-seq:
+      #   edges() -> Array[Edge]
       def edges
-        @edges ||= nodes.map { |n| @edge_class.new(n, self) }
+        @edges ||= nodes.each_with_index.map do |n, index|
+          edge = @edge_class.new(n, self)
+          edge.graphql_connection_position = index
+          edge
+        end
       end
 
-      # @return [Class] A wrapper class for edges of this connection
+      # **Returns**
+      #
+      # - `Class` — A wrapper class for edges of this connection
       attr_accessor :edge_class
 
-      # @return [GraphQL::Schema::Field] The field this connection was returned by
+      # **Returns**
+      #
+      # - `GraphQL::Schema::Field` — The field this connection was returned by
       attr_accessor :field
+  
+      # **Returns**
+      # 
+      # - `GraphQL::Execution::Lookahead` Selections on this connection, set by connection fields
+      attr_accessor :lookahead
 
-      # @return [Array<Object>] A slice of {items}, constrained by {@first_value}/{@after_value}/{@last_value}/{@before_value}
+      # **Returns**
+      #
+      # - `Array<Object>` — A slice of [items](rdoc-ref:items), constrained by `@first_value`/`@after_value`/`@last_value`/`@before_value`
+      #
+      # :call-seq:
+      #   nodes() -> Array[Object]
       def nodes
         raise PaginationImplementationMissingError, "Implement #{self.class}#nodes to paginate `@items`"
       end
 
-      # A dynamic alias for compatibility with {Relay::BaseConnection}.
-      # @deprecated use {#nodes} instead
+      # A dynamic alias for compatibility with [GraphQL::Types::Relay::BaseConnection](rdoc-ref:GraphQL::Types::Relay::BaseConnection).
+      # **Deprecated:** use [nodes](rdoc-ref:#nodes) instead
       def edge_nodes
         nodes
       end
@@ -194,35 +267,77 @@ module GraphQL
         self
       end
 
-      # @return [Boolean] True if there are more items after this page
+      # **Returns**
+      #
+      # - `Boolean` — True if there are more items after this page
+      #
+      # :call-seq:
+      #   has_next_page() -> bool
       def has_next_page
         raise PaginationImplementationMissingError, "Implement #{self.class}#has_next_page to return the next-page check"
       end
 
-      # @return [Boolean] True if there were items before these items
+      # **Returns**
+      #
+      # - `Boolean` — True if there were items before these items
+      #
+      # :call-seq:
+      #   has_previous_page() -> bool
       def has_previous_page
         raise PaginationImplementationMissingError, "Implement #{self.class}#has_previous_page to return the previous-page check"
       end
 
-      # @return [String] The cursor of the first item in {nodes}
+      # **Returns**
+      #
+      # - `String` — The cursor of the first item in [nodes](rdoc-ref:nodes)
+      #
+      # :call-seq:
+      #   start_cursor() -> String
       def start_cursor
-        nodes.first && cursor_for(nodes.first)
+        nodes.first && cursor_for_position(nodes.first, 0)
       end
 
-      # @return [String] The cursor of the last item in {nodes}
+      # **Returns**
+      #
+      # - `String` — The cursor of the last item in [nodes](rdoc-ref:nodes)
+      #
+      # :call-seq:
+      #   end_cursor() -> String
       def end_cursor
-        nodes.last && cursor_for(nodes.last)
+        nodes.last && cursor_for_position(nodes.last, nodes.length - 1)
       end
 
       # Return a cursor for this item.
-      # @param item [Object] one of the passed in {items}, taken from {nodes}
-      # @return [String]
+      #
+      # **Parameters**
+      #
+      # - `item` (`Object`) — one of the passed in [items](rdoc-ref:items), taken from [nodes](rdoc-ref:nodes)
+      #
+      # **Returns**
+      #
+      # - `String`
+      #
+      # :call-seq:
+      #   cursor_for(Object item) -> String
       def cursor_for(item)
         raise PaginationImplementationMissingError, "Implement #{self.class}#cursor_for(item) to return the cursor for #{item.inspect}"
       end
 
+      def cursor_for_position(item, _position) # :nodoc:
+        cursor_for(item)
+      end
+
       private
 
+      def cursor_index_for(item, collection)
+        @cursor_indexes ||= {}.compare_by_identity.tap do |indexes|
+          collection.each_with_index { |node, index| indexes[node] ||= index }
+        end
+        @cursor_indexes.fetch(item) do
+          raise GraphQL::ExecutionError, "Can't generate a cursor for an item outside this connection"
+        end
+      end
+
       def detect_was_authorized_by_scope_items
         if @context &&
             (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
@@ -233,9 +348,17 @@ module GraphQL
         end
       end
 
-      # @param argument [nil, Integer] `first` or `last`, as provided by the client
-      # @param max_page_size [nil, Integer]
-      # @return [nil, Integer] `nil` if the input was `nil`, otherwise a value between `0` and `max_page_size`
+      # **Parameters**
+      #
+      # - `argument` (`nil, Integer`) — `first` or `last`, as provided by the client
+      # - `max_page_size` (`nil, Integer`)
+      #
+      # **Returns**
+      #
+      # - `nil, Integer` — `nil` if the input was `nil`, otherwise a value between `0` and `max_page_size`
+      #
+      # :call-seq:
+      #   limit_pagination_argument(nil | Integer argument, nil | Integer max_page_size) -> nil | Integer
       def limit_pagination_argument(argument, max_page_size)
         if argument
           if argument < 0
@@ -255,11 +378,14 @@ module GraphQL
         context.schema.cursor_encoder.encode(cursor, nonce: true)
       end
 
-      # A wrapper around paginated items. It includes a {cursor} for pagination
+      # A wrapper around paginated items. It includes a [cursor](rdoc-ref:#cursor) for pagination
       # and could be extended with custom relationship-level data.
       class Edge
         attr_reader :node
 
+        # The zero-based position of this edge in the page
+        attr_accessor :graphql_connection_position # :nodoc:
+
         def initialize(node, connection)
           @connection = connection
           @node = node
@@ -270,7 +396,11 @@ module GraphQL
         end
 
         def cursor
-          @cursor ||= @connection.cursor_for(@node)
+          @cursor ||= if @graphql_connection_position
+            @connection.cursor_for_position(@node, @graphql_connection_position)
+          else
+            @connection.cursor_for(@node)
+          end
         end
 
         def was_authorized_by_scope_items?

data/lib/graphql/pagination/connections.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Pagination
@@ -6,17 +7,25 @@ module GraphQL
     #
     # Attach as a plugin.
     #
-    # @example Adding a custom wrapper
-    #   class MySchema < GraphQL::Schema
-    #     connections.add(MyApp::SearchResults, MyApp::SearchResultsConnection)
-    #   end
+    # See [Schema.connections](rdoc-ref:Schema.connections)
     #
-    # @example Removing default connection support for arrays (they can still be manually wrapped)
-    #   class MySchema < GraphQL::Schema
-    #     connections.delete(Array)
-    #   end
+    # **Examples**
     #
-    # @see {Schema.connections}
+    # **Example: Adding a custom wrapper**
+    #
+    # ```ruby
+    # class MySchema < GraphQL::Schema
+    #   connections.add(MyApp::SearchResults, MyApp::SearchResultsConnection)
+    # end
+    # ```
+    #
+    # **Example: Removing default connection support for arrays (they can still be manually wrapped)**
+    #
+    # ```ruby
+    # class MySchema < GraphQL::Schema
+    #   connections.delete(Array)
+    # end
+    # ```
     class Connections
       class ImplementationMissingError < GraphQL::Error
       end
@@ -46,7 +55,7 @@ module GraphQL
       end
 
       def wrapper_for(items, wrappers: all_wrappers)
-        impl = nil
+        impl = nil #: untyped
 
         items.class.ancestors.each { |cls|
           impl = wrappers[cls]
@@ -57,8 +66,7 @@ module GraphQL
       end
 
       # Used by the runtime to wrap values in connection wrappers.
-      # @api Private
-      def wrap(field, parent, items, arguments, context)
+      def wrap(field, parent, items, arguments, context) # :nodoc:
         return items if GraphQL::Execution::Interpreter::RawValue === items
         wrappers = context ? context.namespace(:connections)[:all_wrappers] : all_wrappers
         impl = wrapper_for(items, wrappers: wrappers)
@@ -114,8 +122,7 @@ module GraphQL
         end
       end
       # use an override if there is one
-      # @api private
-      def edge_class_for_field(field)
+      def edge_class_for_field(field) # :nodoc:
         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

data/lib/graphql/pagination/mongoid_relation_connection.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "graphql/pagination/relation_connection"
 
 module GraphQL

data/lib/graphql/pagination/relation_connection.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "graphql/pagination/connection"
 require "monitor"
 
@@ -29,6 +30,12 @@ module GraphQL
       end
 
       def has_next_page
+        # If the query loads the page anyway, load it now so its extra row answers this
+        if @has_next_page.nil? && peek_next_page? &&
+            (lookahead.selects?(:nodes) || lookahead.selects?(:edges) ||
+              page_info_selection.selects?(:start_cursor) || page_info_selection.selects?(:end_cursor))
+          load_nodes
+        end
         if @has_next_page.nil?
           @has_next_page = if before_offset && before_offset > 0
             true
@@ -47,48 +54,110 @@ 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)
-        encode(offset.to_s)
+        position = cursor_index_for(item, nodes)
+        offset_cursor_for_position(position)
+      end
+
+      def cursor_for_position(item, position) # :nodoc:
+        if self.class.custom_cursor_for?(RelationConnection)
+          super
+        else
+          offset_cursor_for_position(position)
+        end
       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 offset_cursor_for_position(position)
+        # position in nodes + existing offset + 1 (because it's offset, not index)
+        offset = position + 1 + (@paged_nodes_offset || 0) - (relation_offset(items) || 0)
+        encode(offset.to_s)
+      end
+
+      # **Parameters**
+      #
+      # - `relation` (`Object`) — A database query object
+      # - `_initial_offset` (`Integer`) — The number of items already excluded from the relation
+      # - `size` (`Integer`) — The value against which we check the relation size
+      #
+      # **Returns**
+      #
+      # - `Boolean` — True if the number of items in this relation is larger than `size`
+      #
+      # :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
       end
 
-      # @param relation [Object] A database query object
-      # @return [Integer, nil] The offset value, or nil if there isn't one
+      # **Parameters**
+      #
+      # - `relation` (`Object`) — A database query object
+      #
+      # **Returns**
+      #
+      # - `Integer, nil` — The offset value, or nil if there isn't one
+      #
+      # :call-seq:
+      #   relation_offset(Object relation) -> Integer | nil
       def relation_offset(relation)
         raise "#{self.class}#relation_offset(relation) must return the offset value for a #{relation.class} (#{relation.inspect})"
       end
 
-      # @param relation [Object] A database query object
-      # @return [Integer, nil] The limit value, or nil if there isn't one
+      # **Parameters**
+      #
+      # - `relation` (`Object`) — A database query object
+      #
+      # **Returns**
+      #
+      # - `Integer, nil` — The limit value, or nil if there isn't one
+      #
+      # :call-seq:
+      #   relation_limit(Object relation) -> Integer | nil
       def relation_limit(relation)
         raise "#{self.class}#relation_limit(relation) must return the limit value for a #{relation.class} (#{relation.inspect})"
       end
 
-      # @param relation [Object] A database query object
-      # @return [Integer, nil] The number of items in this relation (hopefully determined without loading all records into memory!)
+      # **Parameters**
+      #
+      # - `relation` (`Object`) — A database query object
+      #
+      # **Returns**
+      #
+      # - `Integer, nil` — The number of items in this relation (hopefully determined without loading all records into memory!)
+      #
+      # :call-seq:
+      #   relation_count(Object relation) -> Integer | nil
       def relation_count(relation)
         raise "#{self.class}#relation_count(relation) must return the count of records for a #{relation.class} (#{relation.inspect})"
       end
 
-      # @param relation [Object] A database query object
-      # @return [Object] A modified query object which will return no records
+      # **Parameters**
+      #
+      # - `relation` (`Object`) — A database query object
+      #
+      # **Returns**
+      #
+      # - `Object` — A modified query object which will return no records
+      #
+      # :call-seq:
+      #   null_relation(Object relation) -> Object
       def null_relation(relation)
         raise "#{self.class}#null_relation(relation) must return an empty relation for a #{relation.class} (#{relation.inspect})"
       end
 
-      # @return [Integer]
+      # **Returns**
+      #
+      # - `Integer`
+      #
+      # :call-seq:
+      #   offset_from_cursor(cursor) -> Integer
       def offset_from_cursor(cursor)
-        decode(cursor).to_i
+        offset = Integer(decode(cursor), 10, exception: false) #: Integer?
+        if offset.nil? || offset <= 0
+          raise GraphQL::ExecutionError, "Invalid cursor: #{cursor.inspect}"
+        end
+        offset
       end
 
       # Abstract this operation so we can always ignore inputs less than zero.
@@ -166,12 +235,22 @@ module GraphQL
         end
       end
 
-      # @return [Integer, nil]
+      # **Returns**
+      #
+      # - `Integer, nil`
+      #
+      # :call-seq:
+      #   before_offset() -> Integer | nil
       def before_offset
         @before_offset ||= before && offset_from_cursor(before)
       end
 
-      # @return [Integer, nil]
+      # **Returns**
+      #
+      # - `Integer, nil`
+      #
+      # :call-seq:
+      #   after_offset() -> Integer | nil
       def after_offset
         @after_offset ||= after && offset_from_cursor(after)
       end
@@ -230,7 +309,7 @@ module GraphQL
       end
 
       def async_dataloader?
-        @context&.[](:dataloader).is_a?(GraphQL::Dataloader::AsyncDataloader)
+        @context&.dataloader.is_a?(GraphQL::Dataloader::AsyncDataloader)
       end
 
       # Load nodes after applying first/last/before/after,
@@ -242,12 +321,34 @@ module GraphQL
           # `AsyncDataloader` may resolve sibling fields (eg, `edges` and `pageInfo`)
           # in separate Fibers, so several callers can get here before `@nodes` is set.
           (@load_monitor ||= Monitor.new).synchronize do
-            @nodes ||= limited_nodes.to_a
+            # Not `||=`: Sorbet assumes `@nodes` is still falsy in this block
+            @nodes = load_page unless @nodes
           end
         else
-          @nodes = limited_nodes.to_a
+          @nodes = load_page
         end
       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).
+      def load_page
+        page = limited_nodes
+        return page.to_a if page.is_a?(Array) || !peek_next_page? || relation_limit(page) != first
+
+        rows = set_limit(page, first + 1).to_a
+        @has_next_page = rows.size > first
+        rows.first(first)
+      end
+
+      # Peek on forward pages that select `hasNextPage`; `last` and `before` keep the separate check
+      def peek_next_page?
+        return @peek_next_page if defined?(@peek_next_page)
+        @peek_next_page = first&.positive? && last.nil? && before.nil? && page_info_selection.selects?(:has_next_page)
+      end
+
+      def page_info_selection
+        @page_info_selection ||= (lookahead || GraphQL::Execution::Lookahead::NULL_LOOKAHEAD).selection(:page_info)
+      end
     end
   end
 end

data/lib/graphql/pagination/sequel_dataset_connection.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "graphql/pagination/relation_connection"
 
 module GraphQL

data/lib/graphql/pagination.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "graphql/pagination/array_connection"
 require "graphql/pagination/active_record_relation_connection"
 require "graphql/pagination/connections"

data/lib/graphql/parse_error.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class ParseError < GraphQL::Error
     attr_reader :line, :col, :query