graphql-stitching 1.6.0 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 227a7813eed1050c451d9bbee900305cfbac67aff35baa88f6ba9551535d1e97
-  data.tar.gz: 1533e6109c6a72af3f7d07891714c09a73476ca0a5a7ea53d83cbe829564ace3
+  metadata.gz: b6b2cc734796d7455701bcc5b376a8efb49534c43b7a75de53bc1f2e686bf54c
+  data.tar.gz: 449c09b94257de6ae720b4b7938c13b8881da9f1f8dc7684aabdc4c493b2c6d2
 SHA512:
-  metadata.gz: 8342158a10bc25fb68c833a3366c2fd6e831cf86cccf15a2491067680bb5299700783af57fd5042b394131b48759f077d32f4b210149a2b3cb34e43e3cca77ff
-  data.tar.gz: 7313c93bb8cedf7ac06708a1f7fba6a2c46196982380a28a6d9244cf7320ad0149cb17df8ecb1abe438e14eac08b2f71e154dd9f2d6c3095be8e849c46061e16
+  metadata.gz: 94345a14cc9bcee462854188b543a170b3dbd65cc948e55773e1a07357f47026f41018ea35eedbacc8647d8a92634be1f143d86543f0ea092f48ddb1281a86f5
+  data.tar.gz: ae7cb67b6f36ca209f327d43bd293fa6afc4e6a93e8e91e83f4acf2893b744831836959402cd236e789ade5602857bb39d484025ea58c7e16d19b9ec5eb69d67

data/.github/workflows/ci.yml

@@ -14,6 +14,8 @@ jobs:
         include:
           - gemfile: Gemfile
             ruby: 3.3
+          - gemfile: gemfiles/graphql_2.4.0.gemfile
+            ruby: 3.2
           - gemfile: gemfiles/graphql_2.3.0.gemfile
             ruby: 3.2
           - gemfile: gemfiles/graphql_2.2.0.gemfile

data/README.md

@@ -74,7 +74,7 @@ result = client.execute(
 
 Schemas provided in [location settings](./docs/composer.md#performing-composition) may be class-based schemas with local resolvers (locally-executable schemas), or schemas built from SDL strings (schema definition language parsed using `GraphQL::Schema.from_definition`) and mapped to remote locations via [executables](#executables).
 
-While `Client` is sufficient for most usecases, the library offers several discrete components that can be assembled into tailored workflows:
+A Client bundles up the component parts of stitching, which are worth familiarizing with:
 
 - [Composer](./docs/composer.md) - merges and validates many schemas into one supergraph.
 - [Supergraph](./docs/supergraph.md) - manages the combined schema, location routing maps, and executable resources. Can be exported, cached, and rehydrated.
@@ -87,7 +87,7 @@ While `Client` is sufficient for most usecases, the library offers several discr
 
 ![Merging types](./docs/images/merging.png)
 
-To facilitate this, schemas should be designed around [merged type keys](#merged-type-keys) that stitching can cross-reference and fetch across locations using [type resolver queries](#merged-type-resolver-queries). For those in an Apollo ecosystem, there's also _limited_ support for merging types though a [federation `_entities` protocol](./docs/federation_entities.md).
+To facilitate this, schemas should be designed around **merged type keys** that stitching can cross-reference and fetch across locations using **type resolver queries** (discussed below). For those in an Apollo ecosystem, there's also _limited_ support for merging types though [federation `_entities`](./docs/federation_entities.md).
 
 ### Merged type keys
 

data/gemfiles/graphql_2.4.0.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'graphql', '~> 2.4.0'
+gem 'warning'
+gem 'minitest-stub-const'
+
+gemspec path: "../"

data/lib/graphql/stitching/{supergraph/resolver_directive.rb → composer/supergraph_directives.rb}

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
 module GraphQL::Stitching
-  class Supergraph
+  class Composer
+    class KeyDirective < GraphQL::Schema::Directive
+      graphql_name "key"
+      locations OBJECT, INTERFACE, UNION
+      argument :key, String, required: true
+      argument :location, String, required: true
+      repeatable true
+    end
+
     class ResolverDirective < GraphQL::Schema::Directive
       graphql_name "resolver"
       locations OBJECT, INTERFACE, UNION
@@ -14,5 +22,12 @@ module GraphQL::Stitching
       argument :type_name, String, required: false
       repeatable true
     end
+    
+    class SourceDirective < GraphQL::Schema::Directive
+      graphql_name "source"
+      locations FIELD_DEFINITION
+      argument :location, String, required: true
+      repeatable true
+    end
   end
 end

data/lib/graphql/stitching/composer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "composer/base_validator"
+require_relative "composer/supergraph_directives"
 require_relative "composer/validate_interfaces"
 require_relative "composer/validate_type_resolvers"
 require_relative "composer/type_resolver_config"
@@ -13,13 +14,11 @@ module GraphQL
     class Composer
       # @api private
       NO_DEFAULT_VALUE = begin
-        class T < GraphQL::Schema::Object
-          field(:f, String) do
-            argument(:a, String)
-          end
+        t = Class.new(GraphQL::Schema::Object) do
+          field(:f, String) { _1.argument(:a, String) }
         end
 
-        T.get_field("f").get_argument("a").default_value
+        t.get_field("f").get_argument("a").default_value
       end
 
       # @api private
@@ -84,9 +83,16 @@ module GraphQL
 
         schemas, executables = prepare_locations_input(locations_input)
 
+        directives_to_omit = [
+          GraphQL::Stitching.stitch_directive,
+          KeyDirective.graphql_name,
+          ResolverDirective.graphql_name,
+          SourceDirective.graphql_name,
+        ]
+
         # "directive_name" => "location" => subgraph_directive
         @subgraph_directives_by_name_and_location = schemas.each_with_object({}) do |(location, schema), memo|
-          (schema.directives.keys - schema.default_directives.keys - GraphQL::Stitching.stitching_directive_names).each do |directive_name|
+          (schema.directives.keys - schema.default_directives.keys - directives_to_omit).each do |directive_name|
             memo[directive_name] ||= {}
             memo[directive_name][location] = schema.directives[directive_name]
           end
@@ -103,9 +109,8 @@ module GraphQL
         @subgraph_types_by_name_and_location = schemas.each_with_object({}) do |(location, schema), memo|
           raise CompositionError, "Location keys must be strings" unless location.is_a?(String)
 
-          introspection_types = schema.introspection_system.types.keys
           schema.types.each do |type_name, subgraph_type|
-            next if introspection_types.include?(type_name)
+            next if subgraph_type.introspection?
 
             if type_name == @query_name && subgraph_type != schema.query
               raise CompositionError, "Query name \"#{@query_name}\" is used by non-query type in #{location} schema."
@@ -157,25 +162,26 @@ module GraphQL
 
         builder = self
         schema = Class.new(GraphQL::Schema) do
+          object_types = schema_types.values.select { |t| t.respond_to?(:kind) && t.kind.object? }
           add_type_and_traverse(schema_types.values, root: false)
-          orphan_types(schema_types.values.select { |t| t.respond_to?(:kind) && t.kind.object? })
+          orphan_types(object_types)
           query schema_types[builder.query_name]
           mutation schema_types[builder.mutation_name]
           subscription schema_types[builder.subscription_name]
           directives builder.schema_directives.values
 
+          object_types.each do |t|
+            t.interfaces.each { _1.orphan_types(t) }
+          end
+
           own_orphan_types.clear
         end
 
         select_root_field_locations(schema)
         expand_abstract_resolvers(schema, schemas)
+        apply_supergraph_directives(schema, @resolver_map, @field_map)
 
-        supergraph = Supergraph.new(
-          schema: schema,
-          fields: @field_map,
-          resolvers: @resolver_map,
-          executables: executables,
-        )
+        supergraph = Supergraph.from_definition(schema, executables: executables)
 
         COMPOSITION_VALIDATORS.each do |validator_class|
           validator_class.new.perform(supergraph, self)
@@ -373,6 +379,7 @@ module GraphQL
             deprecation_reason: merge_deprecations(type_name, fields_by_location, field_name: field_name),
             type: Util.unwrap_non_null(type),
             null: !type.non_null?,
+            connection: false,
             camelize: false,
           )
 
@@ -403,14 +410,6 @@ module GraphQL
             next
           end
 
-          # Getting double args sometimes... why?
-          begin
-            next if owner.arguments(GraphQL::Query::NullContext.instance, false).key?(argument_name)
-          rescue ArgumentError
-            # pre- graphql v2.4.5
-            next if owner.arguments.key?(argument_name)
-          end
-
           kwargs = {}
           default_values_by_location = arguments_by_location.each_with_object({}) do |(location, argument), memo|
             next if argument.default_value == NO_DEFAULT_VALUE
@@ -648,9 +647,8 @@ module GraphQL
         writes = []
 
         schemas.each do |schema|
-          introspection_types = schema.introspection_system.types.keys
           schema.types.each_value do |type|
-            next if introspection_types.include?(type.graphql_name)
+            next if type.introspection?
 
             if type.kind.object? || type.kind.interface?
               type.fields.each_value do |field|
@@ -681,6 +679,72 @@ module GraphQL
           memo[enum_name] << :write
         end
       end
+
+      def apply_supergraph_directives(schema, resolvers_by_type_name, locations_by_type_and_field)
+        schema_directives = {}
+        schema.types.each do |type_name, type|
+          if resolvers_for_type = resolvers_by_type_name.dig(type_name)
+            # Apply key directives for each unique type/key/location
+            # (this allows keys to be composite selections and/or omitted from the supergraph schema)
+            keys_for_type = resolvers_for_type.each_with_object({}) do |resolver, memo|
+              memo[resolver.key.to_definition] ||= Set.new
+              memo[resolver.key.to_definition].merge(resolver.key.locations)
+            end
+  
+            keys_for_type.each do |key, locations|
+              locations.each do |location|
+                schema_directives[KeyDirective.graphql_name] ||= KeyDirective
+                type.directive(KeyDirective, key: key, location: location)
+              end
+            end
+  
+            # Apply resolver directives for each unique query resolver
+            resolvers_for_type.each do |resolver|
+              params = {
+                location: resolver.location,
+                field: resolver.field,
+                list: resolver.list? || nil,
+                key: resolver.key.to_definition,
+                arguments: resolver.arguments.map(&:to_definition).join(", "),
+                argument_types: resolver.arguments.map(&:to_type_definition).join(", "),
+                type_name: (resolver.type_name if resolver.type_name != type_name),
+              }
+  
+              schema_directives[ResolverDirective.graphql_name] ||= ResolverDirective
+              type.directive(ResolverDirective, **params.tap(&:compact!))
+            end
+          end
+  
+          next unless type.kind.fields? && !type.introspection?
+  
+          type.fields.each do |field_name, field|
+            if field.owner != type
+              # make a local copy of fields inherited from an interface
+              # to assure that source attributions reflect the object, not the interface.
+              field = type.field(
+                field.graphql_name,
+                description: field.description,
+                deprecation_reason: field.deprecation_reason,
+                type: Util.unwrap_non_null(field.type),
+                null: !field.type.non_null?,
+                connection: false,
+                camelize: false,
+              )
+            end
+            
+            locations_for_field = locations_by_type_and_field.dig(type_name, field_name)
+            next if locations_for_field.nil?
+  
+            # Apply source directives to annotate the possible locations of each field
+            locations_for_field.each do |location|
+              schema_directives[SourceDirective.graphql_name] ||= SourceDirective
+              field.directive(SourceDirective, location: location)
+            end
+          end
+        end
+        
+        schema_directives.each_value { |directive_class| schema.directive(directive_class) }
+      end
     end
   end
 end

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

@@ -31,8 +31,11 @@ module GraphQL::Stitching
           when GraphQL::Language::Nodes::Field
             field_name = node.alias || node.name
 
-            next if introspection_field?(parent_type, node) do |is_root_typename|
-              raw_object[field_name] = @root_type.graphql_name if is_root_typename
+            if @request.query.get_field(parent_type, node.name).introspection?
+              if node.name == TYPENAME && parent_type == @root_type
+                raw_object[field_name] = @root_type.graphql_name
+              end
+              next
             end
 
             node_type = @supergraph.memoized_schema_fields(parent_type.graphql_name)[node.name].type
@@ -100,21 +103,6 @@ module GraphQL::Stitching
         resolved_list
       end
 
-      def introspection_field?(parent_type, node)
-        return false unless node.name.start_with?("__")
-        is_root = parent_type == @root_type
-
-        case node.name
-        when TYPENAME
-          yield(is_root)
-          true
-        when "__schema", "__type"
-          is_root && @request.operation.operation_type == "query"
-        else
-          false
-        end
-      end
-
       def typename_in_type?(typename, type)
         return true if type.graphql_name == typename
 

data/lib/graphql/stitching/supergraph/from_definition.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Supergraph
+    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 = {}
+        resolver_map = {}
+        possible_locations = {}
+
+        schema.types.each do |type_name, type|
+          next if type.introspection?
+
+          # Collect/build key definitions for each type
+          locations_by_key = type.directives.each_with_object({}) do |directive, memo|
+            next unless directive.graphql_name == Composer::KeyDirective.graphql_name
+
+            kwargs = directive.arguments.keyword_arguments
+            memo[kwargs[:key]] ||= []
+            memo[kwargs[:key]] << kwargs[:location]
+          end
+
+          key_definitions = locations_by_key.each_with_object({}) do |(key, locations), memo|
+            memo[key] = TypeResolver.parse_key(key, locations)
+          end
+
+          # Collect/build resolver definitions for each type
+          type.directives.each do |directive|
+            next unless directive.graphql_name == Composer::ResolverDirective.graphql_name
+
+            kwargs = directive.arguments.keyword_arguments
+            resolver_map[type_name] ||= []
+            resolver_map[type_name] << TypeResolver.new(
+              location: kwargs[:location],
+              type_name: kwargs.fetch(:type_name, type_name),
+              field: kwargs[:field],
+              list: kwargs[:list] || false,
+              key: key_definitions[kwargs[:key]],
+              arguments: TypeResolver.parse_arguments_with_type_defs(kwargs[:arguments], kwargs[:argument_types]),
+            )
+          end
+
+          next unless type.kind.fields?
+
+          type.fields.each do |field_name, field|
+            # Collection locations for each field definition
+            field.directives.each do |d|
+              next unless d.graphql_name == Composer::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
+
+        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: field_map,
+          resolvers: resolver_map,
+          executables: executables,
+        )
+      end
+    end
+  end
+end

data/lib/graphql/stitching/supergraph.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "supergraph/to_definition"
+require_relative "supergraph/from_definition"
 
 module GraphQL
   module Stitching
@@ -16,25 +16,25 @@ module GraphQL
       # @return [Hash<String, Executable>] a map of executable resources by location.
       attr_reader :executables
 
-      attr_reader :resolvers, :locations_by_type_and_field
+      attr_reader :resolvers
+      attr_reader :memoized_schema_types
+      attr_reader :memoized_introspection_types
+      attr_reader :locations_by_type_and_field
 
       def initialize(schema:, fields: {}, resolvers: {}, executables: {})
         @schema = schema
-        @schema.use(GraphQL::Schema::AlwaysVisible)
-
         @resolvers = resolvers
         @resolvers_by_version = nil
         @fields_by_type_and_location = nil
         @locations_by_type = nil
-        @memoized_introspection_types = nil
+        @memoized_introspection_types = @schema.introspection_system.types
+        @memoized_schema_types = @schema.types
         @memoized_schema_fields = {}
-        @memoized_schema_types = nil
         @possible_keys_by_type = {}
         @possible_keys_by_type_and_location = {}
-        @static_validator = 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|
+        @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|
@@ -48,6 +48,12 @@ module GraphQL
             memo[location.to_s] = executable
           end
         end.freeze
+
+        @schema.use(GraphQL::Schema::AlwaysVisible)
+      end
+
+      def to_definition
+        @schema.to_definition
       end
 
       def resolvers_by_version
@@ -64,17 +70,9 @@ module GraphQL
         @executables.keys.reject { _1 == SUPERGRAPH_LOCATION }
       end
 
-      def memoized_introspection_types
-        @memoized_introspection_types ||= schema.introspection_system.types
-      end
-
-      def memoized_schema_types
-        @memoized_schema_types ||= @schema.types
-      end
-
       def memoized_schema_fields(type_name)
         @memoized_schema_fields[type_name] ||= begin
-          fields = memoized_schema_types[type_name].fields
+          fields = @memoized_schema_types[type_name].fields
           @schema.introspection_system.dynamic_fields.each do |field|
             fields[field.name] ||= field # adds __typename
           end

data/lib/graphql/stitching/type_resolver.rb

@@ -65,6 +65,10 @@ module GraphQL
           argument_types: arguments.map(&:to_type_definition).join(", "),
         }.tap(&:compact!)
       end
+
+      def inspect
+        as_json.to_json
+      end
     end
   end
 end

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "1.6.0"
+    VERSION = "1.6.2"
   end
 end

data/lib/graphql/stitching.rb

@@ -49,12 +49,6 @@ module GraphQL
       def stitch_directive
         @stitch_directive ||= "stitch"
       end
-
-      # Names of stitching directives to omit from the composed supergraph.
-      # @returns [Array<String>] list of stitching directive names.
-      def stitching_directive_names
-        [stitch_directive]
-      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.6.2
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-17 00:00:00.000000000 Z
+date: 2025-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -155,11 +155,13 @@ files:
 - gemfiles/graphql_2.1.0.gemfile
 - gemfiles/graphql_2.2.0.gemfile
 - gemfiles/graphql_2.3.0.gemfile
+- gemfiles/graphql_2.4.0.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/supergraph_directives.rb
 - lib/graphql/stitching/composer/type_resolver_config.rb
 - lib/graphql/stitching/composer/validate_interfaces.rb
 - lib/graphql/stitching/composer/validate_type_resolvers.rb
@@ -174,10 +176,7 @@ files:
 - lib/graphql/stitching/request.rb
 - lib/graphql/stitching/request/skip_include.rb
 - lib/graphql/stitching/supergraph.rb
-- lib/graphql/stitching/supergraph/key_directive.rb
-- lib/graphql/stitching/supergraph/resolver_directive.rb
-- lib/graphql/stitching/supergraph/source_directive.rb
-- lib/graphql/stitching/supergraph/to_definition.rb
+- lib/graphql/stitching/supergraph/from_definition.rb
 - lib/graphql/stitching/type_resolver.rb
 - lib/graphql/stitching/type_resolver/arguments.rb
 - lib/graphql/stitching/type_resolver/keys.rb

data/lib/graphql/stitching/supergraph/key_directive.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL::Stitching
-  class Supergraph
-    class KeyDirective < GraphQL::Schema::Directive
-      graphql_name "key"
-      locations OBJECT, INTERFACE, UNION
-      argument :key, String, required: true
-      argument :location, String, required: true
-      repeatable true
-    end
-  end
-end

data/lib/graphql/stitching/supergraph/source_directive.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL::Stitching
-  class Supergraph
-    class SourceDirective < GraphQL::Schema::Directive
-      graphql_name "source"
-      locations FIELD_DEFINITION
-      argument :location, String, required: true
-      repeatable true
-    end
-  end
-end

data/lib/graphql/stitching/supergraph/to_definition.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-require_relative "./key_directive"
-require_relative "./resolver_directive"
-require_relative "./source_directive"
-
-module GraphQL::Stitching
-  class Supergraph
-    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 = {}
-        resolver_map = {}
-        possible_locations = {}
-        introspection_types = schema.introspection_system.types.keys
-
-        schema.types.each do |type_name, type|
-          next if introspection_types.include?(type_name)
-
-          # Collect/build key definitions for each type
-          locations_by_key = type.directives.each_with_object({}) do |directive, memo|
-            next unless directive.graphql_name == KeyDirective.graphql_name
-
-            kwargs = directive.arguments.keyword_arguments
-            memo[kwargs[:key]] ||= []
-            memo[kwargs[:key]] << kwargs[:location]
-          end
-
-          key_definitions = locations_by_key.each_with_object({}) do |(key, locations), memo|
-            memo[key] = TypeResolver.parse_key(key, locations)
-          end
-
-          # Collect/build resolver definitions for each type
-          type.directives.each do |directive|
-            next unless directive.graphql_name == ResolverDirective.graphql_name
-
-            kwargs = directive.arguments.keyword_arguments
-            resolver_map[type_name] ||= []
-            resolver_map[type_name] << TypeResolver.new(
-              location: kwargs[:location],
-              type_name: kwargs.fetch(:type_name, type_name),
-              field: kwargs[:field],
-              list: kwargs[:list] || false,
-              key: key_definitions[kwargs[:key]],
-              arguments: TypeResolver.parse_arguments_with_type_defs(kwargs[:arguments], kwargs[:argument_types]),
-            )
-          end
-
-          next unless type.kind.fields?
-
-          type.fields.each do |field_name, field|
-            # Collection locations for each field definition
-            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
-
-        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: field_map,
-          resolvers: resolver_map,
-          executables: executables,
-        )
-      end
-    end
-
-    def to_definition
-      if @schema.directives[KeyDirective.graphql_name].nil?
-        @schema.directive(KeyDirective)
-      end
-      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 resolvers_for_type = @resolvers.dig(type_name)
-          # Apply key directives for each unique type/key/location
-          # (this allows keys to be composite selections and/or omitted from the supergraph schema)
-          keys_for_type = resolvers_for_type.each_with_object({}) do |resolver, memo|
-            memo[resolver.key.to_definition] ||= Set.new
-            memo[resolver.key.to_definition].merge(resolver.key.locations)
-          end
-
-          keys_for_type.each do |key, locations|
-            locations.each do |location|
-              params = { key: key, location: location }
-
-              unless has_directive?(type, KeyDirective.graphql_name, params)
-                type.directive(KeyDirective, **params)
-              end
-            end
-          end
-
-          # Apply resolver directives for each unique query resolver
-          resolvers_for_type.each do |resolver|
-            params = {
-              location: resolver.location,
-              field: resolver.field,
-              list: resolver.list? || nil,
-              key: resolver.key.to_definition,
-              arguments: resolver.arguments.map(&:to_definition).join(", "),
-              argument_types: resolver.arguments.map(&:to_type_definition).join(", "),
-              type_name: (resolver.type_name if resolver.type_name != type_name),
-            }
-
-            unless has_directive?(type, ResolverDirective.graphql_name, params)
-              type.directive(ResolverDirective, **params.tap(&:compact!))
-            end
-          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?
-
-          # Apply source directives to annotate the possible locations of each field
-          locations_for_field.each do |location|
-            params = { location: location }
-
-            unless has_directive?(field, SourceDirective.graphql_name, params)
-              field.directive(SourceDirective, **params)
-            end
-          end
-        end
-      end
-
-      @schema.to_definition
-    end
-
-    private
-
-    def has_directive?(element, directive_name, params)
-      existing = element.directives.find do |d|
-        kwargs = d.arguments.keyword_arguments
-        d.graphql_name == directive_name && params.all? { |k, v| kwargs[k] == v }
-      end
-
-      !existing.nil?
-    end
-  end
-end