graphql-stitching 1.7.2 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10934c3d783de823cba55bfe33b361f7ffb6ead4a113a415199f660db97790be
-  data.tar.gz: b310d93e9493319363924fd4eaca3a828e110479a91906394b35df5cb2b7d2d7
+  metadata.gz: 66715354401a5907a302fcecc6e5a285344e31357060f093f5804e6c27dab1d2
+  data.tar.gz: c51d4046ad4c6101edec196d97b7e44f083640ad739c81f9f27612067646c6fb
 SHA512:
-  metadata.gz: d998d78a25d271bd41b70df55f6d9e5442e2a5ce38c05c30ed281cc34a28e88aa41a0f923f07e306e1c472143e4a164ad109f1297a8b0af0c621769e38b92f30
-  data.tar.gz: 9aee659c12c236428062e2621d189b6a79518e31ed8fed60c995a27fb18fe746479c554edcb0bc9e091ed39e412185c63da0223d7acee21b304bd6707c630298
+  metadata.gz: 641b5c2903c1d07b00d794ac445aadc96bb7be640ef0e5b2607842e8c5d296eebfd39ddde3e75a97978e2533994a0c9d0b587c68cfd76c8d2c5cde4fb0dc302a
+  data.tar.gz: 916a94f76a1d453cf24ea7e382fe3b1b41184390720dd55c5b0ef1ffe32306f40ee33de73574e7672a0a895461e049b9204ef3fbd1e907a2570f29e463b1c1c1

data/README.md

@@ -21,7 +21,7 @@ This Ruby implementation is designed as a generic library to join basic spec-com
 
 ## Documentation
 
-1. [Introduction](./docs/introduction.md)
+1. [Introduction](./docs/README.md)
 1. [Composing a supergraph](./docs/composing_a_supergraph.md)
 1. [Merged types](./docs/merged_types.md)
 1. [Executables & file uploads](./docs/executables.md)

data/Rakefile

@@ -9,4 +9,14 @@ Rake::TestTask.new(:test) do |t, args|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+namespace :benchmark do
+  desc "Benchmark planner throughput"
+  task :planner do
+    ruby "benchmark/run.rb"
+  end
+end
+
+desc "Run benchmarks"
+task benchmark: "benchmark:planner"
+
+task :default => :test

data/benchmark/run.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "bundler/setup"
+require "graphql/stitching"
+
+STITCH_DEFINITION = "directive @stitch(key: String!, arguments: String, typeName: String) repeatable on FIELD_DEFINITION\n"
+
+def compose_definitions(locations)
+  locations = locations.each_with_object({}) do |(location, schema_config), memo|
+    schema_config = STITCH_DEFINITION + schema_config if schema_config.include?("@stitch")
+    memo[location.to_s] = { schema: GraphQL::Schema.from_definition(schema_config) }
+  end
+
+  GraphQL::Stitching::Composer.new.perform(locations)
+end
+
+class PlannerBenchmark
+  Case = Struct.new(:name, :supergraph, :document, :variables, keyword_init: true)
+
+  MINIMUM_SECONDS = Float(ENV.fetch("BENCHMARK_SECONDS", 2.0))
+  WARMUP_ITERATIONS = Integer(ENV.fetch("BENCHMARK_WARMUP", 200))
+
+  def initialize(cases)
+    @cases = cases
+  end
+
+  def run
+    width = @cases.map { |c| c.name.length }.max
+
+    puts "GraphQL::Stitching::Planner"
+    puts "ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
+    puts "graphql #{GraphQL::VERSION}"
+    puts "minimum #{MINIMUM_SECONDS}s per case"
+    puts
+
+    @cases.each do |bench_case|
+      WARMUP_ITERATIONS.times { plan(bench_case) }
+
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      iterations = 0
+      elapsed = 0.0
+
+      loop do
+        plan(bench_case)
+        iterations += 1
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        break if elapsed >= MINIMUM_SECONDS
+      end
+
+      ips = iterations / elapsed
+      microseconds = 1_000_000.0 / ips
+      puts "%-#{width}s %10.1f i/s %10.2f us/i" % [bench_case.name, ips, microseconds]
+    end
+  end
+
+  private
+
+  def plan(bench_case)
+    GraphQL::Stitching::Request.new(
+      bench_case.supergraph,
+      bench_case.document,
+      variables: bench_case.variables,
+    ).plan
+  end
+end
+
+root_supergraph = compose_definitions({
+  "widgets" => %|
+    input MakeWidgetInput { name: String child: MakeWidgetInput }
+    type Widget { id: ID! name(lang: String): String size: Int color: String }
+    type Query { widget(id: ID!): Widget widgets(ids: [ID!]): [Widget!]! }
+    type Mutation { makeWidget(input: MakeWidgetInput!): Widget }
+  |,
+  "sprockets" => %|
+    input MakeSprocketInput { name: String child: MakeSprocketInput }
+    type Sprocket { id: ID! name(lang: String): String size: Int color: String }
+    type Query { sprocket(id: ID!): Sprocket sprockets(ids: [ID!]): [Sprocket!]! }
+    type Mutation { makeSprocket(input: MakeSprocketInput!): Sprocket }
+  |,
+})
+
+delegation_supergraph = compose_definitions({
+  "alpha" => %|
+    type Widget { id: ID! a: String! b: String! }
+    type Query { alpha(id: ID!): Widget @stitch(key: "id") }
+  |,
+  "bravo" => %|
+    type Widget { id: ID! a: String! b: String! }
+    type Query { bravo(id: ID!): Widget @stitch(key: "id") }
+  |,
+  "charlie" => %|
+    type Widget { id: ID! c: String! d: String! }
+    type Query { charlie(id: ID!): Widget @stitch(key: "id") }
+  |,
+  "delta" => %|
+    type Widget { id: ID! d: String! e: String! }
+    type Query { delta(id: ID!): Widget @stitch(key: "id") }
+  |,
+  "echo" => %|
+    type Widget { id: ID! d: String! e: String! f: String! }
+    type Query { echo(id: ID!): Widget @stitch(key: "id") }
+  |,
+  "foxtrot" => %|
+    type Widget { id: ID! d: String! f: String! }
+    type Query { foxtrot(id: ID!): Widget @stitch(key: "id") }
+  |,
+})
+
+resolver_supergraph = compose_definitions({
+  "storefronts" => %|
+    type Storefront {
+      id: ID!
+      name: String!
+      products: [Product]!
+    }
+    type Product {
+      upc: ID!
+    }
+    type Query {
+      storefront(id: ID!): Storefront
+    }
+  |,
+  "products" => %|
+    type Product {
+      upc: ID!
+      name: String!
+      price: Float!
+      manufacturer: Manufacturer!
+    }
+    type Manufacturer {
+      id: ID!
+      name: String!
+      products: [Product]!
+    }
+    type Query {
+      product(upc: ID!): Product @stitch(key: "upc")
+      productsManufacturer(id: ID!): Manufacturer @stitch(key: "id")
+    }
+  |,
+  "manufacturers" => %|
+    type Manufacturer {
+      id: ID!
+      name: String!
+      address: String!
+    }
+    type Query {
+      manufacturer(id: ID!): Manufacturer @stitch(key: "id")
+    }
+  |,
+})
+
+abstract_supergraph = compose_definitions({
+  "a" => %|
+    interface Buyable {
+      id: ID!
+      name: String!
+      price: Float!
+    }
+    type Product implements Buyable {
+      id: ID!
+      name: String!
+      price: Float!
+    }
+    type Query {
+      products(ids: [ID!]!): [Product]! @stitch(key: "id")
+    }
+  |,
+  "b" => %|
+    interface Buyable { id: ID! }
+    type Product implements Buyable { id: ID! }
+    type Bundle implements Buyable {
+      id: ID!
+      name: String!
+      price: Float!
+      products: [Product]!
+    }
+    type Query {
+      buyable(id: ID!): Buyable @stitch(key: "id")
+    }
+  |,
+})
+
+cases = [
+  PlannerBenchmark::Case.new(
+    name: "root groups",
+    supergraph: root_supergraph,
+    document: %|
+      query($wid: ID!, $sid: ID!, $ids: [ID!], $lang: String) {
+        a: widget(id: $wid) { id name(lang: $lang) size color }
+        b: sprocket(id: $sid) { id name(lang: $lang) size color }
+        c: widgets(ids: $ids) { id name size color }
+        d: sprockets(ids: $ids) { id name size color }
+      }
+    |,
+    variables: { "wid" => "1", "sid" => "2", "ids" => ["1", "2"], "lang" => "en" },
+  ),
+  PlannerBenchmark::Case.new(
+    name: "variables",
+    supergraph: root_supergraph,
+    document: %|
+      mutation($wname1: String!, $wname2: String!, $sname1: String!, $sname2: String!, $lang: String) {
+        makeWidget(input: { name: $wname1, child: { name: $wname2 } }) { id name(lang: $lang) }
+        makeSprocket(input: { name: $sname1, child: { name: $sname2 } }) { id name(lang: $lang) }
+      }
+    |,
+    variables: {
+      "wname1" => "a",
+      "wname2" => "b",
+      "sname1" => "c",
+      "sname2" => "d",
+      "lang" => "en",
+    },
+  ),
+  PlannerBenchmark::Case.new(
+    name: "delegation",
+    supergraph: delegation_supergraph,
+    document: %|query { alpha(id: "1") { a b c d e f } }|,
+  ),
+  PlannerBenchmark::Case.new(
+    name: "nested resolvers",
+    supergraph: resolver_supergraph,
+    document: %|
+      query {
+        storefront(id: "1") {
+          name
+          products {
+            name
+            manufacturer {
+              address
+              products {
+                name
+              }
+            }
+          }
+        }
+      }
+    |,
+  ),
+  PlannerBenchmark::Case.new(
+    name: "fragments",
+    supergraph: resolver_supergraph,
+    document: %|
+      query {
+        storefront(id: "1") {
+          products {
+            ...ProductAttrs
+            manufacturer {
+              ...ManufacturerAttrs
+            }
+          }
+        }
+      }
+      fragment ProductAttrs on Product { name price }
+      fragment ManufacturerAttrs on Manufacturer {
+        name
+        address
+        products { ...ProductAttrs }
+      }
+    |,
+  ),
+  PlannerBenchmark::Case.new(
+    name: "abstracts",
+    supergraph: abstract_supergraph,
+    document: %|
+      query {
+        buyable(id: "1") {
+          ... {
+            ...BuyableAttrs
+          }
+        }
+      }
+      fragment BuyableAttrs on Buyable { id name price }
+    |,
+  ),
+]
+
+PlannerBenchmark.new(cases).run

data/docs/performance.md

@@ -57,6 +57,34 @@ query($id: ID!) {
 # variables: { "id" => "1" }
 ```
 
+### Subgraph validations
+
+Requests are validated by the supergraph, and should always divide into valid subgraph documents. Therefore, you can skip redundant subgraph validations for requests sent by the supergraph, ex:
+
+```ruby
+exe = GraphQL::Stitching::HttpExecutable.new(
+  url: "http://localhost:3001",
+  headers: { 
+    "Authorization" => "...",
+    "X-Supergraph-Secret" => "<shared-secret>",
+  },
+)
+```
+
+A shared secret allows a subgraph location to trust the supergraph origin, at which time it can disable validations:
+
+```ruby
+def query
+  sg_header = request.headers["X-Supergraph-Secret"]
+  MySchema.execute(
+    query: params[:query],
+    variables: params[:variables],
+    operation_name: params[:operationName],
+    validate: sg_header.nil? || sg_header != Rails.env.credentials.supergraph,
+  )
+end
+```
+
 ### Digests
 
 All computed digests use SHA2 hashing by default. You can swap in [a faster algorithm](https://github.com/Shopify/blake3-rb) and/or add base state by reconfiguring `Stitching.digest`:

data/graphql-stitching.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'graphql', '>= 2.0'
 
-  spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'rake', '~> 12.0'
-  spec.add_development_dependency 'minitest', '~> 5.12'
+  spec.add_development_dependency 'bundler', '>= 2.0'
+  spec.add_development_dependency 'rake', '>= 12.0'
+  spec.add_development_dependency 'minitest', '>= 5.12'
 end

data/lib/graphql/stitching/client.rb

@@ -25,7 +25,7 @@ module GraphQL
           raise ArgumentError, "Cannot provide both locations and a supergraph."
         elsif supergraph && !supergraph.is_a?(Supergraph)
           raise ArgumentError, "Provided supergraph must be a GraphQL::Stitching::Supergraph instance."
-        elsif supergraph && composer_options.any?
+        elsif supergraph && !composer_options.empty?
           raise ArgumentError, "Cannot provide composer options with a pre-built supergraph."
         elsif supergraph
           supergraph
@@ -50,7 +50,7 @@ module GraphQL
 
         if validate
           validation_errors = request.validate
-          return error_result(request, validation_errors) if validation_errors.any?
+          return error_result(request, validation_errors) unless validation_errors.empty?
         end
 
         load_plan(request)

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

@@ -8,7 +8,7 @@ module GraphQL::Stitching
 
       class << self
         def extract_directive_assignments(schema, location, assignments)
-          return EMPTY_OBJECT unless assignments && assignments.any?
+          return EMPTY_OBJECT unless assignments && !assignments.empty?
 
           assignments.each_with_object({}) do |kwargs, memo|
             type = kwargs[:parent_type_name] ? schema.get_type(kwargs[:parent_type_name]) : schema.query

data/lib/graphql/stitching/composer.rb

@@ -423,7 +423,7 @@ module GraphQL
             memo[location] = argument.default_value
           end
 
-          if default_values_by_location.any?
+          unless default_values_by_location.empty?
             kwargs[:default_value] = @default_value_merger.call(default_values_by_location, {
               type_name: type_name,
               field_name: field_name,
@@ -468,8 +468,6 @@ module GraphQL
           kwarg_values_by_name_location = directives_by_location.each_with_object({}) do |(location, directive), memo|
             directive.arguments.keyword_arguments.each do |key, value|
               key = key.to_s
-              next unless directive_class.arguments[key]
-
               memo[key] ||= {}
               memo[key][location] = value
             end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Executor
+    # Utilities for traversing aggregate executor data along planned paths.
+    module PathAccess
+      private
+
+      def path_objects(root, path)
+        objects = []
+        each_path_object(root, path) { |object| objects << object }
+        objects
+      end
+
+      def each_path_object(scope, path, &block)
+        return enum_for(:each_path_object, scope, path) unless block
+        return if scope.nil?
+
+        if path.empty?
+          each_leaf_object(scope, &block)
+        elsif scope.is_a?(Array)
+          scope.each { |element| each_path_object(element, path, &block) }
+        elsif scope.respond_to?(:[])
+          path_segment = path.first
+          each_path_object(scope[path_segment], path[1..-1], &block)
+        end
+      end
+
+      def each_leaf_object(scope, &block)
+        return if scope.nil?
+
+        if scope.is_a?(Array)
+          scope.each { |element| each_leaf_object(element, &block) }
+        else
+          yield(scope)
+        end
+      end
+
+      def path_entries(root, path)
+        entries = []
+        each_path_entry(root, path) { |object, response_path| entries << [object, response_path] }
+        entries
+      end
+
+      def each_path_entry(scope, path, response_path = [], &block)
+        return enum_for(:each_path_entry, scope, path, response_path) unless block
+        return if scope.nil?
+
+        if path.empty?
+          each_leaf_entry(scope, response_path, &block)
+        elsif scope.is_a?(Array)
+          scope.each_with_index do |element, index|
+            each_path_entry(element, path, [*response_path, index], &block)
+          end
+        elsif scope.respond_to?(:[])
+          path_segment = path.first
+          each_path_entry(scope[path_segment], path[1..-1], [*response_path, path_segment], &block)
+        end
+      end
+
+      def each_leaf_entry(scope, response_path, &block)
+        return if scope.nil?
+
+        if scope.is_a?(Array)
+          scope.each_with_index do |element, index|
+            each_leaf_entry(element, [*response_path, index], &block)
+          end
+        else
+          yield(scope, response_path)
+        end
+      end
+
+      def sanitized_error(error, path: nil)
+        error.dup.tap do |formatted|
+          formatted.delete("locations")
+          formatted["path"] = path if path
+        end
+      end
+    end
+  end
+end

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

@@ -3,75 +3,94 @@
 module GraphQL::Stitching
   class Executor
     class RootSource < GraphQL::Dataloader::Source
+      include PathAccess
+
       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_document(
-          op,
-          @executor.request.operation_name,
-          @executor.request.operation_directives,
-        )
-        query_variables = @executor.request.variables.slice(*op.variables.each_key)
-        result = @executor.request.supergraph.execute_at_location(op.location, query_document, query_variables, @executor.request)
-        @executor.query_count += 1
-
-        if result["data"]
-          if op.path.any?
-            # Nested root scopes must expand their pathed origin set
-            origin_set = op.path.reduce([@executor.data]) do |set, ns|
-              set.flat_map { |obj| obj && obj[ns] }.tap(&:compact!)
+        ops.map do |op|
+          origin_set = op.path.empty? ? [@executor.data] : path_objects(@executor.data, op.path)
+
+          query_document = build_document(
+            op,
+            @executor.request.operation_name,
+            @executor.request.operation_directives,
+          )
+          query_variables = @executor.request.variables.slice(*op.variables.each_key)
+          result = @executor.request.supergraph.execute_at_location(op.location, query_document, query_variables, @executor.request)
+          @executor.query_count += 1
+
+          errors = result["errors"]
+          origin_entries = nil
+
+          if errors && !errors.empty?
+            origin_entries = op.path.empty? ? [[@executor.data, []]] : path_entries(@executor.data, op.path)
+          end
+
+          if result["data"]
+            if op.path.empty?
+              # Actual root scopes merge directly into results data
+              @executor.data.merge!(result["data"])
+            elsif !origin_set.empty?
+              # Nested root scopes merge the same root payload into each pathed origin
+              origin_set.each { |origin_obj| origin_obj.merge!(result["data"]) }
             end
+          end
 
-            origin_set.each { _1.merge!(result["data"]) }
-          else
-            # Actual root scopes merge directly into results data
-            @executor.data.merge!(result["data"])
+          if errors && !errors.empty?
+            @executor.errors.concat(format_errors(errors, origin_entries, op.path))
           end
-        end
 
-        if result["errors"]&.any?
-          @executor.errors.concat(format_errors!(result["errors"], op.path))
+          op.step
         end
-
-        ops.map(&:step)
       end
 
       # Builds root source documents
       # "query MyOperation_1($var:VarType) { rootSelections ... }"
       def build_document(op, operation_name = nil, operation_directives = nil)
-        doc = String.new
-        doc << op.operation_type
+        doc_buffer = String.new
+        doc_buffer << op.operation_type
 
         if operation_name
-          doc << " #{operation_name}_#{op.step}"
+          doc_buffer << " " << operation_name << "_" << op.step.to_s
         end
 
-        if op.variables.any?
-          variable_defs = op.variables.map { |k, v| "$#{k}:#{v}" }.join(",")
-          doc << "(#{variable_defs})"
+        unless op.variables.empty?
+          doc_buffer << "("
+          op.variables.each_with_index do |(k, v), i|
+            doc_buffer << "," unless i.zero?
+            doc_buffer << "$" << k << ":" << v
+          end
+          doc_buffer << ")"
         end
 
         if operation_directives
-          doc << " #{operation_directives} "
+          doc_buffer << " " << operation_directives << " "
         end
 
-        doc << op.selections
-        doc
+        doc_buffer << op.selections
+        doc_buffer
       end
 
       # Format response errors without a document location (because it won't match the request doc),
-      # and prepend any insertion path for the scope into error paths.
-      def format_errors!(errors, path)
-        errors.each do |err|
-          err.delete("locations")
-          err["path"].unshift(*path) if err["path"] && path.any?
+      # and prepend all concrete insertion paths for nested scopes into error paths.
+      def format_errors(errors, origin_entries, fallback_path = [])
+        errors.flat_map do |err|
+          path = err["path"]
+
+          if path && !origin_entries.empty?
+            origin_entries.map do |_origin_obj, origin_path|
+              sanitized_error(err, path: origin_path + path)
+            end
+          elsif path && !fallback_path.empty?
+            sanitized_error(err, path: fallback_path + path)
+          else
+            sanitized_error(err)
+          end
         end
-        errors
       end
     end
   end