graphql-stitching 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32918bd6b17708d712d3ac945f6007b0405299379372aabda8b0c3a5f0c246da
-  data.tar.gz: 608562f6b35cfe912e2388c6cbfce8c774bedc6f6518d257eb0de8b45fdc8b52
+  metadata.gz: 4cb8c0d3b16cda5db8b82d0d0f9eba93a4537c3faa584b1b301dc84b34b5fd0e
+  data.tar.gz: 83f4b436479307ac8575f718ace5a82288024a6e5741f786151e55920d7ef61f
 SHA512:
-  metadata.gz: c0f40d79e3b06c9477f5967f12f6e33c0534b916c3454669d2802357137ff78d7bb9bb7d99d7c82d43ea47f58fac1c4d0e5aa38243d4cbfcdec6ba192ef56c0e
-  data.tar.gz: eed8c018a8efde4500bb0eb93de78803f555c77fad284718e945648160442eea249439d2a2cb5b4c0a5121fc148197f48b9ea0d50a21e7cfa291499fe4533912
+  metadata.gz: e247e539e223a1fbefcd398c1aeb3940fa91320b81c45caeaa21b3ddca50631ffb6ddbd3963cde07f11609cbaacc1f814a167fefebab8f888979afe929bcb93f
+  data.tar.gz: 66de3bacb73749bd90b4d8e7ade4bf35cc144e0ae60b3ff1c81a5f548b20d74e204454b6727875984da293b4b3853aa9bf6215283666f2b037a7dc148e8aa64b

data/.yardopts

@@ -0,0 +1,5 @@
+--no-private
+--markup=markdown
+--readme=readme.md
+--title='GraphQL Stitching Ruby API Documentation'
+'lib/**/*.rb' - '*.md'

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
-    class Composer::BaseValidator
+module GraphQL::Stitching
+  class Composer
+    class BaseValidator
       def perform(ctx, composer)
         raise "not implemented"
       end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
-    class Composer::ValidateBoundaries < Composer::BaseValidator
+module GraphQL::Stitching
+  class Composer
+    class ValidateBoundaries < BaseValidator
 
       def perform(ctx, composer)
         ctx.schema.types.each do |type_name, type|

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

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
-    class Composer::ValidateInterfaces < Composer::BaseValidator
-
+module GraphQL::Stitching
+  class Composer
+    class ValidateInterfaces < BaseValidator
       # For each composed interface, check the interface against each possible type
       # to assure that intersecting fields have compatible types, structures, and nullability.
       # Verifies compatibility of types that inherit interface contracts through merging.

data/lib/graphql/stitching/composer.rb

@@ -1,26 +1,49 @@
 # frozen_string_literal: true
 
+require_relative "./composer/base_validator"
+require_relative "./composer/validate_interfaces"
+require_relative "./composer/validate_boundaries"
+
 module GraphQL
   module Stitching
     class Composer
       class ComposerError < StitchingError; end
       class ValidationError < ComposerError; end
-      class ReferenceType < GraphQL::Schema::Object
-        field(:f, String) do
-          argument(:a, String)
+
+      # @api private
+      NO_DEFAULT_VALUE = begin
+        class T < GraphQL::Schema::Object
+          field(:f, String) do
+            argument(:a, String)
+          end
         end
+
+        T.get_field("f").get_argument("a").default_value
       end
 
-      NO_DEFAULT_VALUE = ReferenceType.get_field("f").get_argument("a").default_value
+      # @api private
       BASIC_VALUE_MERGER = ->(values_by_location, _info) { values_by_location.values.find { !_1.nil? } }
+
+      # @api private
       BASIC_ROOT_FIELD_LOCATION_SELECTOR = ->(locations, _info) { locations.last }
 
+      # @api private
       VALIDATORS = [
         "ValidateInterfaces",
         "ValidateBoundaries",
       ].freeze
 
-      attr_reader :query_name, :mutation_name, :candidate_types_by_name_and_location, :schema_directives
+      # @return [String] name of the Query type in the composed schema.
+      attr_reader :query_name
+
+      # @return [String] name of the Mutation type in the composed schema.
+      attr_reader :mutation_name
+
+      # @api private
+      attr_reader :candidate_types_by_name_and_location
+
+      # @api private
+      attr_reader :schema_directives
 
       def initialize(
         query_name: "Query",
@@ -148,6 +171,8 @@ module GraphQL
         supergraph
       end
 
+      # @!scope class
+      # @!visibility private
       def prepare_locations_input(locations_input)
         schemas = {}
         executables = {}
@@ -200,6 +225,8 @@ module GraphQL
         return schemas, executables
       end
 
+      # @!scope class
+      # @!visibility private
       def build_directive(directive_name, directives_by_location)
         builder = self
 
@@ -212,6 +239,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_scalar_type(type_name, types_by_location)
         built_in_type = GraphQL::Schema::BUILT_IN_TYPES[type_name]
         return built_in_type if built_in_type
@@ -225,6 +254,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_enum_type(type_name, types_by_location, enum_usage)
         builder = self
 
@@ -261,6 +292,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_object_type(type_name, types_by_location)
         builder = self
 
@@ -278,6 +311,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_interface_type(type_name, types_by_location)
         builder = self
 
@@ -296,6 +331,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_union_type(type_name, types_by_location)
         builder = self
 
@@ -309,6 +346,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_input_object_type(type_name, types_by_location)
         builder = self
 
@@ -320,10 +359,14 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_type_binding(type_name)
         GraphQL::Schema::LateBoundType.new(@mapped_type_names.fetch(type_name, type_name))
       end
 
+      # @!scope class
+      # @!visibility private
       def build_merged_fields(type_name, types_by_location, owner)
         # "field_name" => "location" => field
         fields_by_name_location = types_by_location.each_with_object({}) do |(location, type_candidate), memo|
@@ -356,6 +399,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_merged_arguments(type_name, members_by_location, owner, field_name: nil, directive_name: nil)
         # "argument_name" => "location" => argument
         args_by_name_location = members_by_location.each_with_object({}) do |(location, member_candidate), memo|
@@ -410,6 +455,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_merged_directives(type_name, members_by_location, owner, field_name: nil, argument_name: nil, enum_value: nil)
         directives_by_name_location = members_by_location.each_with_object({}) do |(location, member_candidate), memo|
           member_candidate.directives.each do |directive|
@@ -451,6 +498,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def merge_value_types(type_name, type_candidates, field_name: nil, argument_name: nil)
         path = [type_name, field_name, argument_name].tap(&:compact!).join(".")
         alt_structures = type_candidates.map { Util.flatten_type_structure(_1) }
@@ -482,6 +531,8 @@ module GraphQL
         type
       end
 
+      # @!scope class
+      # @!visibility private
       def merge_descriptions(type_name, members_by_location, field_name: nil, argument_name: nil, enum_value: nil)
         strings_by_location = members_by_location.each_with_object({}) { |(l, m), memo| memo[l] = m.description }
         @description_merger.call(strings_by_location, {
@@ -492,6 +543,8 @@ module GraphQL
         }.tap(&:compact!))
       end
 
+      # @!scope class
+      # @!visibility private
       def merge_deprecations(type_name, members_by_location, field_name: nil, argument_name: nil, enum_value: nil)
         strings_by_location = members_by_location.each_with_object({}) { |(l, m), memo| memo[l] = m.deprecation_reason }
         @deprecation_merger.call(strings_by_location, {
@@ -502,6 +555,8 @@ module GraphQL
         }.tap(&:compact!))
       end
 
+      # @!scope class
+      # @!visibility private
       def extract_boundaries(type_name, types_by_location)
         types_by_location.each do |location, type_candidate|
           type_candidate.fields.each do |field_name, field_candidate|
@@ -554,6 +609,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def select_root_field_locations(schema)
         [schema.query, schema.mutation].tap(&:compact!).each do |root_type|
           root_type.fields.each do |root_field_name, root_field|
@@ -572,6 +629,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def expand_abstract_boundaries(schema)
         @boundary_map.keys.each do |type_name|
           boundary_type = schema.types[type_name]
@@ -585,6 +644,8 @@ module GraphQL
         end
       end
 
+      # @!scope class
+      # @!visibility private
       def build_enum_usage_map(schemas)
         reads = []
         writes = []
@@ -636,7 +697,3 @@ module GraphQL
     end
   end
 end
-
-require_relative "./composer/base_validator"
-require_relative "./composer/validate_interfaces"
-require_relative "./composer/validate_boundaries"

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
-    class Executor::BoundarySource < GraphQL::Dataloader::Source
+module GraphQL::Stitching
+  class Executor
+    class BoundarySource < GraphQL::Dataloader::Source
       def initialize(executor, location)
         @executor = executor
         @location = location
@@ -29,7 +29,7 @@ module GraphQL
             @executor.request.operation_directives,
           )
           variables = @executor.request.variables.slice(*variable_names)
-          raw_result = @executor.supergraph.execute_at_location(@location, query_document, variables, @executor.request)
+          raw_result = @executor.request.supergraph.execute_at_location(@location, query_document, variables, @executor.request)
           @executor.query_count += 1
 
           merge_results!(origin_sets_by_operation, raw_result.dig("data"))
@@ -183,9 +183,7 @@ module GraphQL
           end
 
         elsif forward_path.any?
-          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|

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module GraphQL
-  module Stitching
-    class Executor::RootSource < GraphQL::Dataloader::Source
+module GraphQL::Stitching
+  class Executor
+    class RootSource < GraphQL::Dataloader::Source
       def initialize(executor, location)
         @executor = executor
         @location = location
@@ -17,7 +17,7 @@ module GraphQL
           @executor.request.operation_directives,
         )
         query_variables = @executor.request.variables.slice(*op.variables.keys)
-        result = @executor.supergraph.execute_at_location(op.location, query_document, query_variables, @executor.request)
+        result = @executor.request.supergraph.execute_at_location(op.location, query_document, query_variables, @executor.request)
         @executor.query_count += 1
 
         @executor.data.merge!(result["data"]) if result["data"]

data/lib/graphql/stitching/executor.rb

@@ -1,17 +1,26 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "./executor/boundary_source"
+require_relative "./executor/root_source"
 
 module GraphQL
   module Stitching
     class Executor
-      attr_reader :supergraph, :request, :plan, :data, :errors
+      # @return [Request] the stitching request to execute.
+      attr_reader :request
+
+      # @return [Hash] an aggregate data payload to return.
+      attr_reader :data
+
+      # @return [Array<Hash>] aggregate GraphQL errors to return.
+      attr_reader :errors
+
+      # @return [Integer] tally of queries performed while executing.
       attr_accessor :query_count
 
       def initialize(request, nonblocking: false)
         @request = request
-        @supergraph = request.supergraph
-        @plan = request.plan
         @data = {}
         @errors = []
         @query_count = 0
@@ -37,13 +46,13 @@ module GraphQL
       private
 
       def exec!(next_steps = [0])
-        if @exec_cycles > @plan.ops.length
+        if @exec_cycles > @request.plan.ops.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
-          tasks = @plan
+          tasks = @request.plan
             .ops
             .select { next_steps.include?(_1.after) }
             .group_by { [_1.location, _1.boundary.nil?] }
@@ -66,6 +75,3 @@ module GraphQL
     end
   end
 end
-
-require_relative "./executor/boundary_source"
-require_relative "./executor/root_source"

data/lib/graphql/stitching/http_executable.rb

@@ -7,27 +7,33 @@ require "json"
 module GraphQL
   module Stitching
     class HttpExecutable
-      def initialize(url:, headers:{}, upload_types: nil)
+      # Builds a new executable for proxying subgraph requests via HTTP.
+      # @param url [String] the url of the remote location to proxy.
+      # @param headers [Hash] headers to include in upstream requests.
+      # @param upload_types [Array<String>, nil] a list of scalar names that represent file uploads. These types extract into multipart forms.
+      def initialize(url:, headers: {}, upload_types: nil)
         @url = url
         @headers = { "Content-Type" => "application/json" }.merge!(headers)
         @upload_types = upload_types
       end
 
       def call(request, document, variables)
-        multipart_form = if request.variable_definitions.any? && variables&.any?
-          extract_multipart_form(request, document, variables)
-        end
+        form_data = extract_multipart_form(request, document, variables)
 
-        response = if multipart_form
-          post_multipart(multipart_form)
+        response = if form_data
+          send_multipart_form(request, form_data)
         else
-          post(document, variables)
+          send(request, document, variables)
         end
 
         JSON.parse(response.body)
       end
 
-      def post(document, variables)
+      # Sends a POST request to the remote location.
+      # @param request [Request] the original supergraph request.
+      # @param document [String] the location-specific subgraph document to send.
+      # @param variables [Hash] a hash of variables specific to the subgraph document.
+      def send(_request, document, variables)
         Net::HTTP.post(
           URI(@url),
           JSON.generate({ "query" => document, "variables" => variables }),
@@ -35,7 +41,10 @@ module GraphQL
         )
       end
 
-      def post_multipart(form_data)
+      # Sends a POST request to the remote location with multipart form data.
+      # @param request [Request] the original supergraph request.
+      # @param form_data [Hash] a rendered multipart form with an "operations", "map", and file sections.
+      def send_multipart_form(_request, form_data)
         uri = URI(@url)
         req = Net::HTTP::Post.new(uri)
         @headers.each_pair do |key, value|
@@ -48,16 +57,18 @@ module GraphQL
         end
       end
 
-      # extract multipart upload forms
-      # spec: https://github.com/jaydenseric/graphql-multipart-request-spec
+      # Extracts multipart upload forms per the spec:
+      # https://github.com/jaydenseric/graphql-multipart-request-spec
+      # @param request [Request] the original supergraph request.
+      # @param document [String] the location-specific subgraph document to send.
+      # @param variables [Hash] a hash of variables specific to the subgraph document.
       def extract_multipart_form(request, document, variables)
-        return unless @upload_types
+        return unless @upload_types && request.variable_definitions.any? && variables&.any?
 
-        path = []
         files_by_path = {}
 
         # extract all upload scalar values mapped by their input path
-        variables.each do |key, value|
+        variables.each_with_object([]) do |(key, value), path|
           ast_node = request.variable_definitions[key]
           path << key
           extract_ast_node(ast_node, value, files_by_path, path, request) if ast_node
@@ -70,14 +81,14 @@ module GraphQL
         files = files_by_path.values.tap(&:uniq!)
         variables_copy = variables.dup
 
-        files_by_path.keys.each do |path|
+        files_by_path.each_key do |path|
           orig = variables
           copy = variables_copy
           path.each_with_index do |key, i|
             if i == path.length - 1
-              map_key = files.index(copy[key]).to_s
-              map[map_key] ||= []
-              map[map_key] << "variables.#{path.join(".")}"
+              file_index = files.index(copy[key]).to_s
+              map[file_index] ||= []
+              map[file_index] << "variables.#{path.join(".")}"
               copy[key] = nil
             elsif orig[key].object_id == copy[key].object_id
               copy[key] = copy[key].dup

data/lib/graphql/stitching/planner.rb

@@ -324,7 +324,7 @@ module GraphQL
         end
 
         if expanded_selections
-          @supergraph.memoized_schema_possible_types(parent_type.graphql_name).each do |possible_type|
+          @request.warden.possible_types(parent_type).each do |possible_type|
             next unless @supergraph.locations_by_type[possible_type.graphql_name].include?(current_location)
 
             type_name = GraphQL::Language::Nodes::TypeName.new(name: possible_type.graphql_name)

data/lib/graphql/stitching/request.rb

@@ -6,8 +6,30 @@ module GraphQL
       SUPPORTED_OPERATIONS = ["query", "mutation"].freeze
       SKIP_INCLUDE_DIRECTIVE = /@(?:skip|include)/
 
-      attr_reader :supergraph, :document, :variables, :operation_name, :context
+      # @return [Supergraph] supergraph instance that resolves the request.
+      attr_reader :supergraph
 
+      # @return [GraphQL::Language::Nodes::Document] the parsed GraphQL AST document.
+      attr_reader :document
+
+      # @return [Hash] input variables for the request.
+      attr_reader :variables
+
+      # @return [String] operation name selected for the request.
+      attr_reader :operation_name
+
+      # @return [Hash] contextual object passed through resolver flows.
+      attr_reader :context
+
+      # @return [GraphQL::Schema::Warden] a visibility warden for this request.
+      attr_reader :warden
+
+      # Creates a new supergraph request.
+      # @param supergraph [Supergraph] supergraph instance that resolves the request.
+      # @param document [String, GraphQL::Language::Nodes::Document] the request string or parsed AST.
+      # @param operation_name [String, nil] operation name selected for the request.
+      # @param variables [Hash, nil] input variables for the request.
+      # @param context [Hash, nil] a contextual object passed through resolver flows.
       def initialize(supergraph, document, operation_name: nil, variables: nil, context: nil)
         @supergraph = supergraph
         @string = nil
@@ -29,25 +51,34 @@ module GraphQL
 
         @operation_name = operation_name
         @variables = variables || {}
-        @context = context || GraphQL::Stitching::EMPTY_OBJECT
+
+        @query = GraphQL::Query.new(@supergraph.schema, document: @document, context: context)
+        @warden = @query.warden
+        @context = @query.context
+        @context[:request] = self
       end
 
+      # @return [String] the original document string, or a print of the parsed AST document.
       def string
         @string || normalized_string
       end
 
+      # @return [String] a print of the parsed AST document with consistent whitespace.
       def normalized_string
         @normalized_string ||= @document.to_query_string
       end
 
+      # @return [String] a digest of the original document string. Generally faster but less consistent.
       def digest
         @digest ||= Digest::SHA2.hexdigest(string)
       end
 
+      # @return [String] a digest of the normalized document string. Slower but more consistent.
       def normalized_digest
         @normalized_digest ||= Digest::SHA2.hexdigest(normalized_string)
       end
 
+      # @return [GraphQL::Language::Nodes::OperationDefinition] The selected root operation for the request.
       def operation
         @operation ||= begin
           operation_defs = @document.definitions.select do |d|
@@ -66,6 +97,7 @@ module GraphQL
         end
       end
 
+      # @return [String] A string of directives applied to the root operation. These are passed through in all subgraph requests.
       def operation_directives
         @operation_directives ||= if operation.directives.any?
           printer = GraphQL::Language::Printer.new
@@ -73,22 +105,27 @@ module GraphQL
         end
       end
 
+      # @return [Hash<String, GraphQL::Language::Nodes::AbstractNode>] map of variable names to AST type definitions.
       def variable_definitions
         @variable_definitions ||= operation.variables.each_with_object({}) do |v, memo|
           memo[v.name] = v.type
         end
       end
 
+      # @return [Hash<String, GraphQL::Language::Nodes::FragmentDefinition>] map of fragment names to their AST definitions.
       def fragment_definitions
         @fragment_definitions ||= @document.definitions.each_with_object({}) do |d, memo|
           memo[d.name] = d if d.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
         end
       end
 
+      # Validates the request using the combined supergraph schema.
       def validate
-        @supergraph.schema.validate(@document, context: @context)
+        result = @supergraph.static_validator.validate(@query)
+        result[:errors]
       end
 
+      # Prepares the request for stitching by rendering variable defaults and applying @skip/@include conditionals.
       def prepare!
         operation.variables.each do |v|
           @variables[v.name] = v.default_value if @variables[v.name].nil? && !v.default_value.nil?
@@ -106,6 +143,9 @@ module GraphQL
         self
       end
 
+      # Gets and sets the query plan for the request. Assigned query plans may pull from cache.
+      # @param new_plan [Plan, nil] a cached query plan for the request.
+      # @return [Plan] query plan for the request.
       def plan(new_plan = nil)
         if new_plan
           raise StitchingError, "Plan must be a `GraphQL::Stitching::Plan`." unless new_plan.is_a?(Plan)
@@ -115,6 +155,9 @@ module GraphQL
         end
       end
 
+      # Executes the request and returns the rendered response.
+      # @param raw [Boolean] specifies the result should be unshaped without pruning or null bubbling. Useful for debugging.
+      # @return [Hash] the rendered GraphQL response with "data" and "errors" sections.
       def execute(raw: false)
         GraphQL::Stitching::Executor.new(self).perform(raw: raw)
       end

data/lib/graphql/stitching/shaper.rb

@@ -5,6 +5,7 @@ module GraphQL
   module Stitching
     # Shapes the final results payload to the request selection and schema definition.
     # This eliminates unrequested export selections and applies null bubbling.
+    # @api private
     class Shaper
       def initialize(request)
         @request = request
@@ -117,7 +118,7 @@ module GraphQL
       def typename_in_type?(typename, type)
         return true if type.graphql_name == typename
 
-        type.kind.abstract? && @supergraph.memoized_schema_possible_types(type.graphql_name).any? do |t|
+        type.kind.abstract? && @request.warden.possible_types(type).any? do |t|
           t.graphql_name == typename
         end
       end

data/lib/graphql/stitching/skip_include.rb

@@ -2,11 +2,12 @@
 
 module GraphQL
   module Stitching
+    # Faster implementation of an AST visitor for prerendering
+    # @skip and @include conditional directives into a document.
+    # This avoids unnecessary planning steps, and prepares result shaping.
+    # @api private
     class SkipInclude
       class << self
-        # Faster implementation of an AST visitor for prerendering
-        # @skip and @include conditional directives into a document.
-        # This avoids unnecessary planning steps, and prepares result shaping.
         def render(document, variables)
           changed = false
           definitions = document.definitions.map do |original_definition|

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Supergraph
+    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
+  end
+end

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

@@ -0,0 +1,12 @@
+# 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.rb

@@ -1,29 +1,13 @@
 # frozen_string_literal: true
 
+require_relative "./supergraph/resolver_directive"
+require_relative "./supergraph/source_directive"
+
 module GraphQL
   module Stitching
     class Supergraph
       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
-
-      class SourceDirective < GraphQL::Schema::Directive
-        graphql_name "source"
-        locations FIELD_DEFINITION
-        argument :location, String, required: true
-        repeatable true
-      end
-
       class << self
         def validate_executable!(location, executable)
           return true if executable.is_a?(Class) && executable <= GraphQL::Schema
@@ -88,19 +72,27 @@ module GraphQL
         end
       end
 
-      attr_reader :schema, :boundaries, :locations_by_type_and_field, :executables
+      # @return [GraphQL::Schema] the composed schema for the supergraph.
+      attr_reader :schema
+
+      # @return [Hash<String, Executable>] a map of executable resources by location.
+      attr_reader :executables
+
+      attr_reader :boundaries, :locations_by_type_and_field
 
       def initialize(schema:, fields: {}, boundaries: {}, executables: {})
         @schema = schema
+        @schema.use(GraphQL::Schema::AlwaysVisible)
+
         @boundaries = boundaries
-        @possible_keys_by_type = {}
-        @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
+        @memoized_introspection_types = nil
+        @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|
@@ -172,6 +164,11 @@ module GraphQL
         @schema.to_definition
       end
 
+      # @return [GraphQL::StaticValidation::Validator] static validator for the supergraph schema.
+      def static_validator
+        @static_validator ||= @schema.static_validator
+      end
+
       def fields
         @locations_by_type_and_field.reject { |k, _v| memoized_introspection_types[k] }
       end
@@ -188,10 +185,6 @@ module GraphQL
         @memoized_schema_types ||= @schema.types
       end
 
-      def memoized_schema_possible_types(type_name)
-        @memoized_schema_possible_types[type_name] ||= @schema.possible_types(memoized_schema_types[type_name])
-      end
-
       def memoized_schema_fields(type_name)
         @memoized_schema_fields[type_name] ||= begin
           fields = memoized_schema_types[type_name].fields

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "1.2.0"
+    VERSION = "1.2.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-29 00:00:00.000000000 Z
+date: 2024-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -74,6 +74,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
 - ".gitignore"
+- ".yardopts"
 - Gemfile
 - LICENSE
 - README.md
@@ -125,6 +126,8 @@ files:
 - lib/graphql/stitching/shaper.rb
 - lib/graphql/stitching/skip_include.rb
 - lib/graphql/stitching/supergraph.rb
+- lib/graphql/stitching/supergraph/resolver_directive.rb
+- lib/graphql/stitching/supergraph/source_directive.rb
 - lib/graphql/stitching/util.rb
 - lib/graphql/stitching/version.rb
 homepage: https://github.com/gmac/graphql-stitching-ruby