graphql-stitching 1.7.2 → 1.8.0

data/lib/graphql/stitching/planner.rb

@@ -10,6 +10,15 @@ module GraphQL
       SUPERGRAPH_LOCATIONS = [Supergraph::SUPERGRAPH_LOCATION].freeze
       ROOT_INDEX = 0
 
+      class ScopePartition
+        attr_reader :location, :selections
+
+        def initialize(location:, selections:)
+          @location = location
+          @selections = selections
+        end
+      end
+
       def initialize(request)
         @request = request
         @supergraph = request.supergraph
@@ -76,11 +85,15 @@ module GraphQL
         resolver: nil
       )
         # coalesce repeat parameters into a single entrypoint
-        entrypoint = [parent_index, location, parent_type.graphql_name, resolver&.key&.to_definition, "#", *path].join("/")
+        entrypoint = String.new
+        entrypoint << parent_index.to_s << "/" << location << "/" << parent_type.graphql_name
+        entrypoint << "/" << (resolver&.key&.to_s || "") << "/#"
+        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
 
-        if selections.any?
+        unless selections.empty?
           selections = extract_locale_selections(location, parent_type, next_index, selections, path, variables)
         end
 
@@ -97,13 +110,12 @@ module GraphQL
             resolver: resolver,
           )
         else
+          step.variables.merge!(variables)
           step.selections.concat(selections)
           step
         end
       end
 
-      ScopePartition = Struct.new(:location, :selections, keyword_init: true)
-
       # A) Group all root selections by their preferred entrypoint locations.
       def build_root_entrypoints
         parent_type = @request.query.root_type_for_operation(@request.operation.operation_type)
@@ -111,10 +123,9 @@ module GraphQL
         case @request.operation.operation_type
         when QUERY_OP
           # A.1) Group query fields by location for parallel execution.
-          selections_by_location = {}
+          selections_by_location = Hash.new { |h, k| h[k] = [] }
           each_field_in_scope(parent_type, @request.operation.selections) do |node|
             locations = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name] || SUPERGRAPH_LOCATIONS
-            selections_by_location[locations.first] ||= []
             selections_by_location[locations.first] << node
           end
 
@@ -132,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: [])
@@ -213,7 +225,7 @@ module GraphQL
         input_selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            if node.alias&.start_with?(TypeResolver::EXPORT_PREFIX) && node != TypeResolver::TYPENAME_EXPORT_NODE
+            if node.alias&.start_with?(TypeResolver::EXPORT_PREFIX) && node.object_id != TypeResolver::TYPENAME_EXPORT_NODE.object_id
               raise StitchingError, %(Alias "#{node.alias}" is not allowed because "#{TypeResolver::EXPORT_PREFIX}" is a reserved prefix.)
             elsif node.name == TYPENAME
               locale_selections << node
@@ -228,8 +240,10 @@ module GraphQL
             end
 
             # B.3) Collect all variable definitions used within the filtered selection.
-            extract_node_variables(node, locale_variables)
-            field_type = @supergraph.memoized_schema_fields(parent_type.graphql_name)[node.name].type.unwrap
+            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
 
             if Util.is_leaf_type?(field_type)
               locale_selections << node
@@ -245,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)
 
@@ -258,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
@@ -344,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
 
@@ -377,9 +403,11 @@ module GraphQL
         end
 
         # C.2) Distribute non-unique fields among locations that were added during C.1.
-        if selections_by_location.any? && remote_selections.any?
+        if !selections_by_location.empty? && !remote_selections.empty?
+          available_locations = Set.new(selections_by_location.each_key)
+
           remote_selections.reject! do |node|
-            used_location = possible_locations_by_field[node.name].find { selections_by_location[_1] }
+            used_location = possible_locations_by_field[node.name].find { available_locations.include?(_1) }
             if used_location
               selections_by_location[used_location] << node
               true
@@ -388,29 +416,17 @@ module GraphQL
         end
 
         # C.3) Distribute remaining fields among locations weighted by greatest availability.
-        if remote_selections.any?
-          field_count_by_location = remote_selections.each_with_object({}) do |node, memo|
+        if !remote_selections.empty?
+          field_count_by_location = Hash.new(0)
+          remote_selections.each do |node|
             possible_locations_by_field[node.name].each do |location|
-              memo[location] ||= 0
-              memo[location] += 1
+              field_count_by_location[location] += 1
             end
           end
 
           remote_selections.each do |node|
             possible_locations = possible_locations_by_field[node.name]
-            preferred_location = possible_locations.first
-
-            possible_locations.reduce(0) do |max_availability, possible_location|
-              availability = field_count_by_location.fetch(possible_location, 0)
-
-              if availability > max_availability
-                preferred_location = possible_location
-                availability
-              else
-                max_availability
-              end
-            end
-
+            preferred_location = possible_locations.max_by { field_count_by_location[_1] } || possible_locations.first
             selections_by_location[preferred_location] ||= []
             selections_by_location[preferred_location] << node
           end

data/lib/graphql/stitching/request/skip_include.rb

@@ -34,7 +34,7 @@ module GraphQL::Stitching
               next nil
             end
 
-            node = render_node(node, variables) if node.selections.any?
+            node = render_node(node, variables) unless node.selections.empty?
             changed ||= node.object_id != original_node.object_id
             node
           end
@@ -51,7 +51,7 @@ module GraphQL::Stitching
         end
 
         def prune_node(node, variables)
-          return node unless node.directives.any?
+          return node if node.directives.empty?
 
           delete_node = false
           filtered_directives = node.directives.reject do |directive|

data/lib/graphql/stitching/request.rb

@@ -101,7 +101,7 @@ module GraphQL
       
       # @return [String] A string of directives applied to the root operation. These are passed through in all subgraph requests.
       def operation_directives
-        @operation_directives ||= if operation.directives.any?
+        @operation_directives ||= unless operation.directives.empty?
           printer = GraphQL::Language::Printer.new
           operation.directives.map { printer.print(_1) }.join(" ")
         end

data/lib/graphql/stitching/supergraph.rb

@@ -50,11 +50,11 @@ module GraphQL
           end
         end.freeze
 
-        if visibility_profiles.any?
+        if visibility_profiles.empty?
+          @schema.use(GraphQL::Schema::AlwaysVisible)
+        else
           profiles = visibility_profiles.each_with_object({ nil => {} }) { |p, m| m[p.to_s] = {} }
           @schema.use(GraphQL::Schema::Visibility, profiles: profiles)
-        else
-          @schema.use(GraphQL::Schema::AlwaysVisible)
         end
       end
 
@@ -187,7 +187,17 @@ module GraphQL
 
       private
 
-      PathNode = Struct.new(:location, :key, :cost, :resolver, keyword_init: true)
+      class PathNode
+        attr_reader :location, :key, :resolver
+        attr_accessor :cost
+      
+        def initialize(location:, key:, resolver: nil, cost: 0)
+          @location = location
+          @key = key
+          @resolver = resolver
+          @cost = cost
+        end
+      end
 
       # tunes A* search to favor paths with fewest joining locations, ie:
       # favor longer paths through target locations over shorter paths with additional locations.
@@ -196,10 +206,10 @@ module GraphQL
         costs = {}
 
         paths = possible_keys_for_type_and_location(type_name, start_location).map do |possible_key|
-          [PathNode.new(location: start_location, key: possible_key, cost: 0)]
+          [PathNode.new(location: start_location, key: possible_key)]
         end
 
-        while paths.any?
+        while !paths.empty?
           path = paths.pop
           current_location = path.last.location
           current_key = path.last.key

data/lib/graphql/stitching/type_resolver.rb

@@ -10,6 +10,13 @@ module GraphQL
       extend ArgumentsParser
       extend KeysParser
 
+      class << self
+        # only intended for testing...
+        def use_static_version?
+          @use_static_version ||= false
+        end
+      end
+
       # location name providing the resolver query.
       attr_reader :location
 
@@ -47,7 +54,11 @@ module GraphQL
       end
 
       def version
-        @version ||= Stitching.digest.call("#{Stitching::VERSION}/#{as_json.to_json}")
+        @version ||= if self.class.use_static_version?
+          [location, field, key.to_definition, type_name].join(".")
+        else
+          Stitching.digest.call("#{Stitching::VERSION}/#{as_json.to_json}")
+        end
       end
 
       def ==(other)

data/lib/graphql/stitching/util.rb

@@ -4,12 +4,29 @@ module GraphQL
   module Stitching
     # General utilities to aid with stitching.
     class Util
-      TypeStructure = Struct.new(:list, :null, :name, keyword_init: true) do
-        alias_method :list?, :list
-        alias_method :null?, :null
+      class TypeStructure
+        attr_reader :name
+      
+        def initialize(list:, null:, name:)
+          @list = list
+          @null = null
+          @name = name
+        end
+
+        def list?
+          @list
+        end
+        
+        def null?
+          @null
+        end
 
         def non_null?
-          !null
+          !@null
+        end
+
+        def ==(other)
+          @list == other.list? && @null == other.null? && @name == other.name
         end
       end
 

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "1.7.2"
+    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.2
+  version: 1.8.0
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-19 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,13 +79,14 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- benchmark/run.rb
+- docs/README.md
 - docs/composing_a_supergraph.md
 - docs/error_handling.md
 - docs/executables.md
 - docs/images/library.png
 - docs/images/merging.png
 - docs/images/stitching.png
-- docs/introduction.md
 - docs/merged_types.md
 - docs/merged_types_apollo.md
 - docs/performance.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