graphql-stitching 1.5.0 → 1.5.2

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
@@ -403,8 +403,13 @@ module GraphQL
             next
           end
 
-          # Getting double args sometimes on auto-generated connection types... why?
-          next if owner.arguments.any? { _1.first == argument_name }
+          # Getting double args sometimes... why?
+          begin
+            next if owner.arguments(GraphQL::Query::NullContext.instance, false).key?(argument_name)
+          rescue ArgumentError
+            # pre- graphql v2.4.5
+            next if owner.arguments.key?(argument_name)
+          end
 
           kwargs = {}
           default_values_by_location = arguments_by_location.each_with_object({}) do |(location, argument), memo|
@@ -546,13 +551,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 +566,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 +586,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 +625,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?
+
+          @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 = 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])
+            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
@@ -64,7 +64,7 @@ module GraphQL::Stitching
             return nil if result.nil?
 
           else
-            raise StitchingError, "Unexpected node of type #{node.class.name} in selection set."
+            raise DocumentError.new("selection node type")
           end
         end
 
@@ -118,7 +118,7 @@ module GraphQL::Stitching
       def typename_in_type?(typename, type)
         return true if type.graphql_name == typename
 
-        type.kind.abstract? && @request.warden.possible_types(type).any? do |t|
+        type.kind.abstract? && @supergraph.schema.possible_types(type).any? do |t|
           t.graphql_name == typename
         end
       end

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
@@ -10,14 +10,14 @@ module GraphQL::Stitching
       end
 
       def fetch(ops)
-        origin_sets_by_operation = ops.each_with_object({}) do |op, memo|
+        origin_sets_by_operation = ops.each_with_object({}.compare_by_identity) do |op, memo|
           origin_set = op.path.reduce([@executor.data]) do |set, path_segment|
             set.flat_map { |obj| obj && obj[path_segment] }.tap(&:compact!)
           end
 
           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?
@@ -86,7 +86,7 @@ module GraphQL::Stitching
           end
         end
 
-        doc = String.new("query") # << resolver fulfillment always uses query
+        doc = String.new(QUERY_OP) # << resolver fulfillment always uses query
 
         if operation_name
           doc << " #{operation_name}"

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
@@ -27,7 +27,7 @@ module GraphQL
       # 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)
+      def initialize(request, data: {}, errors: [], after: Planner::ROOT_INDEX, nonblocking: false)
         @request = request
         @data = data
         @errors = errors
@@ -38,7 +38,7 @@ module GraphQL
       end
 
       def perform(raw: false)
-        exec!
+        exec!([@after])
         result = {}
 
         if @data && @data.length > 0
@@ -54,7 +54,7 @@ module GraphQL
 
       private
 
-      def exec!(next_steps = [@after])
+      def exec!(next_steps)
         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."
@@ -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

@@ -20,7 +20,7 @@ module GraphQL
       def perform
         build_root_entrypoints
         expand_abstract_resolvers
-        Plan.new(ops: steps.map(&:to_plan_op))
+        Plan.new(ops: steps.map!(&:to_plan_op))
       end
 
       def steps
@@ -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,9 +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}")
-        path.each { entrypoint << "/#{_1}" }
-
+        entrypoint = [parent_index, location, parent_type.graphql_name, resolver&.key&.to_definition, "#", *path].join("/")
         step = @steps_by_entrypoint[entrypoint]
         next_index = step ? parent_index : @planning_index += 1
 
@@ -107,11 +106,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 +130,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,10 +152,9 @@ 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?
+            raise DocumentError.new("root field") unless @steps_by_entrypoint.empty?
 
             locations = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name] || SUPERGRAPH_LOCATIONS
             add_step(
@@ -171,7 +167,7 @@ module GraphQL
           end
 
         else
-          raise StitchingError, "Invalid operation type."
+          raise DocumentError.new("operation type")
         end
       end
 
@@ -191,7 +187,7 @@ module GraphQL
             each_field_in_scope(parent_type, fragment.selections, &block)
 
           else
-            raise StitchingError, "Unexpected node of type #{node.class.name} in selection set."
+            raise DocumentError.new("selection node type")
           end
         end
       end
@@ -217,8 +213,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
@@ -273,14 +269,14 @@ module GraphQL
             end
 
           else
-            raise StitchingError, "Unexpected node of type #{node.class.name} in selection set."
+            raise DocumentError.new("selection node type")
           end
         end
 
         # 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 +292,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
 
@@ -335,7 +331,7 @@ module GraphQL
         end
 
         if expanded_selections
-          @request.warden.possible_types(parent_type).each do |possible_type|
+          @supergraph.schema.possible_types(parent_type).each do |possible_type|
             next unless @supergraph.locations_by_type[possible_type.graphql_name].include?(current_location)
 
             type_name = GraphQL::Language::Nodes::TypeName.new(name: possible_type.graphql_name)

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

@@ -26,9 +26,6 @@ module GraphQL
       # @return [Hash] contextual object passed through resolver flows.
       attr_reader :context
 
-      # @return [GraphQL::Schema::Warden] a visibility warden for this request.
-      attr_reader :warden
-
       # Creates a new supergraph request.
       # @param supergraph [Supergraph] supergraph instance that resolves the request.
       # @param document [String, GraphQL::Language::Nodes::Document] the request string or parsed AST.
@@ -58,7 +55,6 @@ module GraphQL
         @variables = variables || {}
 
         @query = GraphQL::Query.new(@supergraph.schema, document: @document, context: context)
-        @warden = @query.warden
         @context = @query.context
         @context[:request] = self
       end
@@ -75,12 +71,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.
@@ -141,7 +137,7 @@ module GraphQL
       # Validates the request using the combined supergraph schema.
       # @return [Array<GraphQL::ExecutionError>] an array of static validation errors
       def validate
-        result = @supergraph.static_validator.validate(@query)
+        result = @supergraph.schema.static_validator.validate(@query)
         result[:errors]
       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

@@ -50,11 +50,6 @@ module GraphQL
         end.freeze
       end
 
-      # @return [GraphQL::StaticValidation::Validator] static validator for the supergraph schema.
-      def static_validator
-        @static_validator ||= @schema.static_validator
-      end
-
       def resolvers_by_version
         @resolvers_by_version ||= resolvers.values.tap(&:flatten!).each_with_object({}) do |resolver, memo|
           memo[resolver.version] = resolver
@@ -166,7 +161,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.2"
   end
 end

data/lib/graphql/stitching.rb

@@ -25,14 +25,31 @@ module GraphQL
     class StitchingError < StandardError; end
     class CompositionError < StitchingError; end
     class ValidationError < CompositionError; end
+    class DocumentError < StandardError
+      def initialize(element)
+        super("Invalid #{element} encountered in document")
+      end
+    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 +67,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"