graphql-stitching 1.2.5 → 1.4.0

data/lib/graphql/stitching/composer.rb

@@ -2,15 +2,12 @@
 
 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
     class Composer
-      class ComposerError < StitchingError; end
-      class ValidationError < ComposerError; end
-
       # @api private
       NO_DEFAULT_VALUE = begin
         class T < GraphQL::Schema::Object
@@ -31,7 +28,7 @@ module GraphQL
       # @api private
       VALIDATORS = [
         "ValidateInterfaces",
-        "ValidateBoundaries",
+        "ValidateResolvers",
       ].freeze
 
       # @return [String] name of the Query type in the composed schema.
@@ -41,7 +38,7 @@ module GraphQL
       attr_reader :mutation_name
 
       # @api private
-      attr_reader :candidate_types_by_name_and_location
+      attr_reader :subgraph_types_by_name_and_location
 
       # @api private
       attr_reader :schema_directives
@@ -62,13 +59,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
+        @subgraph_directives_by_name_and_location = nil
+        @subgraph_types_by_name_and_location = nil
         @schema_directives = nil
       end
 
@@ -76,8 +73,8 @@ module GraphQL
         reset!
         schemas, executables = prepare_locations_input(locations_input)
 
-        # "directive_name" => "location" => candidate_directive
-        @candidate_directives_by_name_and_location = schemas.each_with_object({}) do |(location, schema), memo|
+        # "directive_name" => "location" => subgraph_directive
+        @subgraph_directives_by_name_and_location = schemas.each_with_object({}) do |(location, schema), memo|
           (schema.directives.keys - schema.default_directives.keys - GraphQL::Stitching.stitching_directive_names).each do |directive_name|
             memo[directive_name] ||= {}
             memo[directive_name][location] = schema.directives[directive_name]
@@ -85,47 +82,47 @@ module GraphQL
         end
 
         # "directive_name" => merged_directive
-        @schema_directives = @candidate_directives_by_name_and_location.each_with_object({}) do |(directive_name, directives_by_location), memo|
+        @schema_directives = @subgraph_directives_by_name_and_location.each_with_object({}) do |(directive_name, directives_by_location), memo|
           memo[directive_name] = build_directive(directive_name, directives_by_location)
         end
 
         @schema_directives.merge!(GraphQL::Schema.default_directives)
 
-        # "Typename" => "location" => candidate_type
-        @candidate_types_by_name_and_location = schemas.each_with_object({}) do |(location, schema), memo|
-          raise ComposerError, "Location keys must be strings" unless location.is_a?(String)
-          raise ComposerError, "The subscription operation is not supported." if schema.subscription
+        # "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, type_candidate|
+          schema.types.each do |type_name, subgraph_type|
             next if introspection_types.include?(type_name)
 
-            if type_name == @query_name && type_candidate != schema.query
-              raise ComposerError, "Query name \"#{@query_name}\" is used by non-query type in #{location} schema."
-            elsif type_name == @mutation_name && type_candidate != schema.mutation
-              raise ComposerError, "Mutation name \"#{@mutation_name}\" is used by non-mutation type in #{location} schema."
+            if type_name == @query_name && subgraph_type != schema.query
+              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."
             end
 
-            type_name = @query_name if type_candidate == schema.query
-            type_name = @mutation_name if type_candidate == schema.mutation
-            @mapped_type_names[type_candidate.graphql_name] = type_name if type_candidate.graphql_name != type_name
+            type_name = @query_name if subgraph_type == schema.query
+            type_name = @mutation_name if subgraph_type == schema.mutation
+            @mapped_type_names[subgraph_type.graphql_name] = type_name if subgraph_type.graphql_name != type_name
 
             memo[type_name] ||= {}
-            memo[type_name][location] = type_candidate
+            memo[type_name][location] = subgraph_type
           end
         end
 
         enum_usage = build_enum_usage_map(schemas.values)
 
         # "Typename" => merged_type
-        schema_types = @candidate_types_by_name_and_location.each_with_object({}) do |(type_name, types_by_location), memo|
+        schema_types = @subgraph_types_by_name_and_location.each_with_object({}) do |(type_name, types_by_location), memo|
           kinds = types_by_location.values.map { _1.kind.name }.tap(&:uniq!)
 
           if kinds.length > 1
-            raise ComposerError, "Cannot merge different kinds for `#{type_name}`. Found: #{kinds.join(", ")}."
+            raise CompositionError, "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"
@@ -141,7 +138,7 @@ module GraphQL
           when "INPUT_OBJECT"
             build_input_object_type(type_name, types_by_location)
           else
-            raise ComposerError, "Unexpected kind encountered for `#{type_name}`. Found: #{kinds.first}."
+            raise CompositionError, "Unexpected kind encountered for `#{type_name}`. Found: #{kinds.first}."
           end
         end
 
@@ -157,12 +154,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,
         )
 
@@ -184,13 +181,13 @@ module GraphQL
           schema = input[:schema]
 
           if schema.nil?
-            raise ComposerError, "A schema is required for `#{location}` location."
+            raise CompositionError, "A schema is required for `#{location}` location."
           elsif !(schema.is_a?(Class) && schema <= GraphQL::Schema)
-            raise ComposerError, "The schema for `#{location}` location must be a GraphQL::Schema class."
+            raise CompositionError, "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
@@ -234,10 +231,10 @@ module GraphQL
         builder = self
 
         # "value" => "location" => enum_value
-        enum_values_by_name_location = types_by_location.each_with_object({}) do |(location, type_candidate), memo|
-          type_candidate.enum_values.each do |enum_value_candidate|
-            memo[enum_value_candidate.graphql_name] ||= {}
-            memo[enum_value_candidate.graphql_name][location] = enum_value_candidate
+        enum_values_by_name_location = types_by_location.each_with_object({}) do |(location, subgraph_type), memo|
+          subgraph_type.enum_values.each do |subgraph_enum_value|
+            memo[subgraph_enum_value.graphql_name] ||= {}
+            memo[subgraph_enum_value.graphql_name][location] = subgraph_enum_value
           end
         end
 
@@ -342,14 +339,14 @@ module GraphQL
       # @!visibility private
       def build_merged_fields(type_name, types_by_location, owner)
         # "field_name" => "location" => field
-        fields_by_name_location = types_by_location.each_with_object({}) do |(location, type_candidate), memo|
+        fields_by_name_location = types_by_location.each_with_object({}) do |(location, subgraph_type), memo|
           @field_map[type_name] ||= {}
-          type_candidate.fields.each do |field_name, field_candidate|
-            @field_map[type_name][field_candidate.name] ||= []
-            @field_map[type_name][field_candidate.name] << location
+          subgraph_type.fields.each do |field_name, subgraph_field|
+            @field_map[type_name][subgraph_field.name] ||= []
+            @field_map[type_name][subgraph_field.name] << location
 
             memo[field_name] ||= {}
-            memo[field_name][location] = field_candidate
+            memo[field_name][location] = subgraph_field
           end
         end
 
@@ -375,8 +372,8 @@ module GraphQL
       # @!visibility private
       def build_merged_arguments(type_name, members_by_location, owner, field_name: nil, directive_name: nil)
         # "argument_name" => "location" => argument
-        args_by_name_location = members_by_location.each_with_object({}) do |(location, member_candidate), memo|
-          member_candidate.arguments.each do |argument_name, argument|
+        args_by_name_location = members_by_location.each_with_object({}) do |(location, subgraph_member), memo|
+          subgraph_member.arguments.each do |argument_name, argument|
             memo[argument_name] ||= {}
             memo[argument_name][location] = argument
           end
@@ -388,7 +385,7 @@ module GraphQL
           if arguments_by_location.length != members_by_location.length
             if value_types.any?(&:non_null?)
               path = [type_name, field_name, argument_name].compact.join(".")
-              raise ComposerError, "Required argument `#{path}` must be defined in all locations." # ...or hidden?
+              raise CompositionError, "Required argument `#{path}` must be defined in all locations." # ...or hidden?
             end
             next
           end
@@ -429,8 +426,8 @@ module GraphQL
       # @!scope class
       # @!visibility private
       def build_merged_directives(type_name, members_by_location, owner, field_name: nil, argument_name: nil, enum_value: nil)
-        directives_by_name_location = members_by_location.each_with_object({}) do |(location, member_candidate), memo|
-          member_candidate.directives.each do |directive|
+        directives_by_name_location = members_by_location.each_with_object({}) do |(location, subgraph_member), memo|
+          subgraph_member.directives.each do |directive|
             memo[directive.graphql_name] ||= {}
             memo[directive.graphql_name][location] = directive
           end
@@ -470,18 +467,18 @@ module GraphQL
 
       # @!scope class
       # @!visibility private
-      def merge_value_types(type_name, type_candidates, field_name: nil, argument_name: nil)
+      def merge_value_types(type_name, subgraph_types, field_name: nil, argument_name: nil)
         path = [type_name, field_name, argument_name].tap(&:compact!).join(".")
-        alt_structures = type_candidates.map { Util.flatten_type_structure(_1) }
+        alt_structures = subgraph_types.map { Util.flatten_type_structure(_1) }
         basis_structure = alt_structures.shift
 
         alt_structures.each do |alt_structure|
           if alt_structure.length != basis_structure.length
-            raise ComposerError, "Cannot compose mixed list structures at `#{path}`."
+            raise CompositionError, "Cannot compose mixed list structures at `#{path}`."
           end
 
           if alt_structure.last.name != basis_structure.last.name
-            raise ComposerError, "Cannot compose mixed types at `#{path}`."
+            raise CompositionError, "Cannot compose mixed types at `#{path}`."
           end
         end
 
@@ -527,63 +524,61 @@ module GraphQL
 
       # @!scope class
       # @!visibility private
-      def extract_boundaries(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}",  [])
-
-            field_candidate.directives.each do |directive|
+      def extract_resolvers(type_name, types_by_location)
+        types_by_location.each do |location, subgraph_type|
+          subgraph_type.fields.each do |field_name, subgraph_field|
+            resolver_type = subgraph_field.type.unwrap
+            resolver_structure = Util.flatten_type_structure(subgraph_field.type)
+            resolver_configs = @resolver_configs.fetch("#{location}.#{field_name}",  [])
+
+            subgraph_field.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|
-              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."
-              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
+            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."
+                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
+                config.type_name
+              else
+                resolver_type.graphql_name
               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}."
-              end
+              key = Resolver.parse_key_with_types(
+                config.key,
+                @subgraph_types_by_name_and_location[resolver_type_name],
+              )
 
-              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."
-              end
+              arguments_format = config.arguments || begin
+                argument = if subgraph_field.arguments.size == 1
+                  subgraph_field.arguments.values.first
+                else
+                  subgraph_field.arguments[key.default_argument_name]
+                end
 
-              boundary_type_name = if config.type_name
-                if !boundary_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 }
-                  raise ComposerError, "Type `#{config.type_name}` is not a possible return type for query `#{field_name}`."
+                unless argument
+                  raise CompositionError, "No resolver argument matched for `#{type_name}.#{field_name}`." \
+                    "An argument mapping is required for unmatched names and composite keys."
                 end
-                config.type_name
-              else
-                boundary_type.graphql_name
+
+                "#{argument.graphql_name}: $.#{key.default_argument_name}"
               end
 
-              @boundary_map[boundary_type_name] ||= []
-              @boundary_map[boundary_type_name] << Boundary.new(
+              arguments = Resolver.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(
                 location: location,
-                type_name: boundary_type_name,
-                key: key_selections[0].name,
-                field: field_candidate.name,
-                arg: argument_name,
-                list: boundary_structure.first.list?,
-                federation: config.federation,
+                type_name: resolver_type_name,
+                field: subgraph_field.name,
+                list: resolver_structure.first.list?,
+                key: key,
+                arguments: arguments,
               )
             end
           end
@@ -612,15 +607,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?
-
-          expanded_types = Util.expand_abstract_type(schema, boundary_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])
+      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, 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])
           end
         end
       end
@@ -670,9 +665,9 @@ module GraphQL
 
       def reset!
         @field_map = {}
-        @boundary_map = {}
+        @resolver_map = {}
         @mapped_type_names = {}
-        @candidate_directives_by_name_and_location = nil
+        @subgraph_directives_by_name_and_location = nil
         @schema_directives = nil
       end
     end

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

@@ -2,10 +2,11 @@
 
 module GraphQL::Stitching
   class Executor
-    class BoundarySource < GraphQL::Dataloader::Source
+    class ResolverSource < GraphQL::Dataloader::Source
       def initialize(executor, location)
         @executor = executor
         @location = location
+        @variables = {}
       end
 
       def fetch(ops)
@@ -16,7 +17,7 @@ module GraphQL::Stitching
 
           if op.if_type
             # operations planned around unused fragment conditions should not trigger requests
-            origin_set.select! { _1[ExportSelection.typename_node.alias] == op.if_type }
+            origin_set.select! { _1[Resolver::TYPENAME_EXPORT_NODE.alias] == op.if_type }
           end
 
           memo[op] = origin_set if origin_set.any?
@@ -28,7 +29,7 @@ module GraphQL::Stitching
             @executor.request.operation_name,
             @executor.request.operation_directives,
           )
-          variables = @executor.request.variables.slice(*variable_names)
+          variables = @variables.merge!(@executor.request.variables.slice(*variable_names))
           raw_result = @executor.request.supergraph.execute_at_location(@location, query_document, variables, @executor.request)
           @executor.query_count += 1
 
@@ -41,36 +42,51 @@ module GraphQL::Stitching
         ops.map { origin_sets_by_operation[_1] ? _1.step : nil }
       end
 
-      # Builds batched boundary queries
-      # "query MyOperation_2_3($var:VarType) {
-      #   _0_result: list(keys:["a","b","c"]) { boundarySelections... }
-      #   _1_0_result: item(key:"x") { boundarySelections... }
-      #   _1_1_result: item(key:"y") { boundarySelections... }
-      #   _1_2_result: item(key:"z") { boundarySelections... }
+      # Builds batched resolver queries
+      # "query MyOperation_2_3($var:VarType, $_0_key:[ID!]!, $_1_0_key:ID!, $_1_1_key:ID!, $_1_2_key:ID!) {
+      #   _0_result: list(keys: $_0_key) { resolverSelections... }
+      #   _1_0_result: item(key: $_1_0_key) { resolverSelections... }
+      #   _1_1_result: item(key: $_1_1_key) { resolverSelections... }
+      #   _1_2_result: item(key: $_1_2_key) { resolverSelections... }
       # }"
       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|
           variable_defs.merge!(op.variables)
-          boundary = op.boundary
-
-          if boundary.list
-            input = origin_set.each_with_index.reduce(String.new) do |memo, (origin_obj, index)|
-              memo << "," if index > 0
-              memo << build_key(boundary.key, origin_obj, federation: boundary.federation)
-              memo
+          resolver = @executor.request.supergraph.resolvers_by_version[op.resolver]
+
+          if resolver.list?
+            arguments = resolver.arguments.map.with_index do |arg, i|
+              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}"
+              else
+                "#{arg.name}:#{arg.value.print}"
+              end
             end
 
-            "_#{batch_index}_result: #{boundary.field}(#{boundary.arg}:[#{input}]) #{op.selections}"
+            "_#{batch_index}_result: #{resolver.field}(#{arguments.join(",")}) #{op.selections}"
           else
             origin_set.map.with_index do |origin_obj, index|
-              input = build_key(boundary.key, origin_obj, federation: boundary.federation)
-              "_#{batch_index}_#{index}_result: #{boundary.field}(#{boundary.arg}:#{input}) #{op.selections}"
+              arguments = resolver.arguments.map.with_index do |arg, i|
+                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}"
+                else
+                  "#{arg.name}:#{arg.value.print}"
+                end
+              end
+
+              "_#{batch_index}_#{index}_result: #{resolver.field}(#{arguments.join(",")}) #{op.selections}"
             end
           end
         end
 
-        doc = String.new("query") # << boundary fulfillment always uses query
+        doc = String.new("query") # << resolver fulfillment always uses query
 
         if operation_name
           doc << " #{operation_name}"
@@ -80,8 +96,7 @@ module GraphQL::Stitching
         end
 
         if variable_defs.any?
-          variable_str = variable_defs.map { |k, v| "$#{k}:#{v}" }.join(",")
-          doc << "(#{variable_str})"
+          doc << "(#{variable_defs.map { |k, v| "$#{k}:#{v}" }.join(",")})"
         end
 
         if operation_directives
@@ -90,15 +105,8 @@ module GraphQL::Stitching
 
         doc << "{ #{query_fields.join(" ")} }"
 
-        return doc, variable_defs.keys
-      end
-
-      def build_key(key, origin_obj, federation: false)
-        key_value = JSON.generate(origin_obj[ExportSelection.key(key)])
-        if federation
-          "{ __typename: \"#{origin_obj[ExportSelection.typename_node.alias]}\", #{key}: #{key_value} }"
-        else
-          key_value
+        return doc, variable_defs.keys.tap do |names|
+          names.reject! { @variables.key?(_1) }
         end
       end
 
@@ -106,7 +114,7 @@ module GraphQL::Stitching
         return unless raw_result
 
         origin_sets_by_operation.each_with_index do |(op, origin_set), batch_index|
-          results = if op.dig("boundary", "list")
+          results = if @executor.request.supergraph.resolvers_by_version[op.resolver].list?
             raw_result["_#{batch_index}_result"]
           else
             origin_set.map.with_index { |_, index| raw_result["_#{batch_index}_#{index}_result"] }

data/lib/graphql/stitching/executor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
-require_relative "./executor/boundary_source"
+require_relative "./executor/resolver_source"
 require_relative "./executor/root_source"
 
 module GraphQL
@@ -55,9 +55,9 @@ module GraphQL
           tasks = @request.plan
             .ops
             .select { next_steps.include?(_1.after) }
-            .group_by { [_1.location, _1.boundary.nil?] }
+            .group_by { [_1.location, _1.resolver.nil?] }
             .map do |(location, root_source), ops|
-              source_type = root_source ? RootSource : BoundarySource
+              source_type = root_source ? RootSource : ResolverSource
               @dataloader.with(source_type, self, location).request_all(ops)
             end
 

data/lib/graphql/stitching/plan.rb

@@ -14,7 +14,7 @@ module GraphQL
         :variables,
         :path,
         :if_type,
-        :boundary,
+        :resolver,
         keyword_init: true
       ) do
         def as_json
@@ -27,7 +27,7 @@ module GraphQL
             variables: variables,
             path: path,
             if_type: if_type,
-            boundary: boundary&.as_json
+            resolver: resolver
           }.tap(&:compact!)
         end
       end
@@ -36,7 +36,6 @@ module GraphQL
         def from_json(json)
           ops = json["ops"]
           ops = ops.map do |op|
-            boundary = op["boundary"]
             Op.new(
               step: op["step"],
               after: op["after"],
@@ -46,7 +45,7 @@ module GraphQL
               variables: op["variables"],
               path: op["path"],
               if_type: op["if_type"],
-              boundary: boundary ? GraphQL::Stitching::Boundary.new(**boundary) : nil,
+              resolver: op["resolver"],
             )
           end
           new(ops: ops)