graphql-stitching 1.2.3 → 1.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99acc247a0e5e227236b0261b3f975e7277f642a9d76daaf4f6a985bfc4825ea
-  data.tar.gz: ef5f01132498ca4ba1be6f8593f189645ddf8fb6b6d8ab71f9b7d0e55d6ec682
+  metadata.gz: 754e7a61df541f685ef50ec79039df9742e4a2589a30eadf93125d6e4ef47aed
+  data.tar.gz: e2ceb89be07b42dbffeaa75416055fa62ffafa001088fd47b2b4f156aee6123a
 SHA512:
-  metadata.gz: d1bd0db4c7f6d363231330222006f2bbc552a669227a38aeb7861dde843b59bc3e61b0f301f97d4a5c6b55193d01424cd9f240c0ff7a7ee483e49150686ac3da
-  data.tar.gz: 348aa663608fd8b0e5544ccf7ec500d4295a63bb9bd19a91031f927165da2a206024ce6cb17111c3ebda2c172e08072be8d01716c11f0a05c3ea8a9a4b99466e
+  metadata.gz: 561ecdc36e78b31e4f4fd2f85d4ff5e0f1ab23d44570de7d8ffe63c2e46b5856214eb07c25b98eafbd64857602ebd839e187175e9e3ec347caedf4651a00d332
+  data.tar.gz: dd7a98e1c97f7bd5a6ca2585c34b6538e94b6dfaaa83edf9b3f1bc287a79d04f62a29ebe2a6b6fae4d06e8af9f08bb20203a89f1b062f24dc622a66973f87abc

data/README.md

@@ -10,12 +10,13 @@ GraphQL stitching composes a single schema from multiple underlying GraphQL reso
 - Shared objects, fields, enums, and inputs across locations.
 - Combining local and remote schemas.
 - File uploads via [multipart form spec](https://github.com/jaydenseric/graphql-multipart-request-spec).
+- Tested with all minor versions of `graphql-ruby`.
 
 **NOT Supported:**
 - Computed fields (ie: federation-style `@requires`).
 - Subscriptions, defer/stream.
 
-This Ruby implementation is a sibling to [GraphQL Tools](https://the-guild.dev/graphql/stitching) (JS) and [Bramble](https://movio.github.io/bramble/) (Go), and its capabilities fall somewhere in between them. GraphQL stitching is similar in concept to [Apollo Federation](https://www.apollographql.com/docs/federation/), though more generic. The opportunity here is for a Ruby application to stitch its local schemas together or onto remote sources without requiring an additional proxy service running in another language. If your goal is to build a purely high-throughput API gateway, consider not using Ruby.
+This Ruby implementation is a sibling to [GraphQL Tools](https://the-guild.dev/graphql/stitching) (JS) and [Bramble](https://movio.github.io/bramble/) (Go), and its capabilities fall somewhere in between them. GraphQL stitching is similar in concept to [Apollo Federation](https://www.apollographql.com/docs/federation/), though more generic. The opportunity here is for a Ruby application to stitch its local schemas together or onto remote sources without requiring an additional proxy service running in another language. If your goal is to build a purely high-throughput federated reverse proxy, consider not using Ruby.
 
 ## Getting started
 
@@ -152,7 +153,7 @@ 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](#multiple-query-arguments) later).
 
-Each location that provides a unique variant of a type must provide at least one stitching query for the type. The exception to this requirement are [foreign key types](./docs/mechanics.md##modeling-foreign-keys-for-stitching) that contain only a single key field:
+Each location that provides a unique variant of a type must provide at least one resolver query for the type. The exception to this requirement are [outbound-only types](./docs/mechanics.md#outbound-only-merged-types) and/or [foreign key types](./docs/mechanics.md##modeling-foreign-keys-for-stitching) that contain no exclusive data:
 
 ```graphql
 type Product {
@@ -160,11 +161,11 @@ type Product {
 }
 ```
 
-The above representation of a `Product` type provides no unique data beyond a key that is available in other locations. Thus, this representation will never require an inbound request to fetch it, and its stitching query may be omitted.
+The above representation of a `Product` type contains nothing but a key that is available in other locations. Therefore, this representation will never require an inbound request to fetch it, and its resolver query may be omitted.
 
 #### List queries
 
-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.
+It's okay ([even preferable](#batching) in most circumstances) to provide a list accessor as a resolver 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 {
@@ -179,7 +180,7 @@ See [error handling](./docs/mechanics.md#stitched-errors) tips for list queries.
 
 #### Abstract queries
 
-It's okay for stitching queries to be implemented through abstract types. An abstract query will provide access to all of its possible types. For interfaces, the key selection should match a field within the interface. For unions, all possible types must implement the key selection individually.
+It's okay for resolver queries to be implemented through abstract types. An abstract query will provide access to all of its possible types by default, each of which must implement the key.
 
 ```graphql
 interface Node {
@@ -194,13 +195,33 @@ type Query {
 }
 ```
 
+To customize which types an abstract query provides and their respective keys, you may extend the `@stitch` directive with a `typeName` constraint. This can be repeated to select multiple types.
+
+```graphql
+directive @stitch(key: String!, typeName: String) repeatable on FIELD_DEFINITION
+
+type Product { sku: ID! }
+type Order { id: ID! }
+type Customer { id: ID! } # << not stitched
+union Entity = Product | Order | Customer
+
+type Query {
+  entity(key: ID!): Entity
+    @stitch(key: "sku", typeName: "Product")
+    @stitch(key: "id", typeName: "Order")
+}
+```
+
 #### Multiple query arguments
 
-Stitching infers which argument to use for queries with a single argument. For queries that accept multiple arguments, the key must provide an argument mapping specified as `"<arg>:<key>"`. Note the `"id:id"` key:
+Stitching infers which argument to use for queries with a single argument, or when the key name matches its intended argument. For queries that accept multiple arguments with unmatched names, the key should provide an argument alias specified as `"<arg>:<key>"`.
 
 ```graphql
+type Product {
+  id: ID!
+}
 type Query {
-  product(id: ID, upc: ID): Product @stitch(key: "id:id")
+  product(byId: ID, bySku: ID): Product @stitch(key: "byId:id")
 }
 ```
 
@@ -210,20 +231,20 @@ A type may exist in multiple locations across the graph using different keys, fo
 
 ```graphql
 type Product { id:ID! }          # storefronts location
-type Product { id:ID! upc:ID! }  # products location
-type Product { upc:ID! }         # catelog location
+type Product { id:ID! sku:ID! }  # products location
+type Product { sku:ID! }         # catelog location
 ```
 
-In the above graph, the `storefronts` and `catelog` locations have different keys that join through an intermediary. This pattern is perfectly valid and resolvable as long as the intermediary provides stitching queries for each possible key:
+In the above graph, the `storefronts` and `catelog` locations have different keys that join through an intermediary. This pattern is perfectly valid and resolvable as long as the intermediary provides resolver queries for each possible key:
 
 ```graphql
 type Product {
   id: ID!
-  upc: ID!
+  sku: ID!
 }
 type Query {
   productById(id: ID!): Product @stitch(key: "id")
-  productByUpc(upc: ID!): Product @stitch(key: "upc")
+  productBySku(sku: ID!): Product @stitch(key: "sku")
 }
 ```
 
@@ -232,10 +253,10 @@ The `@stitch` directive is also repeatable, allowing a single query to associate
 ```graphql
 type Product {
   id: ID!
-  upc: ID!
+  sku: ID!
 }
 type Query {
-  product(id: ID, upc: ID): Product @stitch(key: "id:id") @stitch(key: "upc:upc")
+  product(id: ID, sku: ID): Product @stitch(key: "id") @stitch(key: "sku")
 }
 ```
 
@@ -269,11 +290,11 @@ A clean SDL string may also have stitching directives applied via static configu
 sdl_string = <<~GRAPHQL
   type Product {
     id: ID!
-    upc: ID!
+    sku: ID!
   }
   type Query {
     productById(id: ID!): Product
-    productByUpc(upc: ID!): Product
+    productBySku(sku: ID!): Product
   }
 GRAPHQL
 
@@ -283,7 +304,7 @@ supergraph = GraphQL::Stitching::Composer.new.perform({
     executable: ->() { ... },
     stitch: [
       { field_name: "productById", key: "id" },
-      { field_name: "productByUpc", key: "upc" },
+      { field_name: "productBySku", key: "sku" },
     ]
   },
   # ...

data/docs/mechanics.md

@@ -303,3 +303,45 @@ And produces this result:
 ```
 
 Location B is allowed to return `null` here because its one unique field, `rating`, is nullable (the `id` field can be provided by Location A). If `rating` were non-null, then null bubbling would invalidate the response data.
+
+### Outbound-only merged types
+
+Merged types do not always require a resolver query. For example:
+
+```graphql
+# -- Location A
+
+type Widget {
+  id: ID!
+  name: String
+}
+
+type Query {
+  widgetA(id: ID!): Widget @stitch(key: "id")
+}
+
+# -- Location B
+
+type Widget {
+  id: ID!
+  size: Float
+}
+
+type Query {
+  widgetB(id: ID!): Widget @stitch(key: "id")
+}
+
+# -- Location C
+
+type Widget {
+  id: ID!
+  name: String
+  size: Float
+}
+
+type Query {
+  featuredWidget: Widget
+}
+```
+
+In this graph, `Widget` is a merged type without a resolver query in location C. This works because all of its fields are resolvable in other locations; that means location C can provide outbound representations of this type without ever needing to resolve inbound requests for it. Outbound types do still require a key field (such as `id` above) that allow them to join with data in other resolver locations.

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Composer
+    class BoundaryConfig
+      ENTITY_TYPENAME = "_Entity"
+      ENTITIES_QUERY = "_entities"
+
+      class << self
+        def extract_directive_assignments(schema, location, assignments)
+          return EMPTY_OBJECT unless assignments && assignments.any?
+
+          assignments.each_with_object({}) do |kwargs, memo|
+            type = kwargs[:parent_type_name] ? schema.get_type(kwargs[:parent_type_name]) : schema.query
+            raise ComposerError, "Invalid stitch directive type `#{kwargs[:parent_type_name]}`" unless type
+
+            field = type.get_field(kwargs[:field_name])
+            raise ComposerError, "Invalid stitch directive field `#{kwargs[:field_name]}`" unless field
+
+            field_path = "#{location}.#{field.name}"
+            memo[field_path] ||= []
+            memo[field_path] << from_kwargs(kwargs)
+          end
+        end
+
+        def extract_federation_entities(schema, location)
+          return EMPTY_OBJECT unless federation_entities_schema?(schema)
+
+          schema.possible_types(schema.get_type(ENTITY_TYPENAME)).each_with_object({}) do |entity_type, memo|
+            entity_type.directives.each do |directive|
+              next unless directive.graphql_name == "key"
+
+              key = directive.arguments.keyword_arguments.fetch(:fields).strip
+              raise ComposerError, "Composite federation keys are not supported." unless /^\w+$/.match?(key)
+
+              field_path = "#{location}._entities"
+              memo[field_path] ||= []
+              memo[field_path] << new(
+                key: key,
+                type_name: entity_type.graphql_name,
+                federation: true,
+              )
+            end
+          end
+        end
+
+        def from_kwargs(kwargs)
+          new(
+            key: kwargs[:key],
+            type_name: kwargs[:type_name] || kwargs[:typeName],
+            federation: kwargs[:federation] || false,
+          )
+        end
+
+        private
+
+        def federation_entities_schema?(schema)
+          entity_type = schema.get_type(ENTITY_TYPENAME)
+          entities_query = schema.query.get_field(ENTITIES_QUERY)
+          entity_type && entity_type.kind.union? && entities_query && entities_query.type.unwrap == entity_type
+        end
+      end
+
+      attr_reader :key, :type_name, :federation
+
+      def initialize(key:, type_name:, federation: false)
+        @key = key
+        @type_name = type_name
+        @federation = federation
+      end
+    end
+  end
+end

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

@@ -4,29 +4,29 @@ module GraphQL::Stitching
   class Composer
     class ValidateBoundaries < BaseValidator
 
-      def perform(ctx, composer)
-        ctx.schema.types.each do |type_name, type|
+      def perform(supergraph, composer)
+        supergraph.schema.types.each do |type_name, type|
           # objects and interfaces that are not the root operation types
           next unless type.kind.object? || type.kind.interface?
-          next if ctx.schema.query == type || ctx.schema.mutation == type
+          next if supergraph.schema.query == type || supergraph.schema.mutation == type
           next if type.graphql_name.start_with?("__")
 
           # multiple subschemas implement the type
           candidate_types_by_location = composer.candidate_types_by_name_and_location[type_name]
           next unless candidate_types_by_location.length > 1
 
-          boundaries = ctx.boundaries[type_name]
+          boundaries = supergraph.boundaries[type_name]
           if boundaries&.any?
-            validate_as_boundary(ctx, type, candidate_types_by_location, boundaries)
+            validate_as_boundary(supergraph, type, candidate_types_by_location, boundaries)
           elsif type.kind.object?
-            validate_as_shared(ctx, type, candidate_types_by_location)
+            validate_as_shared(supergraph, type, candidate_types_by_location)
           end
         end
       end
 
       private
 
-      def validate_as_boundary(ctx, type, candidate_types_by_location, boundaries)
+      def validate_as_boundary(supergraph, type, candidate_types_by_location, boundaries)
         # abstract boundaries are expanded with their concrete implementations, which each get validated. Ignore the abstract itself.
         return if type.kind.abstract?
 
@@ -41,25 +41,30 @@ module GraphQL::Stitching
           memo[boundary.location][boundary.key] = boundary
         end
 
-        boundary_keys = boundaries.map { _1.key }.uniq
-        key_only_types_by_location = candidate_types_by_location.select do |location, subschema_type|
-          subschema_type.fields.keys.length == 1 && boundary_keys.include?(subschema_type.fields.keys.first)
-        end
+        boundary_keys = boundaries.map(&:key).to_set
+
+        # All non-key fields must be resolvable in at least one boundary location
+        supergraph.locations_by_type_and_field[type.graphql_name].each do |field_name, locations|
+          next if boundary_keys.include?(field_name)
 
-        # all locations have a boundary, or else are key-only
-        candidate_types_by_location.each do |location, subschema_type|
-          unless boundaries_by_location_and_key[location] || key_only_types_by_location[location]
-            raise Composer::ValidationError, "A boundary query is required for `#{type.graphql_name}` in #{location} because it provides unique fields."
+          if locations.none? { boundaries_by_location_and_key[_1] }
+            where = locations.length > 1 ? "one of #{locations.join(", ")} locations" : locations.first
+            raise Composer::ValidationError, "A boundary query is required for `#{type.graphql_name}` in #{where} to resolve field `#{field_name}`."
           end
         end
 
-        outbound_access_locations = key_only_types_by_location.keys
-        bidirectional_access_locations = candidate_types_by_location.keys - outbound_access_locations
+        # All locations of a boundary type must include at least one key field
+        supergraph.fields_by_type_and_location[type.graphql_name].each do |location, field_names|
+          if field_names.none? { boundary_keys.include?(_1) }
+            raise Composer::ValidationError, "A boundary key is required for `#{type.graphql_name}` in #{location} to join with other locations."
+          end
+        end
 
         # verify that all outbound locations can access all inbound locations
-        (outbound_access_locations + bidirectional_access_locations).each do |location|
-          remote_locations = bidirectional_access_locations.reject { _1 == location }
-          paths = ctx.route_type_to_locations(type.graphql_name, location, remote_locations)
+        resolver_locations = boundaries_by_location_and_key.keys
+        candidate_types_by_location.each_key do |location|
+          remote_locations = resolver_locations.reject { _1 == location }
+          paths = supergraph.route_type_to_locations(type.graphql_name, location, remote_locations)
           if paths.length != remote_locations.length || paths.any? { |_loc, path| path.nil? }
             raise Composer::ValidationError, "Cannot route `#{type.graphql_name}` boundaries in #{location} to all other locations. "\
               "All locations must provide a boundary accessor that uses a conjoining key."
@@ -67,7 +72,7 @@ module GraphQL::Stitching
         end
       end
 
-      def validate_as_shared(ctx, type, candidate_types_by_location)
+      def validate_as_shared(supergraph, type, candidate_types_by_location)
         expected_fields = begin
           type.fields.keys.sort
         rescue StandardError => e
@@ -79,8 +84,8 @@ module GraphQL::Stitching
           end
         end
 
-        candidate_types_by_location.each do |location, subschema_type|
-          if subschema_type.fields.keys.sort != expected_fields
+        candidate_types_by_location.each do |location, candidate_type|
+          if candidate_type.fields.keys.sort != expected_fields
             raise Composer::ValidationError, "Shared type `#{type.graphql_name}` must have consistent fields across locations, "\
               "or else define boundary queries so that its unique fields may be accessed remotely."
           end

data/lib/graphql/stitching/composer.rb

@@ -3,6 +3,7 @@
 require_relative "./composer/base_validator"
 require_relative "./composer/validate_interfaces"
 require_relative "./composer/validate_boundaries"
+require_relative "./composer/boundary_config"
 
 module GraphQL
   module Stitching
@@ -61,12 +62,13 @@ module GraphQL
         @default_value_merger = default_value_merger || BASIC_VALUE_MERGER
         @directive_kwarg_merger = directive_kwarg_merger || BASIC_VALUE_MERGER
         @root_field_location_selector = root_field_location_selector || BASIC_ROOT_FIELD_LOCATION_SELECTOR
-        @stitch_directives = {}
+        @boundary_configs = {}
 
         @field_map = nil
         @boundary_map = nil
         @mapped_type_names = nil
         @candidate_directives_by_name_and_location = nil
+        @candidate_types_by_name_and_location = nil
         @schema_directives = nil
       end
 
@@ -187,37 +189,8 @@ module GraphQL
             raise ComposerError, "The schema for `#{location}` location must be a GraphQL::Schema class."
           end
 
-          input.fetch(:stitch, GraphQL::Stitching::EMPTY_ARRAY).each do |dir|
-            type = dir[:parent_type_name] ? schema.types[dir[:parent_type_name]] : schema.query
-            raise ComposerError, "Invalid stitch directive type `#{dir[:parent_type_name]}`" unless type
-
-            field = type.fields[dir[:field_name]]
-            raise ComposerError, "Invalid stitch directive field `#{dir[:field_name]}`" unless field
-
-            field_path = "#{location}.#{field.name}"
-            @stitch_directives[field_path] ||= []
-            @stitch_directives[field_path] << dir.slice(:key, :type_name)
-          end
-
-          federation_entity_type = schema.types["_Entity"]
-          if federation_entity_type && federation_entity_type.kind.union? && schema.query.fields["_entities"]&.type&.unwrap == federation_entity_type
-            schema.possible_types(federation_entity_type).each do |entity_type|
-              entity_type.directives.each do |directive|
-                next unless directive.graphql_name == "key"
-
-                key = directive.arguments.keyword_arguments.fetch(:fields).strip
-                raise ComposerError, "Composite federation keys are not supported." unless /^\w+$/.match?(key)
-
-                field_path = "#{location}._entities"
-                @stitch_directives[field_path] ||= []
-                @stitch_directives[field_path] << {
-                  key: key,
-                  type_name: entity_type.graphql_name,
-                  federation: true,
-                }
-              end
-            end
-          end
+          @boundary_configs.merge!(BoundaryConfig.extract_directive_assignments(schema, location, input[:stitch]))
+          @boundary_configs.merge!(BoundaryConfig.extract_federation_entities(schema, location))
 
           schemas[location.to_s] = schema
           executables[location.to_s] = input[:executable] || schema
@@ -557,19 +530,17 @@ module GraphQL
       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|
-            boundary_type_name = field_candidate.type.unwrap.graphql_name
+            boundary_type = field_candidate.type.unwrap
             boundary_structure = Util.flatten_type_structure(field_candidate.type)
-            boundary_kwargs = @stitch_directives["#{location}.#{field_name}"] || []
+            boundary_configs = @boundary_configs.fetch("#{location}.#{field_name}",  [])
 
             field_candidate.directives.each do |directive|
               next unless directive.graphql_name == GraphQL::Stitching.stitch_directive
-              boundary_kwargs << directive.arguments.keyword_arguments
+              boundary_configs << BoundaryConfig.from_kwargs(directive.arguments.keyword_arguments)
             end
 
-            boundary_kwargs.each do |kwargs|
-              key = kwargs.fetch(:key)
-              impl_type_name = kwargs.fetch(:type_name, boundary_type_name)
-              key_selections = GraphQL.parse("{ #{key} }").definitions[0].selections
+            boundary_configs.each do |config|
+              key_selections = GraphQL.parse("{ #{config.key} }").definitions[0].selections
 
               if key_selections.length != 1
                 raise ComposerError, "Boundary key at #{type_name}.#{field_name} must specify exactly one key."
@@ -578,6 +549,8 @@ module GraphQL
               argument_name = key_selections[0].alias
               argument_name ||= if field_candidate.arguments.size == 1
                 field_candidate.arguments.keys.first
+              elsif field_candidate.arguments[config.key]
+                config.key
               end
 
               argument = field_candidate.arguments[argument_name]
@@ -591,15 +564,26 @@ module GraphQL
                 raise ComposerError, "Mismatched input/output for #{type_name}.#{field_name}.#{argument_name} boundary. Arguments must map directly to results."
               end
 
-              @boundary_map[impl_type_name] ||= []
-              @boundary_map[impl_type_name] << Boundary.new(
+              boundary_type_name = if config.type_name
+                if !boundary_type.kind.abstract?
+                  raise ComposerError, "Resolver config may only specify a type name for abstract resolvers."
+                elsif !boundary_type.possible_types.find { _1.graphql_name == config.type_name }
+                  raise ComposerError, "Type `#{config.type_name}` is not a possible return type for query `#{field_name}`."
+                end
+                config.type_name
+              else
+                boundary_type.graphql_name
+              end
+
+              @boundary_map[boundary_type_name] ||= []
+              @boundary_map[boundary_type_name] << Boundary.new(
                 location: location,
-                type_name: impl_type_name,
+                type_name: boundary_type_name,
                 key: key_selections[0].name,
                 field: field_candidate.name,
                 arg: argument_name,
                 list: boundary_structure.first.list?,
-                federation: kwargs[:federation] || false,
+                federation: config.federation,
               )
             end
           end

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

@@ -5,6 +5,7 @@ module GraphQL::Stitching
     class ResolverDirective < GraphQL::Schema::Directive
       graphql_name "resolver"
       locations OBJECT, INTERFACE, UNION
+      argument :type_name, String, required: false
       argument :location, String, required: true
       argument :key, String, required: true
       argument :field, String, required: true

data/lib/graphql/stitching/supergraph.rb

@@ -31,7 +31,7 @@ module GraphQL
               kwargs = directive.arguments.keyword_arguments
               boundary_map[type_name] ||= []
               boundary_map[type_name] << Boundary.new(
-                type_name: type_name,
+                type_name: kwargs.fetch(:type_name, type_name),
                 location: kwargs[:location],
                 key: kwargs[:key],
                 field: kwargs[:field],
@@ -134,6 +134,7 @@ module GraphQL
               end
 
               type.directive(ResolverDirective, **{
+                type_name: (boundary.type_name if boundary.type_name != type_name),
                 location: boundary.location,
                 key: boundary.key,
                 field: boundary.field,

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "1.2.3"
+    VERSION = "1.2.5"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.5
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-06 00:00:00.000000000 Z
+date: 2024-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -114,6 +114,7 @@ files:
 - lib/graphql/stitching/client.rb
 - lib/graphql/stitching/composer.rb
 - lib/graphql/stitching/composer/base_validator.rb
+- lib/graphql/stitching/composer/boundary_config.rb
 - lib/graphql/stitching/composer/validate_boundaries.rb
 - lib/graphql/stitching/composer/validate_interfaces.rb
 - lib/graphql/stitching/executor.rb