graphql 1.9.21 → 1.10.0.pre1

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,157 @@
+# 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
+
+      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
+
+          # Apply max page size if nothing else was applied
+          if max_page_size && !first && !last
+            if relation_limit(paginated_nodes).nil? || relation_limit(paginated_nodes) > max_page_size
+              paginated_nodes = set_limit(paginated_nodes, max_page_size)
+            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

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

@@ -134,6 +134,7 @@ module GraphQL
       @executed = false
 
       # TODO add a general way to define schema-level filters
+      # TODO also add this to schema dumps
       if @schema.respond_to?(:visible?)
         merge_filters(only: @schema.method(:visible?))
       end
@@ -299,13 +300,6 @@ module GraphQL
       with_prepared_ast { @subscription }
     end
 
-    # @api private
-    def with_error_handling
-      schema.error_handler.with_error_handling(context) do
-        yield
-      end
-    end
-
     private
 
     def find_operation(operations, operation_name)

data/lib/graphql/query/arguments.rb

@@ -11,6 +11,7 @@ module GraphQL
       def self.construct_arguments_class(argument_owner)
         argument_definitions = argument_owner.arguments
         argument_owner.arguments_class = Class.new(self) do
+          self.argument_owner = argument_owner
           self.argument_definitions = argument_definitions
 
           argument_definitions.each do |_arg_name, arg_definition|
@@ -87,10 +88,6 @@ module GraphQL
 
       def_delegators :to_h, :keys, :values, :each, :any?
 
-      def prepare
-        self
-      end
-
       # Access each key, value and type for the arguments in this set.
       # @yield [argument_value] The {ArgumentValue} for each argument
       # @yieldparam argument_value [ArgumentValue]
@@ -101,7 +98,7 @@ module GraphQL
       end
 
       class << self
-        attr_accessor :argument_definitions
+        attr_accessor :argument_definitions, :argument_owner
       end
 
       NoArguments = Class.new(self) do
@@ -122,8 +119,6 @@ module GraphQL
         ruby_kwargs
       end
 
-      alias :to_hash :to_kwargs
-
       private
 
       class ArgumentValue
@@ -156,8 +151,7 @@ module GraphQL
             wrap_value(value, arg_defn_type.of_type, context)
           when GraphQL::InputObjectType
             if value.is_a?(Hash)
-              result = arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
-              result.prepare
+              arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
             else
               value
             end

data/lib/graphql/query/context.rb

@@ -143,9 +143,9 @@ module GraphQL
       # Make a new context which delegates key lookup to `values`
       # @param query [GraphQL::Query] the query who owns this context
       # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
-      def initialize(query:, schema: query.schema, values:, object:)
+      def initialize(query:, values: , object:)
         @query = query
-        @schema = schema
+        @schema = query.schema
         @provided_values = values || {}
         @object = object
         # Namespaced storage, where user-provided values are in `nil` namespace:
@@ -155,7 +155,6 @@ module GraphQL
         @path = []
         @value = nil
         @context = self # for SharedMethods
-        @scoped_context = {}
       end
 
       # @api private
@@ -164,30 +163,15 @@ module GraphQL
       # @api private
       attr_writer :value
 
-      # @api private
-      attr_accessor :scoped_context
-
-      def_delegators :@provided_values, :[]=
-      def_delegators :to_h, :fetch, :dig
+      def_delegators :@provided_values, :[], :[]=, :to_h, :to_hash, :key?, :fetch, :dig
       def_delegators :@query, :trace, :interpreter?
 
+      # @!method [](key)
+      #   Lookup `key` from the hash passed to {Schema#execute} as `context:`
+
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 
-      # Lookup `key` from the hash passed to {Schema#execute} as `context:`
-      def [](key)
-        return @scoped_context[key] if @scoped_context.key?(key)
-        @provided_values[key]
-      end
-
-      def to_h
-        @provided_values.merge(@scoped_context)
-      end
-      alias :to_hash :to_h
-
-      def key?(key)
-        @scoped_context.key?(key) || @provided_values.key?(key)
-      end
 
       # @return [GraphQL::Schema::Warden]
       def warden
@@ -211,15 +195,6 @@ module GraphQL
         @value = nil
       end
 
-      def scoped_merge!(hash)
-        @scoped_context = @scoped_context.merge(hash)
-      end
-
-      def scoped_set!(key, value)
-        scoped_merge!(key => value)
-        nil
-      end
-
       class FieldResolutionContext
         include SharedMethods
         include Tracing::Traceable
@@ -334,3 +309,6 @@ module GraphQL
     end
   end
 end
+
+
+GraphQL::Schema::Context = GraphQL::Query::Context

data/lib/graphql/query/literal_input.rb

@@ -12,8 +12,8 @@ module GraphQL
         when Language::Nodes::VariableIdentifier
           variables[ast_node.name]
         else
-          case type
-          when GraphQL::ScalarType
+          case type.kind.name
+          when "SCALAR"
             # TODO smell
             # This gets used for plain values during subscriber.trigger
             if variables
@@ -21,7 +21,7 @@ module GraphQL
             else
               type.coerce_isolated_input(ast_node)
             end
-          when GraphQL::EnumType
+          when "ENUM"
             # TODO smell
             # This gets used for plain values sometimes
             v = ast_node.is_a?(GraphQL::Language::Nodes::Enum) ? ast_node.name : ast_node
@@ -30,18 +30,20 @@ module GraphQL
             else
               type.coerce_isolated_input(v)
             end
-          when GraphQL::NonNullType
+          when "NON_NULL"
             LiteralInput.coerce(type.of_type, ast_node, variables)
-          when GraphQL::ListType
+          when "LIST"
             if ast_node.is_a?(Array)
               ast_node.map { |element_ast| LiteralInput.coerce(type.of_type, element_ast, variables) }
             else
               [LiteralInput.coerce(type.of_type, ast_node, variables)]
             end
-          when GraphQL::InputObjectType
+          when "INPUT_OBJECT"
             # TODO smell: handling AST vs handling plain Ruby
             next_args = ast_node.is_a?(Hash) ? ast_node : ast_node.arguments
             from_arguments(next_args, type, variables)
+          else
+            raise "Invariant: unexpected type to coerce to: #{type}"
           end
         end
       end
@@ -78,7 +80,10 @@ module GraphQL
             if (!value_is_a_variable || (value_is_a_variable && variables.key?(arg_value.name)))
 
               value = coerce(arg_defn.type, arg_value, variables)
-              value = arg_defn.prepare(value, context)
+              # Legacy `prepare` application
+              if arg_defn.is_a?(GraphQL::Argument)
+                value = arg_defn.prepare(value, context)
+              end
 
               if value.is_a?(GraphQL::ExecutionError)
                 value.ast_node = ast_arg
@@ -98,7 +103,9 @@ module GraphQL
             defaults_used << arg_name
             # `context` isn't present when pre-calculating defaults
             if context
-              value = arg_defn.prepare(value, context)
+              if arg_defn.is_a?(GraphQL::Argument)
+                value = arg_defn.prepare(value, context)
+              end
               if value.is_a?(GraphQL::ExecutionError)
                 value.ast_node = ast_arg
                 raise value
@@ -108,8 +115,20 @@ module GraphQL
           end
         end
 
-        result = argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
-        result.prepare
+        if argument_owner.is_a?(Class) || argument_owner.is_a?(GraphQL::Schema::Field)
+          # A Schema::InputObject, Schema::GraphQL::Field, Schema::Directive, logic from Query::Arguments#to_kwargs
+          ruby_kwargs = {}
+          values_hash.each do |key, value|
+            ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = value
+          end
+          if argument_owner.is_a?(Class) && argument_owner < GraphQL::Schema::InputObject
+            argument_owner.new(ruby_kwargs: ruby_kwargs, context: context, defaults_used: defaults_used)
+          else
+            ruby_kwargs
+          end
+        else
+          argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
+        end
       end
     end
   end

data/lib/graphql/query/null_context.rb

@@ -21,13 +21,9 @@ module GraphQL
         )
       end
 
-      def [](key); end
-
       class << self
         extend Forwardable
 
-        def [](key); end
-
         def instance
           @instance = self.new
         end