graphql-stitching 1.2.4 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c1c6ae95fd6ec036a7678356c8bc48191d8cf5cfd9e4b2936e79fdb72b52f48
-  data.tar.gz: 7f8002d013e26f69df5a7023e147f98b86a46cc3027d2753b6d704bfe75a835b
+  metadata.gz: d33ec469a7f4598bd9f198b25102bcb3453d034b124fb18bcfd8ec595b78a6ce
+  data.tar.gz: a6ef6c8e218045a508c22ade74fb83504d762c0a6cadb5ed3cd4f58a89bddcea
 SHA512:
-  metadata.gz: 734fe2a73f5412f30ccc6d89a20e62c1da376422de65a816a9680f02330cb2df93c39803cc182c5eed1c310624509beccb0a69162c1dad407ccaf6ada69178dd
-  data.tar.gz: c293a3de403d0888d15047e2de120a8187e4fee598229572f37905dd4e4b3429017ee958ae8ab2a2c16561d25761128b9a6ffb954cbf49b5a310c92aa77f7ffe
+  metadata.gz: dc753d25c70045d1f2f995a0bbc8329ab426e1c5426943fa88e03fa71128fe8c1da928a8c905c997396c4d248e26e4400a02e2b2bc56d9e26b4916b5c63a8a7b
+  data.tar.gz: fdea7099a1cb486df512bdb93e7d90cceef42e7ff875e4c72c8e4b1fb46836d9e15cf5ae6124ca81132ec2a0707aca08a0d2a80d35fc40b18cf036c12576ff43

data/README.md

@@ -16,7 +16,7 @@ GraphQL stitching composes a single schema from multiple underlying GraphQL reso
 - Computed fields (ie: federation-style `@requires`).
 - Subscriptions, defer/stream.
 
-This Ruby implementation is a sibling to [GraphQL Tools](https://the-guild.dev/graphql/stitching) (JS) and [Bramble](https://movio.github.io/bramble/) (Go), and its capabilities fall somewhere in between them. GraphQL stitching is similar in concept to [Apollo Federation](https://www.apollographql.com/docs/federation/), though more generic. The opportunity here is for a Ruby application to stitch its local schemas together or onto remote sources without requiring an additional proxy service running in another language. If your goal is to build a purely high-performance API gateway, consider not using Ruby.
+This Ruby implementation is a sibling to [GraphQL Tools](https://the-guild.dev/graphql/stitching) (JS) and [Bramble](https://movio.github.io/bramble/) (Go), and its capabilities fall somewhere in between them. GraphQL stitching is similar in concept to [Apollo Federation](https://www.apollographql.com/docs/federation/), though more generic. The opportunity here is for a Ruby application to stitch its local schemas together or onto remote sources without requiring an additional proxy service running in another language. If your goal is to build a purely high-throughput federated reverse proxy, consider not using Ruby.
 
 ## Getting started
 
@@ -153,7 +153,7 @@ type Query {
 * The `@stitch` directive is applied to a root query where the merged type may be accessed. The merged type identity is inferred from the field return.
 * The `key: "id"` parameter indicates that an `{ id }` must be selected from prior locations so it may be submitted as an argument to this query. The query argument used to send the key is inferred when possible ([more on arguments](#multiple-query-arguments) later).
 
-Each location that provides a unique variant of a type must provide at least one stitching query for the type. The exception to this requirement are [foreign key types](./docs/mechanics.md##modeling-foreign-keys-for-stitching) that contain only a single key field:
+Each location that provides a unique variant of a type must provide at least one resolver query for the type. The exception to this requirement are [outbound-only types](./docs/mechanics.md#outbound-only-merged-types) and/or [foreign key types](./docs/mechanics.md##modeling-foreign-keys-for-stitching) that contain no exclusive data:
 
 ```graphql
 type Product {
@@ -161,11 +161,11 @@ type Product {
 }
 ```
 
-The above representation of a `Product` type provides no unique data beyond a key that is available in other locations. Thus, this representation will never require an inbound request to fetch it, and its stitching query may be omitted.
+The above representation of a `Product` type contains nothing but a key that is available in other locations. Therefore, this representation will never require an inbound request to fetch it, and its resolver query may be omitted.
 
 #### List queries
 
-It's okay ([even preferable](#batching) in most circumstances) to provide a list accessor as a stitching query. The only requirement is that both the field argument and return type must be lists, and the query results are expected to be a mapped set with `null` holding the position of missing results.
+It's okay ([even preferable](#batching) in most circumstances) to provide a list accessor as a resolver query. The only requirement is that both the field argument and return type must be lists, and the query results are expected to be a mapped set with `null` holding the position of missing results.
 
 ```graphql
 type Query {
@@ -180,7 +180,7 @@ See [error handling](./docs/mechanics.md#stitched-errors) tips for list queries.
 
 #### Abstract queries
 
-It's okay for stitching queries to be implemented through abstract types. An abstract query will provide access to all of its possible types by default, each of which must implement the key.
+It's okay for resolver queries to be implemented through abstract types. An abstract query will provide access to all of its possible types by default, each of which must implement the key.
 
 ```graphql
 interface Node {
@@ -214,14 +214,14 @@ type Query {
 
 #### Multiple query arguments
 
-Stitching infers which argument to use for queries with a single argument, or when the key name matches its intended argument. For queries that accept multiple arguments with unmatched names, the key may provide an argument mapping specified as `"<arg>:<key>"`.
+Stitching infers which argument to use for queries with a single argument, or when the key name matches its intended argument. For queries that accept multiple arguments with unmatched names, the key should provide an argument alias specified as `"<arg>:<key>"`.
 
 ```graphql
 type Product {
   id: ID!
 }
 type Query {
-  product(by_id: ID, by_sku: ID): Product @stitch(key: "by_id:id")
+  product(byId: ID, bySku: ID): Product @stitch(key: "byId:id")
 }
 ```
 
@@ -235,7 +235,7 @@ type Product { id:ID! sku:ID! }  # products location
 type Product { sku:ID! }         # catelog location
 ```
 
-In the above graph, the `storefronts` and `catelog` locations have different keys that join through an intermediary. This pattern is perfectly valid and resolvable as long as the intermediary provides stitching queries for each possible key:
+In the above graph, the `storefronts` and `catelog` locations have different keys that join through an intermediary. This pattern is perfectly valid and resolvable as long as the intermediary provides resolver queries for each possible key:
 
 ```graphql
 type Product {
@@ -244,7 +244,7 @@ type Product {
 }
 type Query {
   productById(id: ID!): Product @stitch(key: "id")
-  productByUpc(sku: ID!): Product @stitch(key: "sku")
+  productBySku(sku: ID!): Product @stitch(key: "sku")
 }
 ```
 
@@ -265,7 +265,7 @@ type Query {
 The `@stitch` directive can be added to class-based schemas with a directive class:
 
 ```ruby
-class StitchField < GraphQL::Schema::Directive
+class StitchingResolver < GraphQL::Schema::Directive
   graphql_name "stitch"
   locations FIELD_DEFINITION
   repeatable true
@@ -274,7 +274,7 @@ end
 
 class Query < GraphQL::Schema::Object
   field :product, Product, null: false do
-    directive StitchField, key: "id"
+    directive StitchingResolver, key: "id"
     argument :id, ID, required: true
   end
 end
@@ -284,7 +284,7 @@ The `@stitch` directive can be exported from a class-based schema to an SDL stri
 
 #### SDL-based schemas
 
-A clean SDL string may also have stitching directives applied via static configuration by passing a `stitch` array in [location settings](./docs/composer.md#performing-composition):
+A clean schema may also have stitching directives applied via static configuration by passing a `stitch` array in [location settings](./docs/composer.md#performing-composition):
 
 ```ruby
 sdl_string = <<~GRAPHQL
@@ -294,7 +294,7 @@ sdl_string = <<~GRAPHQL
   }
   type Query {
     productById(id: ID!): Product
-    productByUpc(sku: ID!): Product
+    productBySku(sku: ID!): Product
   }
 GRAPHQL
 
@@ -304,7 +304,7 @@ supergraph = GraphQL::Stitching::Composer.new.perform({
     executable: ->() { ... },
     stitch: [
       { field_name: "productById", key: "id" },
-      { field_name: "productByUpc", key: "sku" },
+      { field_name: "productBySku", key: "sku" },
     ]
   },
   # ...
@@ -316,7 +316,7 @@ supergraph = GraphQL::Stitching::Composer.new.perform({
 The library is configured to use a `@stitch` directive by default. You may customize this by setting a new name during initialization:
 
 ```ruby
-GraphQL::Stitching.stitch_directive = "merge"
+GraphQL::Stitching.stitch_directive = "resolver"
 ```
 
 ## Executables
@@ -365,17 +365,17 @@ The `GraphQL::Stitching::HttpExecutable` class is provided as a simple executabl
 The stitching executor automatically batches subgraph requests so that only one request is made per location per generation of data. This is done using batched queries that combine all data access for a given a location. For example:
 
 ```graphql
-query MyOperation_2 {
-  _0_result: widgets(ids:["a","b","c"]) { ... } # << 3 Widget
-  _1_0_result: sprocket(id:"x") { ... } # << 1 Sprocket
-  _1_1_result: sprocket(id:"y") { ... } # << 1 Sprocket
-  _1_2_result: sprocket(id:"z") { ... } # << 1 Sprocket
+query MyOperation_2($_0_key:[ID!]!, $_1_0_key:ID!, $_1_1_key:ID!, $_1_2_key:ID!) {
+  _0_result: widgets(ids: $_0_key) { ... } # << 3 Widget
+  _1_0_result: sprocket(id: $_1_0_key) { ... } # << 1 Sprocket
+  _1_1_result: sprocket(id: $_1_1_key) { ... } # << 1 Sprocket
+  _1_2_result: sprocket(id: $_1_2_key) { ... } # << 1 Sprocket
 }
 ```
 
 Tips:
 
-* List queries (like the `widgets` selection above) are more compact for accessing multiple records, and are therefore preferable as stitching accessors.
+* List queries (like the `widgets` selection above) are generally preferable as resolver queries because they keep the batched document consistent regardless of set size, and make for smaller documents that parse and validate faster.
 * Assure that root field resolvers across your subgraph implement batching to anticipate cases like the three `sprocket` selections above.
 
 Otherwise, there's no developer intervention necessary (or generally possible) to improve upon data access. Note that multiple generations of data may still force the executor to return to a previous location for more data.

data/docs/README.md

@@ -14,4 +14,5 @@ Major components include:
 
 Additional topics:
 
-- [Stitching mechanics](./mechanics.md) - learn more about building for stitching.
+- [Stitching mechanics](./mechanics.md) - more about building for stitching and how it operates.
+- [Federation entities](./federation_entities.md) - more about Apollo Federation compatibility.

data/docs/mechanics.md

@@ -303,3 +303,46 @@ And produces this result:
 ```
 
 Location B is allowed to return `null` here because its one unique field, `rating`, is nullable (the `id` field can be provided by Location A). If `rating` were non-null, then null bubbling would invalidate the response data.
+
+### Outbound-only merged types
+
+Merged types do not always require a resolver query. For example:
+
+```graphql
+# -- Location A
+
+type Widget {
+  id: ID!
+  name: String
+  price: Float
+}
+
+type Query {
+  widgetA(id: ID!): Widget @stitch(key: "id")
+}
+
+# -- Location B
+
+type Widget {
+  id: ID!
+  size: Float
+}
+
+type Query {
+  widgetB(id: ID!): Widget @stitch(key: "id")
+}
+
+# -- Location C
+
+type Widget {
+  id: ID!
+  name: String
+  size: Float
+}
+
+type Query {
+  featuredWidget: Widget
+}
+```
+
+In this graph, `Widget` is a merged type without a resolver query in location C. This works because all of its fields are resolvable in other locations; that means location C can provide outbound representations of this type without ever needing to resolve inbound requests for it. Outbound types do still require a shared key field (such as `id` above) that allow them to join with data in other resolver locations (such as `price` above).

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

@@ -2,7 +2,7 @@
 
 module GraphQL::Stitching
   class Composer
-    class BoundaryConfig
+    class ResolverConfig
       ENTITY_TYPENAME = "_Entity"
       ENTITIES_QUERY = "_entities"
 
@@ -38,7 +38,7 @@ module GraphQL::Stitching
               memo[field_path] << new(
                 key: key,
                 type_name: entity_type.graphql_name,
-                federation: true,
+                representations: true,
               )
             end
           end
@@ -48,7 +48,7 @@ module GraphQL::Stitching
           new(
             key: kwargs[:key],
             type_name: kwargs[:type_name] || kwargs[:typeName],
-            federation: kwargs[:federation] || false,
+            representations: kwargs[:representations] || false,
           )
         end
 
@@ -61,12 +61,12 @@ module GraphQL::Stitching
         end
       end
 
-      attr_reader :key, :type_name, :federation
+      attr_reader :key, :type_name, :representations
 
-      def initialize(key:, type_name:, federation: false)
+      def initialize(key:, type_name:, representations: false)
         @key = key
         @type_name = type_name
-        @federation = federation
+        @representations = representations
       end
     end
   end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Composer
+    class ValidateResolvers < BaseValidator
+
+      def perform(supergraph, composer)
+        supergraph.schema.types.each do |type_name, type|
+          # objects and interfaces that are not the root operation types
+          next unless type.kind.object? || type.kind.interface?
+          next if supergraph.schema.query == type || supergraph.schema.mutation == type
+          next if type.graphql_name.start_with?("__")
+
+          # multiple subschemas implement the type
+          candidate_types_by_location = composer.candidate_types_by_name_and_location[type_name]
+          next unless candidate_types_by_location.length > 1
+
+          resolvers = supergraph.resolvers[type_name]
+          if resolvers&.any?
+            validate_as_resolver(supergraph, type, candidate_types_by_location, resolvers)
+          elsif type.kind.object?
+            validate_as_shared(supergraph, type, candidate_types_by_location)
+          end
+        end
+      end
+
+      private
+
+      def validate_as_resolver(supergraph, type, candidate_types_by_location, resolvers)
+        # abstract resolvers are expanded with their concrete implementations, which each get validated. Ignore the abstract itself.
+        return if type.kind.abstract?
+
+        # only one resolver allowed per type/location/key
+        resolvers_by_location_and_key = resolvers.each_with_object({}) do |resolver, memo|
+          if memo.dig(resolver.location, resolver.key)
+            raise Composer::ValidationError, "Multiple resolver queries for `#{type.graphql_name}.#{resolver.key}` "\
+              "found in #{resolver.location}. Limit one resolver query per type and key in each location. "\
+              "Abstract resolvers provide all possible types."
+          end
+          memo[resolver.location] ||= {}
+          memo[resolver.location][resolver.key] = resolver
+        end
+
+        resolver_keys = resolvers.map(&:key).to_set
+
+        # All non-key fields must be resolvable in at least one resolver location
+        supergraph.locations_by_type_and_field[type.graphql_name].each do |field_name, locations|
+          next if resolver_keys.include?(field_name)
+
+          if locations.none? { resolvers_by_location_and_key[_1] }
+            where = locations.length > 1 ? "one of #{locations.join(", ")} locations" : locations.first
+            raise Composer::ValidationError, "A resolver query is required for `#{type.graphql_name}` in #{where} to resolve field `#{field_name}`."
+          end
+        end
+
+        # All locations of a resolver type must include at least one key field
+        supergraph.fields_by_type_and_location[type.graphql_name].each do |location, field_names|
+          if field_names.none? { resolver_keys.include?(_1) }
+            raise Composer::ValidationError, "A resolver key is required for `#{type.graphql_name}` in #{location} to join with other locations."
+          end
+        end
+
+        # verify that all outbound locations can access all inbound locations
+        resolver_locations = resolvers_by_location_and_key.keys
+        candidate_types_by_location.each_key do |location|
+          remote_locations = resolver_locations.reject { _1 == location }
+          paths = supergraph.route_type_to_locations(type.graphql_name, location, remote_locations)
+          if paths.length != remote_locations.length || paths.any? { |_loc, path| path.nil? }
+            raise Composer::ValidationError, "Cannot route `#{type.graphql_name}` resolvers in #{location} to all other locations. "\
+              "All locations must provide a resolver query with a joining key."
+          end
+        end
+      end
+
+      def validate_as_shared(supergraph, type, candidate_types_by_location)
+        expected_fields = begin
+          type.fields.keys.sort
+        rescue StandardError => e
+          # bug with inherited interfaces in older versions of GraphQL
+          if type.interfaces.any? { _1.is_a?(GraphQL::Schema::LateBoundType) }
+            raise Composer::ComposerError, "Merged interface inheritance requires GraphQL >= v2.0.3"
+          else
+            raise e
+          end
+        end
+
+        candidate_types_by_location.each do |location, candidate_type|
+          if candidate_type.fields.keys.sort != expected_fields
+            raise Composer::ValidationError, "Shared type `#{type.graphql_name}` must have consistent fields across locations, "\
+              "or else define resolver queries so that its unique fields may be accessed remotely."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/stitching/composer.rb

@@ -2,8 +2,8 @@
 
 require_relative "./composer/base_validator"
 require_relative "./composer/validate_interfaces"
-require_relative "./composer/validate_boundaries"
-require_relative "./composer/boundary_config"
+require_relative "./composer/validate_resolvers"
+require_relative "./composer/resolver_config"
 
 module GraphQL
   module Stitching
@@ -31,7 +31,7 @@ module GraphQL
       # @api private
       VALIDATORS = [
         "ValidateInterfaces",
-        "ValidateBoundaries",
+        "ValidateResolvers",
       ].freeze
 
       # @return [String] name of the Query type in the composed schema.
@@ -62,12 +62,13 @@ module GraphQL
         @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
-        @boundary_configs = {}
+        @resolver_configs = {}
 
         @field_map = nil
-        @boundary_map = nil
+        @resolver_map = nil
         @mapped_type_names = nil
         @candidate_directives_by_name_and_location = nil
+        @candidate_types_by_name_and_location = nil
         @schema_directives = nil
       end
 
@@ -124,7 +125,7 @@ module GraphQL
             raise ComposerError, "Cannot merge different kinds for `#{type_name}`. Found: #{kinds.join(", ")}."
           end
 
-          extract_boundaries(type_name, types_by_location) if type_name == @query_name
+          extract_resolvers(type_name, types_by_location) if type_name == @query_name
 
           memo[type_name] = case kinds.first
           when "SCALAR"
@@ -156,12 +157,12 @@ module GraphQL
         end
 
         select_root_field_locations(schema)
-        expand_abstract_boundaries(schema)
+        expand_abstract_resolvers(schema)
 
         supergraph = Supergraph.new(
           schema: schema,
           fields: @field_map,
-          boundaries: @boundary_map,
+          resolvers: @resolver_map,
           executables: executables,
         )
 
@@ -188,8 +189,8 @@ module GraphQL
             raise ComposerError, "The schema for `#{location}` location must be a GraphQL::Schema class."
           end
 
-          @boundary_configs.merge!(BoundaryConfig.extract_directive_assignments(schema, location, input[:stitch]))
-          @boundary_configs.merge!(BoundaryConfig.extract_federation_entities(schema, location))
+          @resolver_configs.merge!(ResolverConfig.extract_directive_assignments(schema, location, input[:stitch]))
+          @resolver_configs.merge!(ResolverConfig.extract_federation_entities(schema, location))
 
           schemas[location.to_s] = schema
           executables[location.to_s] = input[:executable] || schema
@@ -526,63 +527,64 @@ module GraphQL
 
       # @!scope class
       # @!visibility private
-      def extract_boundaries(type_name, types_by_location)
+      def extract_resolvers(type_name, types_by_location)
         types_by_location.each do |location, type_candidate|
           type_candidate.fields.each do |field_name, field_candidate|
-            boundary_type = field_candidate.type.unwrap
-            boundary_structure = Util.flatten_type_structure(field_candidate.type)
-            boundary_configs = @boundary_configs.fetch("#{location}.#{field_name}",  [])
+            resolver_type = field_candidate.type.unwrap
+            resolver_structure = Util.flatten_type_structure(field_candidate.type)
+            resolver_configs = @resolver_configs.fetch("#{location}.#{field_name}",  [])
 
             field_candidate.directives.each do |directive|
               next unless directive.graphql_name == GraphQL::Stitching.stitch_directive
-              boundary_configs << BoundaryConfig.from_kwargs(directive.arguments.keyword_arguments)
+              resolver_configs << ResolverConfig.from_kwargs(directive.arguments.keyword_arguments)
             end
 
-            boundary_configs.each do |config|
+            resolver_configs.each do |config|
               key_selections = GraphQL.parse("{ #{config.key} }").definitions[0].selections
 
               if key_selections.length != 1
-                raise ComposerError, "Boundary key at #{type_name}.#{field_name} must specify exactly one key."
+                raise ComposerError, "Resolver key at #{type_name}.#{field_name} must specify exactly one key."
               end
 
-              argument_name = key_selections[0].alias
-              argument_name ||= if field_candidate.arguments.size == 1
-                field_candidate.arguments.keys.first
-              elsif field_candidate.arguments[config.key]
-                config.key
+              argument = field_candidate.arguments[key_selections[0].alias]
+              argument ||= if field_candidate.arguments.size == 1
+                field_candidate.arguments.values.first
+              else
+                field_candidate.arguments[config.key]
               end
 
-              argument = field_candidate.arguments[argument_name]
               unless argument
-                # contextualize this... "boundaries with multiple args need mapping aliases."
-                raise ComposerError, "Invalid boundary argument `#{argument_name}` for #{type_name}.#{field_name}."
+                raise ComposerError, "No resolver argument matched for #{type_name}.#{field_name}. " \
+                  "Add an alias to the key that specifies its intended argument, ex: `arg:key`"
               end
 
               argument_structure = Util.flatten_type_structure(argument.type)
-              if argument_structure.length != boundary_structure.length
-                raise ComposerError, "Mismatched input/output for #{type_name}.#{field_name}.#{argument_name} boundary. Arguments must map directly to results."
+              if argument_structure.length != resolver_structure.length
+                raise ComposerError, "Mismatched input/output for #{type_name}.#{field_name}.#{argument.graphql_name} resolver. " \
+                  "Arguments must map directly to results."
               end
 
-              boundary_type_name = if config.type_name
-                if !boundary_type.kind.abstract?
+              resolver_type_name = if config.type_name
+                if !resolver_type.kind.abstract?
                   raise ComposerError, "Resolver config may only specify a type name for abstract resolvers."
-                elsif !boundary_type.possible_types.find { _1.graphql_name == config.type_name }
+                elsif !resolver_type.possible_types.find { _1.graphql_name == config.type_name }
                   raise ComposerError, "Type `#{config.type_name}` is not a possible return type for query `#{field_name}`."
                 end
                 config.type_name
               else
-                boundary_type.graphql_name
+                resolver_type.graphql_name
               end
 
-              @boundary_map[boundary_type_name] ||= []
-              @boundary_map[boundary_type_name] << Boundary.new(
+              @resolver_map[resolver_type_name] ||= []
+              @resolver_map[resolver_type_name] << Resolver.new(
                 location: location,
-                type_name: boundary_type_name,
+                type_name: resolver_type_name,
                 key: key_selections[0].name,
                 field: field_candidate.name,
-                arg: argument_name,
-                list: boundary_structure.first.list?,
-                federation: config.federation,
+                arg: argument.graphql_name,
+                arg_type_name: argument.type.unwrap.graphql_name,
+                list: resolver_structure.first.list?,
+                representations: config.representations,
               )
             end
           end
@@ -611,15 +613,15 @@ module GraphQL
 
       # @!scope class
       # @!visibility private
-      def expand_abstract_boundaries(schema)
-        @boundary_map.keys.each do |type_name|
-          boundary_type = schema.types[type_name]
-          next unless boundary_type.kind.abstract?
+      def expand_abstract_resolvers(schema)
+        @resolver_map.keys.each do |type_name|
+          resolver_type = schema.types[type_name]
+          next unless resolver_type.kind.abstract?
 
-          expanded_types = Util.expand_abstract_type(schema, boundary_type)
+          expanded_types = Util.expand_abstract_type(schema, resolver_type)
           expanded_types.select { @candidate_types_by_name_and_location[_1.graphql_name].length > 1 }.each do |expanded_type|
-            @boundary_map[expanded_type.graphql_name] ||= []
-            @boundary_map[expanded_type.graphql_name].push(*@boundary_map[type_name])
+            @resolver_map[expanded_type.graphql_name] ||= []
+            @resolver_map[expanded_type.graphql_name].push(*@resolver_map[type_name])
           end
         end
       end
@@ -669,7 +671,7 @@ module GraphQL
 
       def reset!
         @field_map = {}
-        @boundary_map = {}
+        @resolver_map = {}
         @mapped_type_names = {}
         @candidate_directives_by_name_and_location = nil
         @schema_directives = nil