graphql 2.2.17 → 2.5.16

data/lib/graphql/execution/interpreter.rb

@@ -20,30 +20,37 @@ module GraphQL
         # @param queries [Array<GraphQL::Query, Hash>]
         # @param context [Hash]
         # @param max_complexity [Integer, nil]
-        # @return [Array<Hash>] One result per query
+        # @return [Array<GraphQL::Query::Result>] One result per query
         def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
           queries = query_options.map do |opts|
-            case opts
+            query = case opts
             when Hash
               schema.query_class.new(schema, nil, **opts)
-            when GraphQL::Query
+            when GraphQL::Query, GraphQL::Query::Partial
               opts
             else
               raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
             end
+            query
           end
 
+          return GraphQL::EmptyObjects::EMPTY_ARRAY if queries.empty?
+
           multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
-          multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
+          trace = multiplex.current_trace
+          Fiber[:__graphql_current_multiplex] = multiplex
+          trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
-            lazies_at_depth = Hash.new { |h, k| h[k] = [] }
             multiplex_analyzers = schema.multiplex_analyzers
             if multiplex.max_complexity
-              multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
             end
 
+            trace.begin_analyze_multiplex(multiplex, multiplex_analyzers)
             schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+            trace.end_analyze_multiplex(multiplex, multiplex_analyzers)
+
             begin
               # Since this is basically the batching context,
               # share it for a whole multiplex
@@ -52,18 +59,20 @@ module GraphQL
               results = []
               queries.each_with_index do |query, idx|
                 if query.subscription? && !query.subscription_update?
-                  query.context.namespace(:subscriptions)[:events] = []
+                  subs_namespace = query.context.namespace(:subscriptions)
+                  subs_namespace[:events] = []
+                  subs_namespace[:subscriptions] = {}
                 end
                 multiplex.dataloader.append_job {
                   operation = query.selected_operation
-                  result = if operation.nil? || !query.valid? || query.context.errors.any?
+                  result = if operation.nil? || !query.valid? || !query.context.errors.empty?
                     NO_OPERATION
                   else
                     begin
                       # 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, lazies_at_depth: lazies_at_depth)
+                      runtime = Runtime.new(query: query)
                       query.context.namespace(:interpreter_runtime)[:runtime] = runtime
 
                       query.current_trace.execute_query(query: query) do
@@ -71,40 +80,23 @@ module GraphQL
                       end
                     rescue GraphQL::ExecutionError => err
                       query.context.errors << err
-                      NO_OPERATION
                     end
                   end
                   results[idx] = result
                 }
               end
 
-              multiplex.dataloader.run
-
-              # Then, work through lazy results in a breadth-first way
-              multiplex.dataloader.append_job {
-                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]
-                  # it might not be present if the query has an error
-                  runtime ? runtime.final_result : nil
-                end
-                final_values.compact!
-                multiplex.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
-                  Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
-                end
-              }
-              multiplex.dataloader.run
+              multiplex.dataloader.run(trace_query_lazy: multiplex)
 
               # Then, find all errors and assign the result to the query object
               results.each_with_index do |data_result, idx|
                 query = queries[idx]
-                if (events = query.context.namespace(:subscriptions)[:events]) && events.any?
+                if (events = query.context.namespace(:subscriptions)[:events]) && !events.empty?
                   schema.subscriptions.write_subscription(query, events)
                 end
                 # Assign the result so that it can be accessed in instrumentation
                 query.result_values = if data_result.equal?(NO_OPERATION)
-                  if !query.valid? || query.context.errors.any?
+                  if !query.valid? || !query.context.errors.empty?
                     # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
                     { "errors" => query.static_errors.map(&:to_h) }
                   else
@@ -113,7 +105,7 @@ module GraphQL
                 else
                   result = {}
 
-                  if query.context.errors.any?
+                  if !query.context.errors.empty?
                     error_result = query.context.errors.map(&:to_h)
                     result["errors"] = error_result
                   end
@@ -136,6 +128,7 @@ module GraphQL
               queries.map { |q| q.result_values ||= {} }
               raise
             ensure
+              Fiber[:__graphql_current_multiplex] = nil
               queries.map { |query|
                 runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                 if runtime

data/lib/graphql/execution/lookahead.rb

@@ -56,7 +56,14 @@ module GraphQL
         else
           @arguments = if @field
             @query.after_lazy(@query.arguments_for(@ast_nodes.first, @field)) do |args|
-              args.is_a?(Execution::Interpreter::Arguments) ? args.keyword_arguments : args
+              case args
+              when Execution::Interpreter::Arguments
+                args.keyword_arguments
+              when GraphQL::ExecutionError
+                EmptyObjects::EMPTY_HASH
+              else
+                args
+              end
             end
           else
             nil
@@ -108,16 +115,16 @@ module GraphQL
       def selection(field_name, selected_type: @selected_type, arguments: nil)
         next_field_defn = case field_name
         when String
-          @query.get_field(selected_type, field_name)
+          @query.types.field(selected_type, field_name)
         when Symbol
           # Try to avoid the `.to_s` below, if possible
           all_fields = if selected_type.kind.fields?
-            @query.warden.fields(selected_type)
+            @query.types.fields(selected_type)
           else
             # Handle unions by checking possible
-            @query.warden
+            @query.types
               .possible_types(selected_type)
-              .map { |t| @query.warden.fields(t) }
+              .map { |t| @query.types.fields(t) }
               .tap(&:flatten!)
           end
 
@@ -128,7 +135,7 @@ module GraphQL
             # 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)
+            @query.types.field(selected_type, guessed_name)
           end
         end
         lookahead_for_selection(next_field_defn, selected_type, arguments)
@@ -144,7 +151,7 @@ module GraphQL
         alias_node = lookup_alias_node(ast_nodes, alias_name)
         return NULL_LOOKAHEAD unless alias_node
 
-        next_field_defn = @query.get_field(selected_type, alias_node.name)
+        next_field_defn = @query.types.field(selected_type, alias_node.name)
 
         alias_arguments = @query.arguments_for(alias_node, next_field_defn)
         if alias_arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments)
@@ -183,7 +190,7 @@ module GraphQL
 
         subselections_by_type.each do |type, ast_nodes_by_response_key|
           ast_nodes_by_response_key.each do |response_key, ast_nodes|
-            field_defn = @query.get_field(type, ast_nodes.first.name)
+            field_defn = @query.types.field(type, ast_nodes.first.name)
             lookahead = Lookahead.new(query: @query, ast_nodes: ast_nodes, field: field_defn, owner_type: type)
             subselections.push(lookahead)
           end
@@ -266,7 +273,7 @@ module GraphQL
             elsif arguments.nil? || arguments.empty?
               selections_on_type[response_key] = [ast_selection]
             else
-              field_defn = @query.get_field(selected_type, ast_selection.name)
+              field_defn = @query.types.field(selected_type, ast_selection.name)
               if arguments_match?(arguments, field_defn, ast_selection)
                 selections_on_type[response_key] = [ast_selection]
               end
@@ -276,14 +283,14 @@ module GraphQL
             subselections_on_type = selections_on_type
             if (t = ast_selection.type)
               # Assuming this is valid, that `t` will be found.
-              on_type = @query.get_type(t.name)
+              on_type = @query.types.type(t.name)
               subselections_on_type = subselections_by_type[on_type] ||= {}
             end
             find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = lookup_fragment(ast_selection)
             # Again, assuming a valid AST
-            on_type = @query.get_type(frag_defn.type.name)
+            on_type = @query.types.type(frag_defn.type.name)
             subselections_on_type = subselections_by_type[on_type] ||= {}
             find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
           else

data/lib/graphql/execution/multiplex.rb

@@ -32,14 +32,15 @@ module GraphQL
         @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}`
-        if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-          @tracers << GraphQL::Backtrace::Tracer
-        end
         @max_complexity = max_complexity
+        @current_trace = context[:trace] ||= schema.new_trace(multiplex: self)
+        @logger = nil
+      end
+
+      def logger
+        @logger ||= @schema.logger_for(context)
       end
     end
   end

data/lib/graphql/introspection/directive_location_enum.rb

@@ -7,7 +7,7 @@ module GraphQL
                   "a __DirectiveLocation describes one such possible adjacencies."
 
       GraphQL::Schema::Directive::LOCATIONS.each do |location|
-        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location)
+        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location, value_method: false)
       end
       introspection true
     end

data/lib/graphql/introspection/directive_type.rb

@@ -22,7 +22,7 @@ module GraphQL
       field :is_repeatable, Boolean, method: :repeatable?
 
       def args(include_deprecated:)
-        args = @context.warden.arguments(@object)
+        args = @context.types.arguments(@object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end

data/lib/graphql/introspection/entry_points.rb

@@ -15,8 +15,8 @@ module GraphQL
       end
 
       def __type(name:)
-        if context.warden.reachable_type?(name)
-          context.warden.get_type(name)
+        if context.types.reachable_type?(name) && (type = context.types.type(name))
+          type
         elsif (type = context.schema.extra_types.find { |t| t.graphql_name == name })
           type
         else

data/lib/graphql/introspection/field_type.rb

@@ -19,7 +19,7 @@ module GraphQL
       end
 
       def args(include_deprecated:)
-        args = @context.warden.arguments(@object)
+        args = @context.types.arguments(@object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end

data/lib/graphql/introspection/schema_type.rb

@@ -20,31 +20,26 @@ module GraphQL
       end
 
       def types
-        types = context.warden.reachable_types + context.schema.extra_types
+        query_types = context.types.all_types
+        types = query_types + context.schema.extra_types
         types.sort_by!(&:graphql_name)
         types
       end
 
       def query_type
-        permitted_root_type("query")
+        @context.types.query_root
       end
 
       def mutation_type
-        permitted_root_type("mutation")
+        @context.types.mutation_root
       end
 
       def subscription_type
-        permitted_root_type("subscription")
+        @context.types.subscription_root
       end
 
       def directives
-        @context.warden.directives
-      end
-
-      private
-
-      def permitted_root_type(op_type)
-        @context.warden.root_type_for_operation(op_type)
+        @context.types.directives.sort_by(&:graphql_name)
       end
     end
   end

data/lib/graphql/introspection/type_type.rb

@@ -52,7 +52,7 @@ module GraphQL
         if !@object.kind.enum?
           nil
         else
-          enum_values = @context.warden.enum_values(@object)
+          enum_values = @context.types.enum_values(@object)
 
           if !include_deprecated
             enum_values = enum_values.select {|f| !f.deprecation_reason }
@@ -64,7 +64,7 @@ module GraphQL
 
       def interfaces
         if @object.kind.object? || @object.kind.interface?
-          @context.warden.interfaces(@object).sort_by(&:graphql_name)
+          @context.types.interfaces(@object).sort_by(&:graphql_name)
         else
           nil
         end
@@ -72,7 +72,7 @@ module GraphQL
 
       def input_fields(include_deprecated:)
         if @object.kind.input_object?
-          args = @context.warden.arguments(@object)
+          args = @context.types.arguments(@object)
           args = args.reject(&:deprecation_reason) unless include_deprecated
           args
         else
@@ -82,7 +82,7 @@ module GraphQL
 
       def possible_types
         if @object.kind.abstract?
-          @context.warden.possible_types(@object).sort_by(&:graphql_name)
+          @context.types.possible_types(@object).sort_by(&:graphql_name)
         else
           nil
         end
@@ -92,7 +92,7 @@ module GraphQL
         if !@object.kind.fields?
           nil
         else
-          fields = @context.warden.fields(@object)
+          fields = @context.types.fields(@object)
           if !include_deprecated
             fields = fields.select {|f| !f.deprecation_reason }
           end

data/lib/graphql/invalid_name_error.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  class InvalidNameError < GraphQL::ExecutionError
+  class InvalidNameError < GraphQL::Error
     attr_reader :name, :valid_regex
     def initialize(name, valid_regex)
       @name = name

data/lib/graphql/invalid_null_error.rb

@@ -2,31 +2,34 @@
 module GraphQL
   # Raised automatically when a field's resolve function returns `nil`
   # for a non-null field.
-  class InvalidNullError < GraphQL::RuntimeTypeError
+  class InvalidNullError < GraphQL::Error
     # @return [GraphQL::BaseType] The owner of {#field}
     attr_reader :parent_type
 
     # @return [GraphQL::Field] The field which failed to return a value
     attr_reader :field
 
-    # @return [nil, GraphQL::ExecutionError] The invalid value for this field
-    attr_reader :value
+    # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
+    attr_reader :ast_node
 
-    def initialize(parent_type, field, value)
+    # @return [Boolean] indicates an array result caused the error
+    attr_reader :is_from_array
+
+    def initialize(parent_type, field, ast_node, is_from_array: false)
       @parent_type = parent_type
       @field = field
-      @value = value
-      super("Cannot return null for non-nullable field #{@parent_type.graphql_name}.#{@field.graphql_name}")
-    end
-
-    # @return [Hash] An entry for the response's "errors" key
-    def to_h
-      { "message" => message }
-    end
-
-    # @deprecated always false
-    def parent_error?
-      false
+      @ast_node = ast_node
+      @is_from_array = is_from_array
+
+      # For List elements, identify the non-null error is for an
+      # element and the required element type so it's not ambiguous
+      # whether it was caused by a null instead of the list or a
+      # null element.
+      if @is_from_array
+        super("Cannot return null for non-nullable element of type '#{@field.type.of_type.of_type.to_type_signature}' for #{@parent_type.graphql_name}.#{@field.graphql_name}")
+      else
+        super("Cannot return null for non-nullable field #{@parent_type.graphql_name}.#{@field.graphql_name}")
+      end
     end
 
     class << self
@@ -39,7 +42,7 @@ module GraphQL
       end
 
       def inspect
-        if (name.nil? || parent_class.name.nil?) && parent_class.respond_to?(:mutation) && (mutation = parent_class.mutation)
+        if (name.nil? || parent_class&.name.nil?) && parent_class.respond_to?(:mutation) && (mutation = parent_class.mutation)
           "#{mutation.inspect}::#{parent_class.graphql_name}::InvalidNullError"
         else
           super

data/lib/graphql/language/cache.rb

@@ -5,12 +5,25 @@ require 'digest/sha2'
 
 module GraphQL
   module Language
+    # This cache is used by {GraphQL::Language::Parser.parse_file} when it's enabled.
+    #
+    # With Rails, parser caching may enabled by setting `config.graphql.parser_cache = true` in your Rails application.
+    #
+    # The cache may be manually built by assigning `GraphQL::Language::Parser.cache = GraphQL::Language::Cache.new("some_dir")`.
+    # This will create a directory (`tmp/cache/graphql` by default) that stores a cache of parsed files.
+    #
+    # Much like [bootsnap](https://github.com/Shopify/bootsnap), the parser cache needs to be cleaned up manually.
+    # You will need to clear the cache directory for each new deployment of your application.
+    # Also note that the parser cache will grow as your schema is loaded, so the cache directory must be writable.
+    #
+    # @see GraphQL::Railtie for simple Rails integration
     class Cache
       def initialize(path)
         @path = path
       end
 
       DIGEST = Digest::SHA256.new << GraphQL::VERSION
+
       def fetch(filename)
         hash = DIGEST.dup << filename
         begin

data/lib/graphql/language/comment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    module Comment
+      def self.print(str, indent: '')
+        lines = str.split("\n").map do |line|
+          comment_str = "".dup
+          comment_str << indent
+          comment_str << "# "
+          comment_str << line
+          comment_str.rstrip
+        end
+
+        lines.join("\n") + "\n"
+      end
+    end
+  end
+end