graphql-stitching 1.5.1 → 1.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8fb3561ddb47de2d07bdcdf32e940e1a151dff731081b2b4bffe09489809021
-  data.tar.gz: 9163e0d0e5116e232ee0594821d02568f85405c7fdc0f80e085e713d2e4d3a71
+  metadata.gz: cf60ae0ef85426a3011223bcc146a74a1664762e5488d8266d0afbf1c2143457
+  data.tar.gz: d20da5d4817193de7e156441cab88b0855f3fa93aeabe5e760f8fd66ac5b3547
 SHA512:
-  metadata.gz: 6823d661a3f812fbf11bbf14edf66f3da27a850399f909061c63d464d3be93777fe7f9c7158ea26cc0d1889aed04749d3ad10cd42c3ca76079604447ab66e3cc
-  data.tar.gz: 27dee9de11b90e960fb0c17d68129332ede38d237ef37ae1eca4cdca2c83696dec4b6c9f0283ee7f508c4f5076029afc81efa4b58d60e5b74411a6a368092947
+  metadata.gz: b89843bfdd353a6b4aec47fce17a6bd6524b29f7d5fa5dc0452570dc1b4bec63691171f7cd3f841c393015df763e20e1be7cf907cc660fcc576cc93e08c3d4dd
+  data.tar.gz: a20f68f8bac0a52271fdc76ec4f173347669acda7f49b18e177746c83df1ec42dc878e8d3af37545a99f5456acc6d9f7577600d79c4568925cd23837fe5c2d0a

data/.github/workflows/ci.yml

@@ -13,22 +13,20 @@ jobs:
       matrix:
         include:
           - gemfile: Gemfile
+            ruby: 3.3
+          - gemfile: gemfiles/graphql_2.3.0.gemfile
             ruby: 3.2
-          - gemfile: Gemfile
-            ruby: 3.1
-          - gemfile: Gemfile
-            ruby: 2.7
           - gemfile: gemfiles/graphql_2.2.0.gemfile
             ruby: 3.1
           - gemfile: gemfiles/graphql_2.1.0.gemfile
             ruby: 3.1
           - gemfile: gemfiles/graphql_2.0.0.gemfile
             ruby: 3.1
-          - gemfile: gemfiles/graphql_1.13.9.gemfile
-            ruby: 3.1
-
+          - gemfile: gemfiles/graphql_2.0.0.gemfile
+            ruby: 2.7
     steps:
-    - uses: actions/checkout@v2
+    - run: echo BUNDLE_GEMFILE=${{ matrix.gemfile }} > $GITHUB_ENV
+    - uses: actions/checkout@v4
     - name: Setup Ruby
       uses: ruby/setup-ruby@v1
       with:

data/Gemfile

@@ -6,3 +6,4 @@ gemspec
 gem 'pry'
 gem 'pry-byebug'
 gem 'warning'
+gem 'minitest-stub-const'

data/README.md

@@ -1,14 +1,13 @@
 ## GraphQL Stitching for Ruby
 
-GraphQL stitching composes a single schema from multiple underlying GraphQL resources, then smartly proxies portions of incoming requests to their respective locations in dependency order and returns the merged results. This allows an entire location graph to be queried through one combined GraphQL surface area.
+GraphQL stitching composes a single schema from multiple underlying GraphQL resources, then smartly proxies portions of incoming requests to their respective locations in dependency order and returns the merged results. This allows an entire graph of locations to be queried through one combined GraphQL surface area.
 
 ![Stitched graph](./docs/images/stitching.png)
 
 **Supports:**
 - All operation types: query, mutation, and [subscription](./docs/subscriptions.md).
-- Merged object and abstract types.
+- Merged object and abstract types joining though multiple keys.
 - Shared objects, fields, enums, and inputs across locations.
-- Multiple and composite type keys.
 - Combining local and remote schemas.
 - [File uploads](./docs/http_executable.md) via multipart forms.
 - Tested with all minor versions of `graphql-ruby`.
@@ -17,7 +16,7 @@ GraphQL stitching composes a single schema from multiple underlying GraphQL reso
 - Computed fields (ie: federation-style `@requires`).
 - 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 federated reverse proxy, consider not using Ruby.
+This Ruby implementation is designed as a generic library to join basic spec-compliant GraphQL schemas using their existing types and fields in a [DIY](https://dictionary.cambridge.org/us/dictionary/english/diy) capacity. 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 a purely high-throughput federation gateway with managed schema deployments, consider more opinionated frameworks such as [Apollo Federation](https://www.apollographql.com/docs/federation/).
 
 ## Getting started
 
@@ -88,17 +87,59 @@ While `Client` is sufficient for most usecases, the library offers several discr
 
 ![Merging types](./docs/images/merging.png)
 
-To facilitate this merging of types, stitching must know how to cross-reference and fetch each variant of a type from its source location 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](#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).
+
+### Merged type keys
+
+Foreign keys in a GraphQL schema frequently look like the `Product.imageId` field here:
+
+```graphql
+# -- Products schema:
+
+type Product {
+  id: ID!
+  imageId: ID!
+}
+
+# -- Images schema:
+
+type Image {
+  id: ID!
+  url: String!
+}
+```
+
+However, this design does not lend itself to merging types across locations. A simple schema refactor makes this foreign key more expressive as an entity type, and turns the key into an _object_ that will merge with analogous objects in other locations:
+
+```graphql
+# -- Products schema:
+
+type Product {
+  id: ID!
+  image: Image!
+}
+
+type Image {
+  id: ID!
+}
+
+# -- Images schema:
+
+type Image {
+  id: ID!
+  url: String!
+}
+```
 
 ### Merged type resolver queries
 
-Types merge through resolver queries identified by a `@stitch` directive:
+Each location that provides a unique variant of a type must provide at least one _resolver query_ for accessing it. Type resolvers are root queries identified by a `@stitch` directive:
 
 ```graphql
 directive @stitch(key: String!, arguments: String) repeatable on FIELD_DEFINITION
 ```
 
-This directive (or [static configuration](#sdl-based-schemas)) is applied to root queries where a merged type may be accessed in each location, and a `key` argument specifies a field needed from other locations to be used as a query argument.
+This directive tells stitching how to cross-reference and fetch types from across locations, for example:
 
 ```ruby
 products_schema = <<~GRAPHQL
@@ -151,10 +192,10 @@ 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](#argument-shapes) later).
+* The `@stitch` directive marks a root query where the merged type may be accessed. The merged type identity is inferred from the field return. This identifier can also be provided as [static configuration](#sdl-based-schemas).
+* The `key: "id"` parameter indicates that an `{ id }` must be selected from prior locations so it can be submitted as an argument to this query. The query argument used to send the key is inferred when possible ([more on arguments](#argument-shapes) later).
 
-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:
+Merged types must have a resolver query in each of their possible locations. The one exception to this requirement are [outbound-only types](./docs/mechanics.md#outbound-only-merged-types) that contain no exclusive data, such as foreign keys:
 
 ```graphql
 type Product {
@@ -162,7 +203,7 @@ type Product {
 }
 ```
 
-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.
+The above type contains nothing but a key field that is available in other locations. Therefore, this variant will never require an inbound request to fetch it, and its resolver query may be omitted from this location.
 
 #### List queries
 
@@ -258,7 +299,6 @@ Resolver keys may make composite selections for multiple key fields and/or neste
 ```graphql
 interface FieldOwner {
   id: ID!
-  type: String!
 }
 type CustomField {
   owner: FieldOwner!
@@ -273,8 +313,8 @@ input CustomFieldLookup {
 
 type Query {
   customFields(lookups: [CustomFieldLookup!]!): [CustomField]! @stitch(
-    key: "owner { id type } key",
-    arguments: "lookups: { ownerId: $.owner.id, ownerType: $.owner.type, key: $.key }"
+    key: "owner { id __typename } key",
+    arguments: "lookups: { ownerId: $.owner.id, ownerType: $.owner.__typename, key: $.key }"
   )
 }
 ```
@@ -443,7 +483,6 @@ The [Executor](./docs/executor.md) component builds atop the Ruby fiber-based im
 
 ## Additional topics
 
-- [Modeling foreign keys for stitching](./docs/mechanics.md##modeling-foreign-keys-for-stitching)
 - [Deploying a stitched schema](./docs/mechanics.md#deploying-a-stitched-schema)
 - [Schema composition merge patterns](./docs/composer.md#merge-patterns)
 - [Subscriptions tutorial](./docs/subscriptions.md)

data/docs/composer.md

@@ -10,6 +10,7 @@ A `Composer` may be constructed with optional settings that tune how it builds a
 composer = GraphQL::Stitching::Composer.new(
   query_name: "Query",
   mutation_name: "Mutation",
+  subscription_name: "Subscription",
   description_merger: ->(values_by_location, info) { values_by_location.values.join("\n") },
   deprecation_merger: ->(values_by_location, info) { values_by_location.values.first },
   default_value_merger: ->(values_by_location, info) { values_by_location.values.first },
@@ -24,6 +25,8 @@ Constructor arguments:
 
 - **`mutation_name:`** _optional_, the name of the root mutation type in the composed schema; `Mutation` by default. The root mutation types from all location schemas will be merged into this type, regardless of their local names.
 
+- **`subscription_name:`** _optional_, the name of the root subscription type in the composed schema; `Subscription` by default. The root subscription types from all location schemas will be merged into this type, regardless of their local names.
+
 - **`description_merger:`** _optional_, a [value merger function](#value-merger-functions) for merging element description strings from across locations.
 
 - **`deprecation_merger:`** _optional_, a [value merger function](#value-merger-functions) for merging element deprecation strings from across locations.
@@ -98,17 +101,16 @@ Location settings have top-level keys that specify arbitrary location names, eac
 
 The strategy used to merge source schemas into the combined schema is based on each element type:
 
+- Arguments of fields, directives, and `InputObject` types intersect for each parent element across locations (an element's arguments must appear in all locations):
+  - Arguments must share a value type, and the strictest nullability across locations is used.
+  - Composition fails if argument intersection would eliminate a non-null argument.
+
 - `Object` and `Interface` types merge their fields and directives together:
   - Common fields across locations must share a value type, and the weakest nullability is used.
-  - Field and directive arguments merge using the same rules as `InputObject`.
   - Objects with unique fields across locations must implement [`@stitch` accessors](../README.md#merged-types).
   - Shared object types without `@stitch` accessors must contain identical fields.
   - Merged interfaces must remain compatible with all underlying implementations.
 
-- `InputObject` types intersect arguments from across locations (arguments must appear in all locations):
-  - Arguments must share a value type, and the strictest nullability across locations is used.
-  - Composition fails if argument intersection would eliminate a non-null argument.
-
 - `Enum` types merge their values based on how the enum is used:
   - Enums used anywhere as an argument will intersect their values (common values across all locations).
   - Enums used exclusively in read contexts will provide a union of values (all values across all locations).
@@ -118,7 +120,6 @@ The strategy used to merge source schemas into the combined schema is based on e
 - `Scalar` types are added for all scalar names across all locations.
 
 - `Directive` definitions are added for all distinct names across locations:
-  - Arguments merge using the same rules as `InputObject`.
   - Stitching directives (both definitions and assignments) are omitted.
 
 Note that the structure of a composed schema may change based on new schema additions and/or element usage (ie: changing input object arguments in one service may cause the intersection of arguments to change). Therefore, it's highly recommended that you use a [schema comparator](https://github.com/xuorig/graphql-schema_comparator) to flag regressions across composed schema versions.

data/docs/federation_entities.md

@@ -65,6 +65,6 @@ It's perfectly fine to mix and match schemas that implement an `_entities` query
 
 ### Federation features that will most definitly break
 
-- `@external` fields will confuse the stitching query planner.
+- `@external` fields will confuse the stitching query planner (as the fields aren't natively resolvable at the location).
 - `@requires` fields will not be sent any dependencies.
 - No support for Apollo composition directives.

data/docs/mechanics.md

@@ -1,47 +1,5 @@
 ## Schema Stitching, mechanics
 
-### Modeling foreign keys for stitching
-
-Foreign keys in a GraphQL schema typically look like the `Product.imageId` field here:
-
-```graphql
-# -- Products schema:
-
-type Product {
-  id: ID!
-  imageId: ID!
-}
-
-# -- Images schema:
-
-type Image {
-  id: ID!
-  url: String!
-}
-```
-
-However, this design does not lend itself to stitching where types need to _merge_ across locations. A simple schema refactor makes this foreign key more expressive as an entity type, and turns the key into an _object_ that will merge with analogous object types in other locations:
-
-```graphql
-# -- Products schema:
-
-type Product {
-  id: ID!
-  image: Image!
-}
-
-type Image {
-  id: ID!
-}
-
-# -- Images schema:
-
-type Image {
-  id: ID!
-  url: String!
-}
-```
-
 ### 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:
@@ -94,7 +52,7 @@ class GraphQlController
 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.
+This process assures that composition always happens before deployment where failures can be detected. Use CI to verify that the repo's supergraph output is always up to date. 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
 

data/docs/request.md

@@ -15,15 +15,15 @@ request = GraphQL::Stitching::Request.new(
 
 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
+- `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 digest of the request string, hashed by the `Stitching.digest` implementation.
+- `req.normalized_string`: printed document string with consistent whitespace.
+- `req.normalized_digest`: a digest of the normalized string, hashed by the `Stitching.digest` implementation.
+- `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.
 
 ### Request lifecycle
 
@@ -32,5 +32,5 @@ component, or you may invoke them manually:
 
 1. `request.validate`: runs static validations on the request using the combined schema.
 2. `request.prepare!`: inserts variable defaults and pre-renders skip/include conditional shaping.
-3. `request.plan`: builds a plan for the request. May act as a setting for plans pulled from cache.
+3. `request.plan`: builds a plan for the request. May act as a setter for plans pulled from cache.
 4. `request.execute`: executes the request, and returns the resulting data.

data/docs/subscriptions.md

@@ -4,7 +4,7 @@ Stitching is an interesting prospect for subscriptions because socket-based inte
 
 ### Composing a subscriptions schema
 
-For simplicity, subscription resolvers should exist together in a single schema (multiple schemas with subscriptions probably aren't worth the confusion). This subscriptions schema may provide basic entity types that will merge with other locations. For example, here's a bare-bones subscriptions schema:
+For simplicity, subscription resolvers are best kept together in a single schema (multiple schemas with subscriptions probably aren't worth the confusion). This subscriptions schema may provide basic entity types that will merge with other locations. For example, here's a bare-bones subscriptions schema:
 
 ```ruby
 class SubscriptionSchema < GraphQL::Schema
@@ -122,7 +122,7 @@ class GraphqlController < ApplicationController
   def execute
     result = StitchedSchema.execute(
       params[:query],
-      context: {}, 
+      context: {},
       variables: params[:variables],
       operation_name: params[:operationName],
     )
@@ -164,7 +164,7 @@ class GraphqlChannel < ApplicationCable::Channel
 
   def unsubscribed
     @subscription_ids.each { |sid|
-      # Go directly through the subscriptions subschema 
+      # Go directly through the subscriptions subschema
       # when managing/triggering subscriptions:
       SubscriptionSchema.subscriptions.delete_subscription(sid)
     }
@@ -172,7 +172,7 @@ class GraphqlChannel < ApplicationCable::Channel
 end
 ```
 
-What happens behind the scenes here is that stitching filters the `execute` request down to just subscription selections, and passes those through to the subscriptions subschema where they register an event binding. The subscriber response gets stitched while passing back out through the stitching client.
+What happens behind the scenes here is that stitching filters the `execute` request down to just subscription selections, and passes those through to the subscriptions subschema where they register an event binding. The subscriber response gets stitched while passing back out through the stitching client. The `unsubscribed` method works directly with the subschema where subscriptions are managed.
 
 #### Plugin
 
@@ -188,7 +188,7 @@ class StitchedActionCableSubscriptions < GraphQL::Subscriptions::ActionCableSubs
 end
 
 class SubscriptionSchema < GraphQL::Schema
-  # switch the plugin on the subscriptions schema to use the patched class... 
+  # switch the plugin on the subscriptions schema to use the patched class...
   use StitchedActionCableSubscriptions
 end
 ```
@@ -200,7 +200,7 @@ Subscription update events are triggered as normal directly through the subscrip
 ```ruby
 class Comment < ApplicationRecord
   after_create :trigger_subscriptions
-  
+
   def trigger_subscriptions
     SubscriptionsSchema.subscriptions.trigger(:comment_added_to_post, { post_id: post_id }, self)
   end

data/docs/supergraph.md

@@ -9,17 +9,17 @@ A Supergraph is designed to be composed, cached, and restored. Calling `to_defin
 ```ruby
 supergraph_sdl = supergraph.to_definition
 
-# stash this composed schema in a cache...
-$cache.set("cached_supergraph_sdl", supergraph_sdl)
-
-# or, write the composed schema as a file into your repo...
+# write the composed schema as a file into your repo...
 File.write("supergraph/schema.graphql", supergraph_sdl)
+
+# or, stash this composed schema in a cache...
+$cache.set("cached_supergraph_sdl", supergraph_sdl)
 ```
 
 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 = $cache.get("cached_supergraph_sdl")
+supergraph_sdl = File.read("supergraph/schema.graphql")
 
 supergraph = GraphQL::Stitching::Supergraph.from_definition(
   supergraph_sdl,

data/gemfiles/graphql_2.0.0.gemfile

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

data/gemfiles/graphql_2.1.0.gemfile

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

data/gemfiles/graphql_2.2.0.gemfile

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

data/gemfiles/graphql_2.3.0.gemfile

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

data/graphql-stitching.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'graphql', '>= 1.13.9'
+  spec.add_runtime_dependency 'graphql', '>= 2.0'
 
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'rake', '~> 12.0'

data/lib/graphql/stitching/client.rb

@@ -7,8 +7,6 @@ module GraphQL
     # Client is an out-of-the-box helper that assembles all 
     # stitching components into a workflow that executes requests.
     class Client
-      class ClientError < StitchingError; end
-
       # @return [Supergraph] composed supergraph that services incoming requests.
       attr_reader :supergraph
 
@@ -18,9 +16,9 @@ module GraphQL
       # @param composer [Composer] optional, a pre-configured composer instance for use with `locations` configuration.
       def initialize(locations: nil, supergraph: nil, composer: nil)
         @supergraph = if locations && supergraph
-          raise ClientError, "Cannot provide both locations and a supergraph."
+          raise ArgumentError, "Cannot provide both locations and a supergraph."
         elsif supergraph && !supergraph.is_a?(Supergraph)
-          raise ClientError, "Provided supergraph must be a GraphQL::Stitching::Supergraph instance."
+          raise ArgumentError, "Provided supergraph must be a GraphQL::Stitching::Supergraph instance."
         elsif supergraph
           supergraph
         else
@@ -58,17 +56,17 @@ module GraphQL
       end
 
       def on_cache_read(&block)
-        raise ClientError, "A cache read block is required." unless block_given?
+        raise ArgumentError, "A cache read block is required." unless block_given?
         @on_cache_read = block
       end
 
       def on_cache_write(&block)
-        raise ClientError, "A cache write block is required." unless block_given?
+        raise ArgumentError, "A cache write block is required." unless block_given?
         @on_cache_write = block
       end
 
       def on_error(&block)
-        raise ClientError, "An error handler block is required." unless block_given?
+        raise ArgumentError, "An error handler block is required." unless block_given?
         @on_error = block
       end
 

data/lib/graphql/stitching/composer.rb

@@ -403,8 +403,13 @@ module GraphQL
             next
           end
 
-          # Getting double args sometimes on auto-generated connection types... why?
-          next if owner.arguments.any? { _1.first == argument_name }
+          # 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|

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

@@ -64,7 +64,7 @@ module GraphQL::Stitching
             return nil if result.nil?
 
           else
-            raise StitchingError, "Unexpected node of type #{node.class.name} in selection set."
+            raise DocumentError.new("selection node type")
           end
         end
 
@@ -118,7 +118,7 @@ module GraphQL::Stitching
       def typename_in_type?(typename, type)
         return true if type.graphql_name == typename
 
-        type.kind.abstract? && @request.warden.possible_types(type).any? do |t|
+        type.kind.abstract? && @supergraph.schema.possible_types(type).any? do |t|
           t.graphql_name == typename
         end
       end

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

@@ -10,7 +10,7 @@ module GraphQL::Stitching
       end
 
       def fetch(ops)
-        origin_sets_by_operation = ops.each_with_object({}) do |op, memo|
+        origin_sets_by_operation = ops.each_with_object({}.compare_by_identity) do |op, memo|
           origin_set = op.path.reduce([@executor.data]) do |set, path_segment|
             set.flat_map { |obj| obj && obj[path_segment] }.tap(&:compact!)
           end
@@ -86,7 +86,7 @@ module GraphQL::Stitching
           end
         end
 
-        doc = String.new("query") # << resolver fulfillment always uses query
+        doc = String.new(QUERY_OP) # << resolver fulfillment always uses query
 
         if operation_name
           doc << " #{operation_name}"

data/lib/graphql/stitching/executor.rb

@@ -27,7 +27,7 @@ module GraphQL
       # Builds a new executor.
       # @param request [Request] the stitching request to execute.
       # @param nonblocking [Boolean] specifies if the dataloader should use async concurrency.
-      def initialize(request, data: {}, errors: [], after: 0, nonblocking: false)
+      def initialize(request, data: {}, errors: [], after: Planner::ROOT_INDEX, nonblocking: false)
         @request = request
         @data = data
         @errors = errors
@@ -38,7 +38,7 @@ module GraphQL
       end
 
       def perform(raw: false)
-        exec!
+        exec!([@after])
         result = {}
 
         if @data && @data.length > 0
@@ -54,7 +54,7 @@ module GraphQL
 
       private
 
-      def exec!(next_steps = [@after])
+      def exec!(next_steps)
         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."

data/lib/graphql/stitching/planner.rb

@@ -20,7 +20,7 @@ module GraphQL
       def perform
         build_root_entrypoints
         expand_abstract_resolvers
-        Plan.new(ops: steps.map(&:to_plan_op))
+        Plan.new(ops: steps.map!(&:to_plan_op))
       end
 
       def steps
@@ -76,9 +76,7 @@ module GraphQL
         resolver: nil
       )
         # coalesce repeat parameters into a single entrypoint
-        entrypoint = String.new("#{parent_index}/#{location}/#{parent_type.graphql_name}/#{resolver&.key&.to_definition}/#")
-        path.each { entrypoint << "/#{_1}" }
-
+        entrypoint = [parent_index, location, parent_type.graphql_name, resolver&.key&.to_definition, "#", *path].join("/")
         step = @steps_by_entrypoint[entrypoint]
         next_index = step ? parent_index : @planning_index += 1
 
@@ -156,7 +154,7 @@ module GraphQL
         when SUBSCRIPTION_OP
           # A.3) Permit exactly one subscription field.
           each_field_in_scope(parent_type, @request.operation.selections) do |node|
-            raise StitchingError, "Too many root fields for subscription." unless @steps_by_entrypoint.empty?
+            raise DocumentError.new("root field") unless @steps_by_entrypoint.empty?
 
             locations = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name] || SUPERGRAPH_LOCATIONS
             add_step(
@@ -169,7 +167,7 @@ module GraphQL
           end
 
         else
-          raise StitchingError, "Invalid operation type."
+          raise DocumentError.new("operation type")
         end
       end
 
@@ -189,7 +187,7 @@ module GraphQL
             each_field_in_scope(parent_type, fragment.selections, &block)
 
           else
-            raise StitchingError, "Unexpected node of type #{node.class.name} in selection set."
+            raise DocumentError.new("selection node type")
           end
         end
       end
@@ -271,7 +269,7 @@ module GraphQL
             end
 
           else
-            raise StitchingError, "Unexpected node of type #{node.class.name} in selection set."
+            raise DocumentError.new("selection node type")
           end
         end
 
@@ -333,7 +331,7 @@ module GraphQL
         end
 
         if expanded_selections
-          @request.warden.possible_types(parent_type).each do |possible_type|
+          @supergraph.schema.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

@@ -26,9 +26,6 @@ module GraphQL
       # @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.
@@ -58,7 +55,6 @@ module GraphQL
         @variables = variables || {}
 
         @query = GraphQL::Query.new(@supergraph.schema, document: @document, context: context)
-        @warden = @query.warden
         @context = @query.context
         @context[:request] = self
       end
@@ -141,7 +137,7 @@ module GraphQL
       # Validates the request using the combined supergraph schema.
       # @return [Array<GraphQL::ExecutionError>] an array of static validation errors
       def validate
-        result = @supergraph.static_validator.validate(@query)
+        result = @supergraph.schema.static_validator.validate(@query)
         result[:errors]
       end
 

data/lib/graphql/stitching/supergraph.rb

@@ -50,11 +50,6 @@ module GraphQL
         end.freeze
       end
 
-      # @return [GraphQL::StaticValidation::Validator] static validator for the supergraph schema.
-      def static_validator
-        @static_validator ||= @schema.static_validator
-      end
-
       def resolvers_by_version
         @resolvers_by_version ||= resolvers.values.tap(&:flatten!).each_with_object({}) do |resolver, memo|
           memo[resolver.version] = resolver

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "1.5.1"
+    VERSION = "1.5.2"
   end
 end

data/lib/graphql/stitching.rb

@@ -25,6 +25,11 @@ module GraphQL
     class StitchingError < StandardError; end
     class CompositionError < StitchingError; end
     class ValidationError < CompositionError; end
+    class DocumentError < StandardError
+      def initialize(element)
+        super("Invalid #{element} encountered in document")
+      end
+    end
 
     class << self
       attr_writer :stitch_directive

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.5.2
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2025-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.13.9
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.13.9
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -151,10 +151,10 @@ files:
 - examples/subscriptions/public/apple-touch-icon.png
 - examples/subscriptions/public/favicon.ico
 - examples/subscriptions/public/robots.txt
-- gemfiles/graphql_1.13.9.gemfile
 - gemfiles/graphql_2.0.0.gemfile
 - gemfiles/graphql_2.1.0.gemfile
 - gemfiles/graphql_2.2.0.gemfile
+- gemfiles/graphql_2.3.0.gemfile
 - graphql-stitching.gemspec
 - lib/graphql/stitching.rb
 - lib/graphql/stitching/client.rb

data/gemfiles/graphql_1.13.9.gemfile

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-gemspec
-
-gem 'graphql', '~> 1.13.9'