graphql 2.0.30 → 2.3.6

data/lib/graphql/execution/interpreter.rb

@@ -20,12 +20,12 @@ 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
             when Hash
-              GraphQL::Query.new(schema, nil, **opts)
+              schema.query_class.new(schema, nil, **opts)
             when GraphQL::Query
               opts
             else
@@ -37,179 +37,113 @@ module GraphQL
           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] = [] }
+            multiplex_analyzers = schema.multiplex_analyzers
+            if multiplex.max_complexity
+              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
+            end
 
-            # First, run multiplex instrumentation, then query instrumentation for each query
-            call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
-              each_query_call_hooks(query_instrumenters, queries) do
-                schema = multiplex.schema
-                multiplex_analyzers = schema.multiplex_analyzers
-                queries = multiplex.queries
-                if multiplex.max_complexity
-                  multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+            schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+            begin
+              # Since this is basically the batching context,
+              # share it for a whole multiplex
+              multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy(deprecation_warning: false).new
+              # Do as much eager evaluation of the query as possible
+              results = []
+              queries.each_with_index do |query, idx|
+                if query.subscription? && !query.subscription_update?
+                  query.context.namespace(:subscriptions)[:events] = []
                 end
-
-                schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
-                begin
-                  # Since this is basically the batching context,
-                  # share it for a whole multiplex
-                  multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy.new
-                  # Do as much eager evaluation of the query as possible
-                  results = []
-                  queries.each_with_index do |query, idx|
-                    multiplex.dataloader.append_job {
-                      operation = query.selected_operation
-                      result = if operation.nil? || !query.valid? || query.context.errors.any?
-                        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)
-                          query.context.namespace(:interpreter_runtime)[:runtime] = runtime
-
-                          query.current_trace.execute_query(query: query) do
-                            runtime.run_eager
-                          end
-                        rescue GraphQL::ExecutionError => err
-                          query.context.errors << err
-                          NO_OPERATION
-                        end
+                multiplex.dataloader.append_job {
+                  operation = query.selected_operation
+                  result = if operation.nil? || !query.valid? || query.context.errors.any?
+                    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)
+                      query.context.namespace(:interpreter_runtime)[:runtime] = runtime
+
+                      query.current_trace.execute_query(query: query) do
+                        runtime.run_eager
                       end
-                      results[idx] = result
-                    }
+                    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
-                    queries.each do |query|
-                      runtime = query.context.namespace(:interpreter_runtime)[:runtime]
-                      if runtime
-                        runtime.delete_all_interpreter_context
-                      end
-                    end
-                  }
-                  multiplex.dataloader.run
+              multiplex.dataloader.run
 
-                  # Then, find all errors and assign the result to the query object
-                  results.each_with_index do |data_result, idx|
-                    query = queries[idx]
-                    # 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?
-                        # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
-                        { "errors" => query.static_errors.map(&:to_h) }
-                      else
-                        data_result
-                      end
-                    else
-                      result = {
-                        "data" => query.context.namespace(:interpreter_runtime)[:runtime].final_result
-                      }
+              # 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
 
-                      if query.context.errors.any?
-                        error_result = query.context.errors.map(&:to_h)
-                        result["errors"] = error_result
-                      end
+              # 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?
+                  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?
+                    # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
+                    { "errors" => query.static_errors.map(&:to_h) }
+                  else
+                    data_result
+                  end
+                else
+                  result = {}
 
-                      result
-                    end
-                    if query.context.namespace?(:__query_result_extensions__)
-                      query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
-                    end
-                    # Get the Query::Result, not the Hash
-                    results[idx] = query.result
+                  if query.context.errors.any?
+                    error_result = query.context.errors.map(&:to_h)
+                    result["errors"] = error_result
                   end
 
-                  results
-                rescue Exception
-                  # TODO rescue at a higher level so it will catch errors in analysis, too
-                  # 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
-                  }
+                  result["data"] = query.context.namespace(:interpreter_runtime)[:runtime].final_result
+
+                  result
+                end
+                if query.context.namespace?(:__query_result_extensions__)
+                  query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
                 end
+                # Get the Query::Result, not the Hash
+                results[idx] = query.result
               end
-            end
-          end
-        end
-
-        private
 
-        # Call the before_ hooks of each query,
-        # Then yield if no errors.
-        # `call_hooks` takes care of appropriate cleanup.
-        def each_query_call_hooks(instrumenters, queries, i = 0)
-          if i >= queries.length
-            yield
-          else
-            query = queries[i]
-            call_hooks(instrumenters, query, :before_query, :after_query) {
-              each_query_call_hooks(instrumenters, queries, i + 1) {
-                yield
+              results
+            rescue Exception
+              # TODO rescue at a higher level so it will catch errors in analysis, too
+              # 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
-
-        # Call each before hook, and if they all succeed, yield.
-        # If they don't all succeed, call after_ for each one that succeeded.
-        def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
-          begin
-            successful = []
-            instrumenters.each do |instrumenter|
-              instrumenter.public_send(before_hook_name, object)
-              successful << instrumenter
-            end
-
-            # if any before hooks raise an exception, quit calling before hooks,
-            # but call the after hooks on anything that succeeded but also
-            # raise the exception that came from the before hook.
-          rescue GraphQL::ExecutionError => err
-            object.context.errors << err
-          rescue => e
-            raise call_after_hooks(successful, object, after_hook_name, e)
-          end
-
-          begin
-            yield # Call the user code
-          ensure
-            ex = call_after_hooks(successful, object, after_hook_name, nil)
-            raise ex if ex
-          end
-        end
-
-        def call_after_hooks(instrumenters, object, after_hook_name, ex)
-          instrumenters.reverse_each do |instrumenter|
-            begin
-              instrumenter.public_send(after_hook_name, object)
-            rescue => e
-              ex = e
             end
           end
-          ex
         end
       end
 

data/lib/graphql/execution/lookahead.rb

@@ -80,6 +80,22 @@ module GraphQL
         selection(field_name, selected_type: selected_type, arguments: arguments).selected?
       end
 
+      # True if this node has a selection with alias matching `alias_name`.
+      # If `alias_name` is a String, it is treated as a GraphQL-style (camelized)
+      # field name and used verbatim. If `alias_name` is a Symbol, it is
+      # treated as a Ruby-style (underscored) name and camelized before comparing.
+      #
+      # If `arguments:` is provided, each provided key/value will be matched
+      # against the arguments in the next selection. This method will return false
+      # if any of the given `arguments:` are not present and matching in the next selection.
+      # (But, the next selection may contain _more_ than the given arguments.)
+      # @param alias_name [String, Symbol]
+      # @param arguments [Hash] Arguments which must match in the selection
+      # @return [Boolean]
+      def selects_alias?(alias_name, arguments: nil)
+        alias_selection(alias_name, arguments: arguments).selected?
+      end
+
       # @return [Boolean] True if this lookahead represents a field that was requested
       def selected?
         true
@@ -102,9 +118,10 @@ module GraphQL
             @query.warden
               .possible_types(selected_type)
               .map { |t| @query.warden.fields(t) }
-              .flatten
+              .tap(&:flatten!)
           end
 
+
           if (match_by_orig_name = all_fields.find { |f| f.original_name == field_name })
             match_by_orig_name
           else
@@ -114,23 +131,29 @@ module GraphQL
             @query.get_field(selected_type, guessed_name)
           end
         end
+        lookahead_for_selection(next_field_defn, selected_type, arguments)
+      end
 
-        if next_field_defn
-          next_nodes = []
-          @ast_nodes.each do |ast_node|
-            ast_node.selections.each do |selection|
-              find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
-            end
-          end
+      # Like {#selection}, but for aliases.
+      # It returns a null object (check with {#selected?})
+      # @return [GraphQL::Execution::Lookahead]
+      def alias_selection(alias_name, selected_type: @selected_type, arguments: nil)
+        alias_cache_key = [alias_name, arguments]
+        return alias_selections[key] if alias_selections.key?(alias_name)
 
-          if next_nodes.any?
-            Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
-          else
-            NULL_LOOKAHEAD
-          end
-        else
-          NULL_LOOKAHEAD
+        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)
+
+        alias_arguments = @query.arguments_for(alias_node, next_field_defn)
+        if alias_arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments)
+          alias_arguments = alias_arguments.keyword_arguments
         end
+
+        return NULL_LOOKAHEAD if arguments && arguments != alias_arguments
+
+        alias_selections[alias_cache_key] = lookahead_for_selection(next_field_defn, selected_type, alias_arguments, alias_name)
       end
 
       # Like {#selection}, but for all nodes.
@@ -258,7 +281,7 @@ module GraphQL
             end
             find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
-            frag_defn = @query.fragments[ast_selection.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{ast_selection.name} (found: #{@query.fragments.keys})")
+            frag_defn = lookup_fragment(ast_selection)
             # Again, assuming a valid AST
             on_type = @query.get_type(frag_defn.type.name)
             subselections_on_type = subselections_by_type[on_type] ||= {}
@@ -271,11 +294,11 @@ module GraphQL
 
       # If a selection on `node` matches `field_name` (which is backed by `field_defn`)
       # and matches the `arguments:` constraints, then add that node to `matches`
-      def find_selected_nodes(node, field_defn, arguments:, matches:)
+      def find_selected_nodes(node, field_name, field_defn, arguments:, matches:, alias_name: NOT_CONFIGURED)
         return if skipped_by_directive?(node)
         case node
         when GraphQL::Language::Nodes::Field
-          if node.name == field_defn.graphql_name
+          if node.name == field_name && (NOT_CONFIGURED.equal?(alias_name) || node.alias == alias_name)
             if arguments.nil? || arguments.empty?
               # No constraint applied
               matches << node
@@ -284,10 +307,10 @@ module GraphQL
             end
           end
         when GraphQL::Language::Nodes::InlineFragment
-          node.selections.each { |s| find_selected_nodes(s, field_defn, arguments: arguments, matches: matches) }
+          node.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches, alias_name: alias_name) }
         when GraphQL::Language::Nodes::FragmentSpread
-          frag_defn = @query.fragments[node.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{node.name} (found: #{@query.fragments.keys})")
-          frag_defn.selections.each { |s| find_selected_nodes(s, field_defn, arguments: arguments, matches: matches) }
+          frag_defn = lookup_fragment(node)
+          frag_defn.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches, alias_name: alias_name) }
         else
           raise "Unexpected selection comparison on #{node.class.name} (#{node})"
         end
@@ -306,6 +329,50 @@ module GraphQL
           query_kwargs.key?(arg_name_sym) && query_kwargs[arg_name_sym] == arg_value
         end
       end
+
+      def lookahead_for_selection(field_defn, selected_type, arguments, alias_name = NOT_CONFIGURED)
+        return NULL_LOOKAHEAD unless field_defn
+
+        next_nodes = []
+        field_name = field_defn.name
+        @ast_nodes.each do |ast_node|
+          ast_node.selections.each do |selection|
+            find_selected_nodes(selection, field_name, field_defn, arguments: arguments, matches: next_nodes, alias_name: alias_name)
+          end
+        end
+
+        return NULL_LOOKAHEAD if next_nodes.empty?
+
+        Lookahead.new(query: @query, ast_nodes: next_nodes, field: field_defn, owner_type: selected_type)
+      end
+
+      def alias_selections
+        return @alias_selections if defined?(@alias_selections)
+        @alias_selections ||= {}
+      end
+
+      def lookup_alias_node(nodes, name)
+        return if nodes.empty?
+
+        nodes.flat_map(&:children)
+             .flat_map { |child| unwrap_fragments(child) }
+             .find { |child| child.is_a?(GraphQL::Language::Nodes::Field) && child.alias == name }
+      end
+
+      def unwrap_fragments(node)
+        case node
+        when GraphQL::Language::Nodes::InlineFragment
+          node.children
+        when GraphQL::Language::Nodes::FragmentSpread
+          lookup_fragment(node).children
+        else
+          [node]
+        end
+      end
+
+      def lookup_fragment(ast_selection)
+        @query.fragments[ast_selection.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{ast_selection.name} (found: #{@query.fragments.keys})")
+      end
     end
   end
 end

data/lib/graphql/introspection/dynamic_fields.rb

@@ -2,7 +2,7 @@
 module GraphQL
   module Introspection
     class DynamicFields < Introspection::BaseObject
-      field :__typename, String, "The name of this type", null: false
+      field :__typename, String, "The name of this type", null: false, dynamic_introspection: true
 
       def __typename
         object.class.graphql_name

data/lib/graphql/introspection/entry_points.rb

@@ -2,20 +2,26 @@
 module GraphQL
   module Introspection
     class EntryPoints < Introspection::BaseObject
-      field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false
-      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system" do
+      field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false, dynamic_introspection: true
+      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", dynamic_introspection: true do
         argument :name, String
       end
 
       def __schema
         # Apply wrapping manually since this field isn't wrapped by instrumentation
-        schema = @context.query.schema
+        schema = context.schema
         schema_type = schema.introspection_system.types["__Schema"]
-        schema_type.wrap(schema, @context)
+        schema_type.wrap(schema, context)
       end
 
       def __type(name:)
-        context.warden.reachable_type?(name) ? context.warden.get_type(name) : nil
+        if context.warden.reachable_type?(name)
+          context.warden.get_type(name)
+        elsif (type = context.schema.extra_types.find { |t| t.graphql_name == name })
+          type
+        else
+          nil
+        end
       end
     end
   end

data/lib/graphql/introspection/schema_type.rb

@@ -20,7 +20,9 @@ module GraphQL
       end
 
       def types
-        @context.warden.reachable_types.sort_by(&:graphql_name)
+        types = context.warden.reachable_types + context.schema.extra_types
+        types.sort_by!(&:graphql_name)
+        types
       end
 
       def query_type

data/lib/graphql/language/block_string.rb

@@ -47,10 +47,10 @@ module GraphQL
         end
 
         # Remove leading & trailing blank lines
-        while lines.size > 0 && lines[0].empty?
+        while lines.size > 0 && contains_only_whitespace?(lines.first)
           lines.shift
         end
-        while lines.size > 0 && lines[-1].empty?
+        while lines.size > 0 && contains_only_whitespace?(lines.last)
           lines.pop
         end
 
@@ -59,40 +59,56 @@ module GraphQL
       end
 
       def self.print(str, indent: '')
-        lines = str.split("\n")
+        line_length = 120 - indent.length
+        block_str = "".dup
+        triple_quotes = "\"\"\"\n"
+        block_str << indent
+        block_str << triple_quotes
 
-        block_str = "#{indent}\"\"\"\n".dup
-
-        lines.each do |line|
-          if line == ''
-            block_str << "\n"
-          else
-            sublines = break_line(line, 120 - indent.length)
-            sublines.each do |subline|
-              block_str << "#{indent}#{subline}\n"
+        if str.include?("\n")
+          str.split("\n") do |line|
+            if line == ''
+              block_str << "\n"
+            else
+              break_line(line, line_length) do |subline|
+                block_str << indent
+                block_str << subline
+                block_str << "\n"
+              end
             end
           end
+        else
+          break_line(str, line_length) do |subline|
+            block_str << indent
+            block_str << subline
+            block_str << "\n"
+          end
         end
 
-        block_str << "#{indent}\"\"\"\n".dup
+        block_str << indent
+        block_str << triple_quotes
       end
 
       private
 
       def self.break_line(line, length)
-        return [line] if line.length < length + 5
+        return yield(line) if line.length < length + 5
 
         parts = line.split(Regexp.new("((?: |^).{15,#{length - 40}}(?= |$))"))
-        return [line] if parts.length < 4
+        return yield(line) if parts.length < 4
 
-        sublines = [parts.slice!(0, 3).join]
+        yield(parts.slice!(0, 3).join)
 
         parts.each_with_index do |part, i|
           next if i % 2 == 1
-          sublines << "#{part[1..-1]}#{parts[i + 1]}"
+          yield "#{part[1..-1]}#{parts[i + 1]}"
         end
 
-        sublines
+        nil
+      end
+
+      def self.contains_only_whitespace?(line)
+        line.match?(/^\s*$/)
       end
     end
   end

data/lib/graphql/language/definition_slice.rb

@@ -15,7 +15,7 @@ module GraphQL
 
       private
 
-      class DependencyVisitor < GraphQL::Language::Visitor
+      class DependencyVisitor < GraphQL::Language::StaticVisitor
         def initialize(doc, definitions, names)
           @names = names
           @definitions = definitions