graphql-stitching 1.7.3 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65951348a6c34feff379cdbfc7483380dce295dbd86cc24870eee264de079a46
-  data.tar.gz: c16673030f3be9728c986b8e4fe5e8084ca7a4e0240ac7e495da26261f1f0a3a
+  metadata.gz: 66715354401a5907a302fcecc6e5a285344e31357060f093f5804e6c27dab1d2
+  data.tar.gz: c51d4046ad4c6101edec196d97b7e44f083640ad739c81f9f27612067646c6fb
 SHA512:
-  metadata.gz: 255495cde4ac822edc3b93ac67af6eb3b49ab657adedebd2870058468d6b49d241fca5e01c494fd3f345e134b21755e1a3f3ce2d2d43bad6e078b1833f47768c
-  data.tar.gz: ac375cfe4ac73d9b1ce732180efada3d56aab8fa6e5cca75b40e0a6a8d133a45e67637090b9e49a76f9b2b20a81de9014bde03f88f03cdf277f85b5aa435504a
+  metadata.gz: 641b5c2903c1d07b00d794ac445aadc96bb7be640ef0e5b2607842e8c5d296eebfd39ddde3e75a97978e2533994a0c9d0b587c68cfd76c8d2c5cde4fb0dc302a
+  data.tar.gz: 916a94f76a1d453cf24ea7e382fe3b1b41184390720dd55c5b0ef1ffe32306f40ee33de73574e7672a0a895461e049b9204ef3fbd1e907a2570f29e463b1c1c1

data/Rakefile

@@ -9,4 +9,14 @@ Rake::TestTask.new(:test) do |t, args|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+namespace :benchmark do
+  desc "Benchmark planner throughput"
+  task :planner do
+    ruby "benchmark/run.rb"
+  end
+end
+
+desc "Run benchmarks"
+task benchmark: "benchmark:planner"
+
+task :default => :test

data/benchmark/run.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "bundler/setup"
+require "graphql/stitching"
+
+STITCH_DEFINITION = "directive @stitch(key: String!, arguments: String, typeName: String) repeatable on FIELD_DEFINITION\n"
+
+def compose_definitions(locations)
+  locations = locations.each_with_object({}) do |(location, schema_config), memo|
+    schema_config = STITCH_DEFINITION + schema_config if schema_config.include?("@stitch")
+    memo[location.to_s] = { schema: GraphQL::Schema.from_definition(schema_config) }
+  end
+
+  GraphQL::Stitching::Composer.new.perform(locations)
+end
+
+class PlannerBenchmark
+  Case = Struct.new(:name, :supergraph, :document, :variables, keyword_init: true)
+
+  MINIMUM_SECONDS = Float(ENV.fetch("BENCHMARK_SECONDS", 2.0))
+  WARMUP_ITERATIONS = Integer(ENV.fetch("BENCHMARK_WARMUP", 200))
+
+  def initialize(cases)
+    @cases = cases
+  end
+
+  def run
+    width = @cases.map { |c| c.name.length }.max
+
+    puts "GraphQL::Stitching::Planner"
+    puts "ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
+    puts "graphql #{GraphQL::VERSION}"
+    puts "minimum #{MINIMUM_SECONDS}s per case"
+    puts
+
+    @cases.each do |bench_case|
+      WARMUP_ITERATIONS.times { plan(bench_case) }
+
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      iterations = 0
+      elapsed = 0.0
+
+      loop do
+        plan(bench_case)
+        iterations += 1
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        break if elapsed >= MINIMUM_SECONDS
+      end
+
+      ips = iterations / elapsed
+      microseconds = 1_000_000.0 / ips
+      puts "%-#{width}s %10.1f i/s %10.2f us/i" % [bench_case.name, ips, microseconds]
+    end
+  end
+
+  private
+
+  def plan(bench_case)
+    GraphQL::Stitching::Request.new(
+      bench_case.supergraph,
+      bench_case.document,
+      variables: bench_case.variables,
+    ).plan
+  end
+end
+
+root_supergraph = compose_definitions({
+  "widgets" => %|
+    input MakeWidgetInput { name: String child: MakeWidgetInput }
+    type Widget { id: ID! name(lang: String): String size: Int color: String }
+    type Query { widget(id: ID!): Widget widgets(ids: [ID!]): [Widget!]! }
+    type Mutation { makeWidget(input: MakeWidgetInput!): Widget }
+  |,
+  "sprockets" => %|
+    input MakeSprocketInput { name: String child: MakeSprocketInput }
+    type Sprocket { id: ID! name(lang: String): String size: Int color: String }
+    type Query { sprocket(id: ID!): Sprocket sprockets(ids: [ID!]): [Sprocket!]! }
+    type Mutation { makeSprocket(input: MakeSprocketInput!): Sprocket }
+  |,
+})
+
+delegation_supergraph = compose_definitions({
+  "alpha" => %|
+    type Widget { id: ID! a: String! b: String! }
+    type Query { alpha(id: ID!): Widget @stitch(key: "id") }
+  |,
+  "bravo" => %|
+    type Widget { id: ID! a: String! b: String! }
+    type Query { bravo(id: ID!): Widget @stitch(key: "id") }
+  |,
+  "charlie" => %|
+    type Widget { id: ID! c: String! d: String! }
+    type Query { charlie(id: ID!): Widget @stitch(key: "id") }
+  |,
+  "delta" => %|
+    type Widget { id: ID! d: String! e: String! }
+    type Query { delta(id: ID!): Widget @stitch(key: "id") }
+  |,
+  "echo" => %|
+    type Widget { id: ID! d: String! e: String! f: String! }
+    type Query { echo(id: ID!): Widget @stitch(key: "id") }
+  |,
+  "foxtrot" => %|
+    type Widget { id: ID! d: String! f: String! }
+    type Query { foxtrot(id: ID!): Widget @stitch(key: "id") }
+  |,
+})
+
+resolver_supergraph = compose_definitions({
+  "storefronts" => %|
+    type Storefront {
+      id: ID!
+      name: String!
+      products: [Product]!
+    }
+    type Product {
+      upc: ID!
+    }
+    type Query {
+      storefront(id: ID!): Storefront
+    }
+  |,
+  "products" => %|
+    type Product {
+      upc: ID!
+      name: String!
+      price: Float!
+      manufacturer: Manufacturer!
+    }
+    type Manufacturer {
+      id: ID!
+      name: String!
+      products: [Product]!
+    }
+    type Query {
+      product(upc: ID!): Product @stitch(key: "upc")
+      productsManufacturer(id: ID!): Manufacturer @stitch(key: "id")
+    }
+  |,
+  "manufacturers" => %|
+    type Manufacturer {
+      id: ID!
+      name: String!
+      address: String!
+    }
+    type Query {
+      manufacturer(id: ID!): Manufacturer @stitch(key: "id")
+    }
+  |,
+})
+
+abstract_supergraph = compose_definitions({
+  "a" => %|
+    interface Buyable {
+      id: ID!
+      name: String!
+      price: Float!
+    }
+    type Product implements Buyable {
+      id: ID!
+      name: String!
+      price: Float!
+    }
+    type Query {
+      products(ids: [ID!]!): [Product]! @stitch(key: "id")
+    }
+  |,
+  "b" => %|
+    interface Buyable { id: ID! }
+    type Product implements Buyable { id: ID! }
+    type Bundle implements Buyable {
+      id: ID!
+      name: String!
+      price: Float!
+      products: [Product]!
+    }
+    type Query {
+      buyable(id: ID!): Buyable @stitch(key: "id")
+    }
+  |,
+})
+
+cases = [
+  PlannerBenchmark::Case.new(
+    name: "root groups",
+    supergraph: root_supergraph,
+    document: %|
+      query($wid: ID!, $sid: ID!, $ids: [ID!], $lang: String) {
+        a: widget(id: $wid) { id name(lang: $lang) size color }
+        b: sprocket(id: $sid) { id name(lang: $lang) size color }
+        c: widgets(ids: $ids) { id name size color }
+        d: sprockets(ids: $ids) { id name size color }
+      }
+    |,
+    variables: { "wid" => "1", "sid" => "2", "ids" => ["1", "2"], "lang" => "en" },
+  ),
+  PlannerBenchmark::Case.new(
+    name: "variables",
+    supergraph: root_supergraph,
+    document: %|
+      mutation($wname1: String!, $wname2: String!, $sname1: String!, $sname2: String!, $lang: String) {
+        makeWidget(input: { name: $wname1, child: { name: $wname2 } }) { id name(lang: $lang) }
+        makeSprocket(input: { name: $sname1, child: { name: $sname2 } }) { id name(lang: $lang) }
+      }
+    |,
+    variables: {
+      "wname1" => "a",
+      "wname2" => "b",
+      "sname1" => "c",
+      "sname2" => "d",
+      "lang" => "en",
+    },
+  ),
+  PlannerBenchmark::Case.new(
+    name: "delegation",
+    supergraph: delegation_supergraph,
+    document: %|query { alpha(id: "1") { a b c d e f } }|,
+  ),
+  PlannerBenchmark::Case.new(
+    name: "nested resolvers",
+    supergraph: resolver_supergraph,
+    document: %|
+      query {
+        storefront(id: "1") {
+          name
+          products {
+            name
+            manufacturer {
+              address
+              products {
+                name
+              }
+            }
+          }
+        }
+      }
+    |,
+  ),
+  PlannerBenchmark::Case.new(
+    name: "fragments",
+    supergraph: resolver_supergraph,
+    document: %|
+      query {
+        storefront(id: "1") {
+          products {
+            ...ProductAttrs
+            manufacturer {
+              ...ManufacturerAttrs
+            }
+          }
+        }
+      }
+      fragment ProductAttrs on Product { name price }
+      fragment ManufacturerAttrs on Manufacturer {
+        name
+        address
+        products { ...ProductAttrs }
+      }
+    |,
+  ),
+  PlannerBenchmark::Case.new(
+    name: "abstracts",
+    supergraph: abstract_supergraph,
+    document: %|
+      query {
+        buyable(id: "1") {
+          ... {
+            ...BuyableAttrs
+          }
+        }
+      }
+      fragment BuyableAttrs on Buyable { id name price }
+    |,
+  ),
+]
+
+PlannerBenchmark.new(cases).run

data/graphql-stitching.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'graphql', '>= 2.0'
 
-  spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'rake', '~> 12.0'
-  spec.add_development_dependency 'minitest', '~> 5.12'
+  spec.add_development_dependency 'bundler', '>= 2.0'
+  spec.add_development_dependency 'rake', '>= 12.0'
+  spec.add_development_dependency 'minitest', '>= 5.12'
 end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Executor
+    # Utilities for traversing aggregate executor data along planned paths.
+    module PathAccess
+      private
+
+      def path_objects(root, path)
+        objects = []
+        each_path_object(root, path) { |object| objects << object }
+        objects
+      end
+
+      def each_path_object(scope, path, &block)
+        return enum_for(:each_path_object, scope, path) unless block
+        return if scope.nil?
+
+        if path.empty?
+          each_leaf_object(scope, &block)
+        elsif scope.is_a?(Array)
+          scope.each { |element| each_path_object(element, path, &block) }
+        elsif scope.respond_to?(:[])
+          path_segment = path.first
+          each_path_object(scope[path_segment], path[1..-1], &block)
+        end
+      end
+
+      def each_leaf_object(scope, &block)
+        return if scope.nil?
+
+        if scope.is_a?(Array)
+          scope.each { |element| each_leaf_object(element, &block) }
+        else
+          yield(scope)
+        end
+      end
+
+      def path_entries(root, path)
+        entries = []
+        each_path_entry(root, path) { |object, response_path| entries << [object, response_path] }
+        entries
+      end
+
+      def each_path_entry(scope, path, response_path = [], &block)
+        return enum_for(:each_path_entry, scope, path, response_path) unless block
+        return if scope.nil?
+
+        if path.empty?
+          each_leaf_entry(scope, response_path, &block)
+        elsif scope.is_a?(Array)
+          scope.each_with_index do |element, index|
+            each_path_entry(element, path, [*response_path, index], &block)
+          end
+        elsif scope.respond_to?(:[])
+          path_segment = path.first
+          each_path_entry(scope[path_segment], path[1..-1], [*response_path, path_segment], &block)
+        end
+      end
+
+      def each_leaf_entry(scope, response_path, &block)
+        return if scope.nil?
+
+        if scope.is_a?(Array)
+          scope.each_with_index do |element, index|
+            each_leaf_entry(element, [*response_path, index], &block)
+          end
+        else
+          yield(scope, response_path)
+        end
+      end
+
+      def sanitized_error(error, path: nil)
+        error.dup.tap do |formatted|
+          formatted.delete("locations")
+          formatted["path"] = path if path
+        end
+      end
+    end
+  end
+end

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

@@ -3,42 +3,49 @@
 module GraphQL::Stitching
   class Executor
     class RootSource < GraphQL::Dataloader::Source
+      include PathAccess
+
       def initialize(executor, location)
         @executor = executor
         @location = location
       end
 
       def fetch(ops)
-        op = ops.first # There should only ever be one per location at a time
-
-        query_document = build_document(
-          op,
-          @executor.request.operation_name,
-          @executor.request.operation_directives,
-        )
-        query_variables = @executor.request.variables.slice(*op.variables.each_key)
-        result = @executor.request.supergraph.execute_at_location(op.location, query_document, query_variables, @executor.request)
-        @executor.query_count += 1
-
-        if result["data"]
-          unless op.path.empty?
-            # Nested root scopes must expand their pathed origin set
-            origin_set = op.path.reduce([@executor.data]) do |set, ns|
-              set.flat_map { |obj| obj && obj[ns] }.tap(&:compact!)
+        ops.map do |op|
+          origin_set = op.path.empty? ? [@executor.data] : path_objects(@executor.data, op.path)
+
+          query_document = build_document(
+            op,
+            @executor.request.operation_name,
+            @executor.request.operation_directives,
+          )
+          query_variables = @executor.request.variables.slice(*op.variables.each_key)
+          result = @executor.request.supergraph.execute_at_location(op.location, query_document, query_variables, @executor.request)
+          @executor.query_count += 1
+
+          errors = result["errors"]
+          origin_entries = nil
+
+          if errors && !errors.empty?
+            origin_entries = op.path.empty? ? [[@executor.data, []]] : path_entries(@executor.data, op.path)
+          end
+
+          if result["data"]
+            if op.path.empty?
+              # Actual root scopes merge directly into results data
+              @executor.data.merge!(result["data"])
+            elsif !origin_set.empty?
+              # Nested root scopes merge the same root payload into each pathed origin
+              origin_set.each { |origin_obj| origin_obj.merge!(result["data"]) }
             end
+          end
 
-            origin_set.each { _1.merge!(result["data"]) }
-          else
-            # Actual root scopes merge directly into results data
-            @executor.data.merge!(result["data"])
+          if errors && !errors.empty?
+            @executor.errors.concat(format_errors(errors, origin_entries, op.path))
           end
-        end
 
-        if result["errors"]&.any?
-          @executor.errors.concat(format_errors!(result["errors"], op.path))
+          op.step
         end
-
-        ops.map(&:step)
       end
 
       # Builds root source documents
@@ -69,13 +76,21 @@ module GraphQL::Stitching
       end
 
       # Format response errors without a document location (because it won't match the request doc),
-      # and prepend any insertion path for the scope into error paths.
-      def format_errors!(errors, path)
-        errors.each do |err|
-          err.delete("locations")
-          err["path"].unshift(*path) if err["path"] && !path.empty?
+      # and prepend all concrete insertion paths for nested scopes into error paths.
+      def format_errors(errors, origin_entries, fallback_path = [])
+        errors.flat_map do |err|
+          path = err["path"]
+
+          if path && !origin_entries.empty?
+            origin_entries.map do |_origin_obj, origin_path|
+              sanitized_error(err, path: origin_path + path)
+            end
+          elsif path && !fallback_path.empty?
+            sanitized_error(err, path: fallback_path + path)
+          else
+            sanitized_error(err)
+          end
         end
-        errors
       end
     end
   end

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,6 +25,8 @@ 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|
@@ -84,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 unless origin_set.empty?
         end
 
         unless origin_sets_by_operation.empty?
-          query_document, variable_names = build_document(
+          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,6 +50,7 @@ module GraphQL::Stitching
       # }"
       def build_document(origin_sets_by_operation, operation_name = nil, operation_directives = nil)
         variable_defs = {}
+        generated_variables = {}
         fields_buffer = String.new
 
         origin_sets_by_operation.each_with_index do |(op, origin_set), batch_index|
@@ -65,7 +65,7 @@ module GraphQL::Stitching
               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
                 fields_buffer << arg.name << ":$" << variable_name
               else
@@ -83,7 +83,7 @@ module GraphQL::Stitching
                 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
                   fields_buffer << arg.name << ":$" << variable_name
                 else
@@ -120,9 +120,11 @@ module GraphQL::Stitching
 
         doc_buffer << "{ " << fields_buffer << " }"
 
-        return doc_buffer, 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)
@@ -145,85 +147,57 @@ module GraphQL::Stitching
       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 = Hash.new { |h, k| h[k] = {} }
+        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
-                pathed_errors_by_op_index = pathed_errors_by_op_index_and_object_id[result_alias[1].to_i]
-                by_object_id = pathed_errors_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
-        end
-
-        unless pathed_errors_by_op_index_and_object_id.empty?
-          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[op_index].path)
-            errors_result.push(*pathed_errors_by_object_id.each_value)
-          end
+          memo << sanitized_error(err)
         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.empty? && 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.empty?
-          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"

data/lib/graphql/stitching/planner.rb

@@ -91,7 +91,7 @@ module GraphQL
         path.each { entrypoint << "/" << _1 }
 
         step = @steps_by_entrypoint[entrypoint]
-        next_index = step ? parent_index : @planning_index += 1
+        next_index = step ? step.index : @planning_index += 1
 
         unless selections.empty?
           selections = extract_locale_selections(location, parent_type, next_index, selections, path, variables)
@@ -110,6 +110,7 @@ module GraphQL
             resolver: resolver,
           )
         else
+          step.variables.merge!(variables)
           step.selections.concat(selections)
           step
         end
@@ -142,7 +143,8 @@ module GraphQL
           # A.2) Partition mutation fields by consecutive location for serial execution.
           partitions = []
           each_field_in_scope(parent_type, @request.operation.selections) do |node|
-            next_location = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name].first
+            locations = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name] || SUPERGRAPH_LOCATIONS
+            next_location = locations.first
 
             if partitions.none? || partitions.last.location != next_location
               partitions << ScopePartition.new(location: next_location, selections: [])
@@ -238,7 +240,8 @@ module GraphQL
             end
 
             # B.3) Collect all variable definitions used within the filtered selection.
-            extract_node_variables(node, locale_variables)
+            extract_node_argument_variables(node, locale_variables)
+            extract_node_directive_variables(node, locale_variables)
             schema_fields = @supergraph.memoized_schema_fields(parent_type.graphql_name)
             field_type = schema_fields[node.name].type.unwrap
 
@@ -256,7 +259,8 @@ module GraphQL
             fragment_type = node.type ? @supergraph.memoized_schema_types[node.type.name] : parent_type
             next unless @supergraph.locations_by_type[fragment_type.graphql_name].include?(current_location)
 
-            is_same_scope = fragment_type == parent_type
+            extract_node_directive_variables(node, locale_variables)
+            is_same_scope = fragment_type == parent_type && node.directives.empty?
             selection_set = is_same_scope ? locale_selections : []
             extract_locale_selections(current_location, fragment_type, parent_index, node.selections, path, locale_variables, selection_set)
 
@@ -269,14 +273,17 @@ module GraphQL
             fragment = @request.fragment_definitions[node.name]
             next unless @supergraph.locations_by_type[fragment.type.name].include?(current_location)
 
+            extract_node_directive_variables(node, locale_variables)
+            extract_node_directive_variables(fragment, locale_variables)
             requires_typename = true
             fragment_type = @supergraph.memoized_schema_types[fragment.type.name]
-            is_same_scope = fragment_type == parent_type
+            directives = fragment.directives.empty? && node.directives.empty? ? EMPTY_ARRAY : fragment.directives + node.directives
+            is_same_scope = fragment_type == parent_type && directives.empty?
             selection_set = is_same_scope ? locale_selections : []
             extract_locale_selections(current_location, fragment_type, parent_index, fragment.selections, path, locale_variables, selection_set)
 
             unless is_same_scope
-              locale_selections << GraphQL::Language::Nodes::InlineFragment.new(type: fragment.type, selections: selection_set)
+              locale_selections << GraphQL::Language::Nodes::InlineFragment.new(type: fragment.type, directives: directives, selections: selection_set)
             end
 
           else
@@ -355,20 +362,28 @@ module GraphQL
 
       # B.3) Collect all variable definitions used within the filtered selection.
       # These specify which request variables to pass along with each step.
-      def extract_node_variables(node_with_args, variable_definitions)
-        node_with_args.arguments.each do |argument|
-          case argument.value
-          when GraphQL::Language::Nodes::InputObject
-            extract_node_variables(argument.value, variable_definitions)
-          when GraphQL::Language::Nodes::VariableIdentifier
-            variable_definitions[argument.value.name] ||= @request.variable_definitions[argument.value.name]
-          end
-        end
+      def extract_node_argument_variables(node, variable_definitions)
+        arguments = node.arguments
+        return if arguments.empty?
 
-        if node_with_args.respond_to?(:directives)
-          node_with_args.directives.each do |directive|
-            extract_node_variables(directive, variable_definitions)
-          end
+        arguments.each { |argument| extract_value_variables(argument.value, variable_definitions) }
+      end
+
+      def extract_node_directive_variables(node, variable_definitions)
+        directives = node.directives
+        return if directives.empty?
+
+        directives.each { |directive| extract_node_argument_variables(directive, variable_definitions) }
+      end
+
+      def extract_value_variables(value, variable_definitions)
+        case value
+        when GraphQL::Language::Nodes::InputObject
+          extract_node_argument_variables(value, variable_definitions)
+        when GraphQL::Language::Nodes::VariableIdentifier
+          variable_definitions[value.name] ||= @request.variable_definitions[value.name]
+        when Array
+          value.each { extract_value_variables(_1, variable_definitions) }
         end
       end
 

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "1.7.3"
+    VERSION = "1.8.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.7.3
+  version: 1.8.0
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-06 00:00:00.000000000 Z
+date: 2026-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -28,42 +28,42 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '12.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.12'
 description: Combine GraphQL services into one unified graph
@@ -79,6 +79,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- benchmark/run.rb
 - docs/README.md
 - docs/composing_a_supergraph.md
 - docs/error_handling.md
@@ -167,6 +168,7 @@ files:
 - lib/graphql/stitching/composer/validate_type_resolvers.rb
 - lib/graphql/stitching/directives.rb
 - lib/graphql/stitching/executor.rb
+- lib/graphql/stitching/executor/path_access.rb
 - lib/graphql/stitching/executor/root_source.rb
 - lib/graphql/stitching/executor/shaper.rb
 - lib/graphql/stitching/executor/type_resolver_source.rb