graphql 2.2.17 → 2.5.16

data/lib/graphql/language/sanitized_printer.rb

@@ -113,7 +113,7 @@ module GraphQL
       end
 
       def print_field(field, indent: "")
-        @current_field = query.get_field(@current_type, field.name)
+        @current_field = query.types.field(@current_type, field.name)
         old_type = @current_type
         @current_type = @current_field.type.unwrap
         super

data/lib/graphql/language.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "graphql/language/block_string"
+require "graphql/language/comment"
 require "graphql/language/printer"
 require "graphql/language/sanitized_printer"
 require "graphql/language/document_from_schema_definition"
@@ -9,9 +10,9 @@ require "graphql/language/nodes"
 require "graphql/language/cache"
 require "graphql/language/parser"
 require "graphql/language/static_visitor"
-require "graphql/language/token"
 require "graphql/language/visitor"
 require "graphql/language/definition_slice"
+require "strscan"
 
 module GraphQL
   module Language
@@ -32,6 +33,65 @@ module GraphQL
       else
         JSON.generate(value, quirks_mode: true)
       end
+    rescue JSON::GeneratorError
+      if Float::INFINITY == value
+        "Infinity"
+      else
+        raise
+      end
+    end
+
+    # Returns a new string if any single-quoted newlines were escaped.
+    # Otherwise, returns `query_str` unchanged.
+    # @return [String]
+    def self.escape_single_quoted_newlines(query_str)
+      scanner = StringScanner.new(query_str)
+      inside_single_quoted_string = false
+      new_query_str = nil
+      while !scanner.eos?
+        if scanner.skip(/(?:\\"|[^"\n\r]|""")+/m)
+          new_query_str && (new_query_str << scanner.matched)
+        elsif scanner.skip('"')
+          new_query_str && (new_query_str << '"')
+          inside_single_quoted_string = !inside_single_quoted_string
+        elsif scanner.skip("\n")
+          if inside_single_quoted_string
+            new_query_str ||= query_str[0, scanner.pos - 1]
+            new_query_str << '\\n'
+          else
+            new_query_str && (new_query_str << "\n")
+          end
+        elsif scanner.skip("\r")
+          if inside_single_quoted_string
+            new_query_str ||= query_str[0, scanner.pos - 1]
+            new_query_str << '\\r'
+          else
+            new_query_str && (new_query_str << "\r")
+          end
+        elsif scanner.eos?
+          break
+        else
+          raise ArgumentError, "Unmatchable string scanner segment: #{scanner.rest.inspect}"
+        end
+      end
+      new_query_str || query_str
+    end
+
+    INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP = %r{
+      (
+        ((?<num>#{Lexer::INT_REGEXP}(#{Lexer::FLOAT_EXP_REGEXP})?)(?<name>#{Lexer::IDENTIFIER_REGEXP})#{Lexer::IGNORE_REGEXP}:)
+        |
+        ((?<num>#{Lexer::INT_REGEXP}#{Lexer::FLOAT_DECIMAL_REGEXP}#{Lexer::FLOAT_EXP_REGEXP})(?<name>#{Lexer::IDENTIFIER_REGEXP})#{Lexer::IGNORE_REGEXP}:)
+        |
+        ((?<num>#{Lexer::INT_REGEXP}#{Lexer::FLOAT_DECIMAL_REGEXP})(?<name>#{Lexer::IDENTIFIER_REGEXP})#{Lexer::IGNORE_REGEXP}:)
+      )}x
+
+    def self.add_space_between_numbers_and_names(query_str)
+      if query_str.match?(INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP)
+        query_str.gsub(INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP, "\\k<num> \\k<name>:")
+      else
+        query_str
+      end
     end
   end
 end

data/lib/graphql/pagination/connection.rb

@@ -223,7 +223,7 @@ module GraphQL
 
       def detect_was_authorized_by_scope_items
         if @context &&
-            (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+            (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
             (query_runtime_state = current_runtime_state[@context.query])
           query_runtime_state.was_authorized_by_scope_items
         else

data/lib/graphql/query/context/scoped_context.rb

@@ -60,7 +60,7 @@ module GraphQL
           each_present_path_ctx do |path_ctx|
             if path_ctx.key?(key)
               found_value = path_ctx[key]
-              if other_keys.any?
+              if !other_keys.empty?
                 return found_value.dig(*other_keys)
               else
                 return found_value

data/lib/graphql/query/context.rb

@@ -1,41 +1,10 @@
 # frozen_string_literal: true
-require "graphql/query/context/scoped_context"
 
 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 this value to tell the runtime
-        # to exclude this field from the response altogether
-        def skip
-          GraphQL::Execution::SKIP
-        end
-
-        # 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
-
-        # @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)
@@ -59,7 +28,6 @@ module GraphQL
         alias :push :add
       end
 
-      include SharedMethods
       extend Forwardable
 
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
@@ -71,27 +39,21 @@ 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:, schema: query.schema, values:, object:)
+      def initialize(query:, schema: query.schema, values:)
         @query = query
         @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
 
+      # Modify this hash to return extensions to client.
       # @return [Hash] A hash that will be added verbatim to the result hash, as `"extensions" => { ... }`
       def response_extensions
         namespace(:__query_result_extensions__)
@@ -114,9 +76,15 @@ module GraphQL
         @provided_values[key] = value
       end
 
-      def_delegators :@query, :trace, :interpreter?
+      def_delegators :@query, :trace
+
+      def types
+        @types ||= @query.types
+      end
+
+      attr_writer :types
 
-      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path])
+      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path]).freeze
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 
@@ -130,7 +98,7 @@ module GraphQL
           if key == :current_path
             current_path
           else
-            (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+            (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
               (query_runtime_state = current_runtime_state[@query]) &&
               (query_runtime_state.public_send(key))
           end
@@ -140,8 +108,37 @@ module GraphQL
         end
       end
 
+      # Return this value to tell the runtime
+      # to exclude this field from the response altogether
+      def skip
+        GraphQL::Execution::SKIP
+      end
+
+      # 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
+
+      # @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
+
       def current_path
-        current_runtime_state = Thread.current[:__graphql_runtime_info]
+        current_runtime_state = Fiber[:__graphql_runtime_info]
         query_runtime_state = current_runtime_state && current_runtime_state[@query]
 
         path = query_runtime_state &&
@@ -166,7 +163,7 @@ module GraphQL
 
       def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
         if RUNTIME_METADATA_KEYS.include?(key)
-          (runtime = Thread.current[:__graphql_runtime_info]) &&
+          (runtime = Fiber[:__graphql_runtime_info]) &&
             (query_runtime_state = runtime[@query]) &&
             (query_runtime_state.public_send(key))
         elsif @scoped_context.key?(key)
@@ -184,7 +181,7 @@ module GraphQL
 
       def dig(key, *other_keys)
         if RUNTIME_METADATA_KEYS.include?(key)
-          (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+          (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
             (query_runtime_state = current_runtime_state[@query]) &&
             (obj = query_runtime_state.public_send(key)) &&
             if other_keys.empty?
@@ -242,7 +239,7 @@ module GraphQL
       end
 
       def inspect
-        "#<Query::Context ...>"
+        "#<#{self.class} ...>"
       end
 
       def scoped_merge!(hash)
@@ -286,3 +283,5 @@ module GraphQL
     end
   end
 end
+
+require "graphql/query/context/scoped_context"

data/lib/graphql/query/null_context.rb

@@ -18,17 +18,15 @@ module GraphQL
       extend Forwardable
 
       attr_reader :schema, :query, :warden, :dataloader
-      def_delegators GraphQL::EmptyObjects::EMPTY_HASH, :[], :fetch, :dig, :key?
+      def_delegators GraphQL::EmptyObjects::EMPTY_HASH, :[], :fetch, :dig, :key?, :to_h
 
       def initialize
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = NullSchema
         @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
-      end
-
-      def interpreter?
-        true
+        @types = @warden.visibility_profile
+        freeze
       end
     end
   end

data/lib/graphql/query/partial.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # This class is _like_ a {GraphQL::Query}, except it can run on an arbitrary path within a query string.
+    #
+    # It depends on a "parent" {Query}.
+    #
+    # During execution, it calls query-related tracing hooks but passes itself as `query:`.
+    #
+    # The {Partial} will use your {Schema.resolve_type} hook to find the right GraphQL type to use for
+    # `object` in some cases.
+    #
+    # @see Query#run_partials Run via {Query#run_partials}
+    class Partial
+      include Query::Runnable
+
+      # @param path [Array<String, Integer>] A path in `query.query_string` to start executing from
+      # @param object [Object] A starting object for execution
+      # @param query [GraphQL::Query] A full query instance that this partial is based on. Caches are shared.
+      # @param context [Hash] Extra context values to merge into `query.context`, if provided
+      # @param fragment_node [GraphQL::Language::Nodes::InlineFragment, GraphQL::Language::Nodes::FragmentDefinition]
+      def initialize(path: nil, object:, query:, context: nil, fragment_node: nil, type: nil)
+        @path = path
+        @object = object
+        @query = query
+        @schema = query.schema
+        context_vals = @query.context.to_h
+        if context
+          context_vals = context_vals.merge(context)
+        end
+        @context = GraphQL::Query::Context.new(query: self, schema: @query.schema, values: context_vals)
+        @multiplex = nil
+        @result_values = nil
+        @result = nil
+
+        if fragment_node
+          @ast_nodes = [fragment_node]
+          @root_type = type || raise(ArgumentError, "Pass `type:` when using `node:`")
+          # This is only used when `@leaf`
+          @field_definition = nil
+        elsif path.nil?
+          raise ArgumentError, "`path:` is required if `node:` is not given; add `path:`"
+        else
+          set_type_info_from_path
+        end
+
+        @leaf = @root_type.unwrap.kind.leaf?
+      end
+
+      def leaf?
+        @leaf
+      end
+
+      attr_reader :context, :query, :ast_nodes, :root_type, :object, :field_definition, :path, :schema
+
+      attr_accessor :multiplex, :result_values
+
+      class Result < GraphQL::Query::Result
+        def path
+          @query.path
+        end
+
+        # @return [GraphQL::Query::Partial]
+        def partial
+          @query
+        end
+      end
+
+      def result
+        @result ||= Result.new(query: self, values: result_values)
+      end
+
+      def current_trace
+        @query.current_trace
+      end
+
+      def types
+        @query.types
+      end
+
+      def resolve_type(...)
+        @query.resolve_type(...)
+      end
+
+      def variables
+        @query.variables
+      end
+
+      def fragments
+        @query.fragments
+      end
+
+      def valid?
+        @query.valid?
+      end
+
+      def analyzers
+        EmptyObjects::EMPTY_ARRAY
+      end
+
+      def analysis_errors=(_ignored)
+        # pass
+      end
+
+      def subscription?
+        @query.subscription?
+      end
+
+      def selected_operation
+        ast_nodes.first
+      end
+
+      def static_errors
+        @query.static_errors
+      end
+
+      def selected_operation_name
+        @query.selected_operation_name
+      end
+
+      private
+
+      def set_type_info_from_path
+        selections = [@query.selected_operation]
+        type = @query.root_type
+        parent_type = nil
+        field_defn = nil
+
+        @path.each do |name_in_doc|
+          if name_in_doc.is_a?(Integer)
+            if type.list?
+              type = type.unwrap
+              next
+            else
+              raise ArgumentError, "Received path with index `#{name_in_doc}`, but type wasn't a list. Type: #{type.to_type_signature}, path: #{@path}"
+            end
+          end
+
+          next_selections = []
+          selections.each do |selection|
+            selections_to_check = []
+            selections_to_check.concat(selection.selections)
+            while (sel = selections_to_check.shift)
+              case sel
+              when GraphQL::Language::Nodes::InlineFragment
+                selections_to_check.concat(sel.selections)
+              when GraphQL::Language::Nodes::FragmentSpread
+                fragment = @query.fragments[sel.name]
+                selections_to_check.concat(fragment.selections)
+              when GraphQL::Language::Nodes::Field
+                if sel.alias == name_in_doc || sel.name == name_in_doc
+                  next_selections << sel
+                end
+              else
+                raise "Unexpected selection in partial path: #{sel.class}, #{sel.inspect}"
+              end
+            end
+          end
+
+          if next_selections.empty?
+            raise ArgumentError, "Path `#{@path.inspect}` is not present in this query. `#{name_in_doc.inspect}` was not found. Try a different path or rewrite the query to include it."
+          end
+          field_name = next_selections.first.name
+          field_defn = @schema.get_field(type, field_name, @query.context) || raise("Invariant: no field called #{field_name} on #{type.graphql_name}")
+          parent_type = type
+          type = field_defn.type
+          if type.non_null?
+            type = type.of_type
+          end
+          selections = next_selections
+        end
+
+        @ast_nodes = selections
+        @root_type = type
+        @field_definition = field_defn
+      end
+    end
+  end
+end

data/lib/graphql/query/validation_pipeline.rb

@@ -100,10 +100,10 @@ module GraphQL
           # 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
+            qa << GraphQL::Analysis::MaxQueryDepth
           end
           if max_complexity
-            qa << GraphQL::Analysis::AST::MaxQueryComplexity
+            qa << GraphQL::Analysis::MaxQueryComplexity
           end
           qa
         else

data/lib/graphql/query/variable_validation_error.rb

@@ -10,7 +10,7 @@ module GraphQL
 
         msg ||= "Variable $#{variable_ast.name} of type #{type.to_type_signature} was provided invalid value"
 
-        if problem_fields.any?
+        if !problem_fields.empty?
           msg += " for #{problem_fields.join(", ")}"
         end