graphql 1.9.21 → 1.10.0.pre1

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
 
@@ -440,7 +442,6 @@ def initialize(query_string, filename:, tracer: Tracing::NullTracer)
   @query_string = query_string
   @filename = filename
   @tracer = tracer
-  @reused_next_token = [nil, nil]
 end
 
 def parse_document
@@ -452,7 +453,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
@@ -471,9 +472,7 @@ def next_token
   if lexer_token.nil?
     nil
   else
-    @reused_next_token[0] = lexer_token.name
-    @reused_next_token[1] = lexer_token
-    @reused_next_token
+    [lexer_token.name, lexer_token]
   end
 end
 

data/lib/graphql/language/token.rb

@@ -14,7 +14,7 @@ module GraphQL
       attr_reader :value
       attr_reader :prev_token, :line, :col
 
-      def initialize(name, value, line, col, prev_token)
+      def initialize(value:, name:, line:, col:, prev_token:)
         @name = name
         @value = -value
         @line = line

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/pagination.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require "graphql/pagination/array_connection"
+require "graphql/pagination/active_record_relation_connection"
+require "graphql/pagination/connections"
+require "graphql/pagination/mongoid_relation_connection"
+require "graphql/pagination/sequel_dataset_connection"

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,78 @@
+# 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 = limited_nodes.first(max_page_size) if max_page_size && !first && !last
+
+          limited_nodes
+        end
+      end
+    end
+  end
+end

data/lib/graphql/pagination/connection.rb

@@ -0,0 +1,150 @@
+# 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
+
+      attr_accessor :before, :after
+
+      # @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.
+      def initialize(items, context: nil, first: nil, after: nil, max_page_size: nil, last: nil, before: nil)
+        @items = items
+        @context = context
+        @first = first
+        @after = after
+        @last = last
+        @before = 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)
+      def first
+        limit_pagination_argument(@first, max_page_size)
+      end
+
+      attr_writer :last
+      # @return [Integer, nil] a clamped `last` value. (The underlying instance variable doesn't have limits on it)
+      def last
+        limit_pagination_argument(@last, 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}/{@after}/{@last}/{@before}
+      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,103 @@
+# 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)
+        [schema_defn.target, schema_defn.target.class].each do |schema|
+          schema.connections = self.new
+        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