graphql-stitching 1.1.1 → 1.2.1

data/lib/graphql/stitching/client.rb

@@ -28,6 +28,7 @@ module GraphQL
 
       def execute(query:, variables: nil, operation_name: nil, context: nil, validate: true)
         request = GraphQL::Stitching::Request.new(
+          @supergraph,
           query,
           operation_name: operation_name,
           variables: variables,
@@ -35,24 +36,13 @@ module GraphQL
         )
 
         if validate
-          validation_errors = @supergraph.schema.validate(request.document)
+          validation_errors = request.validate
           return error_result(validation_errors) if validation_errors.any?
         end
 
         request.prepare!
-
-        plan = fetch_plan(request) do
-          GraphQL::Stitching::Planner.new(
-            supergraph: @supergraph,
-            request: request,
-          ).perform
-        end
-
-        GraphQL::Stitching::Executor.new(
-          supergraph: @supergraph,
-          request: request,
-          plan: plan,
-        ).perform
+        load_plan(request)
+        request.execute
       rescue GraphQL::ParseError, GraphQL::ExecutionError => e
         error_result([e])
       rescue StandardError => e
@@ -77,13 +67,13 @@ module GraphQL
 
       private
 
-      def fetch_plan(request)
-        if @on_cache_read
-          cached_plan = @on_cache_read.call(request)
-          return GraphQL::Stitching::Plan.from_json(JSON.parse(cached_plan)) if cached_plan
+      def load_plan(request)
+        if @on_cache_read && plan_json = @on_cache_read.call(request)
+          plan = GraphQL::Stitching::Plan.from_json(JSON.parse(plan_json))
+          return request.plan(plan)
         end
 
-        plan = yield
+        plan = request.plan
 
         if @on_cache_write
           @on_cache_write.call(request, JSON.generate(plan.as_json))

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
-    class Composer::BaseValidator
+module GraphQL::Stitching
+  class Composer
+    class BaseValidator
       def perform(ctx, composer)
         raise "not implemented"
       end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
-    class Composer::ValidateBoundaries < Composer::BaseValidator
+module GraphQL::Stitching
+  class Composer
+    class ValidateBoundaries < BaseValidator
 
       def perform(ctx, composer)
         ctx.schema.types.each do |type_name, type|

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

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
-    class Composer::ValidateInterfaces < Composer::BaseValidator
-
+module GraphQL::Stitching
+  class Composer
+    class ValidateInterfaces < BaseValidator
       # For each composed interface, check the interface against each possible type
       # to assure that intersecting fields have compatible types, structures, and nullability.
       # Verifies compatibility of types that inherit interface contracts through merging.

data/lib/graphql/stitching/composer.rb

@@ -1,26 +1,49 @@
 # frozen_string_literal: true
 
+require_relative "./composer/base_validator"
+require_relative "./composer/validate_interfaces"
+require_relative "./composer/validate_boundaries"
+
 module GraphQL
   module Stitching
     class Composer
       class ComposerError < StitchingError; end
       class ValidationError < ComposerError; end
-      class ReferenceType < GraphQL::Schema::Object
-        field(:f, String) do
-          argument(:a, String)
+
+      # @api private
+      NO_DEFAULT_VALUE = begin
+        class T < GraphQL::Schema::Object
+          field(:f, String) do
+            argument(:a, String)
+          end
         end
+
+        T.get_field("f").get_argument("a").default_value
       end
 
-      NO_DEFAULT_VALUE = ReferenceType.get_field("f").get_argument("a").default_value
+      # @api private
       BASIC_VALUE_MERGER = ->(values_by_location, _info) { values_by_location.values.find { !_1.nil? } }
+
+      # @api private
       BASIC_ROOT_FIELD_LOCATION_SELECTOR = ->(locations, _info) { locations.last }
 
+      # @api private
       VALIDATORS = [
         "ValidateInterfaces",
         "ValidateBoundaries",
       ].freeze
 
-      attr_reader :query_name, :mutation_name, :candidate_types_by_name_and_location, :schema_directives
+      # @return [String] name of the Query type in the composed schema.
+      attr_reader :query_name
+
+      # @return [String] name of the Mutation type in the composed schema.
+      attr_reader :mutation_name
+
+      # @api private
+      attr_reader :candidate_types_by_name_and_location
+
+      # @api private
+      attr_reader :schema_directives
 
       def initialize(
         query_name: "Query",
@@ -148,6 +171,8 @@ module GraphQL
         supergraph
       end
 
+      # @!scope class
+      # @!visibility private
       def prepare_locations_input(locations_input)
         schemas = {}
         executables = {}
@@ -200,6 +225,8 @@ module GraphQL
         return schemas, executables
       end
 
+      # @!scope class
+      # @!visibility private
       def build_directive(directive_name, directives_by_location)
         builder = self
 
@@ -212,6 +239,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_scalar_type(type_name, types_by_location)
         built_in_type = GraphQL::Schema::BUILT_IN_TYPES[type_name]
         return built_in_type if built_in_type
@@ -225,6 +254,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_enum_type(type_name, types_by_location, enum_usage)
         builder = self
 
@@ -261,6 +292,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_object_type(type_name, types_by_location)
         builder = self
 
@@ -278,6 +311,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_interface_type(type_name, types_by_location)
         builder = self
 
@@ -296,6 +331,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_union_type(type_name, types_by_location)
         builder = self
 
@@ -309,6 +346,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_input_object_type(type_name, types_by_location)
         builder = self
 
@@ -320,10 +359,14 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_type_binding(type_name)
         GraphQL::Schema::LateBoundType.new(@mapped_type_names.fetch(type_name, type_name))
       end
 
+      # @!scope class
+      # @!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|
@@ -356,6 +399,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!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|
@@ -410,6 +455,8 @@ module GraphQL
         end
       end
 
+      # @!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|
@@ -451,6 +498,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def merge_value_types(type_name, type_candidates, 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) }
@@ -482,6 +531,8 @@ module GraphQL
         type
       end
 
+      # @!scope class
+      # @!visibility private
       def merge_descriptions(type_name, members_by_location, field_name: nil, argument_name: nil, enum_value: nil)
         strings_by_location = members_by_location.each_with_object({}) { |(l, m), memo| memo[l] = m.description }
         @description_merger.call(strings_by_location, {
@@ -492,6 +543,8 @@ module GraphQL
         }.tap(&:compact!))
       end
 
+      # @!scope class
+      # @!visibility private
       def merge_deprecations(type_name, members_by_location, field_name: nil, argument_name: nil, enum_value: nil)
         strings_by_location = members_by_location.each_with_object({}) { |(l, m), memo| memo[l] = m.deprecation_reason }
         @deprecation_merger.call(strings_by_location, {
@@ -502,6 +555,8 @@ module GraphQL
         }.tap(&:compact!))
       end
 
+      # @!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|
@@ -554,6 +609,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def select_root_field_locations(schema)
         [schema.query, schema.mutation].tap(&:compact!).each do |root_type|
           root_type.fields.each do |root_field_name, root_field|
@@ -572,6 +629,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def expand_abstract_boundaries(schema)
         @boundary_map.keys.each do |type_name|
           boundary_type = schema.types[type_name]
@@ -585,6 +644,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_enum_usage_map(schemas)
         reads = []
         writes = []
@@ -636,7 +697,3 @@ module GraphQL
     end
   end
 end
-
-require_relative "./composer/base_validator"
-require_relative "./composer/validate_interfaces"
-require_relative "./composer/validate_boundaries"

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
-    class Executor::BoundarySource < GraphQL::Dataloader::Source
+module GraphQL::Stitching
+  class Executor
+    class BoundarySource < GraphQL::Dataloader::Source
       def initialize(executor, location)
         @executor = executor
         @location = location
@@ -29,7 +29,7 @@ module GraphQL
             @executor.request.operation_directives,
           )
           variables = @executor.request.variables.slice(*variable_names)
-          raw_result = @executor.supergraph.execute_at_location(@location, query_document, variables, @executor.request.context)
+          raw_result = @executor.request.supergraph.execute_at_location(@location, query_document, variables, @executor.request)
           @executor.query_count += 1
 
           merge_results!(origin_sets_by_operation, raw_result.dig("data"))
@@ -183,9 +183,7 @@ module GraphQL
           end
 
         elsif forward_path.any?
-          current_path << index
           repath_errors!(pathed_errors_by_object_id, forward_path, current_path, scope)
-          current_path.pop
 
         elsif scope.is_a?(Array)
           scope.each_with_index do |element, index|

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
-    class Executor::RootSource < GraphQL::Dataloader::Source
+module GraphQL::Stitching
+  class Executor
+    class RootSource < GraphQL::Dataloader::Source
       def initialize(executor, location)
         @executor = executor
         @location = location
@@ -17,7 +17,7 @@ module GraphQL
           @executor.request.operation_directives,
         )
         query_variables = @executor.request.variables.slice(*op.variables.keys)
-        result = @executor.supergraph.execute_at_location(op.location, query_document, query_variables, @executor.request.context)
+        result = @executor.request.supergraph.execute_at_location(op.location, query_document, query_variables, @executor.request)
         @executor.query_count += 1
 
         @executor.data.merge!(result["data"]) if result["data"]

data/lib/graphql/stitching/executor.rb

@@ -1,17 +1,26 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "./executor/boundary_source"
+require_relative "./executor/root_source"
 
 module GraphQL
   module Stitching
     class Executor
-      attr_reader :supergraph, :request, :plan, :data, :errors
+      # @return [Request] the stitching request to execute.
+      attr_reader :request
+
+      # @return [Hash] an aggregate data payload to return.
+      attr_reader :data
+
+      # @return [Array<Hash>] aggregate GraphQL errors to return.
+      attr_reader :errors
+
+      # @return [Integer] tally of queries performed while executing.
       attr_accessor :query_count
 
-      def initialize(supergraph:, request:, plan:, nonblocking: false)
-        @supergraph = supergraph
+      def initialize(request, nonblocking: false)
         @request = request
-        @plan = plan
         @data = {}
         @errors = []
         @query_count = 0
@@ -24,10 +33,7 @@ module GraphQL
         result = {}
 
         if @data && @data.length > 0
-          result["data"] = raw ? @data : GraphQL::Stitching::Shaper.new(
-            supergraph: @supergraph,
-            request: @request,
-          ).perform!(@data)
+          result["data"] = raw ? @data : GraphQL::Stitching::Shaper.new(@request).perform!(@data)
         end
 
         if @errors.length > 0
@@ -40,13 +46,13 @@ module GraphQL
       private
 
       def exec!(next_steps = [0])
-        if @exec_cycles > @plan.ops.length
+        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."
         end
 
         @dataloader.append_job do
-          tasks = @plan
+          tasks = @request.plan
             .ops
             .select { next_steps.include?(_1.after) }
             .group_by { [_1.location, _1.boundary.nil?] }
@@ -69,6 +75,3 @@ module GraphQL
     end
   end
 end
-
-require_relative "./executor/boundary_source"
-require_relative "./executor/root_source"

data/lib/graphql/stitching/export_selection.rb

@@ -20,8 +20,13 @@ module GraphQL
           "#{EXPORT_PREFIX}#{name}"
         end
 
+        # The argument assigning Field.alias changed from
+        # a generic `alias` hash key to a structured `field_alias` kwarg.
+        # See https://github.com/rmosolgo/graphql-ruby/pull/4718
+        FIELD_ALIAS_KWARG = !GraphQL::Language::Nodes::Field.new(field_alias: "a").alias.nil?
+
         def key_node(field_name)
-          if Util.graphql_version?(2, 2)
+          if FIELD_ALIAS_KWARG
             GraphQL::Language::Nodes::Field.new(field_alias: key(field_name), name: field_name)
           else
             GraphQL::Language::Nodes::Field.new(alias: key(field_name), name: field_name)

data/lib/graphql/stitching/http_executable.rb

@@ -7,18 +7,159 @@ require "json"
 module GraphQL
   module Stitching
     class HttpExecutable
-      def initialize(url:, headers:{})
+      # Builds a new executable for proxying subgraph requests via HTTP.
+      # @param url [String] the url of the remote location to proxy.
+      # @param headers [Hash] headers to include in upstream requests.
+      # @param upload_types [Array<String>, nil] a list of scalar names that represent file uploads. These types extract into multipart forms.
+      def initialize(url:, headers: {}, upload_types: nil)
         @url = url
         @headers = { "Content-Type" => "application/json" }.merge!(headers)
+        @upload_types = upload_types
       end
 
-      def call(_location, document, variables, _context)
-        response = Net::HTTP.post(
+      def call(request, document, variables)
+        form_data = extract_multipart_form(request, document, variables)
+
+        response = if form_data
+          send_multipart_form(request, form_data)
+        else
+          send(request, document, variables)
+        end
+
+        JSON.parse(response.body)
+      end
+
+      # Sends a POST request to the remote location.
+      # @param request [Request] the original supergraph request.
+      # @param document [String] the location-specific subgraph document to send.
+      # @param variables [Hash] a hash of variables specific to the subgraph document.
+      def send(_request, document, variables)
+        Net::HTTP.post(
           URI(@url),
           JSON.generate({ "query" => document, "variables" => variables }),
           @headers,
         )
-        JSON.parse(response.body)
+      end
+
+      # Sends a POST request to the remote location with multipart form data.
+      # @param request [Request] the original supergraph request.
+      # @param form_data [Hash] a rendered multipart form with an "operations", "map", and file sections.
+      def send_multipart_form(_request, form_data)
+        uri = URI(@url)
+        req = Net::HTTP::Post.new(uri)
+        @headers.each_pair do |key, value|
+          req[key] = value
+        end
+
+        req.set_form(form_data.to_a, "multipart/form-data")
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(req)
+        end
+      end
+
+      # Extracts multipart upload forms per the spec:
+      # https://github.com/jaydenseric/graphql-multipart-request-spec
+      # @param request [Request] the original supergraph request.
+      # @param document [String] the location-specific subgraph document to send.
+      # @param variables [Hash] a hash of variables specific to the subgraph document.
+      def extract_multipart_form(request, document, variables)
+        return unless @upload_types && request.variable_definitions.any? && variables&.any?
+
+        files_by_path = {}
+
+        # extract all upload scalar values mapped by their input path
+        variables.each_with_object([]) do |(key, value), path|
+          ast_node = request.variable_definitions[key]
+          path << key
+          extract_ast_node(ast_node, value, files_by_path, path, request) if ast_node
+          path.pop
+        end
+
+        return if files_by_path.none?
+
+        map = {}
+        files = files_by_path.values.tap(&:uniq!)
+        variables_copy = variables.dup
+
+        files_by_path.each_key do |path|
+          orig = variables
+          copy = variables_copy
+          path.each_with_index do |key, i|
+            if i == path.length - 1
+              file_index = files.index(copy[key]).to_s
+              map[file_index] ||= []
+              map[file_index] << "variables.#{path.join(".")}"
+              copy[key] = nil
+            elsif orig[key].object_id == copy[key].object_id
+              copy[key] = copy[key].dup
+            end
+            orig = orig[key]
+            copy = copy[key]
+          end
+        end
+
+        form = {
+          "operations" => JSON.generate({
+            "query" => document,
+            "variables" => variables_copy,
+          }),
+          "map" => JSON.generate(map),
+        }
+
+        files.each_with_object(form).with_index do |(file, memo), index|
+          memo[index.to_s] = file.respond_to?(:tempfile) ? file.tempfile : file
+        end
+      end
+
+      private
+
+      def extract_ast_node(ast_node, value, files_by_path, path, request)
+        return unless value
+
+        ast_node = ast_node.of_type while ast_node.is_a?(GraphQL::Language::Nodes::NonNullType)
+
+        if ast_node.is_a?(GraphQL::Language::Nodes::ListType)
+          if value.is_a?(Array)
+            value.each_with_index do |val, index|
+              path << index
+              extract_ast_node(ast_node.of_type, val, files_by_path, path, request)
+              path.pop
+            end
+          end
+        elsif @upload_types.include?(ast_node.name)
+          files_by_path[path.dup] = value
+        else
+          type_def = request.supergraph.schema.get_type(ast_node.name)
+          extract_type_node(type_def, value, files_by_path, path) if type_def&.kind&.input_object?
+        end
+      end
+
+      def extract_type_node(parent_type, value, files_by_path, path)
+        return unless value
+
+        parent_type = Util.unwrap_non_null(parent_type)
+
+        if parent_type.list?
+          if value.is_a?(Array)
+            value.each_with_index do |val, index|
+              path << index
+              extract_type_node(parent_type.of_type, val, files_by_path, path)
+              path.pop
+            end
+          end
+        elsif parent_type.kind.input_object?
+          if value.is_a?(Enumerable)
+            arguments = parent_type.arguments
+            value.each do |key, val|
+              arg_type = arguments[key]&.type
+              path << key
+              extract_type_node(arg_type, val, files_by_path, path) if arg_type
+              path.pop
+            end
+          end
+        elsif @upload_types.include?(parent_type.graphql_name)
+          files_by_path[path.dup] = value
+        end
       end
     end
   end

data/lib/graphql/stitching/planner.rb

@@ -9,9 +9,9 @@ module GraphQL
       MUTATION_OP = "mutation"
       ROOT_INDEX = 0
 
-      def initialize(supergraph:, request:)
-        @supergraph = supergraph
+      def initialize(request)
         @request = request
+        @supergraph = request.supergraph
         @planning_index = ROOT_INDEX
         @steps_by_entrypoint = {}
       end
@@ -324,7 +324,7 @@ module GraphQL
         end
 
         if expanded_selections
-          @supergraph.memoized_schema_possible_types(parent_type.graphql_name).each do |possible_type|
+          @request.warden.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)