graphql-stitching 1.4.3 → 1.5.1

data/lib/graphql/stitching/composer.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-require_relative "./composer/base_validator"
-require_relative "./composer/validate_interfaces"
-require_relative "./composer/validate_resolvers"
-require_relative "./composer/resolver_config"
+require_relative "composer/base_validator"
+require_relative "composer/validate_interfaces"
+require_relative "composer/validate_type_resolvers"
+require_relative "composer/type_resolver_config"
 
 module GraphQL
   module Stitching
+    # Composer receives many individual `GraphQL::Schema` instances 
+    # representing various graph locations and merges them into one 
+    # combined Supergraph that is validated for integrity.
     class Composer
       # @api private
       NO_DEFAULT_VALUE = begin
@@ -26,9 +29,9 @@ module GraphQL
       BASIC_ROOT_FIELD_LOCATION_SELECTOR = ->(locations, _info) { locations.last }
 
       # @api private
-      VALIDATORS = [
-        "ValidateInterfaces",
-        "ValidateResolvers",
+      COMPOSITION_VALIDATORS = [
+        ValidateInterfaces,
+        ValidateTypeResolvers,
       ].freeze
 
       # @return [String] name of the Query type in the composed schema.
@@ -37,6 +40,9 @@ module GraphQL
       # @return [String] name of the Mutation type in the composed schema.
       attr_reader :mutation_name
 
+      # @return [String] name of the Subscription type in the composed schema.
+      attr_reader :subscription_name
+
       # @api private
       attr_reader :subgraph_types_by_name_and_location
 
@@ -46,6 +52,7 @@ module GraphQL
       def initialize(
         query_name: "Query",
         mutation_name: "Mutation",
+        subscription_name: "Subscription",
         description_merger: nil,
         deprecation_merger: nil,
         default_value_merger: nil,
@@ -54,23 +61,27 @@ module GraphQL
       )
         @query_name = query_name
         @mutation_name = mutation_name
+        @subscription_name = subscription_name
         @description_merger = description_merger || BASIC_VALUE_MERGER
         @deprecation_merger = deprecation_merger || BASIC_VALUE_MERGER
         @default_value_merger = default_value_merger || BASIC_VALUE_MERGER
         @directive_kwarg_merger = directive_kwarg_merger || BASIC_VALUE_MERGER
         @root_field_location_selector = root_field_location_selector || BASIC_ROOT_FIELD_LOCATION_SELECTOR
+        
+        @field_map = {}
+        @resolver_map = {}
         @resolver_configs = {}
-
-        @field_map = nil
-        @resolver_map = nil
-        @mapped_type_names = nil
+        @mapped_type_names = {}
         @subgraph_directives_by_name_and_location = nil
         @subgraph_types_by_name_and_location = nil
         @schema_directives = nil
       end
 
       def perform(locations_input)
-        reset!
+        if @subgraph_types_by_name_and_location
+          raise CompositionError, "Composer may only perform once per instance."
+        end
+
         schemas, executables = prepare_locations_input(locations_input)
 
         # "directive_name" => "location" => subgraph_directive
@@ -91,7 +102,6 @@ module GraphQL
         # "Typename" => "location" => subgraph_type
         @subgraph_types_by_name_and_location = schemas.each_with_object({}) do |(location, schema), memo|
           raise CompositionError, "Location keys must be strings" unless location.is_a?(String)
-          raise CompositionError, "The subscription operation is not supported." if schema.subscription
 
           introspection_types = schema.introspection_system.types.keys
           schema.types.each do |type_name, subgraph_type|
@@ -101,10 +111,13 @@ module GraphQL
               raise CompositionError, "Query name \"#{@query_name}\" is used by non-query type in #{location} schema."
             elsif type_name == @mutation_name && subgraph_type != schema.mutation
               raise CompositionError, "Mutation name \"#{@mutation_name}\" is used by non-mutation type in #{location} schema."
+            elsif type_name == @subscription_name && subgraph_type != schema.subscription
+              raise CompositionError, "Subscription name \"#{@subscription_name}\" is used by non-subscription type in #{location} schema."
             end
 
             type_name = @query_name if subgraph_type == schema.query
             type_name = @mutation_name if subgraph_type == schema.mutation
+            type_name = @subscription_name if subgraph_type == schema.subscription
             @mapped_type_names[subgraph_type.graphql_name] = type_name if subgraph_type.graphql_name != type_name
 
             memo[type_name] ||= {}
@@ -148,13 +161,14 @@ module GraphQL
           orphan_types(schema_types.values.select { |t| t.respond_to?(:kind) && t.kind.object? })
           query schema_types[builder.query_name]
           mutation schema_types[builder.mutation_name]
+          subscription schema_types[builder.subscription_name]
           directives builder.schema_directives.values
 
           own_orphan_types.clear
         end
 
         select_root_field_locations(schema)
-        expand_abstract_resolvers(schema)
+        expand_abstract_resolvers(schema, schemas)
 
         supergraph = Supergraph.new(
           schema: schema,
@@ -163,9 +177,8 @@ module GraphQL
           executables: executables,
         )
 
-        VALIDATORS.each do |validator|
-          klass = Object.const_get("GraphQL::Stitching::Composer::#{validator}")
-          klass.new.perform(supergraph, self)
+        COMPOSITION_VALIDATORS.each do |validator_class|
+          validator_class.new.perform(supergraph, self)
         end
 
         supergraph
@@ -186,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
@@ -533,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
@@ -548,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],
               )
@@ -568,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,
@@ -588,7 +601,7 @@ module GraphQL
       # @!scope class
       # @!visibility private
       def select_root_field_locations(schema)
-        [schema.query, schema.mutation].tap(&:compact!).each do |root_type|
+        [schema.query, schema.mutation, schema.subscription].tap(&:compact!).each do |root_type|
           root_type.fields.each do |root_field_name, root_field|
             root_field_locations = @field_map[root_type.graphql_name][root_field_name]
             next unless root_field_locations.length > 1
@@ -607,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
@@ -660,16 +676,6 @@ module GraphQL
           memo[enum_name] << :write
         end
       end
-
-      private
-
-      def reset!
-        @field_map = {}
-        @resolver_map = {}
-        @mapped_type_names = {}
-        @subgraph_directives_by_name_and_location = nil
-        @schema_directives = nil
-      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
@@ -105,7 +105,7 @@ module GraphQL::Stitching
         is_root = parent_type == @root_type
 
         case node.name
-        when "__typename"
+        when TYPENAME
           yield(is_root)
           true
         when "__schema", "__type"

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,12 +1,16 @@
 # frozen_string_literal: true
 
 require "json"
-require_relative "./executor/resolver_source"
-require_relative "./executor/root_source"
-require_relative "./executor/shaper"
+require_relative "executor/root_source"
+require_relative "executor/type_resolver_source"
+require_relative "executor/shaper"
 
 module GraphQL
   module Stitching
+    # Executor handles executing upon a planned request.
+    # All planned steps are initiated, their results merged,
+    # and loaded keys are collected for batching subsequent steps.
+    # Final execution results are then shaped to match the request selection.
     class Executor
       # @return [Request] the stitching request to execute.
       attr_reader :request
@@ -20,10 +24,14 @@ module GraphQL
       # @return [Integer] tally of queries performed while executing.
       attr_accessor :query_count
 
-      def initialize(request, nonblocking: false)
+      # Builds a new executor.
+      # @param request [Request] the stitching request to execute.
+      # @param nonblocking [Boolean] specifies if the dataloader should use async concurrency.
+      def initialize(request, data: {}, errors: [], after: 0, nonblocking: false)
         @request = request
-        @data = {}
-        @errors = []
+        @data = data
+        @errors = errors
+        @after = after
         @query_count = 0
         @exec_cycles = 0
         @dataloader = GraphQL::Dataloader.new(nonblocking: nonblocking)
@@ -40,13 +48,13 @@ module GraphQL
         if @errors.length > 0
           result["errors"] = @errors
         end
-
-        result
+        
+        GraphQL::Query::Result.new(query: @request, values: result)
       end
 
       private
 
-      def exec!(next_steps = [0])
+      def exec!(next_steps = [@after])
         if @exec_cycles > @request.plan.ops.length
           # sanity check... if we've exceeded queue size, then something went wrong.
           raise StitchingError, "Too many execution requests attempted."
@@ -58,8 +66,8 @@ module GraphQL
             .select { next_steps.include?(_1.after) }
             .group_by { [_1.location, _1.resolver.nil?] }
             .map do |(location, root_source), ops|
-              source_type = root_source ? RootSource : ResolverSource
-              @dataloader.with(source_type, self, location).request_all(ops)
+              source_class = root_source ? RootSource : TypeResolverSource
+              @dataloader.with(source_class, self, location).request_all(ops)
             end
 
           tasks.each(&method(:exec_task))

data/lib/graphql/stitching/http_executable.rb

@@ -6,6 +6,9 @@ require "json"
 
 module GraphQL
   module Stitching
+    # HttpExecutable provides an out-of-the-box convenience for sending 
+    # HTTP post requests to a remote location, or a base class 
+    # for other implementations with GraphQL multipart uploads.
     class HttpExecutable
       # Builds a new executable for proxying subgraph requests via HTTP.
       # @param url [String] the url of the remote location to proxy.

data/lib/graphql/stitching/plan.rb

@@ -2,7 +2,7 @@
 
 module GraphQL
   module Stitching
-    # Immutable (in theory) structures representing a query plan.
+    # Immutable-ish structures representing a query plan.
     # May serialize to/from JSON.
     class Plan
       Op = Struct.new(

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

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "./planner/step"
+require_relative "planner/step"
 
 module GraphQL
   module Stitching
+    # Planner partitions request selections by best-fit graph locations,
+    # and provides a query plan with sequential execution steps.
     class Planner
       SUPERGRAPH_LOCATIONS = [Supergraph::SUPERGRAPH_LOCATION].freeze
-      TYPENAME = "__typename"
-      QUERY_OP = "query"
-      MUTATION_OP = "mutation"
       ROOT_INDEX = 0
 
       def initialize(request)
@@ -36,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
@@ -76,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]
@@ -108,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
@@ -126,13 +126,12 @@ module GraphQL
               parent_index: ROOT_INDEX,
               parent_type: parent_type,
               selections: selections,
+              operation_type: QUERY_OP,
             )
           end
 
         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
@@ -154,6 +153,21 @@ module GraphQL
             ).index
           end
 
+        when SUBSCRIPTION_OP
+          # 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?
+
+            locations = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name] || SUPERGRAPH_LOCATIONS
+            add_step(
+              location: locations.first,
+              parent_index: ROOT_INDEX,
+              parent_type: parent_type,
+              selections: [node],
+              operation_type: SUBSCRIPTION_OP,
+            )
+          end
+
         else
           raise StitchingError, "Invalid operation type."
         end
@@ -201,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
@@ -263,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
@@ -280,8 +294,8 @@ 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.alias : node
+                export_node = node.is_a?(GraphQL::Language::Nodes::Field) && TypeResolver.export_key?(node.alias)
+                export_node ? node.alias : node.object_id
               end
 
               # E.2) Add a planner step for each new entrypoint location.

data/lib/graphql/stitching/{skip_include.rb → request/skip_include.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
+module GraphQL::Stitching
+  class Request
     # Faster implementation of an AST visitor for prerendering
     # @skip and @include conditional directives into a document.
     # This avoids unnecessary planning steps, and prepares result shaping.
@@ -40,7 +40,7 @@ module GraphQL
           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

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "request/skip_include"
+
 module GraphQL
   module Stitching
+    # Request combines a supergraph, GraphQL document, variables, 
+    # variable/fragment definitions, and the selected operation.
+    # It provides the lifecycle of validating, preparing,
+    # planning, and executing upon these inputs.
     class Request
-      SUPPORTED_OPERATIONS = ["query", "mutation"].freeze
       SKIP_INCLUDE_DIRECTIVE = /@(?:skip|include)/
 
       # @return [Supergraph] supergraph instance that resolves the request.
@@ -70,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.
@@ -83,7 +88,6 @@ module GraphQL
         @operation ||= begin
           operation_defs = @document.definitions.select do |d|
             next unless d.is_a?(GraphQL::Language::Nodes::OperationDefinition)
-            next unless SUPPORTED_OPERATIONS.include?(d.operation_type)
             @operation_name ? d.name == @operation_name : true
           end
 
@@ -97,6 +101,21 @@ module GraphQL
         end
       end
 
+      # @return [Boolean] true if operation type is a query
+      def query?
+        operation.operation_type == QUERY_OP
+      end
+
+      # @return [Boolean] true if operation type is a mutation
+      def mutation?
+        operation.operation_type == MUTATION_OP
+      end
+
+      # @return [Boolean] true if operation type is a subscription
+      def subscription?
+        operation.operation_type == SUBSCRIPTION_OP
+      end
+
       # @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?
@@ -162,7 +181,7 @@ module GraphQL
           raise StitchingError, "Plan must be a `GraphQL::Stitching::Plan`." unless new_plan.is_a?(Plan)
           @plan = new_plan
         else
-          @plan ||= GraphQL::Stitching::Planner.new(self).perform
+          @plan ||= Planner.new(self).perform
         end
       end
 
@@ -170,7 +189,26 @@ module GraphQL
       # @param raw [Boolean] specifies the result should be unshaped without pruning or null bubbling. Useful for debugging.
       # @return [Hash] the rendered GraphQL response with "data" and "errors" sections.
       def execute(raw: false)
-        GraphQL::Stitching::Executor.new(self).perform(raw: raw)
+        add_subscription_update_handler if subscription?
+        Executor.new(self).perform(raw: raw)
+      end
+
+      private
+
+      # Adds a handler into context for enriching subscription updates with stitched data
+      def add_subscription_update_handler
+        request = self
+        @context[:stitch_subscription_update] = -> (result) {
+          stitched_result = Executor.new(
+            request,
+            data: result.to_h["data"] || {},
+            errors: result.to_h["errors"] || [],
+            after: request.plan.ops.first.step,
+          ).perform
+
+          result.to_h.merge!(stitched_result.to_h)
+          result
+        }
       end
     end
   end

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

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "./supergraph/to_definition"
+require_relative "supergraph/to_definition"
 
 module GraphQL
   module Stitching
+    # Supergraph is the singuar representation of a stitched graph. 
+    # It provides the combined GraphQL schema and delegation maps 
+    # used to route selections across subgraph locations.
     class Supergraph
       SUPERGRAPH_LOCATION = "__super"
 
@@ -100,7 +103,7 @@ module GraphQL
           executable.execute(
             query: source,
             variables: variables,
-            context: request.context.frozen? ? request.context.dup : request.context,
+            context: request.context.to_h,
             validate: false,
           )
         elsif executable.respond_to?(:call)
@@ -163,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