graphql 0.16.0 → 2.0.15

data/lib/graphql/query/context.rb

@@ -1,15 +1,64 @@
+# frozen_string_literal: true
 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
-      attr_accessor :execution_strategy
+      module SharedMethods
+        # Return this value to tell the runtime
+        # to exclude this field from the response altogether
+        def skip
+          GraphQL::Execution::SKIP
+        end
 
-      # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
-      attr_accessor :ast_node
+        # Add error at query-level.
+        # @param error [GraphQL::ExecutionError] an execution error
+        # @return [void]
+        def add_error(error)
+          if !error.is_a?(ExecutionError)
+            raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
+          end
+          errors << error
+          nil
+        end
 
-      # @return [GraphQL::InternalRepresentation::Node] The internal representation for this query node
-      attr_accessor :irep_node
+        # @example Print the GraphQL backtrace during field resolution
+        #   puts ctx.backtrace
+        #
+        # @return [GraphQL::Backtrace] The backtrace for this point in query execution
+        def backtrace
+          GraphQL::Backtrace.new(self)
+        end
+
+        def execution_errors
+          @execution_errors ||= ExecutionErrors.new(self)
+        end
+      end
+
+      class ExecutionErrors
+        def initialize(ctx)
+          @context = ctx
+        end
+
+        def add(err_or_msg)
+          err = case err_or_msg
+          when String
+            GraphQL::ExecutionError.new(err_or_msg)
+          when GraphQL::ExecutionError
+            err_or_msg
+          else
+            raise ArgumentError, "expected String or GraphQL::ExecutionError, not #{err_or_msg.class} (#{err_or_msg.inspect})"
+          end
+          # This will assign ast_node and path
+          @context.add_error(err)
+        end
+
+        alias :>> :add
+        alias :push :add
+      end
+
+      include SharedMethods
+      extend Forwardable
 
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
       attr_reader :errors
@@ -20,24 +69,229 @@ module GraphQL
       # @return [GraphQL::Schema]
       attr_reader :schema
 
+      # @return [Array<String, Integer>] The current position in the result
+      attr_reader :path
+
       # 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:)
+      def initialize(query:, schema: query.schema, values:, object:)
         @query = query
-        @schema = query.schema
-        @values = values || {}
+        @schema = schema
+        @provided_values = values || {}
+        @object = object
+        # Namespaced storage, where user-provided values are in `nil` namespace:
+        @storage = Hash.new { |h, k| h[k] = {} }
+        @storage[nil] = @provided_values
         @errors = []
+        @path = []
+        @value = nil
+        @context = self # for SharedMethods TODO delete sharedmethods
+        @scoped_context = ScopedContext.new(self)
+      end
+
+      class ScopedContext
+        def initialize(query_context)
+          @query_context = query_context
+          @path_contexts = {}
+          @no_path = [].freeze
+        end
+
+        def merged_context
+          merged_ctx = {}
+          each_present_path_ctx do |path_ctx|
+            merged_ctx = path_ctx.merge(merged_ctx)
+          end
+          merged_ctx
+        end
+
+        def merge!(hash)
+          current_ctx = @path_contexts[current_path] ||= {}
+          current_ctx.merge!(hash)
+        end
+
+        def current_path
+          @query_context[:current_path] || @no_path
+        end
+
+        def key?(key)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              return true
+            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 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
+          search_path = current_path.dup
+          if (current_path_ctx = @path_contexts[search_path])
+            yield(current_path_ctx)
+          end
+
+          while search_path.size > 0
+            search_path.pop # look one level higher
+            if (search_path_ctx = @path_contexts[search_path])
+              yield(search_path_ctx)
+            end
+          end
+        end
+      end
+
+      # @return [Hash] A hash that will be added verbatim to the result hash, as `"extensions" => { ... }`
+      def response_extensions
+        namespace(:__query_result_extensions__)
       end
 
+      def dataloader
+        @dataloader ||= self[:dataloader] || (query.multiplex ? query.multiplex.dataloader : schema.dataloader_class.new)
+      end
+
+      # @api private
+      attr_writer :interpreter
+
+      # @api private
+      attr_writer :value
+
+      # @api private
+      attr_reader :scoped_context
+
+      def []=(key, value)
+        @provided_values[key] = value
+      end
+
+      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)
-        @values[key]
+        if RUNTIME_METADATA_KEYS.include?(key)
+          thread_info = Thread.current[:__graphql_runtime_info]
+          thread_info && thread_info[key]
+        elsif @scoped_context.key?(key)
+          @scoped_context[key]
+        else
+          @provided_values[key]
+        end
       end
 
-      # Reassign `key` to the hash passed to {Schema#execute} as `context:`
-      def []=(key, value)
-        @values[key] = value
+      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 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
+          default
+        elsif block_given?
+          yield(self, key)
+        else
+          raise KeyError.new(key: key)
+        end
+      end
+
+      def dig(key, *other_keys)
+        if RUNTIME_METADATA_KEYS.include?(key)
+          (thread_info = Thread.current[:__graphql_runtime_info]).key?(key) &&
+            thread_info.dig(key)
+        elsif @scoped_context.key?(key)
+          @scoped_context.dig(key, *other_keys)
+        else
+          @provided_values.dig(key, *other_keys)
+        end
+      end
+
+      def to_h
+        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)
+        @scoped_context.key?(key) || @provided_values.key?(key)
+      end
+
+      # @return [GraphQL::Schema::Warden]
+      def 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
+      def namespace(ns)
+        if ns == :interpreter
+          self
+        else
+          @storage[ns]
+        end
+      end
+
+      # @return [Boolean] true if this namespace was accessed before
+      def namespace?(ns)
+        @storage.key?(ns)
+      end
+
+      def inspect
+        "#<Query::Context ...>"
+      end
+
+      def scoped_merge!(hash)
+        @scoped_context.merge!(hash)
+      end
+
+      def scoped_set!(key, value)
+        scoped_merge!(key => value)
+        nil
       end
     end
   end

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

@@ -1,25 +1,52 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     class InputValidationResult
       attr_accessor :problems
 
+      def self.from_problem(explanation, path = nil, extensions: nil, message: nil)
+        result = self.new
+        result.add_problem(explanation, path, extensions: extensions, message: message)
+        result
+      end
+
+      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?
+        return if inner_result.nil? || 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
+
+      VALID = self.new
+      VALID.freeze
     end
   end
 end

data/lib/graphql/query/null_context.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # This object can be `ctx` in places where there is no query
+    class NullContext
+      class NullWarden < GraphQL::Schema::Warden
+        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
+
+      class NullQuery
+      end
+
+      class NullSchema < GraphQL::Schema
+      end
+
+      attr_reader :schema, :query, :warden, :dataloader
+
+      def initialize
+        @query = NullQuery.new
+        @dataloader = GraphQL::Dataloader::NullDataloader.new
+        @schema = NullSchema
+        @warden = NullWarden.new(
+          GraphQL::Filter.new,
+          context: self,
+          schema: @schema,
+        )
+      end
+
+      def [](key); end
+
+      def interpreter?
+        true
+      end
+
+      class << self
+        extend Forwardable
+
+        def [](key); end
+
+        def instance
+          @instance ||= self.new
+        end
+
+        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader
+      end
+    end
+  end
+end

data/lib/graphql/query/result.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Query
+    # A result from {Schema#execute}.
+    # It provides the requested data and
+    # access to the {Query} and {Query::Context}.
+    class Result
+      extend Forwardable
+
+      def initialize(query:, values:)
+        @query = query
+        @to_h = values
+      end
+
+      # @return [GraphQL::Query] The query that was executed
+      attr_reader :query
+
+      # @return [Hash] The resulting hash of "data" and/or "errors"
+      attr_reader :to_h
+
+      def_delegators :@query, :context, :mutation?, :query?, :subscription?
+
+      def_delegators :@to_h, :[], :keys, :values, :to_json, :as_json
+
+      # Delegate any hash-like method to the underlying hash.
+      def method_missing(method_name, *args, &block)
+        if @to_h.respond_to?(method_name)
+          @to_h.public_send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @to_h.respond_to?(method_name) || super
+      end
+
+      def inspect
+        "#<GraphQL::Query::Result @query=... @to_h=#{@to_h}>"
+      end
+
+      # A result is equal to another object when:
+      #
+      # - The other object is a Hash whose value matches `result.to_h`
+      # - The other object is a Result whose value matches `result.to_h`
+      #
+      # (The query is ignored for comparing result equality.)
+      #
+      # @return [Boolean]
+      def ==(other)
+        case other
+        when Hash
+          @to_h == other
+        when Query::Result
+          @to_h == other.to_h
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/validation_pipeline.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # Contain the validation pipeline and expose the results.
+    #
+    # 0. Checks in {Query#initialize}:
+    #   - Rescue a ParseError, halt if there is one
+    #   - Check for selected operation, halt if not found
+    # 1. Validate the AST, halt if errors
+    # 2. Validate the variables, halt if errors
+    # 3. Run query analyzers, halt if errors
+    #
+    # {#valid?} is false if any of the above checks halted the pipeline.
+    #
+    # @api private
+    class ValidationPipeline
+      attr_reader :max_depth, :max_complexity
+
+      def initialize(query:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
+        @validation_errors = []
+        @parse_error = parse_error
+        @operation_name_error = operation_name_error
+        @query = query
+        @schema = query.schema
+        @max_depth = max_depth
+        @max_complexity = max_complexity
+
+        @has_validated = false
+      end
+
+      # @return [Boolean] does this query have errors that should prevent it from running?
+      def valid?
+        ensure_has_validated
+        @valid
+      end
+
+      # @return [Array<GraphQL::StaticValidation::Error, GraphQL::Query::VariableValidationError>] Static validation errors for the query string
+      def validation_errors
+        ensure_has_validated
+        @validation_errors
+      end
+
+      def analyzers
+        ensure_has_validated
+        @query_analyzers
+      end
+
+      def has_validated?
+        @has_validated == true
+      end
+
+      private
+
+      # If the pipeline wasn't run yet, run it.
+      # If it was already run, do nothing.
+      def ensure_has_validated
+        return if @has_validated
+        @has_validated = true
+
+        if @parse_error
+          # This is kind of crazy: we push the parse error into `ctx`
+          # in `def self.parse_error` by default so that users can _opt out_ by redefining that hook.
+          # That means we can't _re-add_ the error here (otherwise we'd either
+          # add it twice _or_ override the user's choice to not add it).
+          # So we just have to know that it was invalid and go from there.
+          @valid = false
+          return
+        elsif @operation_name_error
+          @validation_errors << @operation_name_error
+        else
+          validation_result = @schema.static_validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
+          @validation_errors.concat(validation_result[:errors])
+
+          if @validation_errors.empty?
+            @validation_errors.concat(@query.variables.errors)
+          end
+
+          if @validation_errors.empty?
+            @query_analyzers = build_analyzers(
+              @schema,
+              @max_depth,
+              @max_complexity
+            )
+          end
+        end
+
+        @valid = @validation_errors.empty?
+      rescue SystemStackError => err
+        @valid = false
+        @schema.query_stack_error(@query, err)
+      end
+
+      # If there are max_* values, add them,
+      # otherwise reuse the schema's list of analyzers.
+      def build_analyzers(schema, max_depth, max_complexity)
+        qa = schema.query_analyzers.dup
+
+        if max_depth || max_complexity
+          # Depending on the analysis engine, we must use different analyzers
+          # remove this once everything has switched over to AST analyzers
+          if max_depth
+            qa << GraphQL::Analysis::AST::MaxQueryDepth
+          end
+          if max_complexity
+            qa << GraphQL::Analysis::AST::MaxQueryComplexity
+          end
+          qa
+        else
+          qa
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/variable_validation_error.rb

@@ -1,19 +1,43 @@
+# frozen_string_literal: true
 module GraphQL
   class Query
     class VariableValidationError < GraphQL::ExecutionError
       attr_accessor :value, :validation_result
 
-      def initialize(variable_ast, type, value, validation_result)
+      def initialize(variable_ast, type, value, validation_result, msg: nil)
         @value = value
         @validation_result = validation_result
 
-        msg = "Variable #{variable_ast.name} of type #{type} was provided invalid value"
+        msg ||= "Variable $#{variable_ast.name} of type #{type.to_type_signature} was provided invalid value"
+
+        if problem_fields.any?
+          msg += " for #{problem_fields.join(", ")}"
+        end
+
         super(msg)
         self.ast_node = variable_ast
       end
 
       def to_h
-        super.merge({ "value" => value, "problems" => validation_result.problems })
+        # It is possible there are other extension items in this error, so handle
+        # 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)
+            oldValue.merge(newValue)
+          else
+            newValue
+          end
+        end
+      end
+
+      private
+
+      def problem_fields
+        @problem_fields ||= @validation_result
+          .problems
+          .reject { |problem| problem["path"].empty? }
+          .map { |problem| "#{problem['path'].join('.')} (#{problem['explanation']})" }
       end
     end
   end