graphql 1.10.1 → 1.13.0

data/lib/graphql/pagination/connections.rb

@@ -6,20 +6,13 @@ module GraphQL
     #
     # 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
     #
@@ -29,17 +22,14 @@ module GraphQL
       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
+        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
+      def initialize(schema:)
+        @schema = schema
         @wrappers = {}
         add_default
       end
@@ -52,29 +42,86 @@ module GraphQL
         @wrappers.delete(nodes_class)
       end
 
-      # Used by the runtime to wrap values in connection wrappers.
-      # @api Private
-      def wrap(field, object, arguments, context)
+      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
-        object.class.ancestors.each { |cls|
-          impl = @wrappers[cls]
+
+        items.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})"
+        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
+          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
         end
+      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],
-        )
+      # 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 != Relay::Edge
+          conn_type_edge_type
+        else
+          nil
+        end
       end
+      protected
+
+      attr_reader :wrappers
 
       private
 
@@ -102,6 +149,11 @@ module GraphQL
         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

data/lib/graphql/pagination/relation_connection.rb

@@ -12,7 +12,7 @@ module GraphQL
 
       def has_previous_page
         if @has_previous_page.nil?
-          @has_previous_page = if @after_offset && @after_offset > 0
+          @has_previous_page = if after_offset && after_offset > 0
             true
           elsif last
             # See whether there are any nodes _before_ the current offset.
@@ -29,10 +29,14 @@ module GraphQL
 
       def has_next_page
         if @has_next_page.nil?
-          @has_next_page = if @before_offset && @before_offset > 0
+          @has_next_page = if before_offset && before_offset > 0
             true
           elsif first
-            relation_count(set_limit(sliced_nodes, first + 1)) == first + 1
+            if @nodes && @nodes.count < first
+              false
+            else
+              relation_larger_than(sliced_nodes, first)
+            end
           else
             false
           end
@@ -44,11 +48,18 @@ module GraphQL
         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)
+        encode(offset.to_s)
       end
 
       private
 
+      # @param relation [Object] A database query object
+      # @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, 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)
@@ -105,40 +116,49 @@ module GraphQL
       def sliced_nodes
         @sliced_nodes ||= begin
           paginated_nodes = items
-          @after_offset = after && offset_from_cursor(after)
-          @before_offset = before && offset_from_cursor(before)
 
-          if @after_offset
+          if after_offset
             previous_offset = relation_offset(items) || 0
-            paginated_nodes = set_offset(paginated_nodes, previous_offset + @after_offset)
+            paginated_nodes = set_offset(paginated_nodes, previous_offset + after_offset)
           end
 
-          if @before_offset && @after_offset
-            if @after_offset < @before_offset
+          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
+              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
+          elsif before_offset
             # Use limit to cut off the tail of the relation
-            paginated_nodes = set_limit(paginated_nodes, @before_offset - 1)
+            paginated_nodes = set_limit(paginated_nodes, before_offset - 1)
           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
           paginated_nodes = sliced_nodes
+          previous_limit = relation_limit(paginated_nodes)
 
-          if first && (relation_limit(paginated_nodes).nil? || relation_limit(paginated_nodes) > first) && last.nil?
+          if first && (previous_limit.nil? || previous_limit > first)
             # `first` would create a stricter limit that the one already applied, so add it
             paginated_nodes = set_limit(paginated_nodes, first)
           end

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

data/lib/graphql/query/arguments.rb

@@ -9,7 +9,7 @@ module GraphQL
       include GraphQL::Dig
 
       def self.construct_arguments_class(argument_owner)
-        argument_definitions = argument_owner.arguments
+        argument_definitions = argument_owner.arguments # rubocop:disable Development/ContextIsPassedCop -- legacy-related
         argument_owner.arguments_class = Class.new(self) do
           self.argument_owner = argument_owner
           self.argument_definitions = argument_definitions
@@ -22,7 +22,7 @@ module GraphQL
               method_names.each do |method_name|
                 # Don't define a helper method if it would override something.
                 if method_defined?(method_name)
-                  warn(
+                  GraphQL::Deprecation.warn(
                     "Unable to define a helper for argument with name '#{method_name}' "\
                     "as this is a reserved name. Add `method_access: false` to stop this warning."
                   )
@@ -86,7 +86,8 @@ module GraphQL
         end
       end
 
-      def_delegators :to_h, :keys, :values, :each, :any?
+      def_delegators :to_h, :keys, :values, :each
+      def_delegators :@argument_values, :any?
 
       def prepare
         self

data/lib/graphql/query/arguments_cache.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../query.rb
 module GraphQL
   class Query
     module ArgumentsCache
@@ -8,7 +7,7 @@ module GraphQL
         Hash.new do |h1, irep_or_ast_node|
           h1[irep_or_ast_node] = Hash.new do |h2, definition|
             ast_node = irep_or_ast_node.is_a?(GraphQL::InternalRepresentation::Node) ? irep_or_ast_node.ast_node : irep_or_ast_node
-            h2[definition] = if definition.arguments.empty?
+            h2[definition] = if definition.arguments(query.context).empty?
               GraphQL::Query::Arguments::NO_ARGS
             else
               GraphQL::Query::LiteralInput.from_arguments(

data/lib/graphql/query/context.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../execution/execute.rb
-# test_via: ../execution/lazy.rb
 module GraphQL
   class Query
     # Expose some query-specific info to field resolve functions.
@@ -34,7 +32,7 @@ module GraphQL
         # Remove this child from the result value
         # (used for null propagation and skip)
         # @api private
-        def delete(child_ctx)
+        def delete_child(child_ctx)
           @value.delete(child_ctx.key)
         end
 
@@ -158,6 +156,10 @@ module GraphQL
         @scoped_context = {}
       end
 
+      def dataloader
+        @dataloader ||= self[:dataloader] || (query.multiplex ? query.multiplex.dataloader : schema.dataloader_class.new)
+      end
+
       # @api private
       attr_writer :interpreter
 
@@ -167,8 +169,10 @@ module GraphQL
       # @api private
       attr_accessor :scoped_context
 
-      def_delegators :@provided_values, :[]=
-      def_delegators :to_h, :fetch, :dig
+      def []=(key, value)
+        @provided_values[key] = value
+      end
+
       def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)
@@ -180,6 +184,34 @@ module GraphQL
         @provided_values[key]
       end
 
+      def delete(key)
+        if @scoped_context.key?(key)
+          @scoped_context.delete(key)
+        else
+          @provided_values.delete(key)
+        end
+      end
+
+      UNSPECIFIED_FETCH_DEFAULT = Object.new
+
+      def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
+        if @scoped_context.key?(key)
+          @scoped_context[key]
+        elsif @provided_values.key?(key)
+          @provided_values[key]
+        elsif default != UNSPECIFIED_FETCH_DEFAULT
+          default
+        elsif block_given?
+          yield(self, key)
+        else
+          raise KeyError.new(key: key)
+        end
+      end
+
+      def dig(key, *other_keys)
+        @scoped_context.key?(key) ? @scoped_context.dig(key, *other_keys) : @provided_values.dig(key, *other_keys)
+      end
+
       def to_h
         @provided_values.merge(@scoped_context)
       end
@@ -191,9 +223,12 @@ module GraphQL
 
       # @return [GraphQL::Schema::Warden]
       def warden
-        @warden ||= @query.warden
+        @warden ||= (@query && @query.warden)
       end
 
+      # @api private
+      attr_writer :warden
+
       # Get an isolated hash for `ns`. Doesn't affect user-provided storage.
       # @param ns [Object] a usage-specific namespace identifier
       # @return [Hash] namespaced storage
@@ -293,7 +328,7 @@ module GraphQL
             end
           when GraphQL::Execution::Execute::SKIP
             @parent.skipped = true
-            @parent.delete(self)
+            @parent.delete_child(self)
           else
             @value = new_value
           end

data/lib/graphql/query/executor.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../query.rb
 module GraphQL
   class Query
     class Executor

data/lib/graphql/query/fingerprint.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'digest/sha2'
+
+module GraphQL
+  class Query
+    # @api private
+    # @see Query#query_fingerprint
+    # @see Query#variables_fingerprint
+    # @see Query#fingerprint
+    module Fingerprint
+      # Make an obfuscated hash of the given string (either a query string or variables JSON)
+      # @param string [String]
+      # @return [String] A normalized, opaque hash
+      def self.generate(input_str)
+        # Implemented to be:
+        # - Short (and uniform) length
+        # - Stable
+        # - Irreversibly Opaque (don't want to leak variable values)
+        # - URL-friendly
+        bytes = Digest::SHA256.digest(input_str)
+        Base64.urlsafe_encode64(bytes)
+      end
+    end
+  end
+end

data/lib/graphql/query/input_validation_result.rb

@@ -4,22 +4,39 @@ module GraphQL
     class InputValidationResult
       attr_accessor :problems
 
+      def initialize(valid: true, problems: nil)
+        @valid = valid
+        @problems = problems
+      end
+
       def valid?
-        @problems.nil?
+        @valid
       end
 
-      def add_problem(explanation, path = nil)
+      def add_problem(explanation, path = nil, extensions: nil, message: nil)
         @problems ||= []
-        @problems.push({ "path" => path || [], "explanation" => explanation })
+        @valid = false
+        problem = { "path" => path || [], "explanation" => explanation }
+        if extensions
+          problem["extensions"] = extensions
+        end
+        if message
+          problem["message"] = message
+        end
+        @problems.push(problem)
       end
 
       def merge_result!(path, inner_result)
         return if inner_result.valid?
 
-        inner_result.problems.each do |p|
-          item_path = [path, *p["path"]]
-          add_problem(p["explanation"], item_path)
+        if inner_result.problems
+          inner_result.problems.each do |p|
+            item_path = [path, *p["path"]]
+            add_problem(p["explanation"], item_path, message: p["message"], extensions: p["extensions"])
+          end
         end
+        # It could have been explicitly set on inner_result (if it had no problems)
+        @valid = false
       end
     end
   end

data/lib/graphql/query/literal_input.rb

@@ -62,7 +62,7 @@ module GraphQL
           raise ArgumentError, "Unexpected ast_arguments: #{ast_arguments}"
         end
 
-        argument_defns = argument_owner.arguments
+        argument_defns = argument_owner.arguments(context || GraphQL::Query::NullContext)
         argument_defns.each do |arg_name, arg_defn|
           ast_arg = indexed_arguments[arg_name]
           # First, check the argument in the AST.

data/lib/graphql/query/null_context.rb

@@ -4,16 +4,28 @@ module GraphQL
     # This object can be `ctx` in places where there is no query
     class NullContext
       class NullWarden < GraphQL::Schema::Warden
-        def visible?(t); true; end
-        def visible_field?(t); true; end
-        def visible_type?(t); true; end
+        def visible_field?(field, ctx); true; end
+        def visible_argument?(arg, ctx); true; end
+        def visible_type?(type, ctx); true; end
+        def visible_enum_value?(ev, ctx); true; end
+        def visible_type_membership?(tm, ctx); true; end
       end
 
-      attr_reader :schema, :query, :warden
+      class NullQuery
+        def with_error_handling
+          yield
+        end
+      end
+
+      class NullSchema < GraphQL::Schema
+      end
+
+      attr_reader :schema, :query, :warden, :dataloader
 
       def initialize
-        @query = nil
-        @schema = GraphQL::Schema.new
+        @query = NullQuery.new
+        @dataloader = GraphQL::Dataloader::NullDataloader.new
+        @schema = NullSchema
         @warden = NullWarden.new(
           GraphQL::Filter.new,
           context: self,
@@ -23,16 +35,20 @@ module GraphQL
 
       def [](key); end
 
+      def interpreter?
+        true
+      end
+
       class << self
         extend Forwardable
 
         def [](key); end
 
         def instance
-          @instance = self.new
+          @instance ||= self.new
         end
 
-        def_delegators :instance, :query, :schema, :warden
+        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader
       end
     end
   end

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -81,7 +81,7 @@ module GraphQL
         # is added to the "errors" key.
         def get_raw_value
           begin
-            @field_ctx.schema.middleware.invoke([parent_type, target, field, arguments, @field_ctx])
+            @field_ctx.schema.middleware.invoke([parent_type, target, field, arguments, @field_ctx]) # rubocop:disable Development/ContextIsPassedCop -- unrelated
           rescue GraphQL::ExecutionError => err
             err
           end

data/lib/graphql/query/serial_execution.rb

@@ -16,6 +16,7 @@ module GraphQL
       # @param query_object [GraphQL::Query] the query object for this execution
       # @return [Hash] a spec-compliant GraphQL result, as a hash
       def execute(ast_operation, root_type, query_object)
+        GraphQL::Deprecation.warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
         operation_resolution.resolve(
           query_object.irep_selection,
           root_type,

data/lib/graphql/query/validation_pipeline.rb

@@ -36,7 +36,7 @@ module GraphQL
         @valid
       end
 
-      # @return [Array<GraphQL::StaticValidation::Error >] Static validation errors for the query string
+      # @return [Array<GraphQL::StaticValidation::Error, GraphQL::Query::VariableValidationError>] Static validation errors for the query string
       def validation_errors
         ensure_has_validated
         @validation_errors
@@ -72,7 +72,7 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @validate)
+          validation_result = @schema.static_validator.validate(@query, validate: @validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
           @internal_representation = validation_result[:irep]
 
@@ -90,6 +90,9 @@ module GraphQL
         end
 
         @valid = @validation_errors.empty?
+      rescue SystemStackError => err
+        @valid = false
+        @schema.query_stack_error(@query, err)
       end
 
       # If there are max_* values, add them,

data/lib/graphql/query/variable_validation_error.rb

@@ -23,7 +23,7 @@ module GraphQL
         # a one level deep merge explicitly. However beyond that only show the
         # latest value and problems.
         super.merge({ "extensions" => { "value" => value, "problems" => validation_result.problems }}) do |key, oldValue, newValue|
-          if oldValue.respond_to? merge
+          if oldValue.respond_to?(:merge)
             oldValue.merge(newValue)
           else
             newValue

data/lib/graphql/query/variables.rb

@@ -34,7 +34,9 @@ module GraphQL
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided
-                  memo[variable_name] = if provided_value.nil?
+                  memo[variable_name] = if ctx.interpreter?
+                    provided_value
+                  elsif provided_value.nil?
                     nil
                   else
                     schema.error_handler.with_error_handling(context) do
@@ -42,11 +44,19 @@ module GraphQL
                     end
                   end
                 elsif default_value != nil
-                  # Add the variable if it wasn't provided but it has a default value (including `null`)
-                  memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
+                  memo[variable_name] = if ctx.interpreter?
+                    if default_value.is_a?(Language::Nodes::NullValue)
+                      nil
+                    else
+                      default_value
+                    end
+                  else
+                    # Add the variable if it wasn't provided but it has a default value (including `null`)
+                    GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
+                  end
                 end
               end
-            rescue GraphQL::CoercionError, GraphQL::ExecutionError => ex
+            rescue GraphQL::ExecutionError => ex
               # TODO: This should really include the path to the problematic node in the variable value
               # like InputValidationResults generated by validate_non_null_input but unfortunately we don't
               # have this information available in the coerce_input call chain. Note this path is the path