graphql 1.12.0 → 1.12.5

data/lib/graphql/execution/multiplex.rb

@@ -35,7 +35,7 @@ module GraphQL
         @queries = queries
         @queries.each { |q| q.multiplex = self }
         @context = context
-        @context[:dataloader] = @dataloader = @schema.dataloader_class.new(context)
+        @context[:dataloader] = @dataloader = @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
@@ -74,6 +74,24 @@ module GraphQL
           end
         end
 
+        # @param query [GraphQL::Query]
+        def begin_query(results, idx, query, multiplex)
+          operation = query.selected_operation
+          result = if operation.nil? || !query.valid? || query.context.errors.any?
+            NO_OPERATION
+          else
+            begin
+              # These were checked to be the same in `#supports_multiplexing?`
+              query.schema.query_execution_strategy.begin_query(query, multiplex)
+            rescue GraphQL::ExecutionError => err
+              query.context.errors << err
+              NO_OPERATION
+            end
+          end
+          results[idx] = result
+          nil
+        end
+
         private
 
         def run_as_multiplex(multiplex)
@@ -83,15 +101,13 @@ module GraphQL
           # Do as much eager evaluation of the query as possible
           results = []
           queries.each_with_index do |query, idx|
-            multiplex.dataloader.enqueue {
-              results[idx] = begin_query(query, multiplex)
-            }
+            multiplex.dataloader.append_job { begin_query(results, idx, query, multiplex) }
           end
 
           multiplex.dataloader.run
 
           # Then, work through lazy results in a breadth-first way
-          multiplex.dataloader.enqueue {
+          multiplex.dataloader.append_job {
             multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
           }
           multiplex.dataloader.run
@@ -112,23 +128,6 @@ module GraphQL
           raise
         end
 
-        # @param query [GraphQL::Query]
-        # @return [Hash] The initial result (may not be finished if there are lazy values)
-        def begin_query(query, multiplex)
-          operation = query.selected_operation
-          if operation.nil? || !query.valid? || query.context.errors.any?
-            NO_OPERATION
-          else
-            begin
-              # These were checked to be the same in `#supports_multiplexing?`
-              query.schema.query_execution_strategy.begin_query(query, multiplex)
-            rescue GraphQL::ExecutionError => err
-              query.context.errors << err
-              NO_OPERATION
-            end
-          end
-        end
-
         # @param data_result [Hash] The result for the "data" key, if any
         # @param query [GraphQL::Query] The query which was run
         # @return [Hash] final result of this query, including all values and errors
@@ -156,7 +155,7 @@ module GraphQL
 
         # use the old `query_execution_strategy` etc to run this query
         def run_one_legacy(schema, query)
-          warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
+          GraphQL::Deprecation.warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
 
           query.result_values = if !query.valid?
             all_errors = query.validation_errors + query.analysis_errors + query.context.errors

data/lib/graphql/function.rb

@@ -3,7 +3,7 @@ module GraphQL
   # @api deprecated
   class Function
     def self.inherited(subclass)
-      warn "GraphQL::Function (used for #{subclass}) will be removed from GraphQL-Ruby 2.0, please upgrade to resolvers: https://graphql-ruby.org/fields/resolvers.html"
+      GraphQL::Deprecation.warn "GraphQL::Function (used for #{subclass}) will be removed from GraphQL-Ruby 2.0, please upgrade to resolvers: https://graphql-ruby.org/fields/resolvers.html"
     end
 
     # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name

data/lib/graphql/internal_representation/document.rb

@@ -14,12 +14,12 @@ module GraphQL
       end
 
       def [](key)
-        warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
+        GraphQL::Deprecation.warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
         operation_definitions[key]
       end
 
       def each(&block)
-        warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
+        GraphQL::Deprecation.warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
         operation_definitions.each(&block)
       end
     end

data/lib/graphql/internal_representation/rewrite.rb

@@ -60,7 +60,7 @@ module GraphQL
 
       # @return [Hash<String, Node>] Roots of this query
       def operations
-        warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
+        GraphQL::Deprecation.warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
         @document.operation_definitions
       end
 

data/lib/graphql/object_type.rb

@@ -121,8 +121,6 @@ module GraphQL
           iface = GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
           if iface.is_a?(GraphQL::InterfaceType)
             @clean_inherited_fields.merge!(iface.fields)
-          else
-            pp iface
           end
         end
         @clean_inherited_fields

data/lib/graphql/pagination/connection.rb

@@ -105,6 +105,15 @@ module GraphQL
         end
       end
 
+      # This is called by `Relay::RangeAdd` -- it can be overridden
+      # when `item` needs some modifications based on this connection's state.
+      #
+      # @param item [Object] An item newly added to `items`
+      # @return [Edge]
+      def range_add_edge(item)
+        edge_class.new(item, self)
+      end
+
       attr_writer :last
       # @return [Integer, nil] A clamped `last` value. (The underlying instance variable doesn't have limits on it)
       def last

data/lib/graphql/pagination/connections.rb

@@ -23,7 +23,7 @@ module GraphQL
 
       def self.use(schema_defn)
         if schema_defn.plugins.any? { |(plugin, args)| plugin == self }
-          warn("#{self} is now the default, remove `use #{self}` from #{caller(2,1).first}")
+          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

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.rb

@@ -251,12 +251,18 @@ module GraphQL
     # @param parent_object [GraphQL::Schema::Object]
     # @return Hash{Symbol => Object}
     def arguments_for(ast_node, definition, parent_object: nil)
+      if interpreter?
+        arguments_cache.fetch(ast_node, definition, parent_object)
+      else
+        arguments_cache[ast_node][definition]
+      end
+    end
+
+    def arguments_cache
       if interpreter?
         @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
-        @arguments_cache.fetch(ast_node, definition, parent_object)
       else
         @arguments_cache ||= ArgumentsCache.build(self)
-        @arguments_cache[ast_node][definition]
       end
     end
 

data/lib/graphql/query/arguments.rb

@@ -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."
                   )

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

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.
@@ -159,7 +157,7 @@ module GraphQL
       end
 
       def dataloader
-        @dataloader ||= query.multiplex.dataloader
+        @dataloader ||= query.multiplex ? query.multiplex.dataloader : schema.dataloader_class.new
       end
 
       # @api private

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/null_context.rb

@@ -9,10 +9,11 @@ module GraphQL
         def visible_type?(t); true; end
       end
 
-      attr_reader :schema, :query, :warden
+      attr_reader :schema, :query, :warden, :dataloader
 
       def initialize
         @query = nil
+        @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = GraphQL::Schema.new
         @warden = NullWarden.new(
           GraphQL::Filter.new,
@@ -36,7 +37,7 @@ module GraphQL
           @instance = self.new
         end
 
-        def_delegators :instance, :query, :schema, :warden, :interpreter?
+        def_delegators :instance, :query, :schema, :warden, :interpreter?, :dataloader
       end
     end
   end

data/lib/graphql/query/serial_execution.rb

@@ -16,7 +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)
-        warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
+        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/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/relay/base_connection.rb

@@ -59,11 +59,11 @@ module GraphQL
       # @param parent [Object] The object which this collection belongs to
       # @param context [GraphQL::Query::Context] The context from the field being resolved
       def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
-        warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
+        GraphQL::Deprecation.warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
 
         deprecated_caller = caller(0, 10).find { |c| !c.include?("lib/graphql") }
         if deprecated_caller
-          warn "  -> called from #{deprecated_caller}"
+          GraphQL::Deprecation.warn "  -> called from #{deprecated_caller}"
         end
 
         @context = context

data/lib/graphql/relay/mutation.rb

@@ -30,7 +30,7 @@ module GraphQL
       alias :input_fields :arguments
 
       def initialize
-        warn "GraphQL::Relay::Mutation will be removed from GraphQL-Ruby 2.0, use GraphQL::Schema::RelayClassicMutation instead: https://graphql-ruby.org/mutations/mutation_classes"
+        GraphQL::Deprecation.warn "GraphQL::Relay::Mutation will be removed from GraphQL-Ruby 2.0, use GraphQL::Schema::RelayClassicMutation instead: https://graphql-ruby.org/mutations/mutation_classes"
         @fields = {}
         @arguments = {}
         @has_generated_return_type = false

data/lib/graphql/relay/node.rb

@@ -5,7 +5,7 @@ module GraphQL
     module Node
       # @return [GraphQL::Field] a field for finding objects by their global ID.
       def self.field(**kwargs, &block)
-        warn "GraphQL::Relay::Node.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodeField instead"
+        GraphQL::Deprecation.warn "GraphQL::Relay::Node.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodeField instead"
         # We have to define it fresh each time because
         # its name will be modified and its description
         # _may_ be modified.
@@ -19,7 +19,7 @@ module GraphQL
       end
 
       def self.plural_field(**kwargs, &block)
-        warn "GraphQL::Relay::Nodes.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodesField instead"
+        GraphQL::Deprecation.warn "GraphQL::Relay::Nodes.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodesField instead"
         field = GraphQL::Types::Relay::NodesField.graphql_definition
 
         if kwargs.any? || block
@@ -31,7 +31,7 @@ module GraphQL
 
       # @return [GraphQL::InterfaceType] The interface which all Relay types must implement
       def self.interface
-        warn "GraphQL::Relay::Node.interface will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::Node instead"
+        GraphQL::Deprecation.warn "GraphQL::Relay::Node.interface will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::Node instead"
         @interface ||= GraphQL::Types::Relay::Node.graphql_definition
       end
     end

data/lib/graphql/relay/range_add.rb

@@ -9,7 +9,7 @@ module GraphQL
     # should be ordered and paginated before providing it here.
     #
     # @example Adding a comment to list of comments
-    #   post = Post.find(args[:postId])
+    #   post = Post.find(args[:post_id])
     #   comments = post.comments
     #   new_comment = comments.build(body: args[:body])
     #   new_comment.save!
@@ -18,13 +18,13 @@ module GraphQL
     #     parent: post,
     #     collection: comments,
     #     item: new_comment,
-    #     context: ctx,
+    #     context: context,
     #   )
     #
     #   response = {
     #     post: post,
-    #     commentsConnection: range_add.connection,
-    #     newCommentEdge: range_add.edge,
+    #     comments_connection: range_add.connection,
+    #     new_comment_edge: range_add.edge,
     #   }
     class RangeAdd
       attr_reader :edge, :connection, :parent
@@ -39,7 +39,12 @@ module GraphQL
           conn_class = context.schema.connections.wrapper_for(collection)
           # The rest will be added by ConnectionExtension
           @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
-          @edge = @connection.edge_class.new(item, @connection)
+          # Check if this connection supports it, to support old versions of GraphQL-Pro
+          @edge = if @connection.respond_to?(:range_add_edge)
+            @connection.range_add_edge(item)
+          else
+            @connection.edge_class.new(item, @connection)
+          end
         else
           connection_class = BaseConnection.connection_for_nodes(collection)
           @connection = connection_class.new(collection, {}, parent: parent, context: context)

data/lib/graphql/relay/type_extensions.rb

@@ -12,7 +12,7 @@ module GraphQL
       # Define a custom connection type for this object type
       # @return [GraphQL::ObjectType]
       def define_connection(**kwargs, &block)
-        warn ".connection_type and .define_connection will be removed from GraphQL-Ruby 2.0, use class-based type definitions instead: https://graphql-ruby.org/schema/class_based_api.html"
+        GraphQL::Deprecation.warn ".connection_type and .define_connection will be removed from GraphQL-Ruby 2.0, use class-based type definitions instead: https://graphql-ruby.org/schema/class_based_api.html"
         GraphQL::Relay::ConnectionType.create_type(self, **kwargs, &block)
       end
 
@@ -24,7 +24,7 @@ module GraphQL
       # Define a custom edge type for this object type
       # @return [GraphQL::ObjectType]
       def define_edge(**kwargs, &block)
-        warn ".edge_type and .define_edge will be removed from GraphQL-Ruby 2.0, use class-based type definitions instead: https://graphql-ruby.org/schema/class_based_api.html"
+        GraphQL::Deprecation.warn ".edge_type and .define_edge will be removed from GraphQL-Ruby 2.0, use class-based type definitions instead: https://graphql-ruby.org/schema/class_based_api.html"
         GraphQL::Relay::EdgeType.create_type(self, **kwargs, &block)
       end
     end

data/lib/graphql/schema.rb

@@ -184,7 +184,7 @@ module GraphQL
       },
       query_analyzer: ->(schema, analyzer) {
         if analyzer == GraphQL::Authorization::Analyzer
-          warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
+          GraphQL::Deprecation.warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
         end
         schema.query_analyzers << analyzer
       },
@@ -1118,14 +1118,15 @@ module GraphQL
             type.possible_types(context: context)
           else
             stored_possible_types = own_possible_types[type.graphql_name]
-            visible_possible_types = stored_possible_types.select do |possible_type|
-              next true unless type.kind.interface?
-              next true unless possible_type.kind.object?
-
-              # Use `.graphql_name` comparison to match legacy vs class-based types.
-              # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
-              possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
-            end if stored_possible_types
+            visible_possible_types = if stored_possible_types && type.kind.interface?
+              stored_possible_types.select do |possible_type|
+                # Use `.graphql_name` comparison to match legacy vs class-based types.
+                # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
+                possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
+              end
+            else
+              stored_possible_types
+            end
             visible_possible_types ||
               introspection_system.possible_types[type.graphql_name] ||
               (
@@ -1564,7 +1565,7 @@ module GraphQL
 
       def instrument(instrument_step, instrumenter, options = {})
         if instrument_step == :field
-          warn "Field instrumentation (#{instrumenter.inspect}) will be removed in GraphQL-Ruby 2.0, please upgrade to field extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
+          GraphQL::Deprecation.warn "Field instrumentation (#{instrumenter.inspect}) will be removed in GraphQL-Ruby 2.0, please upgrade to field extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
         end
 
         step = if instrument_step == :field && options[:after_built_ins]
@@ -1614,7 +1615,7 @@ module GraphQL
 
       def query_analyzer(new_analyzer)
         if new_analyzer == GraphQL::Authorization::Analyzer
-          warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
+          GraphQL::Deprecation.warn("The Authorization query analyzer is deprecated. Authorizing at query runtime is generally a better idea.")
         end
         own_query_analyzers << new_analyzer
       end
@@ -1625,7 +1626,7 @@ module GraphQL
 
       def middleware(new_middleware = nil)
         if new_middleware
-          warn "Middleware will be removed in GraphQL-Ruby 2.0, please upgrade to Field Extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
+          GraphQL::Deprecation.warn "Middleware will be removed in GraphQL-Ruby 2.0, please upgrade to Field Extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
           own_middleware << new_middleware
         else
           # TODO make sure this is cached when running a query
@@ -1702,7 +1703,7 @@ module GraphQL
         if interpreter? && !defined?(@subscription_extension_added) && subscription && self.subscriptions
           @subscription_extension_added = true
           if subscription.singleton_class.ancestors.include?(Subscriptions::SubscriptionRoot)
-            warn("`extend Subscriptions::SubscriptionRoot` is no longer required; you may remove it from #{self}'s `subscription` root type (#{subscription}).")
+            GraphQL::Deprecation.warn("`extend Subscriptions::SubscriptionRoot` is no longer required; you may remove it from #{self}'s `subscription` root type (#{subscription}).")
           else
             subscription.fields.each do |name, field|
               field.extension(Subscriptions::DefaultSubscriptionResolveExtension)