graph_weaver 0.4.6 → 0.5.0

data/lib/graph_weaver/parsing.rb

@@ -0,0 +1,67 @@
+# typed: true
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+require_relative "codegen"
+
+module GraphWeaver
+  # Anything that holds a schema parses against it. That's a Client, an
+  # InProcess wrapper, a FakeClient, and the test Router — each of which
+  # already has the two things parsing needs, a schema to check the query
+  # against and a client for the module to run on:
+  #
+  #      DashboardQuery = router.parse("query { me { username } }")
+  #
+  # so the long form (`GraphWeaver.parse(schema: router.schema, client:
+  # router, query: ...)`) was only ever spelling out what the object knew.
+  #
+  # It is a convenience on top of the client contract, not part of it — the
+  # client slot stays duck-typed, and a bare graphql-ruby schema class fills
+  # it without including this.
+  module Parsing
+    # Parse a query (a .graphql path or raw string) into a typed module bound
+    # to this schema, with this as the module's default client — the module
+    # came from here, so it runs against here (a client passed to #execute
+    # still wins, e.g. a fake). Same as GraphWeaver.parse(schema:, client:).
+    def parse(query, name: nil)
+      # #schema is the mixin's one requirement of its includer, and a module
+      # has no way to declare that short of an abstract interface
+      GraphWeaver.parse(schema: T.unsafe(self).schema, query:, name:, client: parse_client)
+    end
+
+    # Parse every query in a directory (subdirectories included) into typed
+    # modules, named like generation would name them — the no-build-step
+    # analog of generate! + load_generated!:
+    #
+    #      github.load_queries!                        # queries/person.graphql => ::PersonQuery
+    #      github.load_queries!(namespace: Github)     # => Github::PersonQuery
+    #                                                  # a mutation file => ::AdoptMutation
+    #
+    # Reloadable (constants are replaced), so it suits consoles and dev.
+    # Returns the modules.
+    def load_queries!(dir = nil, namespace: Object)
+      GraphWeaver.query_files(dir || GraphWeaver.queries_paths).map do |path|
+        name = GraphWeaver.module_name(path, File.read(path))
+        if namespace.const_defined?(name, false)
+          # the constant moves, its instances don't — a struct built before the
+          # reload keeps failing is_a? against the new module, silently
+          GraphWeaver.log(:info) do
+            "replacing #{name} — objects built from the previous module stay instances of it"
+          end
+          namespace.send(:remove_const, name)
+        end
+        GraphWeaver.log(:info) { "loaded #{name} from #{path}" }
+        namespace.const_set(name, parse(path))
+      end
+    end
+
+    private
+
+    # What a parsed module executes through: this object, which holds the
+    # schema and runs queries. Client is the one that overrides it — its own
+    # #execute is the one-shot parse-and-run, not the client contract, so it
+    # bakes the transport it wraps.
+    def parse_client = self
+  end
+end

data/lib/graph_weaver/query_module.rb

@@ -0,0 +1,55 @@
+# typed: true
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module GraphWeaver
+  # Runtime for generated query modules: the client plumbing, which is the
+  # one part of a generated module that carries no per-query type
+  # information — every module's copy was identical. `extend
+  # GraphWeaver::QueryModule` supplies `client`/`client=`; execute and
+  # from_response stay generated, since their sigs are the query's types and
+  # those are the point.
+  #
+  # Resolution order, per the docs: per call → per module (`MyQuery.client =`)
+  # → the module's baked DEFAULT_CLIENT → `GraphWeaver.client`.
+  module QueryModule
+    extend T::Sig
+
+    sig { params(client: T.untyped).void }
+    attr_writer :client
+
+    # the default client (a GraphWeaver::Client or any transport) for
+    # execute: per-module override, else the baked default, else the app one
+    sig { returns(T.untyped) }
+    def client
+      @client || default_client
+    end
+
+    private
+
+    # The client one execute runs through: the per-call `client:`, else the
+    # module's, else the app default. Checked here so a wrong one names the
+    # contract and the module, rather than surfacing as a NoMethodError from
+    # inside the call.
+    sig { params(override: T.untyped).returns(T.untyped) }
+    def client_for(override)
+      target = override || client
+      return target if target.respond_to?(:execute)
+
+      # Kernel.raise: this module is extended into another, so sorbet can't
+      # see that its host is an Object
+      Kernel.raise GraphWeaver::Error,
+        "#{self}: client must respond to #execute(query, variables:), got #{target.class}"
+    end
+
+    # Codegen's `client:` constant, emitted as a DEFAULT_CLIENT lambda so the
+    # constant it names is resolved on first use rather than at load — a
+    # generated file may load before the initializer that builds the client.
+    sig { returns(T.untyped) }
+    def default_client
+      mod = T.unsafe(self)
+      mod.const_defined?(:DEFAULT_CLIENT, false) ? mod.const_get(:DEFAULT_CLIENT).call : GraphWeaver.client!
+    end
+  end
+end

data/lib/graph_weaver/railtie.rb

@@ -7,16 +7,32 @@
 #   rake_tasks block, so graph_weaver:* tasks appear with no Rakefile
 #   edit. (Outside Rails there is no task-discovery hook — add
 #   `require "graph_weaver/tasks"` to your Rakefile.)
-# - generated modules: required at boot when generated_path exists,
+# - generated modules: required at boot when a generated_paths entry exists,
 #   after config/initializers (registrations and GraphWeaver.client=
 #   run first — block-built type helpers must exist before the files
 #   that include them load). load_generated! stays idempotent, so
 #   calling it yourself too is harmless.
+# - Zeitwerk: the generated directory is hidden from it, since the
+#   default one lives under app/ and its files define top-level
+#   constants.
 class GraphWeaver::Railtie < Rails::Railtie
   rake_tasks do
     require "graph_weaver/tasks"
   end
 
+  # generated/person_query.rb defines ::PersonQuery, but Zeitwerk infers
+  # Generated::PersonQuery from the path — and app/graphql/generated is
+  # inside an autoload root by default, so eager loading raised
+  # "uninitialized constant Generated::PersonQuery" in production while
+  # development (lazy) was fine. load_generated! below requires them.
+  initializer "graph_weaver.ignore_generated", before: :setup_main_autoloader do
+    Rails.autoloaders.each do |loader|
+      # patterns, not paths — generated_paths may be globs, and Zeitwerk
+      # expands its own at setup (which is what this runs before)
+      GraphWeaver.generated_paths.each { |path| loader.ignore(Rails.root.join(path).to_s) }
+    end
+  end
+
   # Rails.logger, unless the app already chose one (set
   # GraphWeaver.logger = nil in an initializer to silence)
   initializer "graph_weaver.logger" do
@@ -24,6 +40,12 @@ class GraphWeaver::Railtie < Rails::Railtie
   end
 
   initializer "graph_weaver.load_generated", after: :load_config_initializers do
+    # The graph_weaver tasks write these files and need none of them loaded.
+    # Loading them would let a stale one block its own repair: a dropped
+    # extend_type leaves a dangling include, and generate depends on
+    # :environment, so boot failed before the task that would regenerate it.
+    next if GraphWeaver.skip_generated_load
+
     # entries may be globs, so Dir[] rather than Dir.exist?
     GraphWeaver.load_generated! if GraphWeaver.generated_paths.any? { |path| Dir[path].any? }
   end

data/lib/graph_weaver/representation.rb

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module GraphWeaver
+  # Runtime for the generated `Representations` builders — the entity
+  # references a federation `_entities(representations:)` query takes.
+  #
+  # Codegen types what it can: the kwargs are the entity's @key fields, so a
+  # single-key entity can't be under-specified without a Sorbet error. What's
+  # left is what a sig can't say — an entity with two alternative keys (either
+  # resolves it, neither is individually required) and a nested key set
+  # (`organization { id }`, a sub-hash the kwarg's Hash type doesn't pin
+  # down). Both land here.
+  module Representation
+    # `key_sets` is the entity's @key field sets as dotted paths, in
+    # declaration order — [["upc", "sku"], ["id"]] for a type keyed either
+    # way. The first fully-supplied one wins; the wire hash carries exactly
+    # that key set plus __typename, so nothing extraneous reaches the router.
+    def self.build(type_name, values, key_sets)
+      satisfied = key_sets.find { |paths| missing(values, paths).empty? }
+      raise incomplete(type_name, values, key_sets) unless satisfied
+
+      satisfied.each_with_object({ "__typename" => type_name }) do |path, wire|
+        assign(wire, path.split("."), dig(values, path))
+      end
+    end
+
+    def self.missing(values, paths) = paths.select { |path| dig(values, path).nil? }
+    private_class_method :missing
+
+    # Nested key values arrive as a caller-built hash, so accept either key
+    # flavour at every hop — a literal `{ id: "1" }` reads the same as a hash
+    # round-tripped through JSON.
+    def self.dig(values, path)
+      path.split(".").reduce(values) do |scope, name|
+        return unless scope.is_a?(Hash)
+
+        scope.key?(name) ? scope[name] : scope[name.to_sym]
+      end
+    end
+    private_class_method :dig
+
+    def self.assign(wire, path, value)
+      *parents, leaf = path
+      target = parents.reduce(wire) { |scope, name| scope[name] ||= {} }
+      target[leaf] = value
+    end
+    private_class_method :assign
+
+    # Name the type and what it's short of, per @key — with a single key
+    # there's one answer, so it also fills InputError#field.
+    def self.incomplete(type_name, values, key_sets)
+      gaps = key_sets.map { |paths| missing(values, paths) }
+
+      if key_sets.one?
+        InputError.new(
+          "#{type_name} representation is missing @key #{gaps.first.map(&:inspect).join(", ")}",
+          field: gaps.first.one? ? gaps.first.first : nil,
+        )
+      else
+        alternatives = key_sets.zip(gaps).map do |paths, gap|
+          # a partly-supplied compound key is the near miss worth pointing at;
+          # for one wholly absent, naming it twice says nothing extra
+          supplied = gap.size < paths.size
+          "#{paths.map(&:inspect).join(" + ")}#{" (missing #{gap.map(&:inspect).join(", ")})" if supplied}"
+        end
+        InputError.new("#{type_name} representation satisfies none of its @keys — supply #{alternatives.join(", or ")}")
+      end
+    end
+    private_class_method :incomplete
+  end
+end

data/lib/graph_weaver/response.rb

@@ -44,6 +44,13 @@ module GraphWeaver
     sig { returns(T::Boolean) }
     def errors? = !errors.empty?
 
+    # The same question the other way round — people reach for the positive,
+    # and a NoMethodError is a poor answer. Spelled `success?` after
+    # Process::Status and Faraday::Response; `ok?` would read as HTTP 200,
+    # which a GraphQL response carrying errors also is.
+    sig { returns(T::Boolean) }
+    def success? = errors.empty?
+
     # The typed result, or raise QueryError if the response carried top-level
     # errors (partial data and extensions ride along on the error).
     sig { returns(Data) }

data/lib/graph_weaver/retry.rb

@@ -19,11 +19,15 @@ require_relative "errors"
 #
 # What retries, by default:
 #   - TransportError: always (the request never arrived)
-#   - ServerError: only 5xx — a 4xx is a bug in the request, retrying
-#     won't fix it. Override with retry_if: ->(error) { ... }
+#   - ServerError: 5xx, plus 408 and 429 — the rest of 4xx is a bug in
+#     the request, retrying won't fix it. Override with
+#     retry_if: ->(error) { ... }
 #   - responses whose GraphQL error codes intersect retry_codes: (off by
 #     default — pass the codes your API uses for transient failures)
 #
+# A server that answers with Retry-After sets the delay itself (clamped
+# to max:); otherwise the configured backoff decides.
+#
 # Exhausting tries re-raises the last error (or returns the last
 # code-matched response).
 class GraphWeaver::Retry
@@ -32,9 +36,15 @@ class GraphWeaver::Retry
     linear: ->(base, attempt) { base * attempt },
   }.freeze
 
-  # retry 5xx, not 4xx; everything else listed in on: retries
+  # a 4xx is a bug in the request — except these two, which are the
+  # server asking you to come back later rather than to fix anything
+  RETRIABLE_CLIENT_STATUSES = [408, 429].freeze
+
+  # retry 5xx (and 408/429), not the rest of 4xx; everything else listed
+  # in on: retries
   DEFAULT_RETRY_IF = lambda do |error|
-    !error.is_a?(GraphWeaver::ServerError) || error.status >= 500
+    !error.is_a?(GraphWeaver::ServerError) ||
+      error.status >= 500 || RETRIABLE_CLIENT_STATUSES.include?(error.status)
   end
 
   def initialize(client, tries: 3, on: [GraphWeaver::TransportError, GraphWeaver::ServerError],
@@ -65,19 +75,23 @@ class GraphWeaver::Retry
     @client.url if @client.respond_to?(:url)
   end
 
-  def execute(query, variables: {})
+  def execute(query, variables: {}, operation_name: nil)
     attempt = 0
+    failure = T.let(nil, T.nilable(Exception))
 
     loop do
       attempt += 1
       begin
-        response = @client.execute(query, variables:)
+        response = @client.execute(query, variables:, operation_name:)
         return response unless attempt < @tries && retryable_response?(response)
       rescue *@on => e
         raise if attempt >= @tries || !@retry_if.call(e)
+
+        failure = e
       end
 
-      @sleeper.call(delay(attempt))
+      @sleeper.call(delay(attempt, failure))
+      failure = nil
     end
   end
 
@@ -90,7 +104,14 @@ class GraphWeaver::Retry
     codes.intersect?(@retry_codes)
   end
 
-  def delay(attempt)
+  def delay(attempt, failure)
+    # A Retry-After wins over our backoff: the server is the only party
+    # that knows when its window reopens, and it isn't guessing. Still
+    # clamped to max:, so "come back in an hour" can't park a thread for
+    # an hour — and not jittered, since it's an instruction, not a guess.
+    after = failure.retry_after if failure.is_a?(GraphWeaver::ServerError)
+    return [after, @max].min.to_f if after
+
     seconds = [@backoff.call(@base, attempt), @max].min.to_f
     @jitter ? seconds * (0.5 + rand * 0.5) : seconds
   end

data/lib/graph_weaver/rspec.rb

@@ -8,46 +8,244 @@ require_relative "testing"
 #
 #      require "graph_weaver/rspec"
 #
-# Then opt in to per-example fakes (explicit on purpose — silently
-# swapping every example onto a fake is too surprising to be a default):
+# Then say what an example runs against with one tag, on the example or on
+# the group it belongs to (rspec metadata inherits, so a whole describe
+# block can run against real resolvers):
 #
-#      GraphWeaver::Testing.configure do |config|
-#        config.auto_fake = true      # every example runs against a fake
-#        # config.schema = MySchema   # optional: the committed dump auto-locates
-#      end
+#      it "renders the empty state", graphql: :fake do        … end
+#      it "authorizes drafts",       graphql: :in_process do  … end
+#      describe "checkout",          graphql: :router do      … end
+#
+#      :fake        fabricated, schema-correct data; no resolvers run
+#      :in_process  your resolvers, one live schema class, in-process
+#      :router      your resolvers, across a federated graph
+#      false        opt out — GraphWeaver.client is left exactly as it is,
+#                   even under config.default_mode
+#
+# `rspec --tag graphql:router` runs one mode's examples.
+#
+# `GraphWeaver.client` is snapshotted before every example and restored
+# after — tagged, untagged, opted out, whatever the example did to it. So
+# an example (or a `before` block, or a shared context) is free to build
+# the client it wants:
+#
+#      before { GraphWeaver.client = GraphWeaver::Testing::Failure.throttled }
+#      it "pins the name" { graphql_fake(overrides: { "Person.name" => "Ada" }) }
+#
+# **Nothing needs configuring.** Each mode derives what it runs against,
+# and refuses — naming what it looked for — rather than guessing:
+#
+#   - the schema is GraphWeaver::Testing.config.schema if you set one, else
+#     the committed dump at GraphWeaver.schema_path, else the schema of
+#     GraphWeaver.client.
+#   - :in_process runs against config.schema, or the schema class your
+#     client already uses. Only a live class has resolvers, so when
+#     neither is there it says so rather than hunting for one.
+#   - :router plans against the composed supergraph: the dump, when that's
+#     what it is, else config.router = { supergraph: … }. Subgraphs are
+#     derived from what each loaded schema defines (Testing::Subgraphs);
+#     one nothing here serves is absent, and only a query that reaches its
+#     fields is refused.
 #
 # What it wires up:
 #   - seed: defaults to rspec's --seed, so `rspec --seed 1234` reproduces
 #     fake data along with test order
-#   - auto_fake: when on (and a schema resolves), each example gets a
-#     fresh seeded FakeClient installed as GraphWeaver.client —
-#     generated modules run in test mode with zero per-test setup. The
-#     prior client is restored after each example.
+#   - a client per example, from the tag (or config.default_mode for an
+#     untagged one; nil, the default, leaves GraphWeaver.client alone),
+#     and GraphWeaver.client restored afterwards either way — so a client
+#     an example builds for itself is cleaned up like a tagged one.
+#   - graphql_context — the GraphQL context resolvers see, merged onto
+#     config.context and reset between examples.
+#
+# The router is built once for the suite (parsing a supergraph per example
+# would be real time) and installed for each.
 #
 # note: modules generated with a baked-in client: constant don't consult
 # GraphWeaver.client — generate without client: to make them fakeable.
 module GraphWeaver
   module Testing
     module RSpecIntegration
+      # the one metadata key — namespaced, because an app's own :fake or
+      # :router tag must never silently change which client an example runs
+      # against
+      TAG = :graphql
+
       def self.install(rspec_config)
+        rspec_config.include(Helpers)
+
         rspec_config.before(:suite) do
           config = GraphWeaver::Testing.config
           config.seed ||= RSpec.configuration.seed
         end
 
+        # snapshot unconditionally: what the example does to GraphWeaver.client
+        # is undone whether the tag installed one or the example built its own,
+        # so there is no idiom to discover and no way to leak a client forward
         rspec_config.before(:each) do
-          config = GraphWeaver::Testing.config
-          next unless config.auto_fake && config.schema
-
           @__graph_weaver_prior_client = GraphWeaver.client
-          GraphWeaver.client = FakeClient.new(schema: config.schema)
+          @__graph_weaver_mode = GraphWeaver::Testing::RSpecIntegration.mode_for(
+            RSpec.current_example&.metadata || {},
+          )
+          if @__graph_weaver_mode
+            GraphWeaver.client = GraphWeaver::Testing::RSpecIntegration.client_for(@__graph_weaver_mode)
+          end
         end
 
         rspec_config.after(:each) do
-          config = GraphWeaver::Testing.config
-          next unless config.auto_fake && config.schema
+          next unless defined?(@__graph_weaver_prior_client)
 
           GraphWeaver.client = @__graph_weaver_prior_client
+          remove_instance_variable(:@__graph_weaver_prior_client)
+          remove_instance_variable(:@__graph_weaver_mode)
+        end
+      end
+
+      # the mode this example's metadata selects, or the configured default
+      def self.mode_for(metadata, config = GraphWeaver::Testing.config)
+        tagged = metadata[TAG]
+        return config.default_mode if tagged.nil?
+        # opt out: no client is installed, and a configured default_mode
+        # doesn't sweep this example up
+        return if tagged == false
+
+        mode = tagged.to_s.to_sym
+        return mode if CLIENT_MODES.include?(mode)
+
+        raise GraphWeaver::Error, "#{TAG}: #{tagged.inspect} is not a mode — " \
+          "#{CLIENT_MODES.map(&:inspect).join(", ")} (or false to opt out)"
+      end
+
+      # the client an example in this mode runs against
+      def self.client_for(mode, config = GraphWeaver::Testing.config)
+        case mode
+        when :fake
+          FakeClient.new(schema: config.reference_schema!)
+        when :in_process
+          GraphWeaver::InProcess.new(config.schema_class!, context: config.context)
+        when :router
+          router = config.built_router
+          router.context = config.context
+          # built once for the suite, so the trace has to be told where this
+          # example starts — otherwise have_fetched reads the last one's
+          router.reset_trace
+        end
+      end
+
+      # included into every example group, so graphql_context is there
+      # whether or not this example took a client from the hook
+      module Helpers
+        # The fake this example runs against, built here rather than by the
+        # tag — which is how it takes options. `graphql: :fake` is exactly
+        # this call with none:
+        #
+        #      it "shows the two paid orders" do
+        #        graphql_fake(overrides: { "Reader.name" => "Ada",
+        #                                  "Reader.orders" => [{ "status" => "PAID" }, {}] })
+        #        expect(DashboardQuery.execute!.reader.orders.size).to eq 2
+        #      end
+        #
+        # Returns the client, for the assertions that are about the request:
+        #
+        #      fake = graphql_fake
+        #      2.times { Dashboard.load }
+        #      expect(fake.requests.size).to eq 1
+        #
+        # Installed as GraphWeaver.client and restored after the example,
+        # like a tagged one — so the tag is optional here, not required.
+        def graphql_fake(**options)
+          claim_mode!(:fake)
+          options[:schema] ||= GraphWeaver::Testing.config.reference_schema!
+          GraphWeaver.client = GraphWeaver::Testing::FakeClient.new(**options)
+        end
+
+        # Run this example against one schema class's real resolvers.
+        # `graphql: :in_process` is exactly this call with no argument, which
+        # runs config.schema when that is a live class.
+        #
+        # Naming one is how a federated app tests a single subgraph directly,
+        # which is a different question from `graphql: :router` — that plans
+        # across the whole graph and stitches. Both are worth asking, and a
+        # suite testing several subgraphs needs to say which per example:
+        #
+        #      it "hides a draft review", graphql: :in_process do
+        #        graphql_in_process(Reviews::Schema)
+        #        …
+        #      end
+        #
+        # Returns the client, and is restored after the example like a tagged
+        # one — so the tag is optional here.
+        def graphql_in_process(schema = nil, **options)
+          claim_mode!(:in_process)
+          schema ||= GraphWeaver::Testing.config.schema_class!
+          options[:context] ||= GraphWeaver::Testing.config.context
+          GraphWeaver.client = GraphWeaver::InProcess.new(schema, **options)
+        end
+
+        # A tag and a helper are two spellings of one choice, so they can
+        # agree (`graphql: :fake` plus `graphql_fake(overrides:)` is the
+        # documented way to pass options) but must not contradict: one of the
+        # two is then a mistake, and silently letting the later one win hides
+        # which.
+        def claim_mode!(mode)
+          tagged = defined?(@__graph_weaver_mode) ? @__graph_weaver_mode : nil
+          if tagged && tagged != mode
+            # Kernel.raise: this module is mixed into every example group, so
+            # it doesn't include Kernel for sorbet to find
+            Kernel.raise GraphWeaver::Error, "this example is tagged #{TAG}: #{tagged.inspect} but calls " \
+              "graphql_#{mode} — drop one. The tag is the helper with no arguments, so keep the " \
+              "helper when you need to pass it something."
+          end
+
+          @__graph_weaver_mode = mode
+        end
+
+        # The GraphQL context this example's resolvers see — merged onto
+        # config.context, and reset before the next example runs:
+        #
+        #      graphql_context(current_user: alice)
+        #      graphql_context(admin: true) { … }   # only inside the block
+        #      graphql_context                      # read it back
+        def graphql_context(values = nil, &block)
+          mode = defined?(@__graph_weaver_mode) ? @__graph_weaver_mode : nil
+          baseline = GraphWeaver::Testing::RSpecIntegration.context!(mode)
+          return baseline unless values
+
+          merged = baseline.merge(values)
+          GraphWeaver::Testing::RSpecIntegration.set_context(mode, merged)
+          return merged unless block
+
+          begin
+            block.call
+          ensure
+            GraphWeaver::Testing::RSpecIntegration.set_context(mode, baseline)
+          end
+        end
+      end
+
+      # A fake has no resolvers to hand a context to, so silently ignoring
+      # one would leave an example asserting on data nothing scoped.
+      def self.context!(mode)
+        case mode
+        when :in_process, :router then GraphWeaver.client.context
+        when :fake
+          raise GraphWeaver::Error, "graphql_context needs resolvers to receive it, and a " \
+            "#{TAG}: :fake example runs against fabricated data — tag it #{TAG}: :in_process or " \
+            "#{TAG}: :router (or pin the data itself: " \
+            "graphql_fake(overrides: { \"Person.name\" => \"Ada\" }))"
+        else
+          raise GraphWeaver::Error, "graphql_context needs an example running against your " \
+            "resolvers — tag it #{TAG}: :in_process or #{TAG}: :router"
+        end
+      end
+
+      def self.set_context(mode, values)
+        client = GraphWeaver.client
+        # the router is built once for the suite, so it takes a new context
+        # rather than being rebuilt; an InProcess is two ivars, so it isn't
+        # worth making mutable for this
+        case mode
+        when :router then client.context = values
+        when :in_process then GraphWeaver.client = GraphWeaver::InProcess.new(client.schema, context: values)
         end
       end
     end