graphql 2.0.14 → 2.0.32

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)
-                          query.context.namespace(:interpreter)[:runtime] = runtime
+                          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
@@ -86,25 +87,21 @@ module GraphQL
 
                   # Then, work through lazy results in a breadth-first way
                   multiplex.dataloader.append_job {
-                    tracer = multiplex
                     query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
                     queries = multiplex ? multiplex.queries : [query]
                     final_values = queries.map do |query|
-                      runtime = query.context.namespace(:interpreter)[:runtime]
+                      runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                       # it might not be present if the query has an error
                       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)
+                    multiplex.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 = 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
                   }
@@ -123,7 +120,7 @@ module GraphQL
                       end
                     else
                       result = {
-                        "data" => query.context.namespace(:interpreter)[:runtime].final_result
+                        "data" => query.context.namespace(:interpreter_runtime)[:runtime].final_result
                       }
 
                       if query.context.errors.any?
@@ -146,6 +143,13 @@ module GraphQL
                   # Assign values here so that the query's `@executed` becomes true
                   queries.map { |q| q.result_values ||= {} }
                   raise
+                ensure
+                  queries.map { |query|
+                    runtime = query.context.namespace(:interpreter_runtime)[:runtime]
+                    if runtime
+                      runtime.delete_all_interpreter_context
+                    end
+                  }
                 end
               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
 
@@ -29,15 +27,11 @@ module GraphQL
       def value
         if !@resolved
           @resolved = true
-          @value = begin
-            v = @get_value_func.call
-            if v.is_a?(Lazy)
-              v = v.value
-            end
-            v
-          rescue GraphQL::ExecutionError => err
-            err
+          v = @get_value_func.call
+          if v.is_a?(Lazy)
+            v = v.value
           end
+          @value = v
         end
 
         # `SKIP` was made into a subclass of `GraphQL::Error` to improve runtime performance

data/lib/graphql/execution/lookahead.rb

@@ -55,7 +55,7 @@ module GraphQL
           @arguments
         else
           @arguments = if @field
-            @query.schema.after_lazy(@query.arguments_for(@ast_nodes.first, @field)) do |args|
+            @query.after_lazy(@query.arguments_for(@ast_nodes.first, @field)) do |args|
               args.is_a?(Execution::Interpreter::Arguments) ? args.keyword_arguments : args
             end
           else
@@ -76,8 +76,8 @@ module GraphQL
       # @param field_name [String, Symbol]
       # @param arguments [Hash] Arguments which must match in the selection
       # @return [Boolean]
-      def selects?(field_name, arguments: nil)
-        selection(field_name, arguments: arguments).selected?
+      def selects?(field_name, selected_type: @selected_type, arguments: nil)
+        selection(field_name, selected_type: selected_type, arguments: arguments).selected?
       end
 
       # @return [Boolean] True if this lookahead represents a field that was requested
@@ -95,11 +95,22 @@ module GraphQL
           @query.get_field(selected_type, field_name)
         when Symbol
           # Try to avoid the `.to_s` below, if possible
-          all_fields = @query.warden.fields(selected_type)
+          all_fields = if selected_type.kind.fields?
+            @query.warden.fields(selected_type)
+          else
+            # Handle unions by checking possible
+            @query.warden
+              .possible_types(selected_type)
+              .map { |t| @query.warden.fields(t) }
+              .flatten
+          end
+
           if (match_by_orig_name = all_fields.find { |f| f.original_name == field_name })
             match_by_orig_name
           else
-            guessed_name = Schema::Member::BuildType.camelize(field_name.to_s)
+            # Symbol#name is only present on 3.0+
+            sym_s = field_name.respond_to?(:name) ? field_name.name : field_name.to_s
+            guessed_name = Schema::Member::BuildType.camelize(sym_s)
             @query.get_field(selected_type, guessed_name)
           end
         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,14 @@
 # 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
+        line = caller(2, 10).find { |l| !l.include?("lib/graphql") }
+        GraphQL::Deprecation.warn("GraphQL::Filter, `only:`, `except:`, and `.merge_filters` are deprecated and will be removed in v2.1.0. Implement `visible?` on your schema members instead (https://graphql-ruby.org/authorization/visibility.html).\n  #{line}")
+      end
       @only = only
       @except = except
     end
@@ -17,7 +23,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/introspection/directive_type.rb

@@ -11,8 +11,8 @@ module GraphQL
                     "to the executor."
       field :name, String, null: false, method: :graphql_name
       field :description, String
-      field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+      field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false, scope: false
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
       field :on_operation, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_operation?

data/lib/graphql/introspection/entry_points.rb

@@ -11,7 +11,7 @@ module GraphQL
         # Apply wrapping manually since this field isn't wrapped by instrumentation
         schema = @context.query.schema
         schema_type = schema.introspection_system.types["__Schema"]
-        schema_type.authorized_new(schema, @context)
+        schema_type.wrap(schema, @context)
       end
 
       def __type(name:)

data/lib/graphql/introspection/field_type.rb

@@ -7,7 +7,7 @@ module GraphQL
                   "a name, potentially a list of arguments, and a return type."
       field :name, String, null: false
       field :description, String
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false

data/lib/graphql/introspection/schema_type.rb

@@ -8,11 +8,11 @@ module GraphQL
                   "available types and directives on the server, as well as the entry points for "\
                   "query, mutation, and subscription operations."
 
-      field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false
+      field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false, scope: false
       field :query_type, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
       field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at."
       field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at."
-      field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
+      field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false, scope: false
       field :description, String, resolver_method: :schema_description
 
       def schema_description

data/lib/graphql/introspection/type_type.rb

@@ -14,15 +14,15 @@ module GraphQL
       field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
       field :name, String, method: :graphql_name
       field :description, String
-      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")] do
+      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")]
-      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")]
-      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")] do
+      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
+      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
+      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")]  do
+      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], scope: false  do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
       field :of_type, GraphQL::Schema::LateBoundType.new("__Type")

data/lib/graphql/introspection.rb

@@ -4,7 +4,7 @@ module GraphQL
     def self.query(include_deprecated_args: false, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false, include_is_one_of: false)
       # The introspection query to end all introspection queries, copied from
       # https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
-      <<-QUERY
+      <<-QUERY.gsub(/\n{2,}/, "\n")
 query IntrospectionQuery {
   __schema {
     #{include_schema_description ? "description" : ""}

data/lib/graphql/language/document_from_schema_definition.rb

@@ -22,18 +22,26 @@ 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)
-        if @schema.respond_to?(:visible?)
-          filter = filter.merge(only: @schema.method(:visible?))
+        schema_context = schema.context_class.new(query: nil, object: nil, schema: schema, values: context)
+
+        @warden = if only || except
+          filter = GraphQL::Filter
+            .new(only: only, except: except)
+            .merge(only: @schema.method(:visible?))
+          GraphQL::Schema::Warden.new(
+              filter,
+              schema: @schema,
+              context: schema_context,
+            )
+        else
+          @schema.warden_class.new(
+            schema: @schema,
+            context: schema_context,
+          )
         end
 
-        schema_context = schema.context_class.new(query: nil, object: nil, schema: schema, values: context)
-        @warden = GraphQL::Schema::Warden.new(
-          filter,
-          schema: @schema,
-          context: schema_context,
-        )
         schema_context.warden = @warden
       end
 
@@ -44,16 +52,18 @@ module GraphQL
       end
 
       def build_schema_node
-        GraphQL::Language::Nodes::SchemaDefinition.new(
-          query: (q = warden.root_type_for_operation("query")) && q.graphql_name,
-          mutation: (m = warden.root_type_for_operation("mutation")) && m.graphql_name,
-          subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
-          # This only supports directives from parsing,
-          # use a custom printer to add to this list.
-          #
+        schema_options = {
           # `@schema.directives` is covered by `build_definition_nodes`
-          directives: ast_directives(@schema),
-        )
+          directives: definition_directives(@schema, :schema_directives),
+        }
+        if !schema_respects_root_name_conventions?(@schema)
+          schema_options.merge!({
+            query: (q = warden.root_type_for_operation("query")) && q.graphql_name,
+            mutation: (m = warden.root_type_for_operation("mutation")) && m.graphql_name,
+            subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
+          })
+        end
+        GraphQL::Language::Nodes::SchemaDefinition.new(schema_options)
       end
 
       def build_object_type_node(object_type)
@@ -243,20 +253,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
 
@@ -283,7 +303,9 @@ module GraphQL
       private
 
       def include_schema_node?
-        always_include_schema || !schema_respects_root_name_conventions?(schema)
+        always_include_schema ||
+          !schema_respects_root_name_conventions?(schema) ||
+          !schema.schema_directives.empty?
       end
 
       def schema_respects_root_name_conventions?(schema)
@@ -293,14 +315,14 @@ module GraphQL
       end
 
       def directives(member)
-        definition_directives(member)
+        definition_directives(member, :directives)
       end
 
-      def definition_directives(member)
-        dirs = if !member.respond_to?(:directives) || member.directives.empty?
+      def definition_directives(member, directives_method)
+        dirs = if !member.respond_to?(directives_method) || member.directives.empty?
           []
         else
-          member.directives.map do |dir|
+          member.public_send(directives_method).map do |dir|
             args = []
             dir.arguments.argument_values.each_value do |arg_value| # rubocop:disable Development/ContextIsPassedCop -- directive instance method
               arg_defn = arg_value.definition
@@ -314,6 +336,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
@@ -324,10 +351,6 @@ module GraphQL
         dirs
       end
 
-      def ast_directives(member)
-        member.ast_node ? member.ast_node.directives : []
-      end
-
       attr_reader :schema, :warden, :always_include_schema,
         :include_introspection_types, :include_built_in_directives, :include_built_in_scalars
     end