graphql-stitching 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cdcb3361e391ba9b6dd78aa38c308c08ddb6fde2720d15208e8dfb96c3006ea
-  data.tar.gz: 9f64b024bda3987d1c523cf52b49f0ca2dfd688ac4c89bbf18de30c88c098156
+  metadata.gz: 32918bd6b17708d712d3ac945f6007b0405299379372aabda8b0c3a5f0c246da
+  data.tar.gz: 608562f6b35cfe912e2388c6cbfce8c774bedc6f6518d257eb0de8b45fdc8b52
 SHA512:
-  metadata.gz: b51bcfeaa20e9cdea6c2d4b4e472e8c23e13ec8af36e1b23852603d0329045af064e3ae738467a0823be0c9f545105acba001b708c207eb7f08d51ebf0791e1f
-  data.tar.gz: c529e74c88fc7193d7823d8c92a488b3e459b5ba9f88e8d62355ae2bd5e9eb0ed2b0d6f7fd14b6b8ed13ab1bb53a93bc5da49dcecd5deb92ee180fa70604c80b
+  metadata.gz: c0f40d79e3b06c9477f5967f12f6e33c0534b916c3454669d2802357137ff78d7bb9bb7d99d7c82d43ea47f58fac1c4d0e5aa38243d4cbfcdec6ba192ef56c0e
+  data.tar.gz: eed8c018a8efde4500bb0eb93de78803f555c77fad284718e945648160442eea249439d2a2cb5b4c0a5121fc148197f48b9ea0d50a21e7cfa291499fe4533912

data/Gemfile

@@ -3,9 +3,6 @@
 source 'https://rubygems.org'
 gemspec
 
-gem 'rack'
-gem 'rackup'
-gem 'foreman'
 gem 'pry'
 gem 'pry-byebug'
 gem 'warning'

data/README.md

@@ -10,6 +10,7 @@ GraphQL stitching composes a single schema from multiple underlying GraphQL reso
 - Shared objects, fields, enums, and inputs across locations.
 - Combining local and remote schemas.
 - Type merging via arbitrary queries or federation `_entities` protocol.
+- File uploads via [multipart form spec](https://github.com/jaydenseric/graphql-multipart-request-spec).
 
 **NOT Supported:**
 - Computed fields (ie: federation-style `@requires`).
@@ -80,6 +81,7 @@ While the `Client` constructor is an easy quick start, the library also has seve
 - [Request](./docs/request.md) - prepares a requested GraphQL document and variables for stitching.
 - [Planner](./docs/planner.md) - builds a cacheable query plan for a request document.
 - [Executor](./docs/executor.md) - executes a query plan with given request variables.
+- [HttpExecutable](./docs/http_executable.md) - proxies requests to remotes with multipart file upload support.
 
 ## Merged types
 
@@ -360,11 +362,11 @@ It's perfectly fine to mix and match schemas that implement an `_entities` query
 
 ## Executables
 
-An executable resource performs location-specific GraphQL requests. Executables may be `GraphQL::Schema` classes, or any object that responds to `.call(location, source, variables, context)` and returns a raw GraphQL response:
+An executable resource performs location-specific GraphQL requests. Executables may be `GraphQL::Schema` classes, or any object that responds to `.call(request, source, variables)` and returns a raw GraphQL response:
 
 ```ruby
 class MyExecutable
-  def call(location, source, variables, context)
+  def call(request, source, variables)
     # process a GraphQL request...
     return {
       "data" => { ... },
@@ -392,12 +394,12 @@ supergraph = GraphQL::Stitching::Composer.new.perform({
   },
   fourth: {
     schema: FourthSchema,
-    executable: ->(loc, query, vars, ctx) { ... },
+    executable: ->(req, query, vars) { ... },
   },
 })
 ```
 
-The `GraphQL::Stitching::HttpExecutable` class is provided as a simple executable wrapper around `Net::HTTP.post`. You should build your own executables to leverage your existing libraries and to add instrumentation. Note that you must manually assign all executables to a `Supergraph` when rehydrating it from cache ([see docs](./docs/supergraph.md)).
+The `GraphQL::Stitching::HttpExecutable` class is provided as a simple executable wrapper around `Net::HTTP.post` with [file upload](./docs/http_executable.md#graphql-file-uploads) support. You should build your own executables to leverage your existing libraries and to add instrumentation. Note that you must manually assign all executables to a `Supergraph` when rehydrating it from cache ([see docs](./docs/supergraph.md)).
 
 ## Batching
 
@@ -431,36 +433,12 @@ The [Executor](./docs/executor.md) component builds atop the Ruby fiber-based im
 - [Stitched errors](./docs/mechanics.md#stitched-errors)
 - [Null results](./docs/mechanics.md#null-results)
 
-## Example
+## Examples
 
-This repo includes a working example of several stitched schemas running across small Rack servers. Try running it:
+This repo includes working examples of stitched schemas running across small Rack servers. Clone the repo, `cd` into each example and try running it following its README instructions.
 
-```shell
-bundle install
-foreman start
-```
-
-Then visit the gateway service at `http://localhost:3000` and try this query:
-
-```graphql
-query {
-  storefront(id: "1") {
-    id
-    products {
-      upc
-      name
-      price
-      manufacturer {
-        name
-        address
-        products { upc name }
-      }
-    }
-  }
-}
-```
-
-The above query collects data from all locations, two of which are remote schemas and the third a local schema. The combined graph schema is also stitched in to provide introspection capabilities.
+- [Merged types](./examples/merged_types)
+- [File uploads](./examples/file_uploads)
 
 ## Tests
 

data/docs/README.md

@@ -12,6 +12,7 @@ Major components include:
 - [Request](./request.md) - prepares a requested GraphQL document and variables for stitching.
 - [Planner](./planner.md) - builds a cacheable query plan for a request document.
 - [Executor](./executor.md) - executes a query plan with given request variables.
+- [HttpExecutable](./http_executable.md) - proxies requests to remotes with multipart file upload support.
 
 Additional topics:
 

data/docs/client.md

@@ -60,11 +60,11 @@ The client provides cache hooks to enable caching query plans across requests. W
 
 ```ruby
 client.on_cache_read do |request|
-  $redis.get(request.digest) # << 3P code
+  $cache.get(request.digest) # << 3P code
 end
 
 client.on_cache_write do |request, payload|
-  $redis.set(request.digest, payload) # << 3P code
+  $cache.set(request.digest, payload) # << 3P code
 end
 ```
 

data/docs/composer.md

@@ -90,7 +90,7 @@ Location settings have top-level keys that specify arbitrary location names, eac
 
 - **`schema:`** _required_, provides a `GraphQL::Schema` class for the location. This may be a class-based schema that inherits from `GraphQL::Schema`, or built from SDL (Schema Definition Language) string using `GraphQL::Schema.from_definition` and mapped to a remote location. The provided schema is only used for type reference and does not require any real data resolvers (unless it is also used as the location's executable, see below).
 
-- **`executable:`** _optional_, provides an executable resource to be called when delegating a request to this location. Executables are `GraphQL::Schema` classes or any object with a `.call(location, source, variables, context)` method that returns a GraphQL response. Omitting the executable option will use the location's provided `schema` as the executable resource.
+- **`executable:`** _optional_, provides an executable resource to be called when delegating a request to this location. Executables are `GraphQL::Schema` classes or any object with a `.call(request, source, variables)` method that returns a GraphQL response. Omitting the executable option will use the location's provided `schema` as the executable resource.
 
 - **`stitch:`** _optional_, an array of configs used to dynamically apply `@stitch` directives to select root fields prior to composing. This is useful when you can't easily render stitching directives into a location's source schema.
 

data/docs/executor.md

@@ -13,22 +13,18 @@ query = <<~GRAPHQL
 GRAPHQL
 
 request = GraphQL::Stitching::Request.new(
+  supergraph,
   query,
   variables: { "id" => "123" },
   operation_name: "MyQuery",
   context: { ... },
 )
 
-plan = GraphQL::Stitching::Planner.new(
-  supergraph: supergraph,
-  request: request,
-).perform
+# Via Request:
+result = request.execute
 
-result = GraphQL::Stitching::Executor.new(
-  supergraph: supergraph,
-  request: request,
-  plan: plan,
-).perform
+# Via Executor:
+result = GraphQL::Stitching::Executor.new(request).perform
 ```
 
 ### Raw results
@@ -36,12 +32,9 @@ result = GraphQL::Stitching::Executor.new(
 By default, execution results are always returned with document shaping (stitching additions removed, missing fields added, null bubbling applied). You may access the raw execution result by calling the `perform` method with a `raw: true` argument:
 
 ```ruby
-# get the raw result without shaping
-raw_result = GraphQL::Stitching::Executor.new(
-  supergraph: supergraph,
-  request: request,
-  plan: plan,
-).perform(raw: true)
+# get the raw result without shaping using either form:
+raw_result = request.execute(raw: true)
+raw_result = GraphQL::Stitching::Executor.new(request).perform(raw: true)
 ```
 
 The raw result will contain many irregularities from the stitching process, however may be insightful when debugging inconsistencies in results:

data/docs/http_executable.md

@@ -0,0 +1,51 @@
+## GraphQL::Stitching::HttpExecutable
+
+A `HttpExecutable` provides an out-of-the-box convenience for sending HTTP post requests to a remote location, or a base class for your own implementation with [GraphQL multipart uploads](https://github.com/jaydenseric/graphql-multipart-request-spec).
+
+```ruby
+exe = GraphQL::Stitching::HttpExecutable.new(
+  url: "http://localhost:3001",
+  headers: {
+    "Authorization" => "..."
+  }
+)
+```
+
+### GraphQL file uploads
+
+The [GraphQL Upload Spec](https://github.com/jaydenseric/graphql-multipart-request-spec) defines a multipart form structure for submitting GraphQL requests with file upload attachments. It's possible to pass these requests through stitched schemas using the following:
+
+#### 1. Input file uploads as Tempfile variables
+
+```ruby
+client.execute(
+  "mutation($file: Upload) { upload(file: $file) }",
+  variables: { "file" => Tempfile.new(...) }
+)
+```
+
+File uploads must enter the stitched schema as standard GraphQL variables with `Tempfile` values. The simplest way to recieve this input is to install [apollo_upload_server](https://github.com/jetruby/apollo_upload_server-ruby) into your stitching app's middleware so that multipart form submissions automatically unpack into standard variables.
+
+#### 2. Enable `HttpExecutable.upload_types`
+
+```ruby
+client = GraphQL::Stitching::Client.new(locations: {
+  alpha: {
+    schema: GraphQL::Schema.from_definition(...),
+    executable: GraphQL::Stitching::HttpExecutable.new(
+      url: "http://localhost:3000",
+      upload_types: ["Upload"], # << extract `Upload` scalars into multipart forms
+    ),
+  },
+  bravo: {
+    schema: GraphQL::Schema.from_definition(...),
+    executable: GraphQL::Stitching::HttpExecutable.new(
+      url: "http://localhost:3001"
+    ),
+  },
+})
+```
+
+A location's `HttpExecutable` can then re-package `Tempfile` variables into multipart forms before sending them upstream. This is enabled with an `upload_types` parameter that specifies which scalar names require form extraction. Enabling `upload_types` does add some additional subgraph request processing, so it should only be enabled for locations that will actually recieve file uploads.
+
+The upstream location will recieve a multipart form submission from stitching that can again be unpacked using [apollo_upload_server](https://github.com/jetruby/apollo_upload_server-ruby) or similar.

data/docs/planner.md

@@ -13,15 +13,17 @@ document = <<~GRAPHQL
 GRAPHQL
 
 request = GraphQL::Stitching::Request.new(
+  supergraph,
   document,
   variables: { "id" => "1" },
   operation_name: "MyQuery",
 ).prepare!
 
-plan = GraphQL::Stitching::Planner.new(
-  supergraph: supergraph,
-  request: request,
-).perform
+# Via Request:
+plan = request.plan
+
+# Via Planner:
+plan = GraphQL::Stitching::Planner.new(request).perform
 ```
 
 ### Caching
@@ -29,18 +31,14 @@ plan = GraphQL::Stitching::Planner.new(
 Plans are designed to be cacheable. This is very useful for redundant GraphQL documents (commonly sent by frontend clients) where there's no sense in planning every request individually. It's far more efficient to generate a plan once and cache it, then simply retreive the plan and execute it for future requests.
 
 ```ruby
-cached_plan = $redis.get(request.digest)
+cached_plan = $cache.get(request.digest)
 
-plan = if cached_plan
-  GraphQL::Stitching::Plan.from_json(JSON.parse(cached_plan))
+if cached_plan
+  plan = GraphQL::Stitching::Plan.from_json(JSON.parse(cached_plan))
+  request.plan(plan)
 else
-  plan = GraphQL::Stitching::Planner.new(
-    supergraph: supergraph,
-    request: request,
-  ).perform
-
-  $redis.set(request.digest, JSON.generate(plan.as_json))
-  plan
+  plan = request.plan
+  $cache.set(request.digest, JSON.generate(plan.as_json))
 end
 
 # execute the plan...

data/docs/request.md

@@ -5,6 +5,7 @@ A `Request` contains a parsed GraphQL document and variables, and handles the lo
 ```ruby
 source = "query FetchMovie($id: ID!) { movie(id:$id) { id genre } }"
 request = GraphQL::Stitching::Request.new(
+  supergraph,
   source,
   variables: { "id" => "1" },
   operation_name: "FetchMovie",
@@ -42,6 +43,7 @@ document = <<~GRAPHQL
 GRAPHQL
 
 request = GraphQL::Stitching::Request.new(
+  supergraph,
   document,
   variables: { "id" => "1" },
   operation_name: "FetchMovie",

data/docs/supergraph.md

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

data/examples/file_uploads/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'rack'
+gem 'rackup'
+gem 'foreman'
+gem 'graphql'
+gem 'apollo_upload_server', '2.1'

data/examples/file_uploads/Procfile

@@ -0,0 +1,2 @@
+gateway: bundle exec ruby gateway.rb
+remote: bundle exec ruby remote.rb

data/examples/file_uploads/README.md

@@ -0,0 +1,37 @@
+# File uploads example
+
+This example demonstrates uploading files via the [GraphQL Upload spec](https://github.com/jaydenseric/graphql-multipart-request-spec).
+
+Try running it:
+
+```shell
+cd examples/file_uploads
+bundle install
+foreman start
+```
+
+This example is headless, but you can verify the stitched schema is running by querying a field from each graph location:
+
+```shell
+curl -X POST http://localhost:3000 \
+  -H 'Content-Type: application/json' \
+  -d '{"query":"{ gateway remote }"}'
+```
+
+Now try submitting a multipart form upload with a file attachment, per the [spec](https://github.com/jaydenseric/graphql-multipart-request-spec?tab=readme-ov-file#curl-request). The response will echo the uploaded file contents:
+
+```shell
+curl http://localhost:3000 \
+  -H 'Content-Type: multipart/form-data' \
+  -F operations='{ "query": "mutation ($file: Upload!) { gateway upload(file: $file) }", "variables": { "file": null } }' \
+  -F map='{ "0": ["variables.file"] }' \
+  -F 0=@file.txt
+```
+
+This workflow has:
+
+1. Submitted a multipart form to the stitched gateway.
+2. The gateway server unpacked the request using [apollo_upload_server](https://github.com/jetruby/apollo_upload_server-ruby).
+3. Stitching delegated the `upload` field to its appropraite subgraph location.
+4. `HttpExecutable` has re-encoded the subgraph request into a multipart form.
+5. The subgraph location has recieved, unpacked, and resolved the uploaded file.

data/examples/file_uploads/file.txt

@@ -0,0 +1 @@
+Hello World!

data/examples/file_uploads/gateway.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rackup'
+require 'json'
+require 'graphql'
+require_relative '../../lib/graphql/stitching'
+require_relative './helpers'
+
+class StitchedApp
+  def initialize
+    @client = GraphQL::Stitching::Client.new(locations: {
+      gateway: {
+        schema: GatewaySchema,
+      },
+      remote: {
+        schema: RemoteSchema,
+        executable: GraphQL::Stitching::HttpExecutable.new(
+          url: "http://localhost:3001",
+          upload_types: ["Upload"]
+        ),
+      },
+    })
+  end
+
+  def call(env)
+    params = apollo_upload_server_middleware_params(env)
+    result = @client.execute(
+      query: params["query"],
+      variables: params["variables"],
+      operation_name: params["operationName"],
+    )
+
+    [200, {"content-type" => "application/json"}, [JSON.generate(result)]]
+  end
+end
+
+Rackup::Handler.default.run(StitchedApp.new, :Port => 3000)

data/examples/file_uploads/helpers.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'action_dispatch'
+require 'apollo_upload_server/graphql_data_builder'
+require 'apollo_upload_server/upload'
+
+# ApolloUploadServer middleware only modifies Rails request params;
+# for simple Rack apps we need to extract the behavior.
+def apollo_upload_server_middleware_params(env)
+  req = ActionDispatch::Request.new(env)
+  if env['CONTENT_TYPE'].to_s.include?('multipart/form-data')
+    ApolloUploadServer::GraphQLDataBuilder.new(strict_mode: true).call(req.params)
+  else
+    req.params
+  end
+end
+
+# Gateway local schema
+class GatewaySchema < GraphQL::Schema
+  class Query < GraphQL::Schema::Object
+    field :gateway, Boolean, null: false
+
+    def gateway
+      true
+    end
+  end
+
+  class Mutation < GraphQL::Schema::Object
+    field :gateway, Boolean, null: false
+
+    def gateway
+      true
+    end
+  end
+
+  query Query
+  mutation Mutation
+end
+
+# Remote local schema, with file upload
+class RemoteSchema < GraphQL::Schema
+  class Query < GraphQL::Schema::Object
+    field :remote, Boolean, null: false
+
+    def remote
+      true
+    end
+  end
+
+  class Mutation < GraphQL::Schema::Object
+    field :upload, String, null: true do
+      argument :file, ApolloUploadServer::Upload, required: true
+    end
+
+    def upload(file:)
+      file.read
+    end
+  end
+
+  query Query
+  mutation Mutation
+end

data/examples/file_uploads/remote.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rackup'
+require 'json'
+require 'graphql'
+require_relative './helpers'
+
+class RemoteApp
+  def call(env)
+    params = apollo_upload_server_middleware_params(env)
+    result = RemoteSchema.execute(
+      query: params["query"],
+      variables: params["variables"],
+      operation_name: params["operationName"],
+    )
+
+    [200, {"content-type" => "application/json"}, [JSON.generate(result)]]
+  end
+end
+
+Rackup::Handler.default.run(RemoteApp.new, :Port => 3001)

data/examples/merged_types/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'rack'
+gem 'rackup'
+gem 'foreman'
+gem 'graphql'

data/examples/merged_types/Procfile

@@ -0,0 +1,3 @@
+gateway: bundle exec ruby gateway.rb
+remote1: bundle exec ruby remote1.rb
+remote2: bundle exec ruby remote2.rb

data/examples/merged_types/README.md

@@ -0,0 +1,33 @@
+# Merged types example
+
+This example demonstrates several stitched schemas running across small Rack servers with types merged across locations. The main "gateway" location stitches its local schema onto two remote endpoints.
+
+Try running it:
+
+```shell
+cd examples/merged_types
+bundle install
+foreman start
+```
+
+Then visit the gateway service at [`http://localhost:3000`](http://localhost:3000) and try this query:
+
+```graphql
+query {
+  storefront(id: "1") {
+    id
+    products {
+      upc
+      name
+      price
+      manufacturer {
+        name
+        address
+        products { upc name }
+      }
+    }
+  }
+}
+```
+
+The above query collects data from all locations. You can also request introspections that resolve using the combined supergraph schema.

data/{example → examples/merged_types}/gateway.rb

@@ -2,10 +2,9 @@
 
 require 'rackup'
 require 'json'
-require 'byebug'
 require 'graphql'
-require 'graphql/stitching'
-require_relative '../test/schemas/example'
+require_relative '../../lib/graphql/stitching'
+require_relative '../../test/schemas/example'
 
 class StitchedApp
   def initialize
@@ -19,11 +18,11 @@ class StitchedApp
       },
       storefronts: {
         schema: Schemas::Example::Storefronts,
-        executable: GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3001/graphql"),
+        executable: GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3001"),
       },
       manufacturers: {
         schema: Schemas::Example::Manufacturers,
-        executable: GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3002/graphql"),
+        executable: GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3002"),
       }
     })
   end

data/examples/merged_types/remote1.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rackup'
+require 'json'
+require 'graphql'
+require_relative '../../test/schemas/example'
+
+class FirstRemoteApp
+  def call(env)
+    req = Rack::Request.new(env)
+    params = JSON.parse(req.body.read)
+    result = Schemas::Example::Storefronts.execute(
+      query: params["query"],
+      variables: params["variables"],
+      operation_name: params["operationName"],
+    )
+
+    [200, {"content-type" => "application/json"}, [JSON.generate(result)]]
+  end
+end
+
+Rackup::Handler.default.run(FirstRemoteApp.new, :Port => 3001)

data/examples/merged_types/remote2.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rackup'
+require 'json'
+require 'graphql'
+require_relative '../../test/schemas/example'
+
+class SecondRemoteApp
+  def call(env)
+    req = Rack::Request.new(env)
+    params = JSON.parse(req.body.read)
+    result = Schemas::Example::Manufacturers.execute(
+      query: params["query"],
+      variables: params["variables"],
+      operation_name: params["operationName"],
+    )
+
+    [200, {"content-type" => "application/json"}, [JSON.generate(result)]]
+  end
+end
+
+Rackup::Handler.default.run(SecondRemoteApp.new, :Port => 3002)

data/lib/graphql/stitching/client.rb

@@ -28,6 +28,7 @@ module GraphQL
 
       def execute(query:, variables: nil, operation_name: nil, context: nil, validate: true)
         request = GraphQL::Stitching::Request.new(
+          @supergraph,
           query,
           operation_name: operation_name,
           variables: variables,
@@ -35,24 +36,13 @@ module GraphQL
         )
 
         if validate
-          validation_errors = @supergraph.schema.validate(request.document)
+          validation_errors = request.validate
           return error_result(validation_errors) if validation_errors.any?
         end
 
         request.prepare!
-
-        plan = fetch_plan(request) do
-          GraphQL::Stitching::Planner.new(
-            supergraph: @supergraph,
-            request: request,
-          ).perform
-        end
-
-        GraphQL::Stitching::Executor.new(
-          supergraph: @supergraph,
-          request: request,
-          plan: plan,
-        ).perform
+        load_plan(request)
+        request.execute
       rescue GraphQL::ParseError, GraphQL::ExecutionError => e
         error_result([e])
       rescue StandardError => e
@@ -77,13 +67,13 @@ module GraphQL
 
       private
 
-      def fetch_plan(request)
-        if @on_cache_read
-          cached_plan = @on_cache_read.call(request)
-          return GraphQL::Stitching::Plan.from_json(JSON.parse(cached_plan)) if cached_plan
+      def load_plan(request)
+        if @on_cache_read && plan_json = @on_cache_read.call(request)
+          plan = GraphQL::Stitching::Plan.from_json(JSON.parse(plan_json))
+          return request.plan(plan)
         end
 
-        plan = yield
+        plan = request.plan
 
         if @on_cache_write
           @on_cache_write.call(request, JSON.generate(plan.as_json))

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

@@ -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.context)
+          raw_result = @executor.supergraph.execute_at_location(@location, query_document, variables, @executor.request)
           @executor.query_count += 1
 
           merge_results!(origin_sets_by_operation, raw_result.dig("data"))

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

@@ -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.context)
+        result = @executor.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

@@ -8,10 +8,10 @@ module GraphQL
       attr_reader :supergraph, :request, :plan, :data, :errors
       attr_accessor :query_count
 
-      def initialize(supergraph:, request:, plan:, nonblocking: false)
-        @supergraph = supergraph
+      def initialize(request, nonblocking: false)
         @request = request
-        @plan = plan
+        @supergraph = request.supergraph
+        @plan = request.plan
         @data = {}
         @errors = []
         @query_count = 0
@@ -24,10 +24,7 @@ module GraphQL
         result = {}
 
         if @data && @data.length > 0
-          result["data"] = raw ? @data : GraphQL::Stitching::Shaper.new(
-            supergraph: @supergraph,
-            request: @request,
-          ).perform!(@data)
+          result["data"] = raw ? @data : GraphQL::Stitching::Shaper.new(@request).perform!(@data)
         end
 
         if @errors.length > 0

data/lib/graphql/stitching/export_selection.rb

@@ -20,8 +20,13 @@ module GraphQL
           "#{EXPORT_PREFIX}#{name}"
         end
 
+        # The argument assigning Field.alias changed from
+        # a generic `alias` hash key to a structured `field_alias` kwarg.
+        # See https://github.com/rmosolgo/graphql-ruby/pull/4718
+        FIELD_ALIAS_KWARG = !GraphQL::Language::Nodes::Field.new(field_alias: "a").alias.nil?
+
         def key_node(field_name)
-          if Util.graphql_version?(2, 2)
+          if FIELD_ALIAS_KWARG
             GraphQL::Language::Nodes::Field.new(field_alias: key(field_name), name: field_name)
           else
             GraphQL::Language::Nodes::Field.new(alias: key(field_name), name: field_name)

data/lib/graphql/stitching/http_executable.rb

@@ -7,18 +7,148 @@ require "json"
 module GraphQL
   module Stitching
     class HttpExecutable
-      def initialize(url:, headers:{})
+      def initialize(url:, headers:{}, upload_types: nil)
         @url = url
         @headers = { "Content-Type" => "application/json" }.merge!(headers)
+        @upload_types = upload_types
       end
 
-      def call(_location, document, variables, _context)
-        response = Net::HTTP.post(
+      def call(request, document, variables)
+        multipart_form = if request.variable_definitions.any? && variables&.any?
+          extract_multipart_form(request, document, variables)
+        end
+
+        response = if multipart_form
+          post_multipart(multipart_form)
+        else
+          post(document, variables)
+        end
+
+        JSON.parse(response.body)
+      end
+
+      def post(document, variables)
+        Net::HTTP.post(
           URI(@url),
           JSON.generate({ "query" => document, "variables" => variables }),
           @headers,
         )
-        JSON.parse(response.body)
+      end
+
+      def post_multipart(form_data)
+        uri = URI(@url)
+        req = Net::HTTP::Post.new(uri)
+        @headers.each_pair do |key, value|
+          req[key] = value
+        end
+
+        req.set_form(form_data.to_a, "multipart/form-data")
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(req)
+        end
+      end
+
+      # extract multipart upload forms
+      # spec: https://github.com/jaydenseric/graphql-multipart-request-spec
+      def extract_multipart_form(request, document, variables)
+        return unless @upload_types
+
+        path = []
+        files_by_path = {}
+
+        # extract all upload scalar values mapped by their input path
+        variables.each do |key, value|
+          ast_node = request.variable_definitions[key]
+          path << key
+          extract_ast_node(ast_node, value, files_by_path, path, request) if ast_node
+          path.pop
+        end
+
+        return if files_by_path.none?
+
+        map = {}
+        files = files_by_path.values.tap(&:uniq!)
+        variables_copy = variables.dup
+
+        files_by_path.keys.each 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(".")}"
+              copy[key] = nil
+            elsif orig[key].object_id == copy[key].object_id
+              copy[key] = copy[key].dup
+            end
+            orig = orig[key]
+            copy = copy[key]
+          end
+        end
+
+        form = {
+          "operations" => JSON.generate({
+            "query" => document,
+            "variables" => variables_copy,
+          }),
+          "map" => JSON.generate(map),
+        }
+
+        files.each_with_object(form).with_index do |(file, memo), index|
+          memo[index.to_s] = file.respond_to?(:tempfile) ? file.tempfile : file
+        end
+      end
+
+      private
+
+      def extract_ast_node(ast_node, value, files_by_path, path, request)
+        return unless value
+
+        ast_node = ast_node.of_type while ast_node.is_a?(GraphQL::Language::Nodes::NonNullType)
+
+        if ast_node.is_a?(GraphQL::Language::Nodes::ListType)
+          if value.is_a?(Array)
+            value.each_with_index do |val, index|
+              path << index
+              extract_ast_node(ast_node.of_type, val, files_by_path, path, request)
+              path.pop
+            end
+          end
+        elsif @upload_types.include?(ast_node.name)
+          files_by_path[path.dup] = value
+        else
+          type_def = request.supergraph.schema.get_type(ast_node.name)
+          extract_type_node(type_def, value, files_by_path, path) if type_def&.kind&.input_object?
+        end
+      end
+
+      def extract_type_node(parent_type, value, files_by_path, path)
+        return unless value
+
+        parent_type = Util.unwrap_non_null(parent_type)
+
+        if parent_type.list?
+          if value.is_a?(Array)
+            value.each_with_index do |val, index|
+              path << index
+              extract_type_node(parent_type.of_type, val, files_by_path, path)
+              path.pop
+            end
+          end
+        elsif parent_type.kind.input_object?
+          if value.is_a?(Enumerable)
+            arguments = parent_type.arguments
+            value.each do |key, val|
+              arg_type = arguments[key]&.type
+              path << key
+              extract_type_node(arg_type, val, files_by_path, path) if arg_type
+              path.pop
+            end
+          end
+        elsif @upload_types.include?(parent_type.graphql_name)
+          files_by_path[path.dup] = value
+        end
       end
     end
   end

data/lib/graphql/stitching/planner.rb

@@ -9,9 +9,9 @@ module GraphQL
       MUTATION_OP = "mutation"
       ROOT_INDEX = 0
 
-      def initialize(supergraph:, request:)
-        @supergraph = supergraph
+      def initialize(request)
         @request = request
+        @supergraph = request.supergraph
         @planning_index = ROOT_INDEX
         @steps_by_entrypoint = {}
       end

data/lib/graphql/stitching/request.rb

@@ -6,9 +6,10 @@ module GraphQL
       SUPPORTED_OPERATIONS = ["query", "mutation"].freeze
       SKIP_INCLUDE_DIRECTIVE = /@(?:skip|include)/
 
-      attr_reader :document, :variables, :operation_name, :context
+      attr_reader :supergraph, :document, :variables, :operation_name, :context
 
-      def initialize(document, operation_name: nil, variables: nil, context: nil)
+      def initialize(supergraph, document, operation_name: nil, variables: nil, context: nil)
+        @supergraph = supergraph
         @string = nil
         @digest = nil
         @normalized_string = nil
@@ -17,6 +18,7 @@ module GraphQL
         @operation_directives = nil
         @variable_definitions = nil
         @fragment_definitions = nil
+        @plan = nil
 
         @document = if document.is_a?(String)
           @string = document
@@ -83,6 +85,10 @@ module GraphQL
         end
       end
 
+      def validate
+        @supergraph.schema.validate(@document, context: @context)
+      end
+
       def prepare!
         operation.variables.each do |v|
           @variables[v.name] = v.default_value if @variables[v.name].nil? && !v.default_value.nil?
@@ -93,12 +99,25 @@ module GraphQL
             @document = modified_ast
             @string = @normalized_string = nil
             @digest = @normalized_digest = nil
-            @operation = @operation_directives = @variable_definitions = nil
+            @operation = @operation_directives = @variable_definitions = @plan = nil
           end
         end
 
         self
       end
+
+      def plan(new_plan = nil)
+        if new_plan
+          raise StitchingError, "Plan must be a `GraphQL::Stitching::Plan`." unless new_plan.is_a?(Plan)
+          @plan = new_plan
+        else
+          @plan ||= GraphQL::Stitching::Planner.new(self).perform
+        end
+      end
+
+      def execute(raw: false)
+        GraphQL::Stitching::Executor.new(self).perform(raw: raw)
+      end
     end
   end
 end

data/lib/graphql/stitching/shaper.rb

@@ -6,9 +6,9 @@ module GraphQL
     # Shapes the final results payload to the request selection and schema definition.
     # This eliminates unrequested export selections and applies null bubbling.
     class Shaper
-      def initialize(supergraph:, request:)
-        @supergraph = supergraph
+      def initialize(request)
         @request = request
+        @supergraph = request.supergraph
         @root_type = nil
       end
 

data/lib/graphql/stitching/supergraph.rb

@@ -90,7 +90,7 @@ module GraphQL
 
       attr_reader :schema, :boundaries, :locations_by_type_and_field, :executables
 
-      def initialize(schema:, fields:, boundaries:, executables:)
+      def initialize(schema:, fields: {}, boundaries: {}, executables: {})
         @schema = schema
         @boundaries = boundaries
         @possible_keys_by_type = {}
@@ -209,7 +209,7 @@ module GraphQL
         end
       end
 
-      def execute_at_location(location, source, variables, context)
+      def execute_at_location(location, source, variables, request)
         executable = executables[location]
 
         if executable.nil?
@@ -218,11 +218,11 @@ module GraphQL
           executable.execute(
             query: source,
             variables: variables,
-            context: context.frozen? ? context.dup : context,
+            context: request.context.frozen? ? request.context.dup : request.context,
             validate: false,
           )
         elsif executable.respond_to?(:call)
-          executable.call(location, source, variables, context)
+          executable.call(request, source, variables)
         else
           raise StitchingError, "Missing valid executable for #{location} location."
         end

data/lib/graphql/stitching/util.rb

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

data/lib/graphql/stitching/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-26 00:00:00.000000000 Z
+date: 2023-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -76,13 +76,13 @@ files:
 - ".gitignore"
 - Gemfile
 - LICENSE
-- Procfile
 - README.md
 - Rakefile
 - docs/README.md
 - docs/client.md
 - docs/composer.md
 - docs/executor.md
+- docs/http_executable.md
 - docs/images/library.png
 - docs/images/merging.png
 - docs/images/stitching.png
@@ -90,10 +90,20 @@ files:
 - docs/planner.md
 - docs/request.md
 - docs/supergraph.md
-- example/gateway.rb
-- example/graphiql.html
-- example/remote1.rb
-- example/remote2.rb
+- examples/file_uploads/Gemfile
+- examples/file_uploads/Procfile
+- examples/file_uploads/README.md
+- examples/file_uploads/file.txt
+- examples/file_uploads/gateway.rb
+- examples/file_uploads/helpers.rb
+- examples/file_uploads/remote.rb
+- examples/merged_types/Gemfile
+- examples/merged_types/Procfile
+- examples/merged_types/README.md
+- examples/merged_types/gateway.rb
+- examples/merged_types/graphiql.html
+- examples/merged_types/remote1.rb
+- examples/merged_types/remote2.rb
 - gemfiles/graphql_1.13.9.gemfile
 - graphql-stitching.gemspec
 - lib/graphql/stitching.rb

data/Procfile

@@ -1,3 +0,0 @@
-gateway: bundle exec ruby example/gateway.rb
-remote1: bundle exec ruby example/remote1.rb
-remote2: bundle exec ruby example/remote2.rb

data/example/remote1.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'rackup'
-require 'json'
-require 'graphql'
-require_relative '../test/schemas/example'
-
-class FirstRemoteApp
-  def call(env)
-    req = Rack::Request.new(env)
-    case req.path_info
-    when /graphql/
-      params = JSON.parse(req.body.read)
-      result = Schemas::Example::Storefronts.execute(
-        query: params["query"],
-        variables: params["variables"],
-        operation_name: params["operationName"],
-      )
-      [200, {"content-type" => "application/json"}, [JSON.generate(result)]]
-    else
-      [404, {"content-type" => "text/html"}, ["not found"]]
-    end
-  end
-end
-
-Rackup::Handler.default.run(FirstRemoteApp.new, :Port => 3001)

data/example/remote2.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'rackup'
-require 'json'
-require 'graphql'
-require_relative '../test/schemas/example'
-
-class SecondRemoteApp
-  def call(env)
-    req = Rack::Request.new(env)
-    case req.path_info
-    when /graphql/
-      params = JSON.parse(req.body.read)
-      result = Schemas::Example::Manufacturers.execute(
-        query: params["query"],
-        variables: params["variables"],
-        operation_name: params["operationName"],
-      )
-      [200, {"content-type" => "application/json"}, [JSON.generate(result)]]
-    else
-      [404, {"content-type" => "text/html"}, ["not found"]]
-    end
-  end
-end
-
-Rackup::Handler.default.run(SecondRemoteApp.new, :Port => 3002)