graphql-stitching 1.7.1 → 1.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43ca2665bc1d0e0a87eead760ee4f7b1caddf324861b66414bc011958901eeff
-  data.tar.gz: 18a14928e703744d29b57665c51ecdb6a17b1d9d2b7bc58fe8727a37b55fbcd5
+  metadata.gz: 65951348a6c34feff379cdbfc7483380dce295dbd86cc24870eee264de079a46
+  data.tar.gz: c16673030f3be9728c986b8e4fe5e8084ca7a4e0240ac7e495da26261f1f0a3a
 SHA512:
-  metadata.gz: b5ee7817b699447b35c937eb3df872433f8c318310debab6fea1577513171260a39e900c64cf37b4bfcb6f4fde4b509b5216ddf95879dd53a9878a3924016b5d
-  data.tar.gz: 0ddda7a4df33d5b6946a3a6283a4388d507c18d7ff758db1b2f09179546d6be87b6e78390fa6f623442e0f6e79a91aac69b0922542c4134673175377c47cfc0f
+  metadata.gz: 255495cde4ac822edc3b93ac67af6eb3b49ab657adedebd2870058468d6b49d241fca5e01c494fd3f345e134b21755e1a3f3ce2d2d43bad6e078b1833f47768c
+  data.tar.gz: ac375cfe4ac73d9b1ce732180efada3d56aab8fa6e5cca75b40e0a6a8d133a45e67637090b9e49a76f9b2b20a81de9014bde03f88f03cdf277f85b5aa435504a

data/README.md

@@ -21,7 +21,7 @@ This Ruby implementation is designed as a generic library to join basic spec-com
 
 ## Documentation
 
-1. [Introduction](./docs/introduction.md)
+1. [Introduction](./docs/README.md)
 1. [Composing a supergraph](./docs/composing_a_supergraph.md)
 1. [Merged types](./docs/merged_types.md)
 1. [Executables & file uploads](./docs/executables.md)

data/docs/performance.md

@@ -57,6 +57,34 @@ query($id: ID!) {
 # variables: { "id" => "1" }
 ```
 
+### Subgraph validations
+
+Requests are validated by the supergraph, and should always divide into valid subgraph documents. Therefore, you can skip redundant subgraph validations for requests sent by the supergraph, ex:
+
+```ruby
+exe = GraphQL::Stitching::HttpExecutable.new(
+  url: "http://localhost:3001",
+  headers: { 
+    "Authorization" => "...",
+    "X-Supergraph-Secret" => "<shared-secret>",
+  },
+)
+```
+
+A shared secret allows a subgraph location to trust the supergraph origin, at which time it can disable validations:
+
+```ruby
+def query
+  sg_header = request.headers["X-Supergraph-Secret"]
+  MySchema.execute(
+    query: params[:query],
+    variables: params[:variables],
+    operation_name: params[:operationName],
+    validate: sg_header.nil? || sg_header != Rails.env.credentials.supergraph,
+  )
+end
+```
+
 ### Digests
 
 All computed digests use SHA2 hashing by default. You can swap in [a faster algorithm](https://github.com/Shopify/blake3-rb) and/or add base state by reconfiguring `Stitching.digest`:

data/lib/graphql/stitching/client.rb

@@ -25,7 +25,7 @@ module GraphQL
           raise ArgumentError, "Cannot provide both locations and a supergraph."
         elsif supergraph && !supergraph.is_a?(Supergraph)
           raise ArgumentError, "Provided supergraph must be a GraphQL::Stitching::Supergraph instance."
-        elsif supergraph && composer_options.any?
+        elsif supergraph && !composer_options.empty?
           raise ArgumentError, "Cannot provide composer options with a pre-built supergraph."
         elsif supergraph
           supergraph
@@ -50,7 +50,7 @@ module GraphQL
 
         if validate
           validation_errors = request.validate
-          return error_result(request, validation_errors) if validation_errors.any?
+          return error_result(request, validation_errors) unless validation_errors.empty?
         end
 
         load_plan(request)

data/lib/graphql/stitching/composer/type_resolver_config.rb

@@ -8,7 +8,7 @@ module GraphQL::Stitching
 
       class << self
         def extract_directive_assignments(schema, location, assignments)
-          return EMPTY_OBJECT unless assignments && assignments.any?
+          return EMPTY_OBJECT unless assignments && !assignments.empty?
 
           assignments.each_with_object({}) do |kwargs, memo|
             type = kwargs[:parent_type_name] ? schema.get_type(kwargs[:parent_type_name]) : schema.query

data/lib/graphql/stitching/composer.rb

@@ -423,7 +423,7 @@ module GraphQL
             memo[location] = argument.default_value
           end
 
-          if default_values_by_location.any?
+          unless default_values_by_location.empty?
             kwargs[:default_value] = @default_value_merger.call(default_values_by_location, {
               type_name: type_name,
               field_name: field_name,
@@ -468,8 +468,6 @@ module GraphQL
           kwarg_values_by_name_location = directives_by_location.each_with_object({}) do |(location, directive), memo|
             directive.arguments.keyword_arguments.each do |key, value|
               key = key.to_s
-              next unless directive_class.arguments[key]
-
               memo[key] ||= {}
               memo[key][location] = value
             end

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

@@ -16,12 +16,12 @@ module GraphQL::Stitching
           @executor.request.operation_name,
           @executor.request.operation_directives,
         )
-        query_variables = @executor.request.variables.slice(*op.variables.keys)
+        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"]
-          if op.path.any?
+          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!)
@@ -44,24 +44,28 @@ module GraphQL::Stitching
       # Builds root source documents
       # "query MyOperation_1($var:VarType) { rootSelections ... }"
       def build_document(op, operation_name = nil, operation_directives = nil)
-        doc = String.new
-        doc << op.operation_type
+        doc_buffer = String.new
+        doc_buffer << op.operation_type
 
         if operation_name
-          doc << " #{operation_name}_#{op.step}"
+          doc_buffer << " " << operation_name << "_" << op.step.to_s
         end
 
-        if op.variables.any?
-          variable_defs = op.variables.map { |k, v| "$#{k}:#{v}" }.join(",")
-          doc << "(#{variable_defs})"
+        unless op.variables.empty?
+          doc_buffer << "("
+          op.variables.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 << op.selections
-        doc
+        doc_buffer << op.selections
+        doc_buffer
       end
 
       # Format response errors without a document location (because it won't match the request doc),
@@ -69,7 +73,7 @@ module GraphQL::Stitching
       def format_errors!(errors, path)
         errors.each do |err|
           err.delete("locations")
-          err["path"].unshift(*path) if err["path"] && path.any?
+          err["path"].unshift(*path) if err["path"] && !path.empty?
         end
         errors
       end

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

@@ -30,10 +30,15 @@ module GraphQL::Stitching
           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
-                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 +47,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

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

@@ -20,10 +20,10 @@ module GraphQL::Stitching
             origin_set.select! { _1[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?
+        unless origin_sets_by_operation.empty?
           query_document, variable_names = build_document(
             origin_sets_by_operation,
             @executor.request.operation_name,
@@ -51,61 +51,76 @@ 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|
+        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) }
                 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)
                   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|
+        return doc_buffer, variable_defs.keys.tap do |names|
           names.reject! { @variables.key?(_1) }
         end
       end
@@ -120,10 +135,11 @@ 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
@@ -132,7 +148,7 @@ module GraphQL::Stitching
       def extract_errors!(origin_sets_by_operation, errors)
         ops = origin_sets_by_operation.keys
         origin_sets = origin_sets_by_operation.values
-        pathed_errors_by_op_index_and_object_id = {}
+        pathed_errors_by_op_index_and_object_id = Hash.new { |h, k| h[k] = {} }
 
         errors_result = errors.each_with_object([]) do |err, memo|
           err.delete("locations")
@@ -151,8 +167,8 @@ module GraphQL::Stitching
               end
 
               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] ||= []
+                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
               end
@@ -162,10 +178,10 @@ module GraphQL::Stitching
           memo << err
         end
 
-        if pathed_errors_by_op_index_and_object_id.any?
+        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.dig(op_index, "path"))
-            errors_result.concat(pathed_errors_by_object_id.values)
+            repath_errors!(pathed_errors_by_object_id, ops[op_index].path)
+            errors_result.push(*pathed_errors_by_object_id.each_value)
           end
         end
 
@@ -180,7 +196,7 @@ module GraphQL::Stitching
         current_path.push(forward_path.shift)
         scope = root[current_path.last]
 
-        if forward_path.any? && scope.is_a?(Array)
+        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|
@@ -190,7 +206,7 @@ module GraphQL::Stitching
             end
           end
 
-        elsif forward_path.any?
+        elsif !forward_path.empty?
           repath_errors!(pathed_errors_by_object_id, forward_path, current_path, scope)
 
         elsif scope.is_a?(Array)

data/lib/graphql/stitching/executor.rb

@@ -79,7 +79,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

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
 
-        if selections.any?
+        unless selections.empty?
           selections = extract_locale_selections(location, parent_type, next_index, selections, path, variables)
         end
 
@@ -102,8 +115,6 @@ module GraphQL
         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 +122,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
 
@@ -213,7 +223,7 @@ module GraphQL
         input_selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            if node.alias&.start_with?(TypeResolver::EXPORT_PREFIX)
+            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
@@ -229,7 +239,8 @@ module GraphQL
 
             # 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
+            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
@@ -284,7 +295,7 @@ module GraphQL
           remote_selections_by_location = delegate_remote_selections(parent_type, remote_selections)
 
           # D) Create paths routing to new entrypoint locations via resolver queries.
-          routes = @supergraph.route_type_to_locations(parent_type.graphql_name, current_location, remote_selections_by_location.keys)
+          routes = @supergraph.route_type_to_locations(parent_type.graphql_name, current_location, remote_selections_by_location.each_key)
 
           # E) Translate resolver pathways into new entrypoints.
           routes.each_value do |route|
@@ -377,9 +388,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 +401,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
@@ -147,6 +147,11 @@ module GraphQL
         @query.static_errors
       end
 
+      # @return [Boolean] is the request valid?
+      def valid?
+        validate.empty?
+      end
+
       # Gets and sets the query plan for the request. Assigned query plans may pull from a cache,
       # which is useful for redundant GraphQL documents (commonly sent by frontend clients).
       # ```ruby

data/lib/graphql/stitching/supergraph/from_definition.rb

@@ -21,11 +21,8 @@ module GraphQL::Stitching
         field_map = {}
         resolver_map = {}
         possible_locations = {}
-        visibility_profiles = if (visibility_def = schema.directives[GraphQL::Stitching.visibility_directive])
-          visibility_def.get_argument("profiles").default_value
-        else
-          []
-        end
+        visibility_definition = schema.directives[GraphQL::Stitching.visibility_directive]
+        visibility_profiles = visibility_definition&.get_argument("profiles")&.default_value || EMPTY_ARRAY
 
         schema.types.each do |type_name, type|
           next if type.introspection?
@@ -75,7 +72,7 @@ module GraphQL::Stitching
           end
         end
 
-        executables = possible_locations.keys.each_with_object({}) do |location, memo|
+        executables = possible_locations.each_key.each_with_object({}) do |location, memo|
           executable = executables[location] || executables[location.to_sym]
           if validate_executable!(location, executable)
             memo[location] = executable

data/lib/graphql/stitching/supergraph.rb

@@ -38,7 +38,7 @@ module GraphQL
         @locations_by_type_and_field = @memoized_introspection_types.each_with_object(fields) do |(type_name, type), memo|
           next unless type.kind.fields?
 
-          memo[type_name] = type.fields.keys.each_with_object({}) do |field_name, m|
+          memo[type_name] = type.fields.each_key.each_with_object({}) do |field_name, m|
             m[field_name] = [SUPERGRAPH_LOCATION]
           end
         end.freeze
@@ -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
 
@@ -75,7 +75,7 @@ module GraphQL
       end
 
       def locations
-        @executables.keys.reject { _1 == SUPERGRAPH_LOCATION }
+        @executables.each_key.reject { _1 == SUPERGRAPH_LOCATION }
       end
 
       def memoized_schema_fields(type_name)
@@ -130,7 +130,7 @@ module GraphQL
       # "Type" => ["location1", "location2", ...]
       def locations_by_type
         @locations_by_type ||= @locations_by_type_and_field.each_with_object({}) do |(type_name, fields), memo|
-          memo[type_name] = fields.values.flatten.uniq
+          memo[type_name] = fields.values.tap(&:flatten!).tap(&:uniq!)
         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.1"
+    VERSION = "1.7.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.7.1
+  version: 1.7.3
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-10 00:00:00.000000000 Z
+date: 2025-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -79,13 +79,13 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- 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