graphql 1.8.0 → 1.12.12

data/lib/graphql/pagination/relation_connection.rb

@@ -0,0 +1,196 @@
+# 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, 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 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)
+        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
+
+      # Apply `before` and `after` to the underlying `items`,
+      # returning a new relation.
+      def sliced_nodes
+        @sliced_nodes ||= begin
+          paginated_nodes = items
+
+          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
+
+          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 && (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
+
+          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
+              sliced_nodes_count = relation_count(@sliced_nodes)
+              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
+
+          @paged_nodes_offset = relation_offset(paginated_nodes)
+          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

data/lib/graphql/query/arguments.rb

@@ -6,28 +6,31 @@ module GraphQL
     # {Arguments} recursively wraps the input in {Arguments} instances.
     class Arguments
       extend Forwardable
+      include GraphQL::Dig
 
       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|
-            expose_as = arg_definition.expose_as.to_s
-            expose_as_underscored = GraphQL::Schema::Member::BuildType.underscore(expose_as)
-            method_names = [expose_as, expose_as_underscored].uniq
-            method_names.each do |method_name|
-              # Don't define a helper method if it would override something.
-              if instance_methods.include?(method_name)
-                warn(
-                  "Unable to define a helper for argument with name '#{method_name}' "\
-                  "as this is a reserved name. If you're using an argument such as "\
-                  "`argument #{method_name}`, consider renaming this argument.`"
-                )
-              else
-                define_method(method_name) do
-                  # Always use `expose_as` here, since #[] doesn't accept underscored names
-                  self[expose_as]
+            if arg_definition.method_access?
+              expose_as = arg_definition.expose_as.to_s.freeze
+              expose_as_underscored = GraphQL::Schema::Member::BuildType.underscore(expose_as).freeze
+              method_names = [expose_as, expose_as_underscored].uniq
+              method_names.each do |method_name|
+                # Don't define a helper method if it would override something.
+                if method_defined?(method_name)
+                  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."
+                  )
+                else
+                  define_method(method_name) do
+                    # Always use `expose_as` here, since #[] doesn't accept underscored names
+                    self[expose_as]
+                  end
                 end
               end
             end
@@ -35,10 +38,12 @@ module GraphQL
         end
       end
 
+      attr_reader :argument_values
+
       def initialize(values, context:, defaults_used:)
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
           arg_name = inner_key.to_s
-          arg_defn = self.class.argument_definitions[arg_name]
+          arg_defn = self.class.argument_definitions[arg_name] || raise("Not found #{arg_name} among #{self.class.argument_definitions.keys}")
           arg_default_used = defaults_used.include?(arg_name)
           arg_value = wrap_value(inner_value, arg_defn.type, context)
           string_key = arg_defn.expose_as
@@ -81,7 +86,12 @@ 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
+      end
 
       # Access each key, value and type for the arguments in this set.
       # @yield [argument_value] The {ArgumentValue} for each argument
@@ -93,7 +103,7 @@ module GraphQL
       end
 
       class << self
-        attr_accessor :argument_definitions
+        attr_accessor :argument_definitions, :argument_owner
       end
 
       NoArguments = Class.new(self) do
@@ -114,6 +124,8 @@ module GraphQL
         ruby_kwargs
       end
 
+      alias :to_hash :to_kwargs
+
       private
 
       class ArgumentValue
@@ -146,7 +158,8 @@ module GraphQL
             wrap_value(value, arg_defn_type.of_type, context)
           when GraphQL::InputObjectType
             if value.is_a?(Hash)
-              arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
+              result = arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
+              result.prepare
             else
               value
             end
@@ -165,7 +178,7 @@ module GraphQL
             memo[key] = unwrap_value(value)
             memo
           end
-        when GraphQL::Query::Arguments
+        when GraphQL::Query::Arguments, GraphQL::Schema::InputObject
           value.to_h
         else
           value

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.none?
+            h2[definition] = if definition.arguments.empty?
               GraphQL::Query::Arguments::NO_ARGS
             else
               GraphQL::Query::LiteralInput.from_arguments(

data/lib/graphql/query/context.rb

@@ -1,13 +1,11 @@
 # 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.
     # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
     class Context
       module SharedMethods
-        # @return [Object] The target for field resultion
+        # @return [Object] The target for field resolution
         attr_accessor :object
 
         # @return [Hash, Array, String, Integer, Float, Boolean, nil] The resolved value for this field
@@ -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
 
@@ -44,11 +42,11 @@ module GraphQL
         # @api private
         def spawn_child(key:, irep_node:, object:)
           FieldResolutionContext.new(
-            context: @context,
-            parent: self,
-            object: object,
-            key: key,
-            irep_node: irep_node,
+            @context,
+            key,
+            irep_node,
+            self,
+            object
           )
         end
 
@@ -74,6 +72,12 @@ 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
@@ -137,9 +141,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:, values: , object:)
+      def initialize(query:, schema: query.schema, values:, object:)
         @query = query
-        @schema = query.schema
+        @schema = schema
         @provided_values = values || {}
         @object = object
         # Namespaced storage, where user-provided values are in `nil` namespace:
@@ -149,20 +153,73 @@ module GraphQL
         @path = []
         @value = nil
         @context = self # for SharedMethods
+        @scoped_context = {}
+      end
+
+      def dataloader
+        @dataloader ||= query.multiplex ? query.multiplex.dataloader : schema.dataloader_class.new
       end
 
+      # @api private
+      attr_writer :interpreter
+
       # @api private
       attr_writer :value
 
-      def_delegators :@provided_values, :[], :[]=, :to_h, :key?, :fetch
-      def_delegators :@query, :trace
+      # @api private
+      attr_accessor :scoped_context
 
-      # @!method [](key)
-      #   Lookup `key` from the hash passed to {Schema#execute} as `context:`
+      def []=(key, value)
+        @provided_values[key] = value
+      end
+
+      def_delegators :@query, :trace, :interpreter?
 
       # @!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 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
+      alias :to_hash :to_h
+
+      def key?(key)
+        @scoped_context.key?(key) || @provided_values.key?(key)
+      end
 
       # @return [GraphQL::Schema::Warden]
       def warden
@@ -186,6 +243,15 @@ 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
@@ -194,7 +260,7 @@ module GraphQL
         attr_reader :irep_node, :field, :parent_type, :query, :schema, :parent, :key, :type
         alias :selection :irep_node
 
-        def initialize(context:, key:, irep_node:, parent:, object:)
+        def initialize(context, key, irep_node, parent, object)
           @context = context
           @key = key
           @parent = parent
@@ -207,16 +273,22 @@ module GraphQL
           @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,
-          :spawn, :schema, :warden, :errors,
-          :execution_strategy, :strategy
+          :[], :[]=, :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
@@ -253,7 +325,7 @@ module GraphQL
             end
           when GraphQL::Execution::Execute::SKIP
             @parent.skipped = true
-            @parent.delete(self)
+            @parent.delete_child(self)
           else
             @value = new_value
           end
@@ -294,6 +366,3 @@ module GraphQL
     end
   end
 end
-
-
-GraphQL::Schema::Context = GraphQL::Query::Context

data/lib/graphql/query/executor.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../query.rb
 module GraphQL
   class Query
     class Executor
@@ -12,7 +11,7 @@ module GraphQL
         @query = query
       end
 
-      # Evalute {operation_name} on {query}.
+      # Evaluate {operation_name} on {query}.
       # Handle {GraphQL::ExecutionError}s by putting them in the "errors" key.
       # @return [Hash] A GraphQL response, with either a "data" key or an "errors" key
       def result

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