graphql-stitching 1.5.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b71b1d9e65a84356466a0ff822e177ef5faccce1e2a0cbd91d930b06ea50923
-  data.tar.gz: 8c73c1bcc78d23ea3b0c3f09da2659d84b7877000ccba86f79fa9f83f5801c60
+  metadata.gz: d8fb3561ddb47de2d07bdcdf32e940e1a151dff731081b2b4bffe09489809021
+  data.tar.gz: 9163e0d0e5116e232ee0594821d02568f85405c7fdc0f80e085e713d2e4d3a71
 SHA512:
-  metadata.gz: 0e46b25856e61dc033ba0e2640d30133463c550af0071ac0e8bb3836b2fa8f4d0690018359b5b3b086861a907b5c66ea55eece9d4bfebe85296e723aedd96415
-  data.tar.gz: 79180fc8944adde3ee0abf79a6fefa3487724cfbf9fb55e00adf29aa42d637c1c53331aad34a0c9c32ed7e3120fdaa6dd26fba9644df86b0feb774a84a8876b2
+  metadata.gz: 6823d661a3f812fbf11bbf14edf66f3da27a850399f909061c63d464d3be93777fe7f9c7158ea26cc0d1889aed04749d3ad10cd42c3ca76079604447ab66e3cc
+  data.tar.gz: 27dee9de11b90e960fb0c17d68129332ede38d237ef37ae1eca4cdca2c83696dec4b6c9f0283ee7f508c4f5076029afc81efa4b58d60e5b74411a6a368092947

data/README.md

@@ -5,12 +5,12 @@ GraphQL stitching composes a single schema from multiple underlying GraphQL reso
 ![Stitched graph](./docs/images/stitching.png)
 
 **Supports:**
-- All operation types: query, mutation, and subscription.
+- All operation types: query, mutation, and [subscription](./docs/subscriptions.md).
 - Merged object and abstract types.
 - Shared objects, fields, enums, and inputs across locations.
 - Multiple and composite type keys.
 - Combining local and remote schemas.
-- File uploads via [multipart form spec](https://github.com/jaydenseric/graphql-multipart-request-spec).
+- [File uploads](./docs/http_executable.md) via multipart forms.
 - Tested with all minor versions of `graphql-ruby`.
 
 **NOT Supported:**
@@ -35,7 +35,7 @@ require "graphql/stitching"
 
 ## Usage
 
-The quickest way to start is to use the provided [`Client`](./docs/client.md) component that wraps a stitched graph in an executable workflow (with optional query plan caching hooks):
+The [`Client`](./docs/client.md) component builds a stitched graph wrapped in an executable workflow (with optional query plan caching hooks):
 
 ```ruby
 movies_schema = <<~GRAPHQL
@@ -75,7 +75,7 @@ result = client.execute(
 
 Schemas provided in [location settings](./docs/composer.md#performing-composition) may be class-based schemas with local resolvers (locally-executable schemas), or schemas built from SDL strings (schema definition language parsed using `GraphQL::Schema.from_definition`) and mapped to remote locations via [executables](#executables).
 
-While the `Client` constructor is an easy quick start, the library also has several discrete components that can be assembled into custom workflows:
+While `Client` is sufficient for most usecases, the library offers several discrete components that can be assembled into tailored workflows:
 
 - [Composer](./docs/composer.md) - merges and validates many schemas into one supergraph.
 - [Supergraph](./docs/supergraph.md) - manages the combined schema, location routing maps, and executable resources. Can be exported, cached, and rehydrated.
@@ -88,7 +88,7 @@ While the `Client` constructor is an easy quick start, the library also has seve
 
 ![Merging types](./docs/images/merging.png)
 
-To facilitate this merging of types, stitching must know how to cross-reference and fetch each variant of a type from its source location using [resolver queries](#merged-type-resolver-queries). For those in an Apollo ecosystem, there's also _limited_ support for merging types though a [federation `_entities` protocol](./docs/federation_entities.md).
+To facilitate this merging of types, stitching must know how to cross-reference and fetch each variant of a type from its source location using [type resolver queries](#merged-type-resolver-queries). For those in an Apollo ecosystem, there's also _limited_ support for merging types though a [federation `_entities` protocol](./docs/federation_entities.md).
 
 ### Merged type resolver queries
 
@@ -249,7 +249,7 @@ type Query {
 }
 ```
 
-See [resolver arguments](./docs/resolver.md#arguments) for full documentation on shaping input.
+See [resolver arguments](./docs/type_resolver.md#arguments) for full documentation on shaping input.
 
 #### Composite type keys
 
@@ -458,6 +458,7 @@ This repo includes working examples of stitched schemas running across small Rac
 
 - [Merged types](./examples/merged_types)
 - [File uploads](./examples/file_uploads)
+- [Subscriptions](./examples/subscriptions)
 
 ## Tests
 

data/docs/client.md

@@ -68,6 +68,12 @@ client.on_cache_write do |request, payload|
 end
 ```
 
+All request digests use SHA2 by default. You can swap in [a faster algorithm](https://github.com/Shopify/blake3-rb) and/or add base scoping by reconfiguring the stitching library:
+
+```ruby
+GraphQL::Stitching.digest { |str| Digest::MD5.hexdigest("v2/#{str}") }
+```
+
 Note that inlined input data works against caching, so you should _avoid_ these input literals when possible:
 
 ```graphql

data/docs/subscriptions.md

@@ -88,7 +88,7 @@ class EntitiesSchema < GraphQL::Schema
 end
 ```
 
-These schemas can be composed as normal into a stitching client. The subscriptions schema must be locally-executable while other entity schema(s) may be served from anywhere:
+These schemas can be composed as normal into a stitching client. The subscriptions schema must be locally-executable while the other entity schema(s) may be served from anywhere:
 
 ```ruby
 StitchedSchema = GraphQL::Stitching::Client.new(locations: {
@@ -104,7 +104,7 @@ StitchedSchema = GraphQL::Stitching::Client.new(locations: {
 
 ### Serving stitched subscriptions
 
-Once you've stitched a schema with subscriptions, it gets called as part of three workflows:
+Once you've composed a schema with subscriptions, it gets called as part of three workflows:
 
 1. Controller - handles normal query and mutation requests recieved via HTTP.
 2. Channel - handles subscription-create requests recieved through a socket connection.
@@ -172,7 +172,7 @@ class GraphqlChannel < ApplicationCable::Channel
 end
 ```
 
-What happens behind the scenes here is that stitching filters the `execute` request down to just subscription selections, and passes those through to the subscriptions subschema where they register an event binding. The subscriber response gets stitched while passing back up through the stitching client.
+What happens behind the scenes here is that stitching filters the `execute` request down to just subscription selections, and passes those through to the subscriptions subschema where they register an event binding. The subscriber response gets stitched while passing back out through the stitching client.
 
 #### Plugin
 
@@ -181,9 +181,9 @@ Lastly, update events trigger with the filtered subscriptions selection, so must
 ```ruby
 class StitchedActionCableSubscriptions < GraphQL::Subscriptions::ActionCableSubscriptions
   def execute_update(subscription_id, event, object)
-    super(subscription_id, event, object).tap do |result|
-      result.context[:stitch_subscription_update]&.call(result)
-    end
+    result = super(subscription_id, event, object)
+    result.context[:stitch_subscription_update]&.call(result)
+    result
   end
 end
 

data/docs/{resolver.md → type_resolver.md}

@@ -1,10 +1,10 @@
-## GraphQL::Stitching::Resolver
+## GraphQL::Stitching::TypeResolver
 
-A `Resolver` contains all information about a root query used by stitching to fetch location-specific variants of a merged type. Specifically, resolvers manage parsed keys and argument structures.
+A `TypeResolver` contains all information about a root query used by stitching to fetch location-specific variants of a merged type. Specifically, resolvers manage parsed keys and argument structures.
 
 ### Arguments
 
-Resolvers configure arguments through a template string of [GraphQL argument literal syntax](https://spec.graphql.org/October2021/#sec-Language.Arguments). This allows sending multiple arguments that intermix stitching keys with complex object shapes and other static values.
+Type resolvers configure arguments through a template string of [GraphQL argument literal syntax](https://spec.graphql.org/October2021/#sec-Language.Arguments). This allows sending multiple arguments that intermix stitching keys with complex object shapes and other static values.
 
 #### Key insertions
 

data/examples/subscriptions/app/graphql/subscriptions_schema.rb

@@ -1,9 +1,9 @@
 class SubscriptionsSchema < GraphQL::Schema
   class StitchedActionCableSubscriptions < GraphQL::Subscriptions::ActionCableSubscriptions
     def execute_update(subscription_id, event, object)
-      super(subscription_id, event, object).tap do |result|
-        result.context[:stitch_subscription_update]&.call(result)
-      end
+      result = super(subscription_id, event, object)
+      result.context[:stitch_subscription_update]&.call(result)
+      result
     end
   end
 

data/lib/graphql/stitching/composer/{resolver_config.rb → type_resolver_config.rb}

@@ -2,7 +2,7 @@
 
 module GraphQL::Stitching
   class Composer
-    class ResolverConfig
+    class TypeResolverConfig
       ENTITY_TYPENAME = "_Entity"
       ENTITIES_QUERY = "_entities"
 
@@ -30,7 +30,7 @@ module GraphQL::Stitching
             entity_type.directives.each do |directive|
               next unless directive.graphql_name == "key"
 
-              key = Resolver.parse_key(directive.arguments.keyword_arguments.fetch(:fields))
+              key = TypeResolver.parse_key(directive.arguments.keyword_arguments.fetch(:fields))
               key_fields = key.map { "#{_1.name}: $.#{_1.name}" }
               field_path = "#{location}._entities"
 

data/lib/graphql/stitching/composer/{validate_resolvers.rb → validate_type_resolvers.rb}

@@ -2,7 +2,7 @@
 
 module GraphQL::Stitching
   class Composer
-    class ValidateResolvers < BaseValidator
+    class ValidateTypeResolvers < BaseValidator
 
       def perform(supergraph, composer)
         root_types = [

data/lib/graphql/stitching/composer.rb

@@ -2,8 +2,8 @@
 
 require_relative "composer/base_validator"
 require_relative "composer/validate_interfaces"
-require_relative "composer/validate_resolvers"
-require_relative "composer/resolver_config"
+require_relative "composer/validate_type_resolvers"
+require_relative "composer/type_resolver_config"
 
 module GraphQL
   module Stitching
@@ -31,7 +31,7 @@ module GraphQL
       # @api private
       COMPOSITION_VALIDATORS = [
         ValidateInterfaces,
-        ValidateResolvers,
+        ValidateTypeResolvers,
       ].freeze
 
       # @return [String] name of the Query type in the composed schema.
@@ -168,7 +168,7 @@ module GraphQL
         end
 
         select_root_field_locations(schema)
-        expand_abstract_resolvers(schema)
+        expand_abstract_resolvers(schema, schemas)
 
         supergraph = Supergraph.new(
           schema: schema,
@@ -199,8 +199,8 @@ module GraphQL
             raise CompositionError, "The schema for `#{location}` location must be a GraphQL::Schema class."
           end
 
-          @resolver_configs.merge!(ResolverConfig.extract_directive_assignments(schema, location, input[:stitch]))
-          @resolver_configs.merge!(ResolverConfig.extract_federation_entities(schema, location))
+          @resolver_configs.merge!(TypeResolverConfig.extract_directive_assignments(schema, location, input[:stitch]))
+          @resolver_configs.merge!(TypeResolverConfig.extract_federation_entities(schema, location))
 
           schemas[location.to_s] = schema
           executables[location.to_s] = input[:executable] || schema
@@ -546,13 +546,13 @@ module GraphQL
 
             subgraph_field.directives.each do |directive|
               next unless directive.graphql_name == GraphQL::Stitching.stitch_directive
-              resolver_configs << ResolverConfig.from_kwargs(directive.arguments.keyword_arguments)
+              resolver_configs << TypeResolverConfig.from_kwargs(directive.arguments.keyword_arguments)
             end
 
             resolver_configs.each do |config|
               resolver_type_name = if config.type_name
                 if !resolver_type.kind.abstract?
-                  raise CompositionError, "Resolver config may only specify a type name for abstract resolvers."
+                  raise CompositionError, "Type resolver config may only specify a type name for abstract resolvers."
                 elsif !resolver_type.possible_types.find { _1.graphql_name == config.type_name }
                   raise CompositionError, "Type `#{config.type_name}` is not a possible return type for query `#{field_name}`."
                 end
@@ -561,7 +561,7 @@ module GraphQL
                 resolver_type.graphql_name
               end
 
-              key = Resolver.parse_key_with_types(
+              key = TypeResolver.parse_key_with_types(
                 config.key,
                 @subgraph_types_by_name_and_location[resolver_type_name],
               )
@@ -581,11 +581,11 @@ module GraphQL
                 "#{argument.graphql_name}: $.#{key.primitive_name}"
               end
 
-              arguments = Resolver.parse_arguments_with_field(arguments_format, subgraph_field)
+              arguments = TypeResolver.parse_arguments_with_field(arguments_format, subgraph_field)
               arguments.each { _1.verify_key(key) }
 
               @resolver_map[resolver_type_name] ||= []
-              @resolver_map[resolver_type_name] << Resolver.new(
+              @resolver_map[resolver_type_name] << TypeResolver.new(
                 location: location,
                 type_name: resolver_type_name,
                 field: subgraph_field.name,
@@ -620,15 +620,18 @@ module GraphQL
 
       # @!scope class
       # @!visibility private
-      def expand_abstract_resolvers(schema)
+      def expand_abstract_resolvers(composed_schema, schemas_by_location)
         @resolver_map.keys.each do |type_name|
-          resolver_type = schema.types[type_name]
-          next unless resolver_type.kind.abstract?
+          next unless composed_schema.get_type(type_name).kind.abstract?
 
-          expanded_types = Util.expand_abstract_type(schema, resolver_type)
-          expanded_types.select { @subgraph_types_by_name_and_location[_1.graphql_name].length > 1 }.each do |expanded_type|
-            @resolver_map[expanded_type.graphql_name] ||= []
-            @resolver_map[expanded_type.graphql_name].push(*@resolver_map[type_name])
+          @resolver_map[type_name].each do |resolver|
+            abstract_type = @subgraph_types_by_name_and_location[type_name][resolver.location]
+            expanded_types = Util.expand_abstract_type(schemas_by_location[resolver.location], abstract_type)
+
+            expanded_types.select { @subgraph_types_by_name_and_location[_1.graphql_name].length > 1 }.each do |impl_type|
+              @resolver_map[impl_type.graphql_name] ||= []
+              @resolver_map[impl_type.graphql_name].push(resolver)
+            end
           end
         end
       end

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

@@ -23,8 +23,8 @@ module GraphQL::Stitching
       def resolve_object_scope(raw_object, parent_type, selections, typename = nil)
         return nil if raw_object.nil?
 
-        typename ||= raw_object[Resolver::TYPENAME_EXPORT_NODE.alias]
-        raw_object.reject! { |key, _v| Resolver.export_key?(key) }
+        typename ||= raw_object[TypeResolver::TYPENAME_EXPORT_NODE.alias]
+        raw_object.reject! { |key, _v| TypeResolver.export_key?(key) }
 
         selections.each do |node|
           case node

data/lib/graphql/stitching/executor/{resolver_source.rb → type_resolver_source.rb}

@@ -2,7 +2,7 @@
 
 module GraphQL::Stitching
   class Executor
-    class ResolverSource < GraphQL::Dataloader::Source
+    class TypeResolverSource < GraphQL::Dataloader::Source
       def initialize(executor, location)
         @executor = executor
         @location = location
@@ -17,7 +17,7 @@ module GraphQL::Stitching
 
           if op.if_type
             # operations planned around unused fragment conditions should not trigger requests
-            origin_set.select! { _1[Resolver::TYPENAME_EXPORT_NODE.alias] == op.if_type }
+            origin_set.select! { _1[TypeResolver::TYPENAME_EXPORT_NODE.alias] == op.if_type }
           end
 
           memo[op] = origin_set if origin_set.any?

data/lib/graphql/stitching/executor.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require "json"
-require_relative "executor/resolver_source"
 require_relative "executor/root_source"
+require_relative "executor/type_resolver_source"
 require_relative "executor/shaper"
 
 module GraphQL
@@ -66,7 +66,7 @@ module GraphQL
             .select { next_steps.include?(_1.after) }
             .group_by { [_1.location, _1.resolver.nil?] }
             .map do |(location, root_source), ops|
-              source_class = root_source ? RootSource : ResolverSource
+              source_class = root_source ? RootSource : TypeResolverSource
               @dataloader.with(source_class, self, location).request_all(ops)
             end
 

data/lib/graphql/stitching/planner/step.rb

@@ -16,7 +16,7 @@ module GraphQL::Stitching
         parent_type:,
         index:,
         after: nil,
-        operation_type: "query",
+        operation_type: QUERY_OP,
         selections: [],
         variables: {},
         path: [],

data/lib/graphql/stitching/planner.rb

@@ -35,6 +35,7 @@ module GraphQL
       # A) Group all root selections by their preferred entrypoint locations.
       # A.1) Group query fields by location for parallel execution.
       # A.2) Partition mutation fields by consecutive location for serial execution.
+      # A.3) Permit exactly one subscription field.
       #
       # B) Extract contiguous selections for each entrypoint location.
       # B.1) Selections on interface types that do not belong to the interface at the
@@ -75,7 +76,7 @@ module GraphQL
         resolver: nil
       )
         # coalesce repeat parameters into a single entrypoint
-        entrypoint = String.new("#{parent_index}/#{location}/#{parent_type.graphql_name}/#{resolver&.key&.to_definition}")
+        entrypoint = String.new("#{parent_index}/#{location}/#{parent_type.graphql_name}/#{resolver&.key&.to_definition}/#")
         path.each { entrypoint << "/#{_1}" }
 
         step = @steps_by_entrypoint[entrypoint]
@@ -107,11 +108,11 @@ module GraphQL
 
       # A) Group all root selections by their preferred entrypoint locations.
       def build_root_entrypoints
+        parent_type = @supergraph.schema.root_type_for_operation(@request.operation.operation_type)
+
         case @request.operation.operation_type
         when QUERY_OP
           # A.1) Group query fields by location for parallel execution.
-          parent_type = @supergraph.schema.query
-
           selections_by_location = {}
           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
@@ -131,8 +132,6 @@ module GraphQL
 
         when MUTATION_OP
           # A.2) Partition mutation fields by consecutive location for serial execution.
-          parent_type = @supergraph.schema.mutation
-
           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
@@ -155,8 +154,7 @@ module GraphQL
           end
 
         when SUBSCRIPTION_OP
-          parent_type = @supergraph.schema.subscription
-
+          # A.3) Permit exactly one subscription field.
           each_field_in_scope(parent_type, @request.operation.selections) do |node|
             raise StitchingError, "Too many root fields for subscription." unless @steps_by_entrypoint.empty?
 
@@ -217,8 +215,8 @@ module GraphQL
         input_selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            if node.alias&.start_with?(Resolver::EXPORT_PREFIX)
-              raise StitchingError, %(Alias "#{node.alias}" is not allowed because "#{Resolver::EXPORT_PREFIX}" is a reserved prefix.)
+            if node.alias&.start_with?(TypeResolver::EXPORT_PREFIX)
+              raise StitchingError, %(Alias "#{node.alias}" is not allowed because "#{TypeResolver::EXPORT_PREFIX}" is a reserved prefix.)
             elsif node.name == TYPENAME
               locale_selections << node
               next
@@ -279,8 +277,8 @@ module GraphQL
 
         # B.4) Add a `__typename` export to abstracts and types that implement
         # fragments so that resolved type information is available during execution.
-        if requires_typename && !locale_selections.include?(Resolver::TYPENAME_EXPORT_NODE)
-          locale_selections << Resolver::TYPENAME_EXPORT_NODE
+        if requires_typename && !locale_selections.include?(TypeResolver::TYPENAME_EXPORT_NODE)
+          locale_selections << TypeResolver::TYPENAME_EXPORT_NODE
         end
 
         if remote_selections
@@ -296,7 +294,7 @@ module GraphQL
               # E.1) Add the key of each resolver query into the prior location's selection set.
               parent_selections.push(*resolver.key.export_nodes) if resolver.key
               parent_selections.uniq! do |node|
-                export_node = node.is_a?(GraphQL::Language::Nodes::Field) && Resolver.export_key?(node.alias)
+                export_node = node.is_a?(GraphQL::Language::Nodes::Field) && TypeResolver.export_key?(node.alias)
                 export_node ? node.alias : node.object_id
               end
 

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

@@ -40,7 +40,7 @@ module GraphQL::Stitching
           end
 
           if filtered_selections.none?
-            filtered_selections << Resolver::TYPENAME_EXPORT_NODE
+            filtered_selections << TypeResolver::TYPENAME_EXPORT_NODE
           end
 
           if changed

data/lib/graphql/stitching/request.rb

@@ -75,12 +75,12 @@ module GraphQL
 
       # @return [String] a digest of the original document string. Generally faster but less consistent.
       def digest
-        @digest ||= Digest::SHA2.hexdigest(string)
+        @digest ||= Stitching.digest.call("#{Stitching::VERSION}/#{string}")
       end
 
       # @return [String] a digest of the normalized document string. Slower but more consistent.
       def normalized_digest
-        @normalized_digest ||= Digest::SHA2.hexdigest(normalized_string)
+        @normalized_digest ||= Stitching.digest.call("#{Stitching::VERSION}/#{normalized_string}")
       end
 
       # @return [GraphQL::Language::Nodes::OperationDefinition] The selected root operation for the request.

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

@@ -32,7 +32,7 @@ module GraphQL::Stitching
           end
 
           key_definitions = locations_by_key.each_with_object({}) do |(key, locations), memo|
-            memo[key] = Resolver.parse_key(key, locations)
+            memo[key] = TypeResolver.parse_key(key, locations)
           end
 
           # Collect/build resolver definitions for each type
@@ -41,13 +41,13 @@ module GraphQL::Stitching
 
             kwargs = directive.arguments.keyword_arguments
             resolver_map[type_name] ||= []
-            resolver_map[type_name] << Resolver.new(
+            resolver_map[type_name] << TypeResolver.new(
               location: kwargs[:location],
               type_name: kwargs.fetch(:type_name, type_name),
               field: kwargs[:field],
               list: kwargs[:list] || false,
               key: key_definitions[kwargs[:key]],
-              arguments: Resolver.parse_arguments_with_type_defs(kwargs[:arguments], kwargs[:argument_types]),
+              arguments: TypeResolver.parse_arguments_with_type_defs(kwargs[:arguments], kwargs[:argument_types]),
             )
           end
 

data/lib/graphql/stitching/supergraph.rb

@@ -166,7 +166,7 @@ module GraphQL
         if key_count.zero?
           # nested root scopes have no resolver keys and just return a location
           goal_locations.each_with_object({}) do |goal_location, memo|
-            memo[goal_location] = [Resolver.new(location: goal_location)]
+            memo[goal_location] = [TypeResolver.new(location: goal_location)]
           end
 
         elsif key_count > 1

data/lib/graphql/stitching/{resolver → type_resolver}/arguments.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module GraphQL::Stitching
-  class Resolver
+  class TypeResolver
     # Defines a single resolver argument structure
     # @api private
     class Argument
@@ -129,9 +129,9 @@ module GraphQL::Stitching
       end
 
       def verify_key(arg, key)
-        key_field = value.reduce(Resolver::KeyField.new("", inner: key)) do |field, ns|
+        key_field = value.reduce(TypeResolver::KeyField.new("", inner: key)) do |field, ns|
           if ns == TYPENAME
-            Resolver::KeyField.new(TYPENAME)
+            TypeResolver::KeyField.new(TYPENAME)
           elsif field
             field.inner.find { _1.name == ns }
           end
@@ -146,7 +146,7 @@ module GraphQL::Stitching
 
       def build(origin_obj)
         value.each_with_index.reduce(origin_obj) do |obj, (ns, idx)|
-          obj[idx.zero? ? Resolver.export_key(ns) : ns]
+          obj[idx.zero? ? TypeResolver.export_key(ns) : ns]
         end
       end
 
@@ -174,7 +174,7 @@ module GraphQL::Stitching
       # Parses an argument template string into resolver arguments via schema casting.
       # @param template [String] the template string to parse.
       # @param field_def [GraphQL::Schema::FieldDefinition] a field definition providing arguments schema.
-      # @return [[GraphQL::Stitching::Resolver::Argument]] an array of resolver arguments.
+      # @return [[GraphQL::Stitching::TypeResolver::Argument]] an array of resolver arguments.
       def parse_arguments_with_field(template, field_def)
         ast = parse_arg_defs(template)
         args = build_argument_set(ast, field_def.arguments)
@@ -196,7 +196,7 @@ module GraphQL::Stitching
       # Parses an argument template string into resolver arguments via SDL casting.
       # @param template [String] the template string to parse.
       # @param type_defs [String] the type definition string declaring argument types.
-      # @return [[GraphQL::Stitching::Resolver::Argument]] an array of resolver arguments.
+      # @return [[GraphQL::Stitching::TypeResolver::Argument]] an array of resolver arguments.
       def parse_arguments_with_type_defs(template, type_defs)
         type_map = parse_type_defs(type_defs)
         parse_arg_defs(template).map { build_argument(_1, type_struct: type_map[_1.name]) }

data/lib/graphql/stitching/{resolver → type_resolver}/keys.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module GraphQL::Stitching
-  class Resolver
+  class TypeResolver
     EXPORT_PREFIX = "_export_"
 
     class FieldNode

data/lib/graphql/stitching/{resolver.rb → type_resolver.rb}

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "resolver/arguments"
-require_relative "resolver/keys"
+require_relative "type_resolver/arguments"
+require_relative "type_resolver/keys"
 
 module GraphQL
   module Stitching
     # Defines a type resolver query that provides direct access to an entity type.
-    class Resolver
+    class TypeResolver
       extend ArgumentsParser
       extend KeysParser
 
@@ -47,7 +47,7 @@ module GraphQL
       end
 
       def version
-        @version ||= Digest::SHA2.hexdigest("#{Stitching::VERSION}/#{as_json.to_json}")
+        @version ||= Stitching.digest.call("#{Stitching::VERSION}/#{as_json.to_json}")
       end
 
       def ==(other)

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "1.5.0"
+    VERSION = "1.5.1"
   end
 end

data/lib/graphql/stitching.rb

@@ -27,12 +27,24 @@ module GraphQL
     class ValidationError < CompositionError; end
 
     class << self
+      attr_writer :stitch_directive
+
+      # Proc used to compute digests; uses SHA2 by default.
+      # @returns [Proc] proc used to compute digests.
+      def digest(&block)
+        if block_given?
+          @digest = block
+        else
+          @digest ||= ->(str) { Digest::SHA2.hexdigest(str) }
+        end
+      end
+
+      # Name of the directive used to mark type resolvers.
+      # @returns [String] name of the type resolver directive.
       def stitch_directive
         @stitch_directive ||= "stitch"
       end
 
-      attr_writer :stitch_directive
-
       # Names of stitching directives to omit from the composed supergraph.
       # @returns [Array<String>] list of stitching directive names.
       def stitching_directive_names
@@ -50,6 +62,6 @@ require_relative "stitching/http_executable"
 require_relative "stitching/plan"
 require_relative "stitching/planner"
 require_relative "stitching/request"
-require_relative "stitching/resolver"
+require_relative "stitching/type_resolver"
 require_relative "stitching/util"
 require_relative "stitching/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-25 00:00:00.000000000 Z
+date: 2024-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -89,9 +89,9 @@ files:
 - docs/images/stitching.png
 - docs/mechanics.md
 - docs/request.md
-- docs/resolver.md
 - docs/subscriptions.md
 - docs/supergraph.md
+- docs/type_resolver.md
 - examples/file_uploads/Gemfile
 - examples/file_uploads/Procfile
 - examples/file_uploads/README.md
@@ -160,27 +160,27 @@ files:
 - lib/graphql/stitching/client.rb
 - lib/graphql/stitching/composer.rb
 - lib/graphql/stitching/composer/base_validator.rb
-- lib/graphql/stitching/composer/resolver_config.rb
+- lib/graphql/stitching/composer/type_resolver_config.rb
 - lib/graphql/stitching/composer/validate_interfaces.rb
-- lib/graphql/stitching/composer/validate_resolvers.rb
+- lib/graphql/stitching/composer/validate_type_resolvers.rb
 - lib/graphql/stitching/executor.rb
-- lib/graphql/stitching/executor/resolver_source.rb
 - lib/graphql/stitching/executor/root_source.rb
 - lib/graphql/stitching/executor/shaper.rb
+- lib/graphql/stitching/executor/type_resolver_source.rb
 - lib/graphql/stitching/http_executable.rb
 - lib/graphql/stitching/plan.rb
 - lib/graphql/stitching/planner.rb
 - lib/graphql/stitching/planner/step.rb
 - lib/graphql/stitching/request.rb
 - lib/graphql/stitching/request/skip_include.rb
-- lib/graphql/stitching/resolver.rb
-- lib/graphql/stitching/resolver/arguments.rb
-- lib/graphql/stitching/resolver/keys.rb
 - lib/graphql/stitching/supergraph.rb
 - lib/graphql/stitching/supergraph/key_directive.rb
 - lib/graphql/stitching/supergraph/resolver_directive.rb
 - lib/graphql/stitching/supergraph/source_directive.rb
 - lib/graphql/stitching/supergraph/to_definition.rb
+- lib/graphql/stitching/type_resolver.rb
+- lib/graphql/stitching/type_resolver/arguments.rb
+- lib/graphql/stitching/type_resolver/keys.rb
 - lib/graphql/stitching/util.rb
 - lib/graphql/stitching/version.rb
 homepage: https://github.com/gmac/graphql-stitching-ruby