graphql 1.13.17 → 2.0.20

data/lib/graphql/pagination/active_record_relation_connection.rb

@@ -7,14 +7,6 @@ module GraphQL
     class ActiveRecordRelationConnection < Pagination::RelationConnection
       private
 
-      def relation_larger_than(relation, initial_offset, size)
-        if already_loaded?(relation)
-          (relation.size + initial_offset) > size
-        else
-          set_offset(sliced_nodes, initial_offset + size).exists?
-        end
-      end
-
       def relation_count(relation)
         int_or_hash = if already_loaded?(relation)
           relation.size

data/lib/graphql/pagination/array_connection.rb

@@ -35,9 +35,11 @@ module GraphQL
       def load_nodes
         @nodes ||= begin
           sliced_nodes = if before && after
-            items[index_from_cursor(after)..index_from_cursor(before)-1] || []
+            end_idx = index_from_cursor(before)-1
+            end_idx < 0 ? [] : items[index_from_cursor(after)..end_idx] || []
           elsif before
-            items[0..index_from_cursor(before)-2] || []
+            end_idx = index_from_cursor(before)-2
+            end_idx < 0 ? [] : items[0..end_idx] || []
           elsif after
             items[index_from_cursor(after)..-1] || []
           else

data/lib/graphql/pagination/connection.rb

@@ -56,8 +56,9 @@ module GraphQL
       # @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.
-      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil, arguments: nil)
+      # @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.
+      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, default_page_size: :not_given, last: nil, before: nil, edge_class: nil, arguments: nil)
         @items = items
         @parent = parent
         @context = context
@@ -76,6 +77,12 @@ module GraphQL
         else
           max_page_size
         end
+        @has_default_page_size_override = default_page_size != :not_given
+        @default_page_size = if default_page_size == :not_given
+          nil
+        else
+          default_page_size
+        end
       end
 
       def max_page_size=(new_value)
@@ -95,16 +102,36 @@ module GraphQL
         @has_max_page_size_override
       end
 
+      def default_page_size=(new_value)
+        @has_default_page_size_override = true
+        @default_page_size = new_value
+      end
+
+      def default_page_size
+        if @has_default_page_size_override
+          @default_page_size
+        else
+          context.schema.default_page_size
+        end
+      end
+
+      def has_default_page_size_override?
+        @has_default_page_size_override
+      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.
+      #   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`.
       def first
         @first ||= begin
           capped = limit_pagination_argument(@first_value, max_page_size)
           if capped.nil? && last.nil?
-            capped = max_page_size
+            capped = limit_pagination_argument(default_page_size, max_page_size) || max_page_size
           end
           capped
         end

data/lib/graphql/pagination/connections.rb

@@ -21,13 +21,6 @@ module GraphQL
       class ImplementationMissingError < GraphQL::Error
       end
 
-      def self.use(schema_defn)
-        if schema_defn.plugins.any? { |(plugin, args)| plugin == self }
-          GraphQL::Deprecation.warn("#{self} is now the default, remove `use #{self}` from #{caller(2,1).first}")
-        end
-        schema_defn.connections = self.new(schema: schema_defn)
-      end
-
       def initialize(schema:)
         @schema = schema
         @wrappers = {}
@@ -77,6 +70,7 @@ module GraphQL
             parent: parent,
             field: field,
             max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
+            default_page_size: field.has_default_page_size? ? field.default_page_size : context.schema.default_page_size,
             first: arguments[:first],
             after: arguments[:after],
             last: arguments[:last],
@@ -85,26 +79,7 @@ module GraphQL
             edge_class: edge_class_for_field(field),
           )
         else
-          begin
-            connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(items)
-            if parent.is_a?(GraphQL::Schema::Object)
-              parent = parent.object
-            end
-            connection_class.new(
-              items,
-              arguments,
-              field: field,
-              max_page_size: field.max_page_size,
-              parent: parent,
-              context: context,
-            )
-          rescue RuntimeError => err
-            if err.message.include?("No connection implementation to wrap")
-              raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
-            else
-              raise err
-            end
-          end
+          raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
         end
       end
 
@@ -113,7 +88,7 @@ module GraphQL
       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 != Relay::Edge
+        if conn_type_edge_type && conn_type_edge_type != Pagination::Connection::Edge
           conn_type_edge_type
         else
           nil

data/lib/graphql/pagination/relation_connection.rb

@@ -117,6 +117,8 @@ module GraphQL
           return
         else
           next_offset = relation_offset(items) || 0
+          relation_limit = relation_limit(items)
+
           if after_offset
             next_offset += after_offset
           end

data/lib/graphql/query/context.rb

@@ -5,49 +5,10 @@ module GraphQL
     # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
     class Context
       module SharedMethods
-        # @return [Object] The target for field resolution
-        attr_accessor :object
-
-        # @return [Hash, Array, String, Integer, Float, Boolean, nil] The resolved value for this field
-        attr_reader :value
-
-        # @return [Boolean] were any fields of this selection skipped?
-        attr_reader :skipped
-        alias :skipped? :skipped
-
-        # @api private
-        attr_writer :skipped
-
         # Return this value to tell the runtime
         # to exclude this field from the response altogether
         def skip
-          GraphQL::Execution::Execute::SKIP
-        end
-
-        # @return [Boolean] True if this selection has been nullified by a null child
-        def invalid_null?
-          @invalid_null
-        end
-
-        # Remove this child from the result value
-        # (used for null propagation and skip)
-        # @api private
-        def delete_child(child_ctx)
-          @value.delete(child_ctx.key)
-        end
-
-        # Create a child context to use for `key`
-        # @param key [String, Integer] The key in the response (name or index)
-        # @param irep_node [InternalRepresentation::Node] The node being evaluated
-        # @api private
-        def spawn_child(key:, irep_node:, object:)
-          FieldResolutionContext.new(
-            @context,
-            key,
-            irep_node,
-            self,
-            object
-          )
+          GraphQL::Execution::SKIP
         end
 
         # Add error at query-level.
@@ -72,12 +33,6 @@ module GraphQL
         def execution_errors
           @execution_errors ||= ExecutionErrors.new(self)
         end
-
-        def lookahead
-          ast_nodes = irep_node.ast_nodes
-          field = irep_node.definition.metadata[:type_class] || raise("Lookahead is only compatible with class-based schemas")
-          Execution::Lookahead.new(query: query, ast_nodes: ast_nodes, field: field)
-        end
       end
 
       class ExecutionErrors
@@ -105,27 +60,6 @@ module GraphQL
       include SharedMethods
       extend Forwardable
 
-      attr_reader :execution_strategy
-      # `strategy` is required by GraphQL::Batch
-      alias_method :strategy, :execution_strategy
-
-      def execution_strategy=(new_strategy)
-        # GraphQL::Batch re-assigns this value but it was previously not used
-        # (ExecutionContext#strategy was used instead)
-        # now it _is_ used, but it breaks GraphQL::Batch tests
-        @execution_strategy ||= new_strategy
-      end
-
-      # @return [GraphQL::InternalRepresentation::Node] The internal representation for this query node
-      def irep_node
-        @irep_node ||= query.irep_selection
-      end
-
-      # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
-      def ast_node
-        @irep_node.ast_node
-      end
-
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
       attr_reader :errors
 
@@ -152,8 +86,106 @@ module GraphQL
         @errors = []
         @path = []
         @value = nil
-        @context = self # for SharedMethods
-        @scoped_context = {}
+        @context = self # for SharedMethods TODO delete sharedmethods
+        @scoped_context = ScopedContext.new(self)
+      end
+
+      class ScopedContext
+        NO_PATH = [].freeze
+        NO_CONTEXT = {}.freeze
+
+        def initialize(query_context)
+          @query_context = query_context
+          @scoped_contexts = nil
+          @all_keys = nil
+        end
+
+        def merged_context
+          if @scoped_contexts.nil?
+            NO_CONTEXT
+          else
+            merged_ctx = {}
+            each_present_path_ctx do |path_ctx|
+              merged_ctx = path_ctx.merge(merged_ctx)
+            end
+            merged_ctx
+          end
+        end
+
+        def merge!(hash)
+          @all_keys ||= Set.new
+          @all_keys.merge(hash.keys)
+          ctx = @scoped_contexts ||= {}
+          current_path.each do |path_part|
+            ctx = ctx[path_part] ||= { parent: ctx }
+          end
+          this_scoped_ctx = ctx[:scoped_context] ||= {}
+          this_scoped_ctx.merge!(hash)
+        end
+
+        def key?(key)
+          if @all_keys && @all_keys.include?(key)
+            each_present_path_ctx do |path_ctx|
+              if path_ctx.key?(key)
+                return true
+              end
+            end
+          end
+          false
+        end
+
+        def [](key)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              return path_ctx[key]
+            end
+          end
+          nil
+        end
+
+        def current_path
+          @query_context.current_path || NO_PATH
+        end
+
+        def dig(key, *other_keys)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              found_value = path_ctx[key]
+              if other_keys.any?
+                return found_value.dig(*other_keys)
+              else
+                return found_value
+              end
+            end
+          end
+          nil
+        end
+
+        private
+
+        # Start at the current location,
+        # but look up the tree for previously-assigned scoped values
+        def each_present_path_ctx
+          ctx = @scoped_contexts
+          if ctx.nil?
+            # no-op
+          else
+            current_path.each do |path_part|
+              if ctx.key?(path_part)
+                ctx = ctx[path_part]
+              else
+                break
+              end
+            end
+
+            while ctx
+              if (scoped_ctx = ctx[:scoped_context])
+                yield(scoped_ctx)
+              end
+              ctx = ctx[:parent]
+            end
+          end
+        end
       end
 
       # @return [Hash] A hash that will be added verbatim to the result hash, as `"extensions" => { ... }`
@@ -172,7 +204,7 @@ module GraphQL
       attr_writer :value
 
       # @api private
-      attr_accessor :scoped_context
+      attr_reader :scoped_context
 
       def []=(key, value)
         @provided_values[key] = value
@@ -180,13 +212,39 @@ module GraphQL
 
       def_delegators :@query, :trace, :interpreter?
 
+      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path])
       # @!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]
+        if @scoped_context.key?(key)
+          @scoped_context[key]
+        elsif @provided_values.key?(key)
+          @provided_values[key]
+        elsif RUNTIME_METADATA_KEYS.include?(key)
+          if key == :current_path
+            current_path
+          else
+            thread_info = Thread.current[:__graphql_runtime_info]
+            thread_info && thread_info[key]
+          end
+        else
+          # not found
+          nil
+        end
+      end
+
+      def current_path
+        thread_info = Thread.current[:__graphql_runtime_info]
+        path = thread_info &&
+          (result = thread_info[:current_result]) &&
+          (result.path)
+        if path && (rn = thread_info[:current_result_name])
+          path = path.dup
+          path.push(rn)
+        end
+        path
       end
 
       def delete(key)
@@ -200,8 +258,11 @@ module GraphQL
       UNSPECIFIED_FETCH_DEFAULT = Object.new
 
       def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
-        if @scoped_context.key?(key)
-          @scoped_context[key]
+        if RUNTIME_METADATA_KEYS.include?(key)
+          (thread_info = Thread.current[:__graphql_runtime_info]) &&
+            thread_info[key]
+        elsif @scoped_context.key?(key)
+          scoped_context[key]
         elsif @provided_values.key?(key)
           @provided_values[key]
         elsif default != UNSPECIFIED_FETCH_DEFAULT
@@ -214,12 +275,24 @@ module GraphQL
       end
 
       def dig(key, *other_keys)
-        @scoped_context.key?(key) ? @scoped_context.dig(key, *other_keys) : @provided_values.dig(key, *other_keys)
+        if RUNTIME_METADATA_KEYS.include?(key)
+          (thread_info = Thread.current[:__graphql_runtime_info]).key?(key) &&
+            thread_info.dig(key, *other_keys)
+        elsif @scoped_context.key?(key)
+          @scoped_context.dig(key, *other_keys)
+        else
+          @provided_values.dig(key, *other_keys)
+        end
       end
 
       def to_h
-        @provided_values.merge(@scoped_context)
+        if (current_scoped_context = @scoped_context.merged_context)
+          @provided_values.merge(current_scoped_context)
+        else
+          @provided_values
+        end
       end
+
       alias :to_hash :to_h
 
       def key?(key)
@@ -238,7 +311,11 @@ module GraphQL
       # @param ns [Object] a usage-specific namespace identifier
       # @return [Hash] namespaced storage
       def namespace(ns)
-        @storage[ns]
+        if ns == :interpreter
+          self
+        else
+          @storage[ns]
+        end
       end
 
       # @return [Boolean] true if this namespace was accessed before
@@ -250,132 +327,14 @@ module GraphQL
         "#<Query::Context ...>"
       end
 
-      # @api private
-      def received_null_child
-        @invalid_null = true
-        @value = nil
-      end
-
       def scoped_merge!(hash)
-        @scoped_context = @scoped_context.merge(hash)
+        @scoped_context.merge!(hash)
       end
 
       def scoped_set!(key, value)
         scoped_merge!(key => value)
         nil
       end
-
-      class FieldResolutionContext
-        include SharedMethods
-        include Tracing::Traceable
-        extend Forwardable
-
-        attr_reader :irep_node, :field, :parent_type, :query, :schema, :parent, :key, :type
-        alias :selection :irep_node
-
-        def initialize(context, key, irep_node, parent, object)
-          @context = context
-          @key = key
-          @parent = parent
-          @object = object
-          @irep_node = irep_node
-          @field = irep_node.definition
-          @parent_type = irep_node.owner_type
-          @type = field.type
-          # This is needed constantly, so set it ahead of time:
-          @query = context.query
-          @schema = context.schema
-          @tracers = @query.tracers
-          # This hack flag is required by ConnectionResolve
-          @wrapped_connection = false
-          @wrapped_object = false
-        end
-
-        # @api private
-        attr_accessor :wrapped_connection, :wrapped_object
-
-        def path
-          @path ||= @parent.path.dup << @key
-        end
-
-        def_delegators :@context,
-          :[], :[]=, :key?, :fetch, :to_h, :namespace, :dig,
-          :spawn, :warden, :errors,
-          :execution_strategy, :strategy, :interpreter?
-
-        # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
-        def ast_node
-          @irep_node.ast_node
-        end
-
-        # Add error to current field resolution.
-        # @param error [GraphQL::ExecutionError] an execution error
-        # @return [void]
-        def add_error(error)
-          super
-          error.ast_node ||= irep_node.ast_node
-          error.path ||= path
-          nil
-        end
-
-        def inspect
-          "#<GraphQL Context @ #{irep_node.owner_type.name}.#{field.name}>"
-        end
-
-        # Set a new value for this field in the response.
-        # It may be updated after resolving a {Lazy}.
-        # If it is {Execute::PROPAGATE_NULL}, tell the owner to propagate null.
-        # If it's {Execute::Execution::SKIP}, remove this field result from its parent
-        # @param new_value [Any] The GraphQL-ready value
-        # @api private
-        def value=(new_value)
-          case new_value
-          when GraphQL::Execution::Execute::PROPAGATE_NULL, nil
-            @invalid_null = true
-            @value = nil
-            if @type.kind.non_null?
-              @parent.received_null_child
-            end
-          when GraphQL::Execution::Execute::SKIP
-            @parent.skipped = true
-            @parent.delete_child(self)
-          else
-            @value = new_value
-          end
-        end
-
-        protected
-
-        def received_null_child
-          case @value
-          when Hash
-            self.value = GraphQL::Execution::Execute::PROPAGATE_NULL
-          when Array
-            if list_of_non_null_items?(@type)
-              self.value = GraphQL::Execution::Execute::PROPAGATE_NULL
-            end
-          when nil
-            # TODO This is a hack
-            # It was already nulled out but it's getting reassigned
-          else
-            raise "Unexpected value for received_null_child (#{self.value.class}): #{value}"
-          end
-        end
-
-        private
-
-        def list_of_non_null_items?(type)
-          case type
-          when GraphQL::NonNullType
-            # Unwrap [T]!
-            list_of_non_null_items?(type.of_type)
-          when GraphQL::ListType
-            type.of_type.is_a?(GraphQL::NonNullType)
-          else
-            raise "Unexpected list_of_non_null_items check: #{type}"
-          end
-        end
-      end
     end
   end
 end

data/lib/graphql/query/input_validation_result.rb

@@ -33,7 +33,7 @@ module GraphQL
       end
 
       def merge_result!(path, inner_result)
-        return if inner_result.valid?
+        return if inner_result.nil? || inner_result.valid?
 
         if inner_result.problems
           inner_result.problems.each do |p|

data/lib/graphql/query/null_context.rb

@@ -12,9 +12,6 @@ module GraphQL
       end
 
       class NullQuery
-        def with_error_handling
-          yield
-        end
       end
 
       class NullSchema < GraphQL::Schema