graphql 1.9.17 → 1.10.0

data/lib/graphql/language/parser.y

@@ -77,8 +77,11 @@ rule
       }
 
   type:
+      nullable_type           { return val[0] }
+    | nullable_type BANG      { return make_node(:NonNullType, of_type: val[0]) }
+
+  nullable_type:
       name                   { return make_node(:TypeName, name: val[0])}
-    | type BANG              { return make_node(:NonNullType, of_type: val[0]) }
     | LBRACKET type RBRACKET { return make_node(:ListType, of_type: val[1]) }
 
   default_value_opt:
@@ -165,7 +168,6 @@ rule
 
   arguments_opt:
       /* none */                    { return EMPTY_ARRAY }
-    | LPAREN RPAREN                 { return EMPTY_ARRAY }
     | LPAREN arguments_list RPAREN  { return val[1] }
 
   arguments_list:
@@ -187,7 +189,7 @@ rule
     | object_literal_value
 
   input_value:
-    | literal_value
+    literal_value
     | variable
     | object_value
 
@@ -452,7 +454,7 @@ def parse_document
     # From the tokens, build an AST
     @tracer.trace("parse", {query_string: @query_string}) do
       if @tokens.empty?
-        make_node(:Document, definitions: [], filename: @filename)
+        raise GraphQL::ParseError.new("Unexpected end of document", nil, nil, @query_string)
       else
         do_parse
       end

data/lib/graphql/language.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require "graphql/language/block_string"
 require "graphql/language/printer"
-require "graphql/language/definition_slice"
 require "graphql/language/document_from_schema_definition"
 require "graphql/language/generation"
 require "graphql/language/lexer"
@@ -9,6 +8,7 @@ require "graphql/language/nodes"
 require "graphql/language/parser"
 require "graphql/language/token"
 require "graphql/language/visitor"
+require "graphql/language/definition_slice"
 
 module GraphQL
   module Language

data/lib/graphql/non_null_type.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 module GraphQL
-  class DoubleNonNullTypeError < GraphQL::Error
-  end
-
   # A non-null type modifies another type.
   #
   # Non-null types can be created with `!` (`InnerType!`)
@@ -37,13 +34,6 @@ module GraphQL
 
     attr_reader :of_type
     def initialize(of_type:)
-      if of_type.is_a?(GraphQL::NonNullType)
-        raise(
-          DoubleNonNullTypeError,
-          "You tried to add a non-null constraint twice (!! instead of !)"
-        )
-      end
-
       super()
       @of_type = of_type
     end

data/lib/graphql/object_type.rb

@@ -1,26 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  # This type exposes fields on an object.
-  #
-  # @example defining a type for your IMDB clone
-  #   MovieType = GraphQL::ObjectType.define do
-  #     name "Movie"
-  #     description "A full-length film or a short film"
-  #     interfaces [ProductionInterface, DurationInterface]
-  #
-  #     field :runtimeMinutes, !types.Int, property: :runtime_minutes
-  #     field :director, PersonType
-  #     field :cast, CastType
-  #     field :starring, types[PersonType] do
-  #       argument :limit, types.Int
-  #       resolve ->(object, args, ctx) {
-  #         stars = object.cast.stars
-  #         args[:limit] && stars = stars.limit(args[:limit])
-  #         stars
-  #       }
-  #      end
-  #   end
-  #
+  # @api deprecated
   class ObjectType < GraphQL::BaseType
     accepts_definitions :interfaces, :fields, :mutation, :relay_node_type, field: GraphQL::Define::AssignObjectField
     accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }

data/lib/graphql/pagination/active_record_relation_connection.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require "graphql/pagination/relation_connection"
+
+module GraphQL
+  module Pagination
+    # Customizes `RelationConnection` to work with `ActiveRecord::Relation`s.
+    class ActiveRecordRelationConnection < Pagination::RelationConnection
+      def relation_count(relation)
+        if relation.respond_to?(:unscope)
+          relation.unscope(:order).count(:all)
+        else
+          # Rails 3
+          relation.count
+        end
+      end
+
+      def relation_limit(relation)
+        relation.limit_value
+      end
+
+      def relation_offset(relation)
+        relation.offset_value
+      end
+
+      def null_relation(relation)
+        if relation.respond_to?(:none)
+          relation.none
+        else
+          # Rails 3
+          relation.where("1=2")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/pagination/array_connection.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require "graphql/pagination/connection"
+
+module GraphQL
+  module Pagination
+    class ArrayConnection < Pagination::Connection
+      def nodes
+        load_nodes
+        @nodes
+      end
+
+      def has_previous_page
+        load_nodes
+        @has_previous_page
+      end
+
+      def has_next_page
+        load_nodes
+        @has_next_page
+      end
+
+      def cursor_for(item)
+        idx = items.find_index(item) + 1
+        context.schema.cursor_encoder.encode(idx.to_s)
+      end
+
+      private
+
+      def index_from_cursor(cursor)
+        decode(cursor).to_i
+      end
+
+      # Populate all the pagination info _once_,
+      # It doesn't do anything on subsequent calls.
+      def load_nodes
+        @nodes ||= begin
+          sliced_nodes = if before && after
+            items[index_from_cursor(after)..index_from_cursor(before)-1] || []
+          elsif before
+            items[0..index_from_cursor(before)-2] || []
+          elsif after
+            items[index_from_cursor(after)..-1] || []
+          else
+            items
+          end
+
+          @has_previous_page = if last
+            # There are items preceding the ones in this result
+            sliced_nodes.count > last
+          elsif after
+            # We've paginated into the Array a bit, there are some behind us
+            index_from_cursor(after) > 0
+          else
+            false
+          end
+
+          @has_next_page = if first
+            # There are more items after these items
+            sliced_nodes.count > first
+          elsif before
+            # The original array is longer than the `before` index
+            index_from_cursor(before) < items.length
+          else
+            false
+          end
+
+          limited_nodes = sliced_nodes
+
+          limited_nodes = limited_nodes.first(first) if first
+          limited_nodes = limited_nodes.last(last) if last
+
+          limited_nodes
+        end
+      end
+    end
+  end
+end

data/lib/graphql/pagination/connection.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Pagination
+    # A Connection wraps a list of items and provides cursor-based pagination over it.
+    #
+    # Connections were introduced by Facebook's `Relay` front-end framework, but
+    # proved to be generally useful for GraphQL APIs. When in doubt, use connections
+    # to serve lists (like Arrays, ActiveRecord::Relations) via 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}).
+    class Connection
+      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
+
+      # 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
+      def before
+        @before_value
+      end
+
+      # @return [String, nil] the client-provided cursor
+      def after
+        @after_value
+      end
+
+      # @param items [Object] some unpaginated collection item, like an `Array` or `ActiveRecord::Relation`
+      # @param context [Query::Context]
+      # @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)
+        @items = items
+        @context = context
+        @first_value = first
+        @after_value = after
+        @last_value = last
+        @before_value = before
+        @max_page_size = max_page_size
+      end
+
+      attr_writer :max_page_size
+      def max_page_size
+        @max_page_size ||= context.schema.default_max_page_size
+      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.
+      def first
+        @first ||= begin
+          capped = limit_pagination_argument(@first_value, max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
+      end
+
+      attr_writer :last
+      # @return [Integer, nil] A clamped `last` value. (The underlying instance variable doesn't have limits on it)
+      def last
+        @last ||= limit_pagination_argument(@last_value, max_page_size)
+      end
+
+      # @return [Array<Edge>] {nodes}, but wrapped with Edge instances
+      def edges
+        @edges ||= nodes.map { |n| self.class.edge_class.new(n, self) }
+      end
+
+      # @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`"
+      end
+
+      # A dynamic alias for compatibility with {Relay::BaseConnection}.
+      # @deprecated use {#nodes} instead
+      def edge_nodes
+        nodes
+      end
+
+      # The connection object itself implements `PageInfo` fields
+      def page_info
+        self
+      end
+
+      # @return [Boolean] True if there are more items after this page
+      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
+      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}
+      def start_cursor
+        nodes.first && cursor_for(nodes.first)
+      end
+
+      # @return [String] The cursor of the last item in {nodes}
+      def end_cursor
+        nodes.last && cursor_for(nodes.last)
+      end
+
+      # Return a cursor for this item.
+      # @param item [Object] one of the passed in {items}, taken from {nodes}
+      # @return [String]
+      def cursor_for(item)
+        raise PaginationImplementationMissingError, "Implement #{self.class}#cursor_for(item) to return the cursor for #{item.inspect}"
+      end
+
+      private
+
+      # @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`
+      def limit_pagination_argument(argument, max_page_size)
+        if argument
+          if argument < 0
+            argument = 0
+          elsif max_page_size && argument > max_page_size
+            argument = max_page_size
+          end
+        end
+        argument
+      end
+
+      def decode(cursor)
+        context.schema.cursor_encoder.decode(cursor)
+      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)
+          @connection = connection
+          @item = item
+        end
+
+        def node
+          @item
+        end
+
+        def cursor
+          @connection.cursor_for(@item)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/pagination/connections.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Pagination
+    # A schema-level connection wrapper manager.
+    #
+    # 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
+    #
+    # @see {Schema.connections}
+    class Connections
+      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
+        @wrappers = {}
+        add_default
+      end
+
+      def add(nodes_class, implementation)
+        @wrappers[nodes_class] = implementation
+      end
+
+      def delete(nodes_class)
+        @wrappers.delete(nodes_class)
+      end
+
+      # Used by the runtime to wrap values in connection wrappers.
+      # @api Private
+      def wrap(field, object, arguments, context)
+        impl = nil
+        object.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})"
+        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],
+        )
+      end
+
+      private
+
+      def add_default
+        add(Array, Pagination::ArrayConnection)
+
+        if defined?(ActiveRecord::Relation)
+          add(ActiveRecord::Relation, Pagination::ActiveRecordRelationConnection)
+        end
+
+        if defined?(Sequel::Dataset)
+          add(Sequel::Dataset, Pagination::SequelDatasetConnection)
+        end
+
+        if defined?(Mongoid::Criteria)
+          add(Mongoid::Criteria, Pagination::MongoidRelationConnection)
+        end
+
+        # Mongoid 5 and 6
+        if defined?(Mongoid::Relations::Targets::Enumerable)
+          add(Mongoid::Relations::Targets::Enumerable, Pagination::MongoidRelationConnection)
+        end
+
+        # Mongoid 7
+        if defined?(Mongoid::Association::Referenced::HasMany::Targets::Enumerable)
+          add(Mongoid::Association::Referenced::HasMany::Targets::Enumerable, Pagination::MongoidRelationConnection)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/pagination/mongoid_relation_connection.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require "graphql/pagination/relation_connection"
+
+module GraphQL
+  module Pagination
+    class MongoidRelationConnection < Pagination::RelationConnection
+      def relation_offset(relation)
+        relation.options.skip
+      end
+
+      def relation_limit(relation)
+        relation.options.limit
+      end
+
+      def relation_count(relation)
+        # Mongo's `.count` doesn't apply limit or skip, which we need. So we have to load _everything_!
+        relation.to_a.count
+      end
+
+      def null_relation(relation)
+        relation.without_options.none
+      end
+    end
+  end
+end

data/lib/graphql/pagination/relation_connection.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+require "graphql/pagination/connection"
+
+module GraphQL
+  module Pagination
+    # A generic class for working with database query objects.
+    class RelationConnection < Pagination::Connection
+      def nodes
+        load_nodes
+        @nodes
+      end
+
+      def has_previous_page
+        load_nodes
+        @has_previous_page
+      end
+
+      def has_next_page
+        load_nodes
+        @has_next_page
+      end
+
+      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)
+      end
+
+      private
+
+      # @param relation [Object] A database query object
+      # @return [Integer, nil] The offset value, or nil if there isn't one
+      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
+      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!)
+      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
+      def null_relation(relation)
+        raise "#{self.class}#null_relation(relation) must return an empty relation for a #{relation.class} (#{relation.inspect})"
+      end
+
+      # @return [Integer]
+      def offset_from_cursor(cursor)
+        decode(cursor).to_i
+      end
+
+      # Abstract this operation so we can always ignore inputs less than zero.
+      # (Sequel doesn't like it, understandably.)
+      def set_offset(relation, offset_value)
+        if offset_value >= 0
+          relation.offset(offset_value)
+        else
+          relation.offset(0)
+        end
+      end
+
+      # Abstract this operation so we can always ignore inputs less than zero.
+      # (Sequel doesn't like it, understandably.)
+      def set_limit(relation, limit_value)
+        if limit_value > 0
+          relation.limit(limit_value)
+        elsif limit_value == 0
+          null_relation(relation)
+        else
+          relation
+        end
+      end
+
+      # Populate all the pagination info _once_,
+      # It doesn't do anything on subsequent calls.
+      def load_nodes
+        @nodes ||= begin
+          paginated_nodes = items
+          after_offset = after && offset_from_cursor(after)
+          before_offset = before && offset_from_cursor(before)
+
+          if after_offset
+            previous_offset = relation_offset(items) || 0
+            paginated_nodes = set_offset(paginated_nodes, previous_offset + after_offset)
+          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
+              paginated_nodes = set_limit(paginated_nodes, space_between)
+            else
+              # TODO I think this is untested
+              # The cursors overextend one another to an empty set
+              paginated_nodes = null_relation(paginated_nodes)
+            end
+          elsif before_offset
+            # Use limit to cut off the tail of the relation
+            paginated_nodes = set_limit(paginated_nodes, before_offset - 1)
+          end
+
+          sliced_nodes_count = relation_count(paginated_nodes)
+
+          if first && (relation_limit(paginated_nodes).nil? || relation_limit(paginated_nodes) > first)
+            # `first` would create a stricter limit that the one already applied, so add it
+            paginated_nodes = set_limit(paginated_nodes, first)
+          end
+
+          if last
+            if (lv = relation_limit(paginated_nodes))
+              if last <= lv
+                # `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)
+              end
+            else
+              # No limit, so get the last items
+              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)
+            end
+          end
+
+          @has_next_page = !!(
+            (before_offset && before_offset > 0) ||
+            (first && sliced_nodes_count > first)
+          )
+
+          @has_previous_page = !!(
+            (after_offset && after_offset > 0) ||
+            (last && sliced_nodes_count > last)
+          )
+
+          @paged_nodes_offset = relation_offset(paginated_nodes)
+          # Return an array so we can consistently use `.index(node)` on it
+          paginated_nodes.to_a
+        end
+      end
+    end
+  end
+end