graphql-stitching 0.3.4 → 1.0.0

data/lib/graphql/stitching/supergraph.rb

@@ -4,16 +4,6 @@ module GraphQL
   module Stitching
     class Supergraph
       LOCATION = "__super"
-      INTROSPECTION_TYPES = [
-        "__Schema",
-        "__Type",
-        "__Field",
-        "__Directive",
-        "__EnumValue",
-        "__InputValue",
-        "__TypeKind",
-        "__DirectiveLocation",
-      ].freeze
 
       def self.validate_executable!(location, executable)
         return true if executable.is_a?(Class) && executable <= GraphQL::Schema
@@ -50,11 +40,10 @@ module GraphQL
         @memoized_schema_fields = {}
 
         # add introspection types into the fields mapping
-        @locations_by_type_and_field = INTROSPECTION_TYPES.each_with_object(fields) do |type_name, memo|
-          introspection_type = schema.get_type(type_name)
-          next unless introspection_type.kind.fields?
+        @locations_by_type_and_field = memoized_introspection_types.each_with_object(fields) do |(type_name, type), memo|
+          next unless type.kind.fields?
 
-          memo[type_name] = introspection_type.fields.keys.each_with_object({}) do |field_name, m|
+          memo[type_name] = type.fields.keys.each_with_object({}) do |field_name, m|
             m[field_name] = [LOCATION]
           end
         end.freeze
@@ -68,7 +57,7 @@ module GraphQL
       end
 
       def fields
-        @locations_by_type_and_field.reject { |k, _v| INTROSPECTION_TYPES.include?(k) }
+        @locations_by_type_and_field.reject { |k, _v| memoized_introspection_types[k] }
       end
 
       def locations
@@ -83,6 +72,10 @@ module GraphQL
         }
       end
 
+      def memoized_introspection_types
+        @memoized_introspection_types ||= schema.introspection_system.types
+      end
+
       def memoized_schema_types
         @memoized_schema_types ||= @schema.types
       end
@@ -94,11 +87,14 @@ module GraphQL
       def memoized_schema_fields(type_name)
         @memoized_schema_fields[type_name] ||= begin
           fields = memoized_schema_types[type_name].fields
-          fields["__typename"] = @schema.introspection_system.dynamic_field(name: "__typename")
+          @schema.introspection_system.dynamic_fields.each do |field|
+            fields[field.name] ||= field # adds __typename
+          end
 
           if type_name == @schema.query.graphql_name
-            fields["__schema"] = @schema.introspection_system.entry_point(name: "__schema")
-            fields["__type"] = @schema.introspection_system.entry_point(name: "__type")
+            @schema.introspection_system.entry_points.each do |field|
+              fields[field.name] ||= field # adds __schema, __type
+            end
           end
 
           fields
@@ -148,9 +144,7 @@ module GraphQL
       # ("Type") => ["id", ...]
       def possible_keys_for_type(type_name)
         @possible_keys_by_type[type_name] ||= begin
-          keys = @boundaries[type_name].map { _1["selection"] }
-          keys.uniq!
-          keys
+          @boundaries[type_name].map { _1["key"] }.tap(&:uniq!)
         end
       end
 
@@ -190,18 +184,18 @@ module GraphQL
         costs = {}
 
         paths = possible_keys_for_type_and_location(type_name, start_location).map do |possible_key|
-          [{ location: start_location, selection: possible_key, cost: 0 }]
+          [{ location: start_location, key: possible_key, cost: 0 }]
         end
 
         while paths.any?
           path = paths.pop
           current_location = path.last[:location]
-          current_selection = path.last[:selection]
+          current_key = path.last[:key]
           current_cost = path.last[:cost]
 
           @boundaries[type_name].each do |boundary|
             forward_location = boundary["location"]
-            next if current_selection != boundary["selection"]
+            next if current_key != boundary["key"]
             next if path.any? { _1[:location] == forward_location }
 
             best_cost = costs[forward_location] || Float::INFINITY
@@ -210,7 +204,7 @@ module GraphQL
             path.pop
             path << {
               location: current_location,
-              selection: current_selection,
+              key: current_key,
               cost: current_cost,
               boundary: boundary,
             }
@@ -228,14 +222,13 @@ module GraphQL
             costs[forward_location] = forward_cost if forward_cost < best_cost
 
             possible_keys_for_type_and_location(type_name, forward_location).each do |possible_key|
-              paths << [*path, { location: forward_location, selection: possible_key, cost: forward_cost }]
+              paths << [*path, { location: forward_location, key: possible_key, cost: forward_cost }]
             end
           end
 
           paths.sort! do |a, b|
             cost_diff = a.last[:cost] - b.last[:cost]
-            next cost_diff unless cost_diff.zero?
-            a.length - b.length
+            cost_diff.zero? ? a.length - b.length : cost_diff
           end.reverse!
         end
 

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "0.3.4"
+    VERSION = "1.0.0"
   end
 end

data/lib/graphql/stitching.rb

@@ -5,6 +5,7 @@ require "graphql"
 module GraphQL
   module Stitching
     EMPTY_OBJECT = {}.freeze
+    EMPTY_ARRAY = [].freeze
 
     class StitchingError < StandardError; end
 
@@ -23,13 +24,13 @@ module GraphQL
   end
 end
 
-require_relative "stitching/gateway"
 require_relative "stitching/supergraph"
+require_relative "stitching/client"
 require_relative "stitching/composer"
 require_relative "stitching/executor"
+require_relative "stitching/http_executable"
 require_relative "stitching/planner_operation"
 require_relative "stitching/planner"
-require_relative "stitching/remote_client"
 require_relative "stitching/request"
 require_relative "stitching/shaper"
 require_relative "stitching/util"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-27 00:00:00.000000000 Z
+date: 2023-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -80,9 +80,9 @@ files:
 - README.md
 - Rakefile
 - docs/README.md
+- docs/client.md
 - docs/composer.md
 - docs/executor.md
-- docs/gateway.md
 - docs/images/library.png
 - docs/images/merging.png
 - docs/images/stitching.png
@@ -97,15 +97,17 @@ files:
 - gemfiles/graphql_1.13.9.gemfile
 - graphql-stitching.gemspec
 - lib/graphql/stitching.rb
+- lib/graphql/stitching/client.rb
 - lib/graphql/stitching/composer.rb
 - lib/graphql/stitching/composer/base_validator.rb
 - lib/graphql/stitching/composer/validate_boundaries.rb
 - lib/graphql/stitching/composer/validate_interfaces.rb
 - lib/graphql/stitching/executor.rb
-- lib/graphql/stitching/gateway.rb
+- lib/graphql/stitching/executor/boundary_source.rb
+- lib/graphql/stitching/executor/root_source.rb
+- lib/graphql/stitching/http_executable.rb
 - lib/graphql/stitching/planner.rb
 - lib/graphql/stitching/planner_operation.rb
-- lib/graphql/stitching/remote_client.rb
 - lib/graphql/stitching/request.rb
 - lib/graphql/stitching/shaper.rb
 - lib/graphql/stitching/supergraph.rb

data/docs/gateway.md

@@ -1,103 +0,0 @@
-## GraphQL::Stitching::Gateway
-
-The `Gateway` is an out-of-the-box convenience with all stitching components assembled into a default workflow. A gateway is designed to work for most common needs, though you're welcome to assemble the component parts into your own configuration. A Gateway is constructed with the same [location settings](./composer.md#performing-composition) used to perform supergraph composition:
-
-```ruby
-movies_schema = "type Query { ..."
-showtimes_schema = "type Query { ..."
-
-gateway = GraphQL::Stitching::Gateway.new(locations: {
-  products: {
-    schema: GraphQL::Schema.from_definition(movies_schema),
-    executable: GraphQL::Stitching::RemoteClient.new(url: "http://localhost:3000"),
-    stitch: [{ field_name: "products", key: "id" }],
-  },
-  showtimes: {
-    schema: GraphQL::Schema.from_definition(showtimes_schema),
-    executable: GraphQL::Stitching::RemoteClient.new(url: "http://localhost:3001"),
-  },
-  my_local: {
-    schema: MyLocal::GraphQL::Schema,
-  },
-})
-```
-
-Alternatively, you may pass a prebuilt `Supergraph` instance to the Gateway constructor. This is useful when [exporting and rehydrating](./supergraph.md#export-and-caching) supergraph instances, which bypasses the need for runtime composition:
-
-```ruby
-exported_schema = "type Query { ..."
-exported_mapping = JSON.parse("{ ... }")
-supergraph = GraphQL::Stitching::Supergraph.from_export(
-  schema: exported_schema,
-  delegation_map: exported_mapping,
-  executables: { ... },
-)
-
-gateway = GraphQL::Stitching::Gateway.new(supergraph: supergraph)
-```
-
-### Execution
-
-A gateway provides an `execute` method with a subset of arguments provided by [`GraphQL::Schema.execute`](https://graphql-ruby.org/queries/executing_queries). Executing requests on a stitched gateway becomes mostly a drop-in replacement to executing on a `GraphQL::Schema` instance:
-
-```ruby
-result = gateway.execute(
-  query: "query MyProduct($id: ID!) { product(id: $id) { name } }",
-  variables: { "id" => "1" },
-  operation_name: "MyProduct",
-)
-```
-
-Arguments for the `execute` method include:
-
-* `query`: a query (or mutation) as a string or parsed AST.
-* `variables`: a hash of variables for the request.
-* `operation_name`: the name of the operation to execute (when multiple are provided).
-* `validate`: true if static validation should run on the supergraph schema before execution.
-* `context`: an object passed through to executable calls and gateway hooks.
-
-### Cache hooks
-
-The gateway provides cache hooks to enable caching query plans across requests. Without caching, every request made the the gateway will be planned individually. With caching, a query may be planned once, cached, and then executed from cache for subsequent requests. Cache keys are a normalized digest of each query string.
-
-```ruby
-gateway.on_cache_read do |key, _context|
-  $redis.get(key) # << 3P code
-end
-
-gateway.on_cache_write do |key, payload, _context|
-  $redis.set(key, payload) # << 3P code
-end
-```
-
-Note that inlined input data works against caching, so you should _avoid_ this:
-
-```graphql
-query {
-  product(id: "1") { name }
-}
-```
-
-Instead, always leverage variables in queries so that the document body remains consistent across requests:
-
-```graphql
-query($id: ID!) {
-  product(id: $id) { name }
-}
-
-# variables: { "id" => "1" }
-```
-
-### Error hooks
-
-The gateway also provides an error hook. Any program errors rescued during execution will be passed to the `on_error` handler, which can report on the error as needed and return a formatted error message for the gateway to add to the [GraphQL errors](https://spec.graphql.org/June2018/#sec-Errors) result.
-
-```ruby
-gateway.on_error do |err, context|
-  # log the error
-  Bugsnag.notify(err)
-
-  # return a formatted message for the public response
-  "Whoops, please contact support abount request '#{context[:request_id]}'"
-end
-```