graphql-stitching 1.7.2 → 1.8.0

data/lib/graphql/stitching/executor/shaper.rb

@@ -11,6 +11,7 @@ module GraphQL::Stitching
         @request = request
         @supergraph = request.supergraph
         @root_type = nil
+        @possible_type_names_by_type = nil
       end
 
       def perform!(raw)
@@ -24,16 +25,23 @@ module GraphQL::Stitching
         return nil if raw_object.nil?
 
         typename ||= raw_object[TypeResolver::TYPENAME_EXPORT_NODE.alias]
+        typename ||= parent_type.graphql_name unless parent_type.kind.abstract?
+
         raw_object.reject! { |key, _v| TypeResolver.export_key?(key) }
 
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
             field_name = node.alias || node.name
+            raw_value = raw_object.delete(field_name)
 
             if @request.query.get_field(parent_type, node.name).introspection?
-              if node.name == TYPENAME && parent_type == @root_type && node != TypeResolver::TYPENAME_EXPORT_NODE
-                raw_object[field_name] = @root_type.graphql_name
+              next if TypeResolver.export_key?(field_name)
+
+              raw_object[field_name] = if node.name == TYPENAME && parent_type == @root_type
+                @root_type.graphql_name
+              else
+                raw_value
               end
               next
             end
@@ -42,14 +50,14 @@ module GraphQL::Stitching
             named_type = node_type.unwrap
 
             raw_object[field_name] = if node_type.list?
-              resolve_list_scope(raw_object[field_name], Util.unwrap_non_null(node_type), node.selections)
+              resolve_list_scope(raw_value, Util.unwrap_non_null(node_type), node.selections)
             elsif Util.is_leaf_type?(named_type)
-              raw_object[field_name]
+              raw_value
             else
-              resolve_object_scope(raw_object[field_name], named_type, node.selections)
+              resolve_object_scope(raw_value, named_type, node.selections)
             end
 
-            return nil if raw_object[field_name].nil? && node_type.non_null?
+            return nil if node_type.non_null? && raw_object[field_name].nil?
 
           when GraphQL::Language::Nodes::InlineFragment
             fragment_type = node.type ? @supergraph.memoized_schema_types[node.type.name] : parent_type
@@ -79,36 +87,37 @@ module GraphQL::Stitching
 
         next_node_type = Util.unwrap_non_null(current_node_type).of_type
         named_type = next_node_type.unwrap
-        contains_null = false
+
+        if Util.is_leaf_type?(named_type)
+          return nil if next_node_type.non_null? && raw_list.include?(nil)
+
+          return raw_list
+        end
 
         resolved_list = raw_list.map! do |raw_list_element|
           result = if next_node_type.list?
             resolve_list_scope(raw_list_element, next_node_type, selections)
-          elsif Util.is_leaf_type?(named_type)
-            raw_list_element
           else
             resolve_object_scope(raw_list_element, named_type, selections)
           end
 
-          if result.nil?
-            contains_null = true
-            return nil if current_node_type.non_null?
-          end
+          return nil if result.nil? && next_node_type.non_null?
 
           result
         end
 
-        return nil if contains_null && next_node_type.non_null?
-
         resolved_list
       end
 
       def typename_in_type?(typename, type)
         return true if type.graphql_name == typename
+        return false unless typename && type.kind.abstract?
 
-        type.kind.abstract? && @request.query.possible_types(type).any? do |t|
-          t.graphql_name == typename
-        end
+        possible_type_names(type).include?(typename)
+      end
+
+      def possible_type_names(type)
+        (@possible_type_names_by_type ||= {})[type.graphql_name] ||= @request.query.possible_types(type).map(&:graphql_name)
       end
     end
   end

data/lib/graphql/stitching/executor/type_resolver_source.rb

@@ -3,40 +3,39 @@
 module GraphQL::Stitching
   class Executor
     class TypeResolverSource < GraphQL::Dataloader::Source
+      include PathAccess
+
       def initialize(executor, location)
         @executor = executor
         @location = location
-        @variables = {}
       end
 
       def fetch(ops)
         origin_sets_by_operation = ops.each_with_object({}.compare_by_identity) do |op, memo|
-          origin_set = op.path.reduce([@executor.data]) do |set, path_segment|
-            set.flat_map { |obj| obj && obj[path_segment] }.tap(&:compact!)
-          end
+          origin_set = path_objects(@executor.data, op.path)
 
           if op.if_type
             # operations planned around unused fragment conditions should not trigger requests
-            origin_set.select! { _1[TypeResolver::TYPENAME_EXPORT_NODE.alias] == op.if_type }
+            origin_set.select! { |origin_obj| origin_obj[TypeResolver::TYPENAME_EXPORT_NODE.alias] == op.if_type }
           end
 
-          memo[op] = origin_set if origin_set.any?
+          memo[op] = origin_set unless origin_set.empty?
         end
 
-        if origin_sets_by_operation.any?
-          query_document, variable_names = build_document(
+        unless origin_sets_by_operation.empty?
+          query_document, variable_names, generated_variables = build_document(
             origin_sets_by_operation,
             @executor.request.operation_name,
             @executor.request.operation_directives,
           )
-          variables = @variables.merge!(@executor.request.variables.slice(*variable_names))
+          variables = generated_variables.merge(@executor.request.variables.slice(*variable_names))
           raw_result = @executor.request.supergraph.execute_at_location(@location, query_document, variables, @executor.request)
           @executor.query_count += 1
 
           merge_results!(origin_sets_by_operation, raw_result.dig("data"))
 
           errors = raw_result.dig("errors")
-          @executor.errors.concat(extract_errors!(origin_sets_by_operation, errors)) if errors&.any?
+          @executor.errors.concat(extract_errors!(origin_sets_by_operation, errors)) if errors && !errors.empty?
         end
 
         ops.map { origin_sets_by_operation[_1] ? _1.step : nil }
@@ -51,63 +50,81 @@ module GraphQL::Stitching
       # }"
       def build_document(origin_sets_by_operation, operation_name = nil, operation_directives = nil)
         variable_defs = {}
-        query_fields = origin_sets_by_operation.map.with_index do |(op, origin_set), batch_index|
+        generated_variables = {}
+        fields_buffer = String.new
+
+        origin_sets_by_operation.each_with_index do |(op, origin_set), batch_index|
           variable_defs.merge!(op.variables)
           resolver = @executor.request.supergraph.resolvers_by_version[op.resolver]
+          fields_buffer << " " unless batch_index.zero?
 
           if resolver.list?
-            arguments = resolver.arguments.map.with_index do |arg, i|
+            fields_buffer << "_" << batch_index.to_s << "_result: " << resolver.field << "("
+
+            resolver.arguments.each_with_index do |arg, i|
+              fields_buffer << "," unless i.zero?
               if arg.key?
                 variable_name = "_#{batch_index}_key_#{i}".freeze
-                @variables[variable_name] = origin_set.map { arg.build(_1) }
+                generated_variables[variable_name] = origin_set.map { arg.build(_1) }
                 variable_defs[variable_name] = arg.to_type_signature
-                "#{arg.name}:$#{variable_name}"
+                fields_buffer << arg.name << ":$" << variable_name
               else
-                "#{arg.name}:#{arg.value.print}"
+                fields_buffer << arg.name << ":" << arg.value.print
               end
             end
 
-            "_#{batch_index}_result: #{resolver.field}(#{arguments.join(",")}) #{op.selections}"
+            fields_buffer << ") " << op.selections
           else
-            origin_set.map.with_index do |origin_obj, index|
-              arguments = resolver.arguments.map.with_index do |arg, i|
+            origin_set.each_with_index do |origin_obj, index|
+              fields_buffer << " " unless index.zero?
+              fields_buffer << "_" << batch_index.to_s << "_" << index.to_s << "_result: " << resolver.field << "("
+
+              resolver.arguments.each_with_index do |arg, i|
+                fields_buffer << "," unless i.zero?
                 if arg.key?
                   variable_name = "_#{batch_index}_#{index}_key_#{i}".freeze
-                  @variables[variable_name] = arg.build(origin_obj)
+                  generated_variables[variable_name] = arg.build(origin_obj)
                   variable_defs[variable_name] = arg.to_type_signature
-                  "#{arg.name}:$#{variable_name}"
+                  fields_buffer << arg.name << ":$" << variable_name
                 else
-                  "#{arg.name}:#{arg.value.print}"
+                  fields_buffer << arg.name << ":" << arg.value.print
                 end
               end
 
-              "_#{batch_index}_#{index}_result: #{resolver.field}(#{arguments.join(",")}) #{op.selections}"
+              fields_buffer << ") " << op.selections
             end
           end
         end
 
-        doc = String.new(QUERY_OP) # << resolver fulfillment always uses query
+        doc_buffer = String.new(QUERY_OP) # << resolver fulfillment always uses query
 
         if operation_name
-          doc << " #{operation_name}"
+          doc_buffer << " " << operation_name
           origin_sets_by_operation.each_key do |op|
-            doc << "_#{op.step}"
+            doc_buffer << "_" << op.step.to_s
           end
         end
 
-        if variable_defs.any?
-          doc << "(#{variable_defs.map { |k, v| "$#{k}:#{v}" }.join(",")})"
+        unless variable_defs.empty?
+          doc_buffer << "("
+          variable_defs.each_with_index do |(k, v), i|
+            doc_buffer << "," unless i.zero?
+            doc_buffer << "$" << k << ":" << v
+          end
+          doc_buffer << ")"
         end
 
         if operation_directives
-          doc << " #{operation_directives} "
+          doc_buffer << " " << operation_directives << " "
         end
 
-        doc << "{ #{query_fields.join(" ")} }"
+        doc_buffer << "{ " << fields_buffer << " }"
 
-        return doc, variable_defs.keys.tap do |names|
-          names.reject! { @variables.key?(_1) }
+        variable_names = variable_defs.keys.tap do |names|
+          names.reject! { generated_variables.key?(_1) }
         end
+
+        return doc_buffer, variable_names, generated_variables
       end
 
       def merge_results!(origin_sets_by_operation, raw_result)
@@ -120,94 +137,67 @@ module GraphQL::Stitching
             origin_set.map.with_index { |_, index| raw_result["_#{batch_index}_#{index}_result"] }
           end
 
-          next unless results&.any?
+          next if results.nil? || results.empty?
 
           origin_set.each_with_index do |origin_obj, index|
-            origin_obj.merge!(results[index]) if results[index]
+            result = results[index]
+            origin_obj.merge!(result) if result
           end
         end
       end
 
       # https://spec.graphql.org/June2018/#sec-Errors
-      def extract_errors!(origin_sets_by_operation, errors)
+      def extract_errors!(origin_sets_by_operation, errors, origin_paths_by_operation = nil)
         ops = origin_sets_by_operation.keys
         origin_sets = origin_sets_by_operation.values
-        pathed_errors_by_op_index_and_object_id = {}
+        origin_paths_by_operation ||= origin_sets_by_operation.each_with_object({}.compare_by_identity) do |(op, origin_set), memo|
+          memo[op] = paths_for_origin_set(op, origin_set)
+        end
 
-        errors_result = errors.each_with_object([]) do |err, memo|
-          err.delete("locations")
+        errors.each_with_object([]) do |err, memo|
           path = err["path"]
 
           if path && path.length > 0
             result_alias = /^_(\d+)(?:_(\d+))?_result$/.match(path.first.to_s)
 
             if result_alias
-              path = err["path"] = path[1..-1]
+              path = path[1..-1]
+              batch_index = result_alias[1].to_i
 
-              origin_obj = if result_alias[2]
-                origin_sets.dig(result_alias[1].to_i, result_alias[2].to_i)
-              elsif path[0].is_a?(Integer) || /\d+/.match?(path[0].to_s)
-                origin_sets.dig(result_alias[1].to_i, path.shift.to_i)
+              origin_index = if result_alias[2]
+                result_alias[2].to_i
+              elsif path[0].is_a?(Integer) || /\A\d+\z/.match?(path[0].to_s)
+                path.shift.to_i
               end
+              origin_obj = origin_sets.dig(batch_index, origin_index) if origin_index
 
               if origin_obj
-                by_op_index = pathed_errors_by_op_index_and_object_id[result_alias[1].to_i] ||= {}
-                by_object_id = by_op_index[origin_obj.object_id] ||= []
-                by_object_id << err
-                next
+                op = ops[batch_index]
+                object_path = origin_paths_by_operation.dig(op, origin_index)
+
+                if object_path
+                  memo << sanitized_error(err, path: object_path + path)
+                  next
+                end
               end
+
+              memo << sanitized_error(err, path: path)
+              next
             end
           end
 
-          memo << err
+          memo << sanitized_error(err)
         end
-
-        if pathed_errors_by_op_index_and_object_id.any?
-          pathed_errors_by_op_index_and_object_id.each do |op_index, pathed_errors_by_object_id|
-            repath_errors!(pathed_errors_by_object_id, ops.dig(op_index, "path"))
-            errors_result.push(*pathed_errors_by_object_id.each_value)
-          end
-        end
-
-        errors_result.tap(&:flatten!)
       end
 
       private
 
-      # traverse forward through origin data, expanding arrays to follow all paths
-      # any errors found for an origin object_id have their path prefixed by the object path
-      def repath_errors!(pathed_errors_by_object_id, forward_path, current_path=[], root=@executor.data)
-        current_path.push(forward_path.shift)
-        scope = root[current_path.last]
-
-        if forward_path.any? && scope.is_a?(Array)
-          scope.each_with_index do |element, index|
-            inner_elements = element.is_a?(Array) ? element.flatten : [element]
-            inner_elements.each do |inner_element|
-              current_path << index
-              repath_errors!(pathed_errors_by_object_id, forward_path, current_path, inner_element)
-              current_path.pop
-            end
-          end
-
-        elsif forward_path.any?
-          repath_errors!(pathed_errors_by_object_id, forward_path, current_path, scope)
-
-        elsif scope.is_a?(Array)
-          scope.each_with_index do |element, index|
-            inner_elements = element.is_a?(Array) ? element.flatten : [element]
-            inner_elements.each do |inner_element|
-              errors = pathed_errors_by_object_id[inner_element.object_id]
-              errors.each { _1["path"] = [*current_path, index, *_1["path"]] } if errors
-            end
-          end
-
-        else
-          errors = pathed_errors_by_object_id[scope.object_id]
-          errors.each { _1["path"] = [*current_path, *_1["path"]] } if errors
+      def paths_for_origin_set(op, origin_set)
+        paths_by_object_id = path_entries(@executor.data, op.path).each_with_object(Hash.new { |h, k| h[k] = [] }) do |(object, path), memo|
+          memo[object.object_id] << path
         end
 
-        forward_path.unshift(current_path.pop)
+        origin_set.map { |origin_obj| paths_by_object_id[origin_obj.object_id].shift }
       end
     end
   end

data/lib/graphql/stitching/executor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "executor/path_access"
 require_relative "executor/root_source"
 require_relative "executor/type_resolver_source"
 require_relative "executor/shaper"
@@ -79,7 +80,7 @@ module GraphQL
 
       def exec_task(task)
         next_steps = task.load.tap(&:compact!)
-        exec!(next_steps) if next_steps.any?
+        exec!(next_steps) unless next_steps.empty?
       end
     end
   end

data/lib/graphql/stitching/http_executable.rb

@@ -80,7 +80,7 @@ module GraphQL
 
         return if files_by_path.none?
 
-        map = {}
+        map = Hash.new { |h, k| h[k] = [] }
         files = files_by_path.values.tap(&:uniq!)
         variables_copy = variables.dup
 
@@ -90,7 +90,6 @@ module GraphQL
           path.each_with_index do |key, i|
             if i == path.length - 1
               file_index = files.index(copy[key]).to_s
-              map[file_index] ||= []
               map[file_index] << "variables.#{path.join(".")}"
               copy[key] = nil
             elsif orig[key].object_id == copy[key].object_id

data/lib/graphql/stitching/plan.rb

@@ -2,21 +2,42 @@
 
 module GraphQL
   module Stitching
-    # Immutable-ish structures representing a query plan.
+    # Immutable structures representing a query plan.
     # May serialize to/from JSON.
     class Plan
-      Op = Struct.new(
-        :step,
-        :after,
-        :location,
-        :operation_type,
-        :selections,
-        :variables,
-        :path,
-        :if_type,
-        :resolver,
-        keyword_init: true
-      ) do
+      class Op
+        attr_reader :step
+        attr_reader :after
+        attr_reader :location
+        attr_reader :operation_type
+        attr_reader :selections
+        attr_reader :variables
+        attr_reader :path
+        attr_reader :if_type
+        attr_reader :resolver
+        
+        def initialize(
+          step:,
+          after:,
+          location:,
+          operation_type:,
+          selections:,
+          variables: nil,
+          path: nil,
+          if_type: nil,
+          resolver: nil
+        )
+          @step = step
+          @after = after
+          @location = location
+          @operation_type = operation_type
+          @selections = selections
+          @variables = variables
+          @path = path
+          @if_type = if_type
+          @resolver = resolver
+        end
+
         def as_json
           {
             step: step,
@@ -30,6 +51,18 @@ module GraphQL
             resolver: resolver
           }.tap(&:compact!)
         end
+
+        def ==(other)
+          step == other.step &&
+            after == other.after &&
+            location == other.location &&
+            operation_type == other.operation_type &&
+            selections == other.selections &&
+            variables == other.variables &&
+            path == other.path &&
+            if_type == other.if_type &&
+            resolver == other.resolver
+        end
       end
 
       class << self