graphql 2.0.17.2 → 2.0.21

data/lib/graphql/execution/interpreter.rb

@@ -14,7 +14,7 @@ module GraphQL
       class << self
         # Used internally to signal that the query shouldn't be executed
         # @api private
-        NO_OPERATION = {}.freeze
+        NO_OPERATION = GraphQL::EmptyObjects::EMPTY_HASH
 
         # @param schema [GraphQL::Schema]
         # @param queries [Array<GraphQL::Query, Hash>]
@@ -34,11 +34,12 @@ module GraphQL
           end
 
           multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
-          multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
+          multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
             query_instrumenters = schema.instrumenters[:query]
             multiplex_instrumenters = schema.instrumenters[:multiplex]
+            lazies_at_depth = Hash.new { |h, k| h[k] = [] }
 
             # First, run multiplex instrumentation, then query instrumentation for each query
             call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
@@ -67,10 +68,10 @@ module GraphQL
                           # Although queries in a multiplex _share_ an Interpreter instance,
                           # they also have another item of state, which is private to that query
                           # in particular, assign it here:
-                          runtime = Runtime.new(query: query)
+                          runtime = Runtime.new(query: query, lazies_at_depth: lazies_at_depth)
                           query.context.namespace(:interpreter_runtime)[:runtime] = runtime
 
-                          query.trace("execute_query", {query: query}) do
+                          query.current_trace.execute_query(query: query) do
                             runtime.run_eager
                           end
                         rescue GraphQL::ExecutionError => err
@@ -95,16 +96,13 @@ module GraphQL
                       runtime ? runtime.final_result : nil
                     end
                     final_values.compact!
-                    tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
-                      Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
+                    tracer.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
+                      Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
                     end
                     queries.each do |query|
                       runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                       if runtime
-                        runtime.delete_interpreter_context(:current_path)
-                        runtime.delete_interpreter_context(:current_field)
-                        runtime.delete_interpreter_context(:current_object)
-                        runtime.delete_interpreter_context(:current_arguments)
+                        runtime.delete_all_interpreter_context
                       end
                     end
                   }
@@ -150,10 +148,7 @@ module GraphQL
                   queries.map { |query|
                     runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                     if runtime
-                      runtime.delete_interpreter_context(:current_path)
-                      runtime.delete_interpreter_context(:current_field)
-                      runtime.delete_interpreter_context(:current_object)
-                      runtime.delete_interpreter_context(:current_arguments)
+                      runtime.delete_all_interpreter_context
                     end
                   }
                 end

data/lib/graphql/execution/lazy.rb

@@ -12,16 +12,14 @@ module GraphQL
     # - It has no error-catching functionality
     # @api private
     class Lazy
-      attr_reader :path, :field
+      attr_reader :field
 
       # Create a {Lazy} which will get its inner value by calling the block
-      # @param path [Array<String, Integer>]
       # @param field [GraphQL::Schema::Field]
       # @param get_value_func [Proc] a block to get the inner value (later)
-      def initialize(path: nil, field: nil, &get_value_func)
+      def initialize(field: nil, &get_value_func)
         @get_value_func = get_value_func
         @resolved = false
-        @path = path
         @field = field
       end
 

data/lib/graphql/execution/multiplex.rb

@@ -25,13 +25,14 @@ module GraphQL
     class Multiplex
       include Tracing::Traceable
 
-      attr_reader :context, :queries, :schema, :max_complexity, :dataloader
+      attr_reader :context, :queries, :schema, :max_complexity, :dataloader, :current_trace
 
       def initialize(schema:, queries:, context:, max_complexity:)
         @schema = schema
         @queries = queries
         @queries.each { |q| q.multiplex = self }
         @context = context
+        @current_trace = @context[:trace] || schema.new_trace(multiplex: self)
         @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`

data/lib/graphql/filter.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
+require "graphql/deprecation"
+
 module GraphQL
   # @api private
   class Filter
-    def initialize(only: nil, except: nil)
+    def initialize(only: nil, except: nil, silence_deprecation_warning: false)
+      if !silence_deprecation_warning
+        GraphQL::Deprecation.warn("GraphQL::Filter is deprecated and will be removed in v2.1.0. Implement `visible?` on your schema members instead (https://graphql-ruby.org/authorization/visibility.html).")
+      end
       @only = only
       @except = except
     end
@@ -17,7 +22,7 @@ module GraphQL
       onlies = [self].concat(Array(only))
       merged_only = MergedOnly.build(onlies)
       merged_except = MergedExcept.build(Array(except))
-      self.class.new(only: merged_only, except: merged_except)
+      self.class.new(only: merged_only, except: merged_except, silence_deprecation_warning: true)
     end
 
     private

data/lib/graphql/language/document_from_schema_definition.rb

@@ -22,8 +22,9 @@ module GraphQL
         @include_introspection_types = include_introspection_types
         @include_built_in_scalars = include_built_in_scalars
         @include_built_in_directives = include_built_in_directives
+        @include_one_of = false
 
-        filter = GraphQL::Filter.new(only: only, except: except)
+        filter = GraphQL::Filter.new(only: only, except: except, silence_deprecation_warning: true)
         if @schema.respond_to?(:visible?)
           filter = filter.merge(only: @schema.method(:visible?))
         end
@@ -245,20 +246,30 @@ module GraphQL
       end
 
       def build_directive_nodes(directives)
-        if !include_built_in_directives
-          directives = directives.reject { |directive| directive.default_directive? }
-        end
-
         directives
           .map { |directive| build_directive_node(directive) }
           .sort_by(&:name)
       end
 
       def build_definition_nodes
-        definitions = []
-        definitions << build_schema_node if include_schema_node?
-        definitions += build_directive_nodes(warden.directives)
-        definitions += build_type_definition_nodes(warden.reachable_types)
+        dirs_to_build = warden.directives
+        if !include_built_in_directives
+          dirs_to_build = dirs_to_build.reject { |directive| directive.default_directive? }
+        end
+        dir_nodes = build_directive_nodes(dirs_to_build)
+
+        type_nodes = build_type_definition_nodes(warden.reachable_types)
+
+        if @include_one_of
+          # This may have been set to true when iterating over all types
+          dir_nodes.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))
+        end
+
+        definitions = [*dir_nodes, *type_nodes]
+        if include_schema_node?
+          definitions.unshift(build_schema_node)
+        end
+
         definitions
       end
 
@@ -318,6 +329,11 @@ module GraphQL
                 )
               end
             end
+
+            # If this schema uses this built-in directive definition,
+            # include it in the print-out since it's not part of the spec yet.
+            @include_one_of ||= dir.class == GraphQL::Schema::Directive::OneOf
+
             GraphQL::Language::Nodes::Directive.new(
               name: dir.class.graphql_name,
               arguments: args