graphql 2.0.32 → 2.5.22

data/lib/graphql/pagination/connections.rb

@@ -83,6 +83,38 @@ module GraphQL
         end
       end
 
+      def populate_connection(field, object, value, original_arguments, context)
+        if value.is_a? GraphQL::ExecutionError
+          # This isn't even going to work because context doesn't have ast_node anymore
+          context.add_error(value)
+          nil
+        elsif value.nil?
+          nil
+        elsif value.is_a?(GraphQL::Pagination::Connection)
+          # update the connection with some things that may not have been provided
+          value.context ||= context
+          value.parent ||= object
+          value.first_value ||= original_arguments[:first]
+          value.after_value ||= original_arguments[:after]
+          value.last_value ||= original_arguments[:last]
+          value.before_value ||= original_arguments[:before]
+          value.arguments ||= original_arguments # rubocop:disable Development/ContextIsPassedCop -- unrelated .arguments method
+          value.field ||= field
+          if field.has_max_page_size? && !value.has_max_page_size_override?
+            value.max_page_size = field.max_page_size
+          end
+          if field.has_default_page_size? && !value.has_default_page_size_override?
+            value.default_page_size = field.default_page_size
+          end
+          if (custom_t = context.schema.connections.edge_class_for_field(field))
+            value.edge_class = custom_t
+          end
+          value
+        else
+          context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
+          context.schema.connections.wrap(field, object, value, original_arguments, context)
+        end
+      end
       # use an override if there is one
       # @api private
       def edge_class_for_field(field)

data/lib/graphql/pagination/mongoid_relation_connection.rb

@@ -13,8 +13,7 @@ module GraphQL
       end
 
       def relation_count(relation)
-        # Mongo's `.count` doesn't apply limit or skip, which we need. So we have to load _everything_!
-        relation.to_a.count
+        relation.all.count(relation.options.slice(:limit, :skip))
       end
 
       def null_relation(relation)

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    class Context
+      class ScopedContext
+        def initialize(query_context)
+          @query_context = query_context
+          @scoped_contexts = nil
+          @all_keys = nil
+        end
+
+        def merged_context
+          if @scoped_contexts.nil?
+            GraphQL::EmptyObjects::EMPTY_HASH
+          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, at: current_path)
+          @all_keys ||= Set.new
+          @all_keys.merge(hash.keys)
+          ctx = @scoped_contexts ||= {}
+          at.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 || GraphQL::EmptyObjects::EMPTY_ARRAY
+        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.empty?
+                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
+    end
+  end
+end

data/lib/graphql/query/context.rb

@@ -1,39 +1,10 @@
 # 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
-      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)
@@ -57,8 +28,8 @@ module GraphQL
         alias :push :add
       end
 
-      include SharedMethods
       extend Forwardable
+      include Schema::Member::HasDataloader
 
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
       attr_reader :errors
@@ -69,125 +40,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
 
-      class ScopedContext
-        NO_PATH = GraphQL::EmptyObjects::EMPTY_ARRAY
-        NO_CONTEXT = GraphQL::EmptyObjects::EMPTY_HASH
-
-        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
-
+      # 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__)
@@ -210,9 +77,15 @@ module GraphQL
         @provided_values[key] = value
       end
 
-      def_delegators :@query, :trace, :interpreter?
+      def_delegators :@query, :trace
+
+      def types
+        @types ||= @query.types
+      end
 
-      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path])
+      attr_writer :types
+
+      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:`
 
@@ -226,7 +99,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
@@ -236,8 +109,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?(GraphQL::RuntimeError)
+          raise TypeError, "expected error to be a GraphQL::RuntimeError, 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 &&
@@ -262,7 +164,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)
@@ -280,7 +182,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?
@@ -333,8 +235,12 @@ module GraphQL
         @storage.key?(ns)
       end
 
+      def logger
+        @query && @query.logger
+      end
+
       def inspect
-        "#<Query::Context ...>"
+        "#<#{self.class} ...>"
       end
 
       def scoped_merge!(hash)
@@ -345,6 +251,38 @@ module GraphQL
         scoped_merge!(key => value)
         nil
       end
+
+      # Use this when you need to do a scoped set _inside_ a lazy-loaded (or batch-loaded)
+      # block of code.
+      #
+      # @example using scoped context inside a promise
+      #   scoped_ctx = context.scoped
+      #   SomeBatchLoader.load(...).then do |thing|
+      #     # use a scoped_ctx which was created _before_ dataloading:
+      #     scoped_ctx.set!(:thing, thing)
+      #   end
+      # @return [Context::Scoped]
+      def scoped
+        Scoped.new(@scoped_context, current_path)
+      end
+
+      class Scoped
+        def initialize(scoped_context, path)
+          @path = path
+          @scoped_context = scoped_context
+        end
+
+        def merge!(hash)
+          @scoped_context.merge!(hash, at: @path)
+        end
+
+        def set!(key, value)
+          @scoped_context.merge!({ key => value }, at: @path)
+          nil
+        end
+      end
     end
   end
 end
+
+require "graphql/query/context/scoped_context"

data/lib/graphql/query/null_context.rb

@@ -1,8 +1,17 @@
 # frozen_string_literal: true
+require "graphql/query/context"
 module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
-    class NullContext
+    class NullContext < Context
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def self.instance=(new_inst)
+        @instance = new_inst
+      end
+
       class NullQuery
         def after_lazy(value)
           yield(value)
@@ -15,27 +24,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
+      def initialize(schema: NullSchema)
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
-        @schema = NullSchema
+        @schema = schema
         @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
-      end
-
-      def interpreter?
-        true
-      end
-
-      class << self
-        extend Forwardable
-
-        def instance
-          @instance ||= self.new
-        end
-
-        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader, :[], :fetch, :dig, :key?
+        @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