graphql 1.9.21 → 2.0.0

data/lib/graphql/pagination/connections.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Pagination
+    # A schema-level connection wrapper manager.
+    #
+    # Attach as a plugin.
+    #
+    # @example Adding a custom wrapper
+    #   class MySchema < GraphQL::Schema
+    #     connections.add(MyApp::SearchResults, MyApp::SearchResultsConnection)
+    #   end
+    #
+    # @example Removing default connection support for arrays (they can still be manually wrapped)
+    #   class MySchema < GraphQL::Schema
+    #     connections.delete(Array)
+    #   end
+    #
+    # @see {Schema.connections}
+    class Connections
+      class ImplementationMissingError < GraphQL::Error
+      end
+
+      def initialize(schema:)
+        @schema = schema
+        @wrappers = {}
+        add_default
+      end
+
+      def add(nodes_class, implementation)
+        @wrappers[nodes_class] = implementation
+      end
+
+      def delete(nodes_class)
+        @wrappers.delete(nodes_class)
+      end
+
+      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
+
+        items.class.ancestors.each { |cls|
+          impl = wrappers[cls]
+          break if impl
+        }
+
+        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,
+            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
+
+      # 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
+
+      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
+
+        # Mongoid 7.3+
+        if defined?(Mongoid::Association::Referenced::HasMany::Enumerable)
+          add(Mongoid::Association::Referenced::HasMany::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,226 @@
+# 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
+        if @has_previous_page.nil?
+          @has_previous_page = if after_offset && after_offset > 0
+            true
+          elsif last
+            # See whether there are any nodes _before_ the current offset.
+            # If there _is no_ current offset, then there can't be any nodes before it.
+            # Assume that if the offset is positive, there are nodes before the offset.
+            limited_nodes
+            !(@paged_nodes_offset.nil? || @paged_nodes_offset == 0)
+          else
+            false
+          end
+        end
+        @has_previous_page
+      end
+
+      def has_next_page
+        if @has_next_page.nil?
+          @has_next_page = if before_offset && before_offset > 0
+            true
+          elsif first
+            if @nodes && @nodes.count < first
+              false
+            else
+              relation_larger_than(sliced_nodes, @sliced_nodes_offset, first)
+            end
+          else
+            false
+          end
+        end
+        @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)
+        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)
+        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
+
+      def calculate_sliced_nodes_parameters
+        if defined?(@sliced_nodes_limit)
+          return
+        else
+          next_offset = relation_offset(items) || 0
+          if after_offset
+            next_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
+              relation_limit = space_between
+            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
+          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
+          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.nil? || relation_limit > first)
+            # `first` would create a stricter limit that the one already applied, so add it
+            relation_limit = first
+          end
+
+          if last
+            if relation_limit
+              if last <= relation_limit
+                # `last` is a smaller slice than the current limit, so apply it
+                relation_offset += (relation_limit - last)
+                relation_limit = last
+              end
+            else
+              # No limit, so get the last items
+              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 = 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
+
+      # Load nodes after applying first/last/before/after,
+      # returns an array of nodes
+      def load_nodes
+        # Return an array so we can consistently use `.index(node)` on it
+        @nodes ||= limited_nodes.to_a
+      end
+    end
+  end
+end

data/lib/graphql/pagination/sequel_dataset_connection.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require "graphql/pagination/relation_connection"
+
+module GraphQL
+  module Pagination
+    # Customizes `RelationConnection` to work with `Sequel::Dataset`s.
+    class SequelDatasetConnection < Pagination::RelationConnection
+      private
+
+      def relation_offset(relation)
+        relation.opts[:offset]
+      end
+
+      def relation_limit(relation)
+        relation.opts[:limit]
+      end
+
+      def relation_count(relation)
+        # Remove order to make it faster
+        relation.order(nil).count
+      end
+
+      def null_relation(relation)
+        relation.where(false)
+      end
+    end
+  end
+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/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