graph_weaver 0.7.4 → 0.7.5

data/lib/graph_weaver/internal/values.rb

@@ -57,6 +57,11 @@ class GraphWeaver::Internal::Values
   # registration says the server writes "12.5".
   WIRE = [NilClass, TrueClass, FalseClass, Integer, Float, String, Symbol, Array, Hash].freeze
 
+  # Whether a value is already one of those. At a leaf it means the registry's
+  # serializer has nothing to do; at a composite position (FakeClient) it means
+  # the pin stands as written.
+  def self.wire?(value) = WIRE.any? { |klass| value.is_a?(klass) }
+
   # The fallback, for a scalar nobody registered: its prop is T.untyped, so
   # anything holds and a plausible shape beats a placeholder.
   NAMED_SHAPES = {
@@ -146,10 +151,10 @@ class GraphWeaver::Internal::Values
   # as written. Shared with the object-pin door, so both read a pin the same
   # way.
   def wire(type_name, value, coordinate = nil)
-    return value if WIRE.any? { |klass| value.is_a?(klass) }
+    return value if self.class.wire?(value)
 
     serialized = @registry.scalar(type_name, coordinate).serialize_value(value)
-    return serialized if WIRE.any? { |klass| serialized.is_a?(klass) }
+    return serialized if self.class.wire?(serialized)
 
     article = GraphWeaver::Internal::Util.article(value.class.to_s)
     raise GraphWeaver::Error, "the pin for #{type_name.inspect} is #{article} #{value.class}, and a pin " \

data/lib/graph_weaver/internal.rb

@@ -18,6 +18,11 @@ module GraphWeaver
   # lexical scope, so a private constant would be unreachable from exactly
   # the files that need it. The name and the surface lock carry the rule.
   module Internal
+    # The wire value the member register_enum fallback: true adds to a
+    # generated enum serializes to. The GraphQL spec reserves a leading `__`,
+    # so no schema can declare a value that collides with it.
+    ENUM_FALLBACK_WIRE = "__other__"
+
     # Odds and ends several files share. Each is here because more than one
     # caller needs it, not because it belongs together with the others.
     module Util
@@ -50,6 +55,18 @@ module GraphWeaver
         # "a" or "an" for a word an error message is about to name.
         def article(word) = word.downcase.start_with?(/[aeiou]/) ? "an" : "a"
 
+        # how many entries a message names before it says "and N more"
+        SAMPLE = 5
+        private_constant :SAMPLE
+
+        # A list a message names inline, held to a readable length — a wall
+        # of schema coordinates says less than the first few and a count.
+        def sample(list)
+          return list.join(", ") if list.size <= SAMPLE
+
+          "#{list.first(SAMPLE).join(", ")} and #{list.size - SAMPLE} more"
+        end
+
         # The module a .graphql file generates, and the basename of the file
         # it generates into: the camelized file name plus the operation's own
         # word. Every run of non-alphanumerics in the name is a word boundary,

data/lib/graph_weaver/logging.rb

@@ -101,7 +101,11 @@ module GraphWeaver
         # about the key the value arrived under, so it reads a filtered key one
         # level in as safe; this scrubs at every depth, like #value. The key is
         # optional because a coercer refusing a value hasn't been told one.
-        def shown(raw, key = nil) = filtered?(key) ? FILTERED : cap(value(key, raw).inspect)
+        def shown(raw, key = nil) = filtered?(key) ? FILTERED : cap(spell(value(key, raw)))
+
+        # How a value reads inside a sentence. inspect, except that
+        # BigDecimal#inspect is scientific ("0.25e1" for the 2.5 a caller wrote).
+        def spell(value) = defined?(BigDecimal) && value.is_a?(BigDecimal) ? value.to_s("F") : value.inspect
 
         # A short server-chosen string the library republishes inside its own
         # text — the APM's :code, the [CODE] in the one line info writes, a
@@ -215,36 +219,13 @@ module GraphWeaver
         end
 
         # What a Retry has already spent, read by the attempt it is about
-        # to make. A dynamic extent rather than a global: the count is only
-        # visible while the call it describes is on the stack, so a client
-        # that never reaches instrument can't leave a stale one behind.
-        def with_retries(count)
-          return yield unless GraphWeaver.instrumenter
-
-          previous = Thread.current[RETRIES]
-          Thread.current[RETRIES] = count
-          begin
-            yield
-          ensure
-            Thread.current[RETRIES] = previous
-          end
-        end
+        # to make.
+        def with_retries(count, &block) = during(RETRIES, count, &block)
 
         # The graph a generated module is dispatching, read by the request it
-        # is about to make. Same dynamic extent as with_retries, for the same
-        # reason — and instrument clears it for the duration of the request it
-        # labels, so exactly one request wears the label.
-        def with_graph(name)
-          return yield unless GraphWeaver.instrumenter
-
-          previous = Thread.current[GRAPH]
-          Thread.current[GRAPH] = name
-          begin
-            yield
-          ensure
-            Thread.current[GRAPH] = previous
-          end
-        end
+        # is about to make — and instrument clears it for the duration of the
+        # request it labels, so exactly one request wears the label.
+        def with_graph(name, &block) = during(GRAPH, name, &block)
 
         # The variables as one JSON line for a log: filtered, and unable to
         # raise. A value with no JSON form (NaN, binary) is the caller's bug
@@ -278,6 +259,22 @@ module GraphWeaver
 
         private
 
+        # One fiber-local, set for the length of one call. A dynamic extent
+        # rather than a global: the value is only visible while the call it
+        # describes is on the stack, so a client that never reaches instrument
+        # can't leave a stale one behind.
+        def during(key, value)
+          return yield unless GraphWeaver.instrumenter
+
+          previous = Thread.current[key]
+          Thread.current[key] = value
+          begin
+            yield
+          ensure
+            Thread.current[key] = previous
+          end
+        end
+
         # The GraphQL errors a response carries, whatever answered it — a
         # Hash from a transport, a graphql-ruby Result in-process, a fake.
         # Never raises: an instrumenter that decides which exception a

data/lib/graph_weaver/query_module.rb

@@ -7,8 +7,6 @@ require_relative "internal"
 require_relative "internal/test_clients"
 
 module GraphWeaver
-  # Called by generated code — not semver'd for direct use.
-  #
   # 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
@@ -16,6 +14,13 @@ module GraphWeaver
   # stay generated, since their sigs are the query's types and those are the
   # point.
   #
+  # It is also the type every generated module satisfies, so code that takes
+  # any of them says `GraphWeaver::QueryModule` and reads `query_string` /
+  # `operation_name` with a sig behind each — rather than `const_get(:QUERY)`
+  # on a Module, which is what rubocop-sorbet forbids (ConstantsFromStrings,
+  # and ForbidTUnsafe for the T.unsafe that gets around it). Those readers
+  # and `client` are the supported surface; the rest is generated code's.
+  #
   # Resolution order, per the docs: per call → a test mode's stand-in
   # (Internal::TestClients) → the client the module's graph names →
   # `GraphWeaver.client`. A module has no fifth slot you can set: a parsed
@@ -32,6 +37,18 @@ module GraphWeaver
       @client || default_client
     end
 
+    # The operation, verbatim — what goes on the wire as `query`.
+    sig { returns(String) }
+    def query_string
+      T.unsafe(self).const_get(:QUERY)
+    end
+
+    # What goes on the wire as `operationName`; nil for an anonymous operation.
+    sig { returns(T.nilable(String)) }
+    def operation_name
+      T.unsafe(self).const_get(:OPERATION_NAME)
+    end
+
     private
 
     # Bound by GraphWeaver.parse, which is the only caller: a parsed module
@@ -59,12 +76,10 @@ module GraphWeaver
       # comes through here.)
       GraphWeaver::Internal::Wire.check_variables!(variables)
 
-      mod = T.unsafe(self)
       # the graph codegen baked in, never one inferred from the client — a
       # wrong label on a request is worse than no label
       GraphWeaver::Internal::Log.with_graph(graph_name) do
-        client_for(client).execute(mod.const_get(:QUERY), variables:,
-          operation_name: mod.const_get(:OPERATION_NAME))
+        client_for(client).execute(query_string, variables:, operation_name:)
       end
     end
 

data/lib/graph_weaver/railtie.rb

@@ -35,7 +35,7 @@ class GraphWeaver::Railtie < Rails::Railtie
     KEYS = %i[watch].freeze
 
     def method_missing(name, *args)
-      key = name.to_s.delete_suffix("=").delete_suffix("?").delete_suffix("!").to_sym
+      key = setting(name)
       return super if KEYS.include?(key)
 
       raise ArgumentError, refusal(key)
@@ -53,11 +53,16 @@ class GraphWeaver::Railtie < Rails::Railtie
     alias_method :store, :[]=
 
     def respond_to_missing?(name, _private = false)
-      KEYS.include?(name.to_s.delete_suffix("=").delete_suffix("?").delete_suffix("!").to_sym)
+      KEYS.include?(setting(name))
     end
 
     private
 
+    # the setting a reader, writer or predicate is about
+    def setting(name)
+      name.to_s.delete_suffix("=").delete_suffix("?").delete_suffix("!").to_sym
+    end
+
     def refusal(key)
       near = GraphWeaver::Internal::Util.did_you_mean(KEYS.map(&:to_s), key.to_s)
       fix =

data/lib/graph_weaver/rspec.rb

@@ -592,7 +592,6 @@ module GraphWeaver
           "may itself be a proc, so it can vary per request."
       end
       private_class_method :wire_context!
-
     end
   end
 end

data/lib/graph_weaver/schema_loader.rb

@@ -887,9 +887,10 @@ module GraphWeaver::SchemaLoader
     return recompose_hint(path) if composed_dump?(path)
 
     missing = path ? "#{path} records no source url" : "no schema dump at #{GraphWeaver.schema_path}"
-    "#{missing} — pass one: rake graph_weaver:schema:refresh URL=https://api.example.com/graphql " \
-      "(if this app serves the schema itself, point GraphWeaver.client at the class and the dump is " \
-      "rebuilt from it — see docs/getting_started.md#your-apps-own-schema-in-process)"
+    "#{missing} — pass one: rake graph_weaver:schema:refresh " \
+      "URL=https://api.example.com/graphql, or point the graph's client at the server — an app " \
+      "that serves the schema itself points GraphWeaver.client at the class and the dump is built " \
+      "from that (docs/getting_started.md#your-apps-own-schema-in-process)"
   end
   private_class_method :refresh_hint
 
@@ -922,11 +923,9 @@ module GraphWeaver::SchemaLoader
   # ends up honoured in some places and not others.
   def self.source_transport(path)
     meta = provenance(path)
-    unless meta&.key?("url")
-      raise GraphWeaver::Error,
-        "#{path} records no source url — it wasn't introspected from one. Pass transport:, " \
-        "or rebuild it from the schema class that produced it."
-    end
+    # the same sentence refresh! gives: this is reached by typing a rake task
+    # (schema:diff), and `transport:` is not something a rake user can pass
+    raise GraphWeaver::Error, refresh_hint(path) unless meta&.key?("url")
 
     GraphWeaver.new(meta["url"], auth: ENV[auth_env(path)]).transport
   end

data/lib/graph_weaver/tasks.rb

@@ -170,6 +170,30 @@ module GraphWeaver
         }.filter_map { |kind, names| "  #{kind}: #{names.sort.join(", ")}" if names.any? }
       end
 
+      # What `queries:check` just answered. It re-introspects the url a dump
+      # records and asks a live class directly; anything else it checks as it
+      # stands on disk, which is `verify`'s question — and both exited 0
+      # saying "against the schema".
+      def self.validated
+        dumps = GraphWeaver.graphs.filter_map { |graph| as_committed(graph) }
+        return "every query validates against the schema" if dumps.empty?
+
+        "every query validates against #{dumps.join(", ")} as committed — not the server " \
+          "(rake graph_weaver:schema:diff asks whether the server moved)"
+      end
+
+      # A graph whose queries were checked against the file rather than the
+      # server: a graph that names its own schema is checked against exactly
+      # that, and a dump with no recorded url has nothing to re-read.
+      def self.as_committed(graph)
+        path = graph.dump_path
+        return unless path && graph.live_schema.nil?
+        return if !graph.named_schema? && GraphWeaver::SchemaLoader.provenance(path)&.key?("url")
+
+        GraphWeaver::Internal::Util.relative(path)
+      end
+      private_class_method :as_committed
+
       # Neither task that needs the committed dump can take one itself, so both
       # say which task can — the same sentence SchemaLoader gives on refresh.
       def self.no_dump
@@ -184,7 +208,23 @@ module GraphWeaver
       # rewrites it from the graph's source, `diff` says how far that source
       # has drifted from it, whichever the source is. A graph whose schema IS
       # a live class reads no dump at all, so it has neither.
-      def self.dumps = GraphWeaver.graphs.map { |graph| [graph, graph.dump_path, graph.dump_source] }
+      #
+      # The dump's own record of where it came from first, then the client the
+      # graph's modules already call: a dump inherited with no provenance, or a
+      # schema kept by hand, still has a server behind it, and refusing one
+      # took every other graph's refresh down with it.
+      def self.dumps
+        GraphWeaver.graphs.map { |graph| [graph, graph.dump_path, graph.dump_source || graph.client_url] }
+      end
+
+      # A dump with no recorded url whose graph names no client: nothing
+      # behind the file to re-read, so the file is the schema. Said and
+      # stepped over rather than refused — the task's job is the graphs it
+      # CAN refresh.
+      def self.no_source(path)
+        "#{GraphWeaver::Internal::Util.relative(path)} records no source url and the graph names " \
+          "no client — left as checked in"
+      end
 
       # A graph that generates straight from a schema class has no dump
       # between the code and the output — so there is nothing here to
@@ -202,6 +242,19 @@ module GraphWeaver
         "#{whose} generates from #{source_name(source)} directly — no dump to keep in step"
       end
 
+      # What `diff` re-introspects for one graph. A schema class answers
+      # introspection itself. A url the dump recorded is left to
+      # SchemaLoader.diff, which builds the transport and so honours the
+      # auth_env the dump named. A source that came from the graph's client
+      # instead is that client's own transport — headers, auth and all.
+      def self.diff_transport(graph, source)
+        return source if source.is_a?(Module)
+        return if graph.dump_source
+
+        client = graph.client || GraphWeaver.client
+        client.respond_to?(:transport) ? client.transport : client
+      end
+
       # How a dump's source reads in a report: a url as itself, a schema
       # class by name.
       def self.source_name(source) = source.is_a?(Module) ? GraphWeaver::SchemaLoader.endpoint(source) : source
@@ -350,9 +403,8 @@ namespace :graph_weaver do
         # dump between the code and the output, so nothing can be stale
         next puts GraphWeaver::Internal::Tasks.no_dump_needed(graph, source) unless path
 
-        # a schema class answers introspection itself; left nil, diff builds
-        # the dump's own transport, auth and all
-        diff = GraphWeaver::SchemaLoader.diff(path, transport: (source if source.is_a?(Module)))
+        diff = GraphWeaver::SchemaLoader.diff(path,
+          transport: GraphWeaver::Internal::Tasks.diff_transport(graph, source))
         dump = GraphWeaver::Internal::Util.relative(path)
         next puts "#{dump} matches #{GraphWeaver::Internal::Tasks.source_name(source)}" if diff.empty?
 
@@ -398,6 +450,9 @@ namespace :graph_weaver do
         # below and refresh! bootstraps its first dump (or says how).
         path ||= graph.named_dump_path
         next puts GraphWeaver::Internal::Tasks.no_dump_needed(graph, source) if !path && graph.named_schema?
+        # a supergraph has no source by construction — nothing serves one —
+        # and refresh! answers that with "recompose", which is not a skip
+        next puts GraphWeaver::Internal::Tasks.no_source(path) if path && !source && !graph.supergraph
 
         written, from = GraphWeaver::SchemaLoader.refresh!(url: (source unless source.is_a?(Module)),
           schema: (source if source.is_a?(Module)), path:)
@@ -425,7 +480,7 @@ namespace :graph_weaver do
       # block-buffered stdout, so a piped CI log shows the verdict first
       $stdout.flush
       abort "#{failures.size} invalid #{(failures.size == 1) ? "query" : "queries"}" if failures.any?
-      puts "every query validates against the schema"
+      puts GraphWeaver::Internal::Tasks.validated
     end
   end
 

data/lib/graph_weaver/testing/fake_client.rb

@@ -137,12 +137,6 @@ class GraphWeaver::Testing::FakeClient
     null_chance: nil, errors: nil, fail_at: nil, corrupt: nil,
   }.freeze
 
-  # JSON's own types are already on the wire: at a leaf they skip the
-  # registry's serializer (Values#wire), and at a composite position (a Hash
-  # aside, which is response keys) they pin the field as written — nil is
-  # null, the rest is the corrupt payload the example asked for.
-  WIRE = GraphWeaver::Internal::Values::WIRE
-
   # Methods every Ruby object answers aren't fields: a schema does have a
   # `hash` or a `count`, and a Struct answers both with plausible nonsense
   # where fabricating is right.
@@ -151,7 +145,7 @@ class GraphWeaver::Testing::FakeClient
   # The scalars the GraphQL spec serializes as JSON strings, whatever Ruby
   # holds them.
   STRING_SCALARS = %w[ID String].freeze
-  private_constant :OPTIONS, :WIRE, :RUBY_OWN, :STRING_SCALARS
+  private_constant :OPTIONS, :RUBY_OWN, :STRING_SCALARS
 
   def initialize(pins = {}, **options)
     config = GraphWeaver::Testing.config
@@ -467,7 +461,9 @@ class GraphWeaver::Testing::FakeClient
   # reads them off — a FactoryBot build, a model, a Struct. Either way it
   # MERGES: what it doesn't answer is fabricated.
   def pinned_object(type, selections, value, source)
-    return value if !value.is_a?(Hash) && wire?(value)
+    # what JSON already holds is the pin as written — nil is null, and the rest
+    # is the corrupt payload the example asked for (a Hash is response keys)
+    return value if !value.is_a?(Hash) && GraphWeaver::Internal::Values.wire?(value)
 
     concrete = pinned_type(type, value, source)
     pins = value.is_a?(Hash) ? value : read_fields(concrete, selections, value)
@@ -497,8 +493,6 @@ class GraphWeaver::Testing::FakeClient
     object.respond_to?(name) && !RUBY_OWN.include?(object.method(name).owner)
   end
 
-  def wire?(value) = WIRE.any? { |klass| value.is_a?(klass) }
-
   # An object pin holds Ruby values — a Time, a Money, a T::Enum — where the
   # wire holds what the registration says they serialize to. A value that
   # is already wire-shaped is taken as written.

data/lib/graph_weaver/testing/router.rb

@@ -326,11 +326,14 @@ module GraphWeaver
 
         plan = @planner.plan(document, operation_name:)
         return introspect(query, variables, plan.operation_name) if plan.introspection
+        # read once, so every hop runs as the identity the query started
+        # with, whatever writes #context= while it is in flight
+        context = Internal::Util.context!(@context)
         # one subgraph answers the whole thing: hand it the document as
         # written, so nothing is rewritten that didn't have to be
-        return fetch(plan.entry, query, variables, plan.operation_name) if plan.verbatim
+        return fetch(plan.entry, query, variables, plan.operation_name, context) if plan.verbatim
 
-        run(plan, variables)
+        run(plan, variables, context)
       end
 
       # never leak the context (tokens, current_user) through logs or errors
@@ -374,7 +377,7 @@ module GraphWeaver
 
       # ---- execution ----------------------------------------------------
 
-      def run(plan, variables)
+      def run(plan, variables, context)
         errors = []
         data = {}
         # An operation's declared defaults are part of the variables, and
@@ -384,7 +387,7 @@ module GraphWeaver
           .merge(variables.to_h { |name, value| [name.to_s, value] })
 
         plan.steps.each do |step|
-          result = fetch_step(step, plan.operation, given)
+          result = fetch_step(step, plan.operation, given, context)
           Array(result["errors"]).each { |error| errors << rewrite(error, step.subgraph) }
           payload = result["data"]
           if payload.nil?
@@ -397,7 +400,7 @@ module GraphWeaver
           end
         end
 
-        plan.steps.each { |step| stitch(step, [[data, []]], plan.operation, given, errors) }
+        plan.steps.each { |step| stitch(step, [[data, []]], plan.operation, given, context, errors) }
 
         # A stitched fetch can leave a null where the composed schema says
         # non-null, and nothing re-applies GraphQL's propagation rules over a
@@ -443,7 +446,7 @@ module GraphWeaver
       # Everything the plan applies at this level: one _entities fetch per
       # subgraph the level defers to (all nodes at once — _entities answers
       # in representation order), then the same again one level down.
-      def stitch(step, nodes, operation, variables, errors)
+      def stitch(step, nodes, operation, variables, context, errors)
         return if nodes.empty?
 
         # An abstract position: the plan holds one branch per concrete type
@@ -454,12 +457,12 @@ module GraphWeaver
         if step.is_a?(Internal::Planner::Branches)
           step.steps.each do |type_name, branch|
             stitch(branch, nodes.select { |(node, _)| node[TYPENAME] == type_name },
-              operation, variables, errors)
+              operation, variables, context, errors)
           end
           return
         end
 
-        blocked = prefetch(step, nodes, operation, variables, errors)
+        blocked = prefetch(step, nodes, operation, variables, context, errors)
 
         # A fetch for a selection the operation excluded is a fetch a real
         # router never makes, and `trace` is something specs assert on. The
@@ -478,7 +481,8 @@ module GraphWeaver
 
           entities = []
           if fetched.any?
-            result = entities_fetch(target, step.type_name, deferrals.map(&:node), representations, operation, variables)
+            result = entities_fetch(target, step.type_name, deferrals.map(&:node), representations, operation,
+              variables, context)
             entities = result.dig("data", "_entities") || []
             Array(result["errors"]).each { |error| errors << rewrite(error, target, fetched) }
           end
@@ -502,12 +506,12 @@ module GraphWeaver
           deferrals.each do |deferral|
             next unless deferral.step
 
-            stitch(deferral.step, descend(nodes, deferral.response_key), operation, variables, errors)
+            stitch(deferral.step, descend(nodes, deferral.response_key), operation, variables, context, errors)
           end
         end
 
         step.children.each do |key, child|
-          stitch(child, descend(nodes, key), operation, variables, errors)
+          stitch(child, descend(nodes, key), operation, variables, context, errors)
         end
 
         nodes.each { |(node, _)| strip!(node, step) }
@@ -517,7 +521,7 @@ module GraphWeaver
       # keys before the fetch whose representation carries them. Returns the
       # nodes the holding subgraph didn't recognize: their required fields
       # don't exist, so nothing depending on them can resolve.
-      def prefetch(step, nodes, operation, variables, errors)
+      def prefetch(step, nodes, operation, variables, context, errors)
         blocked = []
         # the field it feeds was excluded, so this is a fetch a real router
         # never makes — and a test double that runs a resolver production
@@ -533,7 +537,7 @@ module GraphWeaver
           selections = Internal::Planner.injected_selections(group.flat_map(&:paths).uniq)
           roots = selections.map(&:alias)
 
-          result = entities_fetch(subgraph, step.type_name, selections, representations, operation, variables)
+          result = entities_fetch(subgraph, step.type_name, selections, representations, operation, variables, context)
           entities = result.dig("data", "_entities") || []
           Array(result["errors"]).each { |error| errors << rewrite(error, subgraph, nodes) }
 
@@ -621,16 +625,16 @@ module GraphWeaver
         Array(path).map { |segment| segment.is_a?(String) ? segment.delete_prefix(PREFIX) : segment }
       end
 
-      def fetch_step(step, operation, variables)
+      def fetch_step(step, operation, variables, context)
         document = GraphQL::Language::Nodes::OperationDefinition.new(
           operation_type: operation.operation_type || "query",
           variables: used_variables(step.selections, operation),
           selections: step.selections,
         )
-        run_subgraph(step.subgraph, document, variables)
+        run_subgraph(step.subgraph, document, variables, context)
       end
 
-      def entities_fetch(subgraph, type_name, nodes, representations, operation, variables)
+      def entities_fetch(subgraph, type_name, nodes, representations, operation, variables, context)
         entities = GraphQL::Language::Nodes::Field.new(
           name: "_entities",
           arguments: [GraphQL::Language::Nodes::Argument.new(
@@ -647,7 +651,7 @@ module GraphWeaver
           variables: [REPRESENTATIONS_DEFINITION] + used_variables(nodes, operation),
           selections: [entities],
         )
-        run_subgraph(subgraph, document, variables.merge(REPRESENTATIONS => representations))
+        run_subgraph(subgraph, document, variables.merge(REPRESENTATIONS => representations), context)
       end
 
       REPRESENTATIONS = "representations"
@@ -682,12 +686,12 @@ module GraphWeaver
         end
       end
 
-      def run_subgraph(subgraph, document, variables)
+      def run_subgraph(subgraph, document, variables, context)
         declared = document.variables.map(&:name)
-        fetch(subgraph, document.to_query_string, variables.slice(*declared), nil)
+        fetch(subgraph, document.to_query_string, variables.slice(*declared), nil, context)
       end
 
-      def fetch(name, query, variables, operation_name)
+      def fetch(name, query, variables, operation_name, context)
         faked = @faked.include?(name)
         entry = { subgraph: name, query:, variables: variables.to_h }
         entry[:faked] = true if faked
@@ -701,14 +705,12 @@ module GraphWeaver
         end
 
         GraphWeaver::Internal::Log.log(:debug) do
-          "router -> #{name} #{tag} variables=#{JSON.generate(GraphWeaver::Internal::Log.filter_variables(variables))}
-" \
+          "router -> #{name} #{tag} variables=#{JSON.generate(GraphWeaver::Internal::Log.filter_variables(variables))}\n" \
             "#{GraphWeaver::Internal::Wire.truncate_for_log(query)}"
         end
 
         GraphWeaver::Internal::Log.log_timed(:debug, "router -> #{name} #{tag} completed") do
-          @subgraphs.fetch(name).execute(query, variables:, operation_name:,
-            context: Internal::Util.context!(@context)).to_h
+          @subgraphs.fetch(name).execute(query, variables:, operation_name:, context:).to_h
         end
       end
 
@@ -783,7 +785,6 @@ module GraphWeaver
         end
         ordered
       end
-
     end
   end
 end

data/lib/graph_weaver/testing.rb

@@ -352,7 +352,6 @@ module GraphWeaver
       def runnable(schema)
         schema if schema.is_a?(Class) && schema <= GraphQL::Schema
       end
-
     end
 
     class << self
@@ -476,7 +475,7 @@ module GraphWeaver
         end
         return if back == sample
 
-        "#{name}: round-trips lossily — sent #{sample.inspect}, got back #{back.inspect}"
+        "#{name}: round-trips lossily — sent #{Internal::Redact.spell(sample)}, got back #{Internal::Redact.spell(back)}"
       end
 
       # The registration's `cast:`, RUN rather than emitted. A cast builds

data/lib/graph_weaver/version.rb

@@ -1,3 +1,3 @@
 module GraphWeaver
-  VERSION = "0.7.4"
+  VERSION = "0.7.5"
 end