graphql-stitching 1.0.6 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbeabcd8c2327504cc5ccc613942d163bddddb2087e7eb90c966861777d67b9d
-  data.tar.gz: cf03589e91ef96fb8dc9b74ca2703c20095e586bab45f91a89b3579376edbdac
+  metadata.gz: 9cdcb3361e391ba9b6dd78aa38c308c08ddb6fde2720d15208e8dfb96c3006ea
+  data.tar.gz: 9f64b024bda3987d1c523cf52b49f0ca2dfd688ac4c89bbf18de30c88c098156
 SHA512:
-  metadata.gz: 78b5d6bbf4abccb99795c6225e1a61807ed74f94ad9ce5bdde0be534133e101c7d51f677d3c89aebaad7ebe2b125ff11a192a3d1a29cdacb3d3b51049801212f
-  data.tar.gz: ade024c4ace1474d9c7a7cd80fb8820fc71e456e566d89fe656d07bf4b64e60db83561546a908b5d2fcbec9d88ac740a7080946e981a74f7bd904b3da0aeebfb
+  metadata.gz: b51bcfeaa20e9cdea6c2d4b4e472e8c23e13ec8af36e1b23852603d0329045af064e3ae738467a0823be0c9f545105acba001b708c207eb7f08d51ebf0791e1f
+  data.tar.gz: c529e74c88fc7193d7823d8c92a488b3e459b5ba9f88e8d62355ae2bd5e9eb0ed2b0d6f7fd14b6b8ed13ab1bb53a93bc5da49dcecd5deb92ee180fa70604c80b

data/.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
             ruby: 3.2
           - gemfile: Gemfile
             ruby: 3.1
-          - gemfile: gemfiles/graphql_1.13.gemfile
+          - gemfile: gemfiles/graphql_1.13.9.gemfile
             ruby: 3.1
           - gemfile: Gemfile
             ruby: 2.7
@@ -30,6 +30,6 @@ jobs:
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically
     - name: Run tests
       run: |
-        gem install bundler
+        gem install bundler -v 2.4.22
         bundle install --jobs 4 --retry 3
         bundle exec rake test

data/README.md

@@ -113,12 +113,12 @@ products_schema = <<~GRAPHQL
   }
 GRAPHQL
 
-shipping_schema = <<~GRAPHQL
+catalog_schema = <<~GRAPHQL
   directive @stitch(key: String!) repeatable on FIELD_DEFINITION
 
   type Product {
     id: ID!
-    weight: Float!
+    price: Float!
   }
 
   type Query {
@@ -131,7 +131,7 @@ client = GraphQL::Stitching::Client.new(locations: {
     schema: GraphQL::Schema.from_definition(products_schema),
     executable:  GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3001"),
   },
-  shipping: {
+  catalog: {
     schema: GraphQL::Schema.from_definition(shipping_schema),
     executable:  GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3002"),
   },
@@ -151,9 +151,9 @@ type Query {
 ```
 
 * The `@stitch` directive is applied to a root query where the merged type may be accessed. The merged type identity is inferred from the field return.
-* The `key: "id"` parameter indicates that an `{ id }` must be selected from prior locations so it may be submitted as an argument to this query. The query argument used to send the key is inferred when possible (more on arguments later).
+* The `key: "id"` parameter indicates that an `{ id }` must be selected from prior locations so it may be submitted as an argument to this query. The query argument used to send the key is inferred when possible ([more on arguments](#multiple-query-arguments) later).
 
-Each location that provides a unique variant of a type must provide one stitching query per key. The exception to this requirement are types that contain only a single key field:
+Each location that provides a unique variant of a type must provide at least one stitching query. The exception to this requirement are types that contain only a single key field:
 
 ```graphql
 type Product {
@@ -165,7 +165,7 @@ The above representation of a `Product` type provides no unique data beyond a ke
 
 #### List queries
 
-It's okay ([even preferable](https://www.youtube.com/watch?v=VmK0KBHTcWs) in many circumstances) to provide a list accessor as a stitching query. The only requirement is that both the field argument and return type must be lists, and the query results are expected to be a mapped set with `null` holding the position of missing results.
+It's okay ([even preferable](#batching) in most circumstances) to provide a list accessor as a stitching query. The only requirement is that both the field argument and return type must be lists, and the query results are expected to be a mapped set with `null` holding the position of missing results.
 
 ```graphql
 type Query {
@@ -228,7 +228,7 @@ type Query {
 }
 ```
 
-The `@stitch` directive is also repeatable (_requires graphql-ruby >= v2.0.15_), allowing a single query to associate with multiple keys:
+The `@stitch` directive is also repeatable, allowing a single query to associate with multiple keys:
 
 ```graphql
 type Product {
@@ -311,16 +311,15 @@ The [Apollo Federation specification](https://www.apollographql.com/docs/federat
 The composer will automatcially detect and stitch schemas with an `_entities` query, for example:
 
 ```ruby
-accounts_schema = <<~GRAPHQL
+products_schema = <<~GRAPHQL
   directive @key(fields: String!) repeatable on OBJECT
 
-  type User @key(fields: "id") {
+  type Product @key(fields: "id") {
     id: ID!
     name: String!
-    address: String!
   }
 
-  union _Entity = User
+  union _Entity = Product
   scalar _Any
 
   type Query {
@@ -329,15 +328,15 @@ accounts_schema = <<~GRAPHQL
   }
 GRAPHQL
 
-comments_schema = <<~GRAPHQL
+catalog_schema = <<~GRAPHQL
   directive @key(fields: String!) repeatable on OBJECT
 
-  type User @key(fields: "id") {
+  type Product @key(fields: "id") {
     id: ID!
-    comments: [String!]!
+    price: Float!
   }
 
-  union _Entity = User
+  union _Entity = Product
   scalar _Any
 
   type Query {
@@ -346,12 +345,12 @@ comments_schema = <<~GRAPHQL
 GRAPHQL
 
 client = GraphQL::Stitching::Client.new(locations: {
-  accounts: {
-    schema: GraphQL::Schema.from_definition(accounts_schema),
+  products: {
+    schema: GraphQL::Schema.from_definition(products_schema),
     executable: ...,
   },
-  comments: {
-    schema: GraphQL::Schema.from_definition(comments_schema),
+  catalog: {
+    schema: GraphQL::Schema.from_definition(catalog_schema),
     executable: ...,
   },
 })
@@ -426,6 +425,7 @@ The [Executor](./docs/executor.md) component builds atop the Ruby fiber-based im
 
 ## Additional topics
 
+- [Deploying a stitched schema](./docs/mechanics.md#deploying-a-stitched-schema)
 - [Field selection routing](./docs/mechanics.md#field-selection-routing)
 - [Root selection routing](./docs/mechanics.md#root-selection-routing)
 - [Stitched errors](./docs/mechanics.md#stitched-errors)

data/docs/client.md

@@ -25,11 +25,9 @@ client = GraphQL::Stitching::Client.new(locations: {
 Alternatively, you may pass a prebuilt `Supergraph` instance to the `Client` 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,
+supergraph_sdl = File.read("precomposed_schema.graphql")
+supergraph = GraphQL::Stitching::Supergraph.from_definition(
+  supergraph_sdl,
   executables: { ... },
 )
 
@@ -61,16 +59,16 @@ Arguments for the `execute` method include:
 The client provides cache hooks to enable caching query plans across requests. Without caching, every request made to the client 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
-client.on_cache_read do |key, _context, _request|
-  $redis.get(key) # << 3P code
+client.on_cache_read do |request|
+  $redis.get(request.digest) # << 3P code
 end
 
-client.on_cache_write do |key, payload, _context, _request|
-  $redis.set(key, payload) # << 3P code
+client.on_cache_write do |request, payload|
+  $redis.set(request.digest, payload) # << 3P code
 end
 ```
 
-Note that inlined input data works against caching, so you should _avoid_ this when possible:
+Note that inlined input data works against caching, so you should _avoid_ these input literals when possible:
 
 ```graphql
 query {
@@ -93,11 +91,11 @@ query($id: ID!) {
 The client 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 client to add to the [GraphQL errors](https://spec.graphql.org/June2018/#sec-Errors) result.
 
 ```ruby
-client.on_error do |err, context|
+client.on_error do |request, err|
   # log the error
   Bugsnag.notify(err)
 
   # return a formatted message for the public response
-  "Whoops, please contact support abount request '#{context[:request_id]}'"
+  "Whoops, please contact support abount request '#{request.context[:request_id]}'"
 end
 ```

data/docs/executor.md

@@ -16,6 +16,7 @@ request = GraphQL::Stitching::Request.new(
   query,
   variables: { "id" => "123" },
   operation_name: "MyQuery",
+  context: { ... },
 )
 
 plan = GraphQL::Stitching::Planner.new(
@@ -26,7 +27,7 @@ plan = GraphQL::Stitching::Planner.new(
 result = GraphQL::Stitching::Executor.new(
   supergraph: supergraph,
   request: request,
-  plan: plan.to_h,
+  plan: plan,
 ).perform
 ```
 
@@ -39,7 +40,7 @@ By default, execution results are always returned with document shaping (stitchi
 raw_result = GraphQL::Stitching::Executor.new(
   supergraph: supergraph,
   request: request,
-  plan: plan.to_h,
+  plan: plan,
 ).perform(raw: true)
 ```
 

data/docs/mechanics.md

@@ -1,5 +1,59 @@
 ## Schema Stitching, mechanics
 
+### Deploying a stitched schema
+
+Among the simplest and most effective ways to manage a stitched schema is to compose it locally, write the composed SDL as a `.graphql` file in your repo, and then load the composed schema into a stitching client at runtime. For example, setup a `rake` task that loads/fetches subgraph schemas, composes them, and then writes the composed schema definition as a file committed to the repo:
+
+```ruby
+task :compose_graphql do
+  schema1_sdl = ... # load schema 1
+  schema2_sdl = ... # load schema 2
+
+  supergraph = GraphQL::Stitching::Composer.new.perform({
+    schema1: {
+      schema: GraphQL::Schema.from_definition(schema1_sdl)
+    },
+    schema2: {
+      schema: GraphQL::Schema.from_definition(schema2_sdl)
+    }
+  })
+
+  File.write("schema/supergraph.graphql", supergraph.to_definition)
+  puts "Schema composition was successful."
+end
+
+# bundle exec rake compose-graphql
+```
+
+Then at runtime, load the composed schema into a stitching client:
+
+```ruby
+class GraphQlController
+  class < self
+    def client
+      @client ||= begin
+        supergraph_sdl = File.read("schema/supergraph.graphql")
+        supergraph = GraphQL::Stitching::Supergraph.from_definition(supergraph_sdl, executables: {
+          schema1: GraphQL::Stitching::HttpExecutable.new("http://localhost:3001/graphql"),
+          schema2: GraphQL::Stitching::HttpExecutable.new("http://localhost:3002/graphql"),
+        })
+        GraphQL::Stitching::Client.new(supergraph: supergraph)
+      end
+    end
+  end
+
+  def exec
+    self.class.client.execute(
+      params[:query],
+      variables: params[:variables],
+      operation_name: params[:operation_name]
+    )
+  end 
+end
+```
+
+This process assures that composition always happens before deployment where failures can be detected. Hot reloading of the supergraph can also be accommodated by uploading the composed schema to a sync location (cloud storage, etc) that is polled by the application runtime. When the schema changes, load it into a new stitching client and swap that into the application.
+
 ### Field selection routing
 
 Fields of a merged type may exist in multiple locations. For example, the `title` field below is provided by both locations:

data/docs/planner.md

@@ -32,15 +32,15 @@ Plans are designed to be cacheable. This is very useful for redundant GraphQL do
 cached_plan = $redis.get(request.digest)
 
 plan = if cached_plan
-  JSON.parse(cached_plan)
+  GraphQL::Stitching::Plan.from_json(JSON.parse(cached_plan))
 else
-  plan_hash = GraphQL::Stitching::Planner.new(
+  plan = GraphQL::Stitching::Planner.new(
     supergraph: supergraph,
     request: request,
-  ).perform.to_h
+  ).perform
 
-  $redis.set(request.digest, JSON.generate(plan_hash))
-  plan_hash
+  $redis.set(request.digest, JSON.generate(plan.as_json))
+  plan
 end
 
 # execute the plan...

data/docs/request.md

@@ -3,18 +3,27 @@
 A `Request` contains a parsed GraphQL document and variables, and handles the logistics of extracting the appropriate operation, variable definitions, and fragments. A `Request` should be built once per server request and passed through to other stitching components that utilize request information.
 
 ```ruby
-document = "query FetchMovie($id: ID!) { movie(id:$id) { id genre } }"
-request = GraphQL::Stitching::Request.new(document, variables: { "id" => "1" }, operation_name: "FetchMovie")
-
-request.document # parsed AST via GraphQL.parse
-request.variables # user-submitted variables
-request.string # normalized printed document string
-request.digest # SHA digest of the normalized document string
-
-request.variable_definitions # a mapping of variable names to their type definitions
-request.fragment_definitions # a mapping of fragment names to their fragment definitions
+source = "query FetchMovie($id: ID!) { movie(id:$id) { id genre } }"
+request = GraphQL::Stitching::Request.new(
+  source,
+  variables: { "id" => "1" },
+  operation_name: "FetchMovie",
+  context: { ... },
+)
 ```
 
+A `Request` provides the following information:
+
+- `req.document`: parsed AST of the GraphQL source
+- `req.variables`: a hash of user-submitted variables
+- `req.string`: the original GraphQL source string, or printed document
+- `req.digest`: a SHA2 of the request string
+- `req.normalized_string`: printed document string with consistent whitespace
+- `req.normalized_digest`: a SHA2 of the normalized string
+- `req.operation`: the operation definition selected for the request
+- `req.variable_definitions`: a mapping of variable names to their type definitions
+- `req.fragment_definitions`: a mapping of fragment names to their fragment definitions
+
 ### Preparing requests
 
 A request should be prepared for stitching using the `prepare!` method _after_ validations have been run:

data/docs/supergraph.md

@@ -4,29 +4,25 @@ A `Supergraph` is the singuar representation of a stitched graph. `Supergraph` i
 
 ### Export and caching
 
-A Supergraph is designed to be composed, cached, and restored. Calling the `export` method will return an SDL (Schema Definition Language) print of the combined graph schema and a delegation mapping hash. These can be persisted in any raw format that suits your stack:
+A Supergraph is designed to be composed, cached, and restored. Calling `to_definition` will return an SDL (Schema Definition Language) print of the combined graph schema with delegation mapping directives. This pre-composed schema can be persisted in any raw format that suits your stack:
 
 ```ruby
-supergraph_sdl, delegation_map = supergraph.export
+supergraph_sdl = supergraph.to_definition
 
-# stash these resources in Redis...
+# stash this composed schema in a cache...
 $redis.set("cached_supergraph_sdl", supergraph_sdl)
-$redis.set("cached_delegation_map", JSON.generate(delegation_map))
 
-# or, write the resources as files and commit them to your repo...
+# or, write the composed schema as a file into your repo...
 File.write("supergraph/schema.graphql", supergraph_sdl)
-File.write("supergraph/delegation_map.json", JSON.generate(delegation_map))
 ```
 
-To restore a Supergraph, call `from_export` proving the cached SDL string, the parsed JSON delegation mapping, and a hash of executables keyed by their location names:
+To restore a Supergraph, call `from_definition` providing the cached SDL string and a hash of executables keyed by their location names:
 
 ```ruby
 supergraph_sdl = $redis.get("cached_supergraph_sdl")
-delegation_map = JSON.parse($redis.get("cached_delegation_map"))
 
-supergraph = GraphQL::Stitching::Supergraph.from_export(
-  schema: supergraph_sdl,
-  delegation_map: delegation_map,
+supergraph = GraphQL::Stitching::Supergraph.from_definition(
+  supergraph_sdl,
   executables: {
     my_remote: GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3000"),
     my_local: MyLocalSchema,

data/lib/graphql/stitching/client.rb

@@ -20,6 +20,10 @@ module GraphQL
           composer ||= GraphQL::Stitching::Composer.new
           composer.perform(locations)
         end
+
+        @on_cache_read = nil
+        @on_cache_write = nil
+        @on_error = nil
       end
 
       def execute(query:, variables: nil, operation_name: nil, context: nil, validate: true)
@@ -52,7 +56,7 @@ module GraphQL
       rescue GraphQL::ParseError, GraphQL::ExecutionError => e
         error_result([e])
       rescue StandardError => e
-        custom_message = @on_error.call(e, request.context) if @on_error
+        custom_message = @on_error.call(request, e) if @on_error
         error_result([{ "message" => custom_message || "An unexpected error occured." }])
       end
 
@@ -75,14 +79,14 @@ module GraphQL
 
       def fetch_plan(request)
         if @on_cache_read
-          cached_plan = @on_cache_read.call(request.digest, request.context, request)
+          cached_plan = @on_cache_read.call(request)
           return GraphQL::Stitching::Plan.from_json(JSON.parse(cached_plan)) if cached_plan
         end
 
         plan = yield
 
         if @on_cache_write
-          @on_cache_write.call(request.digest, JSON.generate(plan.as_json), request.context, request)
+          @on_cache_write.call(request, JSON.generate(plan.as_json))
         end
 
         plan

data/lib/graphql/stitching/composer.rb

@@ -39,6 +39,12 @@ module GraphQL
         @directive_kwarg_merger = directive_kwarg_merger || BASIC_VALUE_MERGER
         @root_field_location_selector = root_field_location_selector || BASIC_ROOT_FIELD_LOCATION_SELECTOR
         @stitch_directives = {}
+
+        @field_map = nil
+        @boundary_map = nil
+        @mapped_type_names = nil
+        @candidate_directives_by_name_and_location = nil
+        @schema_directives = nil
       end
 
       def perform(locations_input)
@@ -541,7 +547,7 @@ module GraphQL
                 field: field_candidate.name,
                 arg: argument_name,
                 list: boundary_structure.first.list?,
-                federation: kwargs[:federation],
+                federation: kwargs[:federation] || false,
               )
             end
           end

data/lib/graphql/stitching/export_selection.rb

@@ -8,6 +8,8 @@ module GraphQL
       EXPORT_PREFIX = "_export_"
 
       class << self
+        @typename_node = nil
+
         def key?(name)
           return false unless name
 
@@ -19,7 +21,11 @@ module GraphQL
         end
 
         def key_node(field_name)
-          GraphQL::Language::Nodes::Field.new(alias: key(field_name), name: field_name)
+          if Util.graphql_version?(2, 2)
+            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)
+          end
         end
 
         def typename_node

data/lib/graphql/stitching/planner.rb

@@ -3,7 +3,7 @@
 module GraphQL
   module Stitching
     class Planner
-      SUPERGRAPH_LOCATIONS = [Supergraph::LOCATION].freeze
+      SUPERGRAPH_LOCATIONS = [Supergraph::SUPERGRAPH_LOCATION].freeze
       TYPENAME = "__typename"
       QUERY_OP = "query"
       MUTATION_OP = "mutation"

data/lib/graphql/stitching/request.rb

@@ -9,6 +9,15 @@ module GraphQL
       attr_reader :document, :variables, :operation_name, :context
 
       def initialize(document, operation_name: nil, variables: nil, context: nil)
+        @string = nil
+        @digest = nil
+        @normalized_string = nil
+        @normalized_digest = nil
+        @operation = nil
+        @operation_directives = nil
+        @variable_definitions = nil
+        @fragment_definitions = nil
+
         @document = if document.is_a?(String)
           @string = document
           GraphQL.parse(document)

data/lib/graphql/stitching/shaper.rb

@@ -9,6 +9,7 @@ module GraphQL
       def initialize(supergraph:, request:)
         @supergraph = supergraph
         @request = request
+        @root_type = nil
       end
 
       def perform!(raw)

data/lib/graphql/stitching/supergraph.rb

@@ -3,34 +3,89 @@
 module GraphQL
   module Stitching
     class Supergraph
-      LOCATION = "__super"
+      SUPERGRAPH_LOCATION = "__super"
+
+      class ResolverDirective < GraphQL::Schema::Directive
+        graphql_name "resolver"
+        locations OBJECT, INTERFACE, UNION
+        argument :location, String, required: true
+        argument :key, String, required: true
+        argument :field, String, required: true
+        argument :arg, String, required: true
+        argument :list, Boolean, required: false
+        argument :federation, Boolean, required: false
+        repeatable true
+      end
 
-      def self.validate_executable!(location, executable)
-        return true if executable.is_a?(Class) && executable <= GraphQL::Schema
-        return true if executable && executable.respond_to?(:call)
-        raise StitchingError, "Invalid executable provided for location `#{location}`."
+      class SourceDirective < GraphQL::Schema::Directive
+        graphql_name "source"
+        locations FIELD_DEFINITION
+        argument :location, String, required: true
+        repeatable true
       end
 
-      def self.from_export(schema:, delegation_map:, executables:)
-        schema = GraphQL::Schema.from_definition(schema) if schema.is_a?(String)
+      class << self
+        def validate_executable!(location, executable)
+          return true if executable.is_a?(Class) && executable <= GraphQL::Schema
+          return true if executable && executable.respond_to?(:call)
+          raise StitchingError, "Invalid executable provided for location `#{location}`."
+        end
+
+        def from_definition(schema, executables:)
+          schema = GraphQL::Schema.from_definition(schema) if schema.is_a?(String)
+          field_map = {}
+          boundary_map = {}
+          possible_locations = {}
+          introspection_types = schema.introspection_system.types.keys
+
+          schema.types.each do |type_name, type|
+            next if introspection_types.include?(type_name)
+
+            type.directives.each do |directive|
+              next unless directive.graphql_name == ResolverDirective.graphql_name
+
+              kwargs = directive.arguments.keyword_arguments
+              boundary_map[type_name] ||= []
+              boundary_map[type_name] << Boundary.new(
+                type_name: type_name,
+                location: kwargs[:location],
+                key: kwargs[:key],
+                field: kwargs[:field],
+                arg: kwargs[:arg],
+                list: kwargs[:list] || false,
+                federation: kwargs[:federation] || false,
+              )
+            end
+
+            next unless type.kind.fields?
 
-        executables = delegation_map["locations"].each_with_object({}) do |location, memo|
-          executable = executables[location] || executables[location.to_sym]
-          if validate_executable!(location, executable)
-            memo[location] = executable
+            type.fields.each do |field_name, field|
+              field.directives.each do |d|
+                next unless d.graphql_name == SourceDirective.graphql_name
+
+                location = d.arguments.keyword_arguments[:location]
+                field_map[type_name] ||= {}
+                field_map[type_name][field_name] ||= []
+                field_map[type_name][field_name] << location
+                possible_locations[location] = true
+              end
+            end
           end
-        end
 
-        boundaries = delegation_map["boundaries"].map do |k, b|
-          [k, b.map { Boundary.new(**_1) }]
-        end
+          executables = possible_locations.keys.each_with_object({}) do |location, memo|
+            executable = executables[location] || executables[location.to_sym]
+            if validate_executable!(location, executable)
+              memo[location] = executable
+            end
+          end
 
-        new(
-          schema: schema,
-          fields: delegation_map["fields"],
-          boundaries: boundaries.to_h,
-          executables: executables,
-        )
+          new(
+            schema: schema,
+            fields: field_map,
+            boundaries: boundary_map,
+            executables: executables,
+          )
+        end
       end
 
       attr_reader :schema, :boundaries, :locations_by_type_and_field, :executables
@@ -42,38 +97,87 @@ module GraphQL
         @possible_keys_by_type_and_location = {}
         @memoized_schema_possible_types = {}
         @memoized_schema_fields = {}
+        @memoized_introspection_types = nil
+        @memoized_schema_types = nil
+        @fields_by_type_and_location = nil
+        @locations_by_type = nil
 
         # add introspection types into the fields mapping
         @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] = type.fields.keys.each_with_object({}) do |field_name, m|
-            m[field_name] = [LOCATION]
+            m[field_name] = [SUPERGRAPH_LOCATION]
           end
         end.freeze
 
         # validate and normalize executable references
-        @executables = executables.each_with_object({ LOCATION => @schema }) do |(location, executable), memo|
+        @executables = executables.each_with_object({ SUPERGRAPH_LOCATION => @schema }) do |(location, executable), memo|
           if self.class.validate_executable!(location, executable)
             memo[location.to_s] = executable
           end
         end.freeze
       end
 
+      def to_definition
+        if @schema.directives[ResolverDirective.graphql_name].nil?
+          @schema.directive(ResolverDirective)
+        end
+        if @schema.directives[SourceDirective.graphql_name].nil?
+          @schema.directive(SourceDirective)
+        end
+
+        @schema.types.each do |type_name, type|
+          if boundaries_for_type = @boundaries.dig(type_name)
+            boundaries_for_type.each do |boundary|
+              existing = type.directives.find do |d|
+                kwargs = d.arguments.keyword_arguments
+                d.graphql_name == ResolverDirective.graphql_name &&
+                  kwargs[:location] == boundary.location &&
+                  kwargs[:key] == boundary.key &&
+                  kwargs[:field] == boundary.field &&
+                  kwargs[:arg] == boundary.arg &&
+                  kwargs.fetch(:list, false) == boundary.list &&
+                  kwargs.fetch(:federation, false) == boundary.federation
+              end
+
+              type.directive(ResolverDirective, **{
+                location: boundary.location,
+                key: boundary.key,
+                field: boundary.field,
+                arg: boundary.arg,
+                list: boundary.list || nil,
+                federation: boundary.federation || nil,
+              }.tap(&:compact!)) if existing.nil?
+            end
+          end
+
+          next unless type.kind.fields?
+
+          type.fields.each do |field_name, field|
+            locations_for_field = @locations_by_type_and_field.dig(type_name, field_name)
+            next if locations_for_field.nil?
+
+            locations_for_field.each do |location|
+              existing = field.directives.find do |d|
+                d.graphql_name == SourceDirective.graphql_name &&
+                  d.arguments.keyword_arguments[:location] == location
+              end
+
+              field.directive(SourceDirective, location: location) if existing.nil?
+            end
+          end
+        end
+
+        @schema.to_definition
+      end
+
       def fields
         @locations_by_type_and_field.reject { |k, _v| memoized_introspection_types[k] }
       end
 
       def locations
-        @executables.keys.reject { _1 == LOCATION }
-      end
-
-      def export
-        return GraphQL::Schema::Printer.print_schema(@schema), {
-          "locations" => locations,
-          "fields" => fields,
-          "boundaries" => @boundaries.map { |k, b| [k, b.map(&:as_json)] }.to_h,
-        }
+        @executables.keys.reject { _1 == SUPERGRAPH_LOCATION }
       end
 
       def memoized_introspection_types

data/lib/graphql/stitching/util.rb

@@ -12,7 +12,16 @@ module GraphQL
         end
       end
 
+      GRAPHQL_VERSION = GraphQL::VERSION.split(".").map(&:to_i).freeze
+
       class << self
+        def graphql_version?(major, minor = nil, patch = nil)
+          result = GRAPHQL_VERSION[0] >= major
+          result &&= GRAPHQL_VERSION[1] >= minor if minor
+          result &&= GRAPHQL_VERSION[2] >= patch if patch
+          result
+        end
+
         # specifies if a type is a primitive leaf value
         def is_leaf_type?(type)
           type.kind.scalar? || type.kind.enum?

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "1.0.6"
+    VERSION = "1.1.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.1.1
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-29 00:00:00.000000000 Z
+date: 2023-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql