graphql-stitching 0.0.1 → 0.2.1

data/lib/graphql/stitching/executor.rb

@@ -7,16 +7,17 @@ module GraphQL
     class Executor
 
       class RootSource < GraphQL::Dataloader::Source
-        def initialize(executor)
+        def initialize(executor, location)
           @executor = executor
+          @location = location
         end
 
         def fetch(ops)
           op = ops.first # There should only ever be one per location at a time
 
           query_document = build_query(op)
-          query_variables = @executor.variables.slice(*op["variables"].keys)
-          result = @executor.supergraph.execute_at_location(op["location"], query_document, query_variables)
+          query_variables = @executor.request.variables.slice(*op["variables"].keys)
+          result = @executor.supergraph.execute_at_location(op["location"], query_document, query_variables, @executor.request.context)
           @executor.query_count += 1
 
           @executor.data.merge!(result["data"]) if result["data"]
@@ -24,7 +25,8 @@ module GraphQL
             result["errors"].each { _1.delete("locations") }
             @executor.errors.concat(result["errors"])
           end
-          op["key"]
+
+          ops.map { op["key"] }
         end
 
         def build_query(op)
@@ -61,8 +63,8 @@ module GraphQL
 
           if origin_sets_by_operation.any?
             query_document, variable_names = build_query(origin_sets_by_operation)
-            variables = @executor.variables.slice(*variable_names)
-            raw_result = @executor.supergraph.execute_at_location(@location, query_document, variables)
+            variables = @executor.request.variables.slice(*variable_names)
+            raw_result = @executor.supergraph.execute_at_location(@location, query_document, variables, @executor.request.context)
             @executor.query_count += 1
 
             merge_results!(origin_sets_by_operation, raw_result.dig("data"))
@@ -165,23 +167,26 @@ module GraphQL
 
         private
 
-        # traverses forward through origin data, expanding arrays to follow all paths
+        # traverse forward through origin data, expanding arrays to follow all paths
         # any errors found for an origin object_id have their path prefixed by the object path
         def repath_errors!(pathed_errors_by_object_id, forward_path, current_path=[], root=@executor.data)
-          current_path << forward_path.first
-          forward_path = forward_path[1..-1]
+          current_path.push(forward_path.shift)
           scope = root[current_path.last]
 
           if forward_path.any? && scope.is_a?(Array)
             scope.each_with_index do |element, index|
               inner_elements = element.is_a?(Array) ? element.flatten : [element]
               inner_elements.each do |inner_element|
-                repath_errors!(pathed_errors_by_object_id, forward_path, [*current_path, index], inner_element)
+                current_path << index
+                repath_errors!(pathed_errors_by_object_id, forward_path, current_path, inner_element)
+                current_path.pop
               end
             end
 
           elsif forward_path.any?
-            repath_errors!(pathed_errors_by_object_id, forward_path, [*current_path, index], scope)
+            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|
@@ -196,56 +201,72 @@ module GraphQL
             errors = pathed_errors_by_object_id[scope.object_id]
             errors.each { _1["path"] = [*current_path, *_1["path"]] } if errors
           end
+
+          forward_path.unshift(current_path.pop)
         end
       end
 
-      attr_reader :supergraph, :data, :errors, :variables
+      attr_reader :supergraph, :request, :data, :errors
       attr_accessor :query_count
 
-      def initialize(supergraph:, plan:, variables: {}, nonblocking: false)
+      def initialize(supergraph:, request:, plan:, nonblocking: false)
         @supergraph = supergraph
-        @variables = variables
+        @request = request
         @queue = plan["ops"]
         @data = {}
         @errors = []
         @query_count = 0
+        @exec_cycles = 0
         @dataloader = GraphQL::Dataloader.new(nonblocking: nonblocking)
       end
 
-      def perform(document=nil)
+      def perform(raw: false)
         exec!
-
         result = {}
-        result["data"] = @data if @data && @data.length > 0
-        result["errors"] = @errors if @errors.length > 0
 
-        result if document.nil?
+        if @data && @data.length > 0
+          result["data"] = raw ? @data : GraphQL::Stitching::Shaper.new(
+            schema: @supergraph.schema,
+            request: @request,
+          ).perform!(@data)
+        end
 
-        GraphQL::Stitching::Shaper.new(supergraph: @supergraph, document: document, raw: result).perform!
+        if @errors.length > 0
+          result["errors"] = @errors
+        end
+
+        result
       end
 
       private
 
       def exec!(after_keys = [0])
+        if @exec_cycles > @queue.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
-          requests = @queue
+          tasks = @queue
             .select { after_keys.include?(_1["after_key"]) }
-            .group_by { _1["location"] }
-            .map do |location, ops|
-              if ops.first["after_key"].zero?
-                @dataloader.with(RootSource, self).request_all(ops)
+            .group_by { [_1["location"], _1["boundary"].nil?] }
+            .map do |(location, root_source), ops|
+              if root_source
+                @dataloader.with(RootSource, self, location).request_all(ops)
               else
                 @dataloader.with(BoundarySource, self, location).request_all(ops)
               end
             end
 
-          requests.each(&method(:exec_request))
+          tasks.each(&method(:exec_task))
         end
+
+        @exec_cycles += 1
         @dataloader.run
       end
 
-      def exec_request(request)
-        next_keys = request.load
+      def exec_task(task)
+        next_keys = task.load
         next_keys.compact!
         exec!(next_keys) if next_keys.any?
       end

data/lib/graphql/stitching/gateway.rb

@@ -7,8 +7,6 @@ module GraphQL
     class Gateway
       class GatewayError < StitchingError; end
 
-      EMPTY_CONTEXT = {}.freeze
-
       attr_reader :supergraph
 
       def initialize(locations: nil, supergraph: nil)
@@ -25,29 +23,36 @@ module GraphQL
         end
       end
 
-      def execute(query:, variables: nil, operation_name: nil, context: EMPTY_CONTEXT, validate: true)
-        document = GraphQL::Stitching::Document.new(query, operation_name: operation_name)
+      def execute(query:, variables: nil, operation_name: nil, context: nil, validate: true)
+        request = GraphQL::Stitching::Request.new(
+          query,
+          operation_name: operation_name,
+          variables: variables,
+          context: context,
+        )
 
         if validate
-          validation_errors = @supergraph.schema.validate(document.ast)
+          validation_errors = @supergraph.schema.validate(request.document)
           return error_result(validation_errors) if validation_errors.any?
         end
 
+        request.prepare!
+
         begin
-          plan = fetch_plan(document, context) do
+          plan = fetch_plan(request) do
             GraphQL::Stitching::Planner.new(
               supergraph: @supergraph,
-              document: document,
+              request: request,
             ).perform.to_h
           end
 
           GraphQL::Stitching::Executor.new(
             supergraph: @supergraph,
+            request: request,
             plan: plan,
-            variables: variables || {},
-          ).perform(document)
+          ).perform
         rescue StandardError => e
-          custom_message = @on_error.call(e, context) if @on_error
+          custom_message = @on_error.call(e, request.context) if @on_error
           error_result([{ "message" => custom_message || "An unexpected error occured." }])
         end
       end
@@ -91,16 +96,16 @@ module GraphQL
         supergraph
       end
 
-      def fetch_plan(document, context)
+      def fetch_plan(request)
         if @on_cache_read
-          cached_plan = @on_cache_read.call(document.digest, context)
+          cached_plan = @on_cache_read.call(request.digest, request.context)
           return JSON.parse(cached_plan) if cached_plan
         end
 
         plan_json = yield
 
         if @on_cache_write
-          @on_cache_write.call(document.digest, JSON.generate(plan_json), context)
+          @on_cache_write.call(request.digest, JSON.generate(plan_json), request.context)
         end
 
         plan_json

data/lib/graphql/stitching/planner.rb

@@ -6,9 +6,9 @@ module GraphQL
       SUPERGRAPH_LOCATIONS = [Supergraph::LOCATION].freeze
       TYPENAME_NODE = GraphQL::Language::Nodes::Field.new(alias: "_STITCH_typename", name: "__typename")
 
-      def initialize(supergraph:, document:)
+      def initialize(supergraph:, request:)
         @supergraph = supergraph
-        @document = document
+        @request = request
         @sequence_key = 0
         @operations_by_grouping = {}
       end
@@ -37,7 +37,11 @@ module GraphQL
           extract_locale_selections(location, parent_type, selections, insertion_path, parent_key)
         end
 
-        grouping = [after_key, location, parent_type.graphql_name, *insertion_path].join("/")
+        grouping = String.new
+        grouping << after_key.to_s << "/" << location << "/" << parent_type.graphql_name
+        grouping = insertion_path.reduce(grouping) do |memo, segment|
+          memo << "/" << segment
+        end
 
         if op = @operations_by_grouping[grouping]
           op.selections += selection_set if selection_set
@@ -62,12 +66,12 @@ module GraphQL
       end
 
       def build_root_operations
-        case @document.operation.operation_type
+        case @request.operation.operation_type
         when "query"
           # plan steps grouping all fields by location for async execution
           parent_type = @supergraph.schema.query
 
-          selections_by_location = @document.operation.selections.each_with_object({}) do |node, memo|
+          selections_by_location = @request.operation.selections.each_with_object({}) do |node, memo|
             locations = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name] || SUPERGRAPH_LOCATIONS
             memo[locations.last] ||= []
             memo[locations.last] << node
@@ -82,7 +86,7 @@ module GraphQL
           parent_type = @supergraph.schema.mutation
           location_groups = []
 
-          @document.operation.selections.reduce(nil) do |last_location, node|
+          @request.operation.selections.reduce(nil) do |last_location, node|
             location = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name].last
             if location != last_location
               location_groups << {
@@ -161,8 +165,10 @@ module GraphQL
             if Util.is_leaf_type?(field_type)
               selections_result << node
             else
-              expanded_path = [*insertion_path, node.alias || node.name]
-              selection_set, variables = extract_locale_selections(current_location, field_type, node.selections, expanded_path, after_key)
+              insertion_path.push(node.alias || node.name)
+              selection_set, variables = extract_locale_selections(current_location, field_type, node.selections, insertion_path, after_key)
+              insertion_path.pop
+
               selections_result << node.merge(selections: selection_set)
               variables_result.merge!(variables)
             end
@@ -177,7 +183,7 @@ module GraphQL
             implements_fragments = true
 
           when GraphQL::Language::Nodes::FragmentSpread
-            fragment = @document.fragment_definitions[node.name]
+            fragment = @request.fragment_definitions[node.name]
             next unless @supergraph.locations_by_type[fragment.type.name].include?(current_location)
 
             fragment_type = @supergraph.schema.types[fragment.type.name]
@@ -260,7 +266,7 @@ module GraphQL
               location: location,
               selections: selections_by_location[location],
               parent_type: parent_type,
-              insertion_path: insertion_path,
+              insertion_path: insertion_path.dup,
               boundary: boundary,
               after_key: after_key,
             )
@@ -289,7 +295,7 @@ module GraphQL
           when GraphQL::Language::Nodes::InputObject
             extract_node_variables!(argument.value, memo)
           when GraphQL::Language::Nodes::VariableIdentifier
-            memo[argument.value.name] ||= @document.variable_definitions[argument.value.name]
+            memo[argument.value.name] ||= @request.variable_definitions[argument.value.name]
           end
         end
       end

data/lib/graphql/stitching/remote_client.rb

@@ -9,14 +9,14 @@ module GraphQL
     class RemoteClient
       def initialize(url:, headers:{})
         @url = url
-        @headers = headers
+        @headers = { "Content-Type" => "application/json" }.merge!(headers)
       end
 
-      def call(location, document, variables)
+      def call(_location, document, variables, _context)
         response = Net::HTTP.post(
           URI(@url),
-          { "query" => document, "variables" => variables }.to_json,
-          { "Content-Type" => "application/json" }.merge!(@headers)
+          JSON.generate({ "query" => document, "variables" => variables }),
+          @headers,
         )
         JSON.parse(response.body)
       end

data/lib/graphql/stitching/request.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Stitching
+    class Request
+      SUPPORTED_OPERATIONS = ["query", "mutation"].freeze
+      EMPTY_CONTEXT = {}.freeze
+
+      class ApplyRuntimeDirectives < GraphQL::Language::Visitor
+        def initialize(document, variables)
+          @changed = false
+          @variables = variables
+          super(document)
+        end
+
+        def changed?
+          @changed
+        end
+
+        def on_field(node, parent)
+          delete_node = false
+          filtered_directives = if node.directives.any?
+            node.directives.select do |directive|
+              if directive.name == "skip"
+                delete_node = assess_argument_value(directive.arguments.first)
+                false
+              elsif directive.name == "include"
+                delete_node = !assess_argument_value(directive.arguments.first)
+                false
+              else
+                true
+              end
+            end
+          end
+
+          if delete_node
+            @changed = true
+            super(DELETE_NODE, parent)
+          elsif filtered_directives && filtered_directives.length != node.directives.length
+            @changed = true
+            super(node.merge(directives: filtered_directives), parent)
+          else
+            super
+          end
+        end
+
+        private
+
+        def assess_argument_value(arg)
+          if arg.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+            return @variables[arg.value.name]
+          end
+          arg.value
+        end
+      end
+
+      attr_reader :document, :variables, :operation_name, :context
+
+      def initialize(document, operation_name: nil, variables: nil, context: nil)
+        @may_contain_runtime_directives = true
+
+        @document = if document.is_a?(String)
+          @may_contain_runtime_directives = document.include?("@")
+          GraphQL.parse(document)
+        else
+          document
+        end
+
+        @operation_name = operation_name
+        @variables = variables || {}
+        @context = context || EMPTY_CONTEXT
+      end
+
+      def string
+        @string ||= @document.to_query_string
+      end
+
+      def digest
+        @digest ||= Digest::SHA2.hexdigest(string)
+      end
+
+      def operation
+        @operation ||= begin
+          operation_defs = @document.definitions.select do |d|
+            next unless d.is_a?(GraphQL::Language::Nodes::OperationDefinition)
+            next unless SUPPORTED_OPERATIONS.include?(d.operation_type)
+            @operation_name ? d.name == @operation_name : true
+          end
+
+          if operation_defs.length < 1
+            raise GraphQL::ExecutionError, "Invalid root operation."
+          elsif operation_defs.length > 1
+            raise GraphQL::ExecutionError, "An operation name is required when sending multiple operations."
+          end
+
+          operation_defs.first
+        end
+      end
+
+      def variable_definitions
+        @variable_definitions ||= operation.variables.each_with_object({}) do |v, memo|
+          memo[v.name] = v.type
+        end
+      end
+
+      def fragment_definitions
+        @fragment_definitions ||= @document.definitions.each_with_object({}) do |d, memo|
+          memo[d.name] = d if d.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+        end
+      end
+
+      def prepare!
+        operation.variables.each do |v|
+          @variables[v.name] ||= v.default_value
+        end
+
+        return self unless @may_contain_runtime_directives
+
+        visitor = ApplyRuntimeDirectives.new(@document, @variables)
+        @document = visitor.visit
+
+        if visitor.changed?
+          @string = nil
+          @digest = nil
+          @operation = nil
+          @variable_definitions = nil
+          @fragment_definitions = nil
+        end
+        self
+      end
+    end
+  end
+end

data/lib/graphql/stitching/shaper.rb

@@ -4,88 +4,92 @@
 module GraphQL
   module Stitching
     class Shaper
-      def initialize(supergraph:, document:, raw:)
-        @supergraph = supergraph
-        @document = document
-        @result = raw
-        @errors = []
+      def initialize(schema:, request:)
+        @schema = schema
+        @request = request
       end
 
-      def perform!
-        if @result.key?("data") && ! @result["data"].empty?
-          munge_entry(@result["data"], @document.operation.selections, @supergraph.schema.query)
-          # hate doing a second pass, but cannot remove _STITCH_ fields until the fragements are processed
-          clean_entry(@result["data"])
-        end
-
-        if @errors.length > 0
-          @result = [] unless @result.key?("errors")
-          @result["errors"] += @errors
-        end
-
-        @result
+      def perform!(raw)
+        root_type = @schema.public_send(@request.operation.operation_type)
+        resolve_object_scope(raw, root_type, @request.operation.selections)
       end
 
       private
 
-      def munge_entry(entry, selections, parent_type)
+      def resolve_object_scope(raw_object, parent_type, selections, typename = nil)
+        return nil if raw_object.nil?
+
+        typename ||= raw_object["_STITCH_typename"]
+        raw_object.reject! { |k, _v| k.start_with?("_STITCH_") }
+
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            next if node.respond_to?(:name) && node&.name == "__typename"
+            next if node.name.start_with?("__")
 
-            munge_field(entry, node, parent_type)
+            field_name = node.alias || node.name
+            node_type = parent_type.fields[node.name].type
+            named_type = Util.get_named_type_for_field_node(@schema, parent_type, node)
+
+            raw_object[field_name] = if node_type.list?
+              resolve_list_scope(raw_object[field_name], Util.unwrap_non_null(node_type), node.selections)
+            elsif Util.is_leaf_type?(named_type)
+              raw_object[field_name]
+            else
+              resolve_object_scope(raw_object[field_name], named_type, node.selections)
+            end
+
+            return nil if raw_object[field_name].nil? && node_type.non_null?
 
           when GraphQL::Language::Nodes::InlineFragment
-            next unless entry["_STITCH_typename"] == node.type.name
-            fragment_type = @supergraph.schema.types[node.type.name]
-            munge_entry(entry, node.selections, fragment_type)
+            next unless typename == node.type.name
+            fragment_type = @schema.types[node.type.name]
+            result = resolve_object_scope(raw_object, fragment_type, node.selections, typename)
+            return nil if result.nil?
 
           when GraphQL::Language::Nodes::FragmentSpread
-            next unless entry["_STITCH_typename"] == node.name
-            fragment = @document.fragment_definitions[node.name]
-            fragment_type = @supergraph.schema.types[node.name]
-            munge_entry(entry, fragment.selections, fragment_type)
+            fragment = @request.fragment_definitions[node.name]
+            fragment_type = @schema.types[fragment.type.name]
+            next unless typename == fragment_type.graphql_name
+
+            result = resolve_object_scope(raw_object, fragment_type, fragment.selections, typename)
+            return nil if result.nil?
+
           else
             raise "Unexpected node of type #{node.class.name} in selection set."
           end
         end
+
+        raw_object
       end
 
-      def munge_field(entry, node, parent_type)
-        field_identifier = (node.alias || node.name)
-        node_type = Util.get_named_type_for_field_node(@supergraph.schema, parent_type, node)
+      def resolve_list_scope(raw_list, current_node_type, selections)
+        return nil if raw_list.nil?
 
-        if entry.nil?
-          return  # TODO bubble up error if not nullable
-        end
+        next_node_type = Util.unwrap_non_null(current_node_type).of_type
+        named_type = Util.get_named_type(next_node_type)
+        contains_null = false
 
-        child_entry = entry[field_identifier]
-        if child_entry.nil?
-          entry[field_identifier] = nil
-        elsif child_entry.is_a? Array
-          child_entry.each do |raw_item|
-            munge_entry(raw_item, node.selections, node_type)
+        resolved_list = raw_list.map! do |raw_list_element|
+          result = if next_node_type.list?
+            resolve_list_scope(raw_list_element, next_node_type, selections)
+          elsif Util.is_leaf_type?(named_type)
+            raw_list_element
+          else
+            resolve_object_scope(raw_list_element, named_type, selections)
           end
-        elsif ! Util.is_leaf_type?(node_type)
-          munge_entry(child_entry, node.selections, node_type)
-        end
-      end
 
-      def clean_entry(entry)
-        return if entry.nil?
-
-        entry.each do |key, value|
-          if key.start_with? "_STITCH_"
-            entry.delete(key)
-          elsif value.is_a?(Array)
-            value.each do |item|
-              clean_entry(item)
-            end
-          elsif value.is_a?(Hash)
-            clean_entry(value)
+          if result.nil?
+            contains_null = true
+            return nil if current_node_type.non_null?
           end
+
+          result
         end
+
+        return nil if contains_null && next_node_type.non_null?
+
+        resolved_list
       end
     end
   end

data/lib/graphql/stitching/supergraph.rb

@@ -57,27 +57,28 @@ module GraphQL
       def assign_executable(location, executable = nil, &block)
         executable ||= block
         unless executable.is_a?(Class) && executable <= GraphQL::Schema
-          raise "A client or block handler must be provided." unless executable
-          raise "A client must be callable" unless executable.respond_to?(:call)
+          raise StitchingError, "A client or block handler must be provided." unless executable
+          raise StitchingError, "A client must be callable" unless executable.respond_to?(:call)
         end
         @executables[location] = executable
       end
 
-      def execute_at_location(location, query, variables)
+      def execute_at_location(location, query, variables, context)
         executable = executables[location]
 
         if executable.nil?
-          raise "No executable assigned for #{location} location."
+          raise StitchingError, "No executable assigned for #{location} location."
         elsif executable.is_a?(Class) && executable <= GraphQL::Schema
           executable.execute(
             query: query,
             variables: variables,
+            context: context,
             validate: false,
           )
         elsif executable.respond_to?(:call)
-          executable.call(location, query, variables)
+          executable.call(location, query, variables, context)
         else
-          raise "Missing valid executable for #{location} location."
+          raise StitchingError, "Missing valid executable for #{location} location."
         end
       end