graphql-stitching 0.1.0 → 0.2.2

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_document = build_document(op, @executor.request.operation_name)
+          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,16 +25,27 @@ 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)
+        # Builds root source documents
+        # "query MyOperation_1($var:VarType) { rootSelections ... }"
+        def build_document(op, operation_name = nil)
+          doc = String.new
+          doc << op["operation_type"]
+
+          if operation_name
+            doc << " " << operation_name << "_" << op["key"].to_s
+          end
+
           if op["variables"].any?
             variable_defs = op["variables"].map { |k, v| "$#{k}:#{v}" }.join(",")
-            "#{op["operation_type"]}(#{variable_defs})#{op["selections"]}"
-          else
-            "#{op["operation_type"]}#{op["selections"]}"
+            doc << "(" << variable_defs << ")"
           end
+
+          doc << op["selections"]
+          doc
         end
       end
 
@@ -60,9 +72,9 @@ module GraphQL
           end
 
           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)
+            query_document, variable_names = build_document(origin_sets_by_operation, @executor.request.operation_name)
+            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"))
@@ -74,7 +86,14 @@ module GraphQL
           ops.map { origin_sets_by_operation[_1] ? _1["key"] : nil }
         end
 
-        def build_query(origin_sets_by_operation)
+        # 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... }
+        # }"
+        def build_document(origin_sets_by_operation, operation_name = nil)
           variable_defs = {}
           query_fields = origin_sets_by_operation.map.with_index do |(op, origin_set), batch_index|
             variable_defs.merge!(op["variables"])
@@ -92,14 +111,24 @@ module GraphQL
             end
           end
 
-          query_document = if variable_defs.any?
-            query_variables = variable_defs.map { |k, v| "$#{k}:#{v}" }.join(",")
-            "query(#{query_variables}){ #{query_fields.join(" ")} }"
-          else
-            "query{ #{query_fields.join(" ")} }"
+          doc = String.new
+          doc << "query" # << boundary fulfillment always uses query
+
+          if operation_name
+            doc << " " << operation_name
+            origin_sets_by_operation.each_key do |op|
+              doc << "_" << op["key"].to_s
+            end
           end
 
-          return query_document, variable_defs.keys
+          if variable_defs.any?
+            variable_str = variable_defs.map { |k, v| "$#{k}:#{v}" }.join(",")
+            doc << "(" << variable_str << ")"
+          end
+
+          doc << "{ " << query_fields.join(" ") << " }"
+
+          return doc, variable_defs.keys
         end
 
         def merge_results!(origin_sets_by_operation, raw_result)
@@ -165,23 +194,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,61 +228,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
 
-        if document && result["data"]
-          GraphQL::Stitching::Shaper.new(
+        if @data && @data.length > 0
+          result["data"] = raw ? @data : GraphQL::Stitching::Shaper.new(
             schema: @supergraph.schema,
-            document: document,
-          ).perform!(result)
-        else
-          result
+            request: @request,
+          ).perform!(@data)
         end
+
+        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