graph_weaver 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0ae9c23b2566bfa26c786e07703e4fad357cbd09a29112d3e0c9dd5d3af916c
-  data.tar.gz: fb5f4534174e5ba9cb7b9d323af26c2a13456c022f8682bcc3ccae5e512a1c96
+  metadata.gz: 2cb0372c9f8505bec490fbb13344cbd586da68cb4932cbce0f86de2467d0eaf4
+  data.tar.gz: 6bc17449eea717c8cb145c159a2395f61f484a2f585c016ee31521f979f1a6d6
 SHA512:
-  metadata.gz: dc780e4f155ea89b9977822a7bb62ed9880d3b7e707fd5046229b1c91c843a9c1ec37c39fb5e2039e71c9095dfb7a0df006347a19ce4544f75f2b3fe13a35a5c
-  data.tar.gz: 3dcc86b06e670408ebc18eaaaad7447d5825d1d580b9640ed8860133ba29908eb42553d52da4a2619eb23f072f4999f5aceb622271fafc8d5431fd57a3106ed3
+  metadata.gz: 63670eee3838644725166822028b4816164450c853e24d74dd6ce47212e4e18c2bda7309d5549f8830e709d547e73678425ae9984d960a5367b97f5102613f5c
+  data.tar.gz: d7b30350095090f9c69e7b5316137ac5324b60965a242ffe5c9be4a893812a48351a172bde26f36000797d830eb01c3e15ea0352eea8ecda9ac775f55b12ac82

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graph_weaver (0.7.1)
+    graph_weaver (0.7.2)
       graphql (>= 2.6.7)
       sorbet-runtime
 
@@ -299,7 +299,7 @@ CHECKSUMS
   google-protobuf (4.35.1-arm64-darwin) sha256=d9c957df04fa89c749fa9a72a7b383eb4296efc9b2303dc6fd6fbe39c698ad6b
   google-protobuf (4.35.1-x86_64-darwin) sha256=66b62b4df00931018a692806df66393efa960d6d2b7da69735187249f950d3ee
   google-protobuf (4.35.1-x86_64-linux-gnu) sha256=c786439087512a3fbd199e9897d265b855f951d4027e218ea55e858d45969edd
-  graph_weaver (0.7.1)
+  graph_weaver (0.7.2)
   graphql (2.6.10) sha256=9b7c8633767f516ff9d48a8d6305b2a00a2101c82aa871b92e69086944f9f83e
   hashdiff (1.2.1) sha256=9c079dbc513dfc8833ab59c0c2d8f230fa28499cc5efb4b8dd276cf931457cd1
   i18n (1.15.2) sha256=00f9eb62412fe593b2a65a97daa75300d37abb8f7202ec748e94b6d46a9dd1b5

data/docs/federation.md

@@ -129,11 +129,13 @@ your resolvers run, which is the whole point.
 
 In rspec that's the [`graphql: :router`](testing.md#a-federated-graph--graphql-router)
 tag and there is nothing to pass — the tag builds it, once for the suite. It finds
-the supergraph where you have already said it is: `Testing.config.router =
-{ supergraph: … }` if you named one there, else the schema a
+the supergraph where you have already said it is: the schema a
 [graph](getting_started.md#more-than-one-schema) declares when that schema is
-composed, else the committed dump when *that* is. Two graphs may name one
-supergraph; two naming different ones is refused rather than picked between.
+composed, else `Testing.config.router = { supergraph: … }` if you named one
+there, else the committed dump when *that* is, else the dump your own client was
+built from (`GraphWeaver.new("supergraph.graphql")` keeps its path). Two graphs
+may name one supergraph; two naming different ones is refused rather than picked
+between.
 Outside rspec, build it yourself:
 
 ```ruby
@@ -406,14 +408,12 @@ client distinct from the one the app uses to reach the gateway from outside:
 
 ```ruby
 # config/initializers/graph_weaver.rb — beside GraphWeaver.graph :reviews,
-# whose client is "Reviews::Schema"
-PLATFORM = GraphWeaver.new(ENV.fetch("PLATFORM_GRAPHQL_URL"))
-
+# whose client is Reviews::Schema
 GraphWeaver.graph :platform do
   schema    "app/graphql/supergraph.graphql"
   queries   "app/graphql/platform/queries"
   output    "app/graphql/platform/generated"
-  client    "PLATFORM"
+  client    GraphWeaver.new(ENV.fetch("PLATFORM_GRAPHQL_URL"))
   namespace "Platform"
 end
 ```

data/docs/generated_modules.md

@@ -38,7 +38,7 @@ module PersonQuery
     const :person, T.nilable(Person)
   end
 
-  extend GraphWeaver::QueryModule # client / client= (see below)
+  extend GraphWeaver::QueryModule # client (see below)
   def self.execute(id:, client: nil)    # -> GraphWeaver::Response[Result]
   def self.execute!(id:, client: nil)   # -> Result, or raises QueryError
 
@@ -543,21 +543,20 @@ bodies. Every form above, and every error it raises, is a named example in
 
 A client is anything satisfying the [execute contract](transports.md) — a
 `GraphWeaver::Client`, a transport, a `Retry`, a live schema class, a fake.
-Resolution is per call (`client:`) → per module → baked constant →
-`GraphWeaver.client`; the canonical list is in
-[transports](transports.md#client-resolution). Generate *without* a baked
-constant when you want modules to follow the app default (`GraphWeaver.client =`
-in an initializer). A baked one is no reason a module escapes
-[testing's `graphql:` tag](testing.md), which is exactly the instruction to
-replace the client generation chose; what the *example* says still wins.
-
-`client`/`client=` live in the gem (`GraphWeaver::QueryModule`, extended by every
-generated module). A baked constant is emitted as a private `DEFAULT_CLIENT`,
-resolved on first use so a module can load before the initializer that builds its
-client. A module generated from a
-[declared graph](getting_started.md#more-than-one-schema) also carries a private
-`GRAPH` naming it — so with two graphs, `graphql: :fake` fabricates each module's
-own schema instead of having to be told which one you meant, and it is the
+A module knows which graph it belongs to, and the graph knows how to reach it:
+resolution is per call (`client:`) → a test mode's stand-in → the client its
+[graph](getting_started.md#more-than-one-schema) names → `GraphWeaver.client`;
+the canonical list is in [transports](transports.md#client-resolution). There is
+no setter — `MyQuery.client` reads back what the module would execute through,
+and a [parsed](#dynamic-mode) module, which has no graph, runs
+against whatever parsed it. A graph naming its own client is no reason a module
+escapes [testing's `graphql:` tag](testing.md), which is exactly the instruction
+to replace it; what the *example* says still wins.
+
+`client` lives in the gem (`GraphWeaver::QueryModule`, extended by every
+generated module). A generated file says nothing about transport — only a private
+`GRAPH` naming its graph, which is also how `graphql: :fake` fabricates each
+module's own schema with two graphs in play, and the
 `:graph` on every [instrumentation event](logging.md#the-payload) the module's
 `execute` produces.
 
@@ -690,8 +689,8 @@ you — a script that generates its own modules sets all four:
 2. `generated_paths` — where it writes, and where `load_generated!` reads. Point
    them at the same directory or generation is invisible.
 3. the call above, before the first `execute` — nothing else requires the files.
-4. `GraphWeaver.client =` — a module generated without a baked
-   [`client:`](#clients) has none of its own.
+4. `GraphWeaver.client =` — a module belonging to no declared graph has no
+   other [client](#clients) to reach for.
 
 Miss (3) and the script gets a `NameError` for its own module; miss (4) and it
 gets `PersonQuery: client must respond to #execute(query, variables:), got
@@ -723,9 +722,16 @@ form: parse and execute in one call, no module kept. In development
 `client.load_queries!` parses every query file into modules with the same names
 generation would use.
 
+A parsed module **runs against whatever parsed it** — `client.parse(query)` and
+`load_queries!` bind the client they came from, and `GraphWeaver.parse(client:)`
+says it outright. That is a property of parsing, not a slot you can set later:
+it generates no file, so it has no graph to read a client off, and a per-call
+`client:` still wins over it.
+
 In an app with [more than one graph](getting_started.md#more-than-one-schema), a
 parsed module belongs to one of them — that is what a `graphql:` tag runs it
-against, the same thing generation bakes into a file. It is read off the schema
+against and whose `client` it reaches for, the same thing generation writes into
+a file. It is read off the schema
 you parsed against when a graph runs that class in-process; say it outright
 otherwise:
 

data/docs/getting_started.md

@@ -52,8 +52,8 @@ would drop the source url it records; delete it and re-run to re-introspect.
 What it wrote:
 
 - **`config/initializers/graph_weaver.rb`.** `GraphWeaver.client =` is the
-  load-bearing line: generated modules without a baked transport resolve to it
-  at execute time (the full
+  load-bearing line: generated modules belonging to no declared graph resolve to
+  it at execute time (the full
   [resolution order](transports.md#client-resolution)). Custom
   scalars/enums/type helpers register here too — the rake tasks bake them into
   generated source, so they have to run first ([scalars](scalars.md)):
@@ -428,7 +428,7 @@ plus `register_scalar`, `register_enum` and `extend_type`).
 | `schema` | a graphql-ruby schema class, a [`Client`](transports.md), a path to a dump, SDL, or a lambda returning one |
 | `queries` | a directory, or a list of them — the `.graphql` files this graph generates from |
 | `output` | one directory — where this graph's generated Ruby is written |
-| `client` | a constant, or its name — what this graph's modules execute against |
+| `client` | what this graph's modules execute against — a client, or the name of the constant holding one |
 | `namespace` | a constant, or its name — what every constant this graph generates nests under |
 | `types_module` | a constant name for the shared types module (default: `GraphQLTypes`, under `namespace`) |
 
@@ -447,14 +447,14 @@ GraphWeaver.graph :app do
 end
 ```
 
-**`client` names a constant, not a url** — its value is spelled into every module
-this graph generates and resolved the first time one of them executes, so it has
-to be something generated source can write down. Build the client wherever you
-like (`GITHUB = GraphWeaver.new(url, auth: …)`) and put the constant holding it
-here. A graph with no `client` generates modules that fall back to
-`GraphWeaver.client`, the app default. `schema "x"` sets and a bare `schema`
-reads back; there is no `schema = "x"` form, since the block is `instance_eval`'d
-and that would be a local variable that silently does nothing.
+**`client` is where this graph's endpoint lives** — its modules say which graph
+they belong to and nothing about transport, so they read it when they execute.
+A graph with no `client` falls back to `GraphWeaver.client`, the app default.
+Name the object (`client GraphWeaver.new(url, auth: …)`) or, when the constant
+holding it is defined later than the graph block, its name (`client "GITHUB"`),
+which is resolved on first use. `schema "x"` sets and a bare `schema` reads
+back; there is no `schema = "x"` form, since the block is `instance_eval`'d and
+that would be a local variable that silently does nothing.
 
 **`namespace` nests everything that graph generates** — `person.graphql` becomes
 `Billing::PersonQuery` ([naming](generated_modules.md#naming)). Constants are

data/docs/testing.md

@@ -36,8 +36,8 @@ it "sends the caller tag",    graphql: :wire do … end
 There is nothing else to set up: each mode works out what to run against per
 graph, and [refuses rather than guessing](#nothing-to-configure). The tag
 installs a stand-in per graph, and every generated module of that graph runs
-against it — including one generated *with* a baked `client:`, since that
-constant is exactly what the tag means to replace. `rspec --tag graphql:router`
+against it — including one whose graph names a `client` of its own, since that
+is exactly what the tag means to replace. `rspec --tag graphql:router`
 runs one mode's examples.
 
 **Every example has exactly one mode.** An untagged one takes
@@ -50,7 +50,8 @@ whatever the example did to it, so building your own client is a plain
 assignment: `before { GraphWeaver.client = GraphWeaver::Testing::Failure.throttled }`.
 Do both at once and **the tag wins**: the assignment reads back while the modules
 keep using the mode. Two things do step out of a tag — a per-call `client:`, and
-`DashboardQuery.client =` on the module itself
+a module [parsed](generated_modules.md#dynamic-mode) from a client of its own,
+which runs against that client
 ([client resolution](transports.md#client-resolution) has the full order).
 
 **The half `:fake` can't reach** is refusal. It fabricates a shape-correct
@@ -340,10 +341,10 @@ suite. The tag adds one stub per endpoint and takes each back after the example
 it never disables net connections on your behalf, and never resets stubs it
 didn't make.
 
-**Every endpoint an example can reach is served**, one per graph: the client each
-[declared graph](getting_started.md#more-than-one-schema) bakes into its modules
-with `client:`, or `GraphWeaver.client` for a graph that bakes none — so a
-billing module posts to billing's url and is answered by billing's schema. What
+**Every endpoint an example can reach is served**, one per graph: the `client`
+each [declared graph](getting_started.md#more-than-one-schema) names, or
+`GraphWeaver.client` for a graph naming none — so a billing module posts to
+billing's url and is answered by billing's schema. What
 sits behind each is **what that graph is**, in descending faithfulness: that
 graph's [router](#a-federated-graph--graphql-router) when it is in a composed
 supergraph, its [live schema class](#real-resolvers--graphql-in_process) when it
@@ -352,8 +353,8 @@ that is a pure *client* of someone else's API gets a schema-correct server
 without writing one. A graph with no schema at all is refused, **by `:wire`'s own
 name** — the one fallback the other tags have and this one can't use is your
 client's own schema, since reading it means introspecting the endpoint `:wire`
-has just stubbed. Commit a dump, or set `config.schema`. A graph whose baked
-client posts nowhere is refused by name too.
+has just stubbed. Commit a dump, or set `config.schema`. A graph whose `client`
+posts nowhere is refused by name too.
 
 **It says which, on the logger** — the choice is the one thing this tag makes for
 you, and it is invisible from inside the example. One line per endpoint, at
@@ -542,11 +543,13 @@ rather than guessing**:
   [maps subgraphs](federation.md#which-schema-serves-which-subgraph).
 - **`:router`** plans against the composed supergraph **that graph** names, else
   `config.router = { supergraph: … }`, else the committed dump when *that*
-  carries `@join__*` markers — which for a federated app is usually no config at
-  all. A graph that is in no supergraph is refused **by name**, rather than
-  planned against another graph's. A client can't stand in for one: a client's
-  schema is the API schema the router serves, with the `@join__*` routing table
-  stripped out. Subgraphs are derived either way.
+  carries `@join__*` markers, else the dump your own client was built from
+  (`GraphWeaver.new("supergraph.graphql")`) — which for a federated app is
+  usually no config at all. A graph that is in no supergraph is refused **by
+  name**, rather than planned against another graph's. A client's *schema* can't
+  stand in for one — it is the API schema the router serves, with the `@join__*`
+  routing table stripped out — but the file it was read from carries the table.
+  Subgraphs are derived either way.
 
 So configure only to override a derivation, or to tune fabricated values — in the
 same file as the require, since support files load in sorted order and one naming

data/docs/transports.md

@@ -37,8 +37,8 @@ applied (exposed as `client.transport`), the schema introspected lazily, and
 
 They combine, so the whole thing is still one call —
 `GraphWeaver.new(url, transport: :faraday, retries: 2) { |conn| conn.response :logger }`.
-To wire generated modules that don't bake a client, make it the app's default:
-`GraphWeaver.client = github`.
+To wire generated modules belonging to no declared graph, make it the app's
+default: `GraphWeaver.client = github`.
 
 ## What fills the client slot
 
@@ -202,22 +202,29 @@ APM payload gets ([errors](errors.md)).
 
 ## Client resolution
 
+A module knows which graph it belongs to, and the graph knows how to reach it.
 The canonical order — how a generated module finds its client (each slot takes a
 `Client` or any bare transport/fake):
 
 1. per call: `execute(client: some_client, ...)` — a kwarg like the variables, and
    a name no GraphQL variable is allowed to take
-2. per module: `MyQuery.client = something`
-3. a test mode's stand-in: under `graphql: :fake` / `:in_process` / `:router`,
+2. a test mode's stand-in: under `graphql: :fake` / `:in_process` / `:router`,
    built from the graph this module was generated from
-4. baked constant: `Codegen.generate(..., client: "MyApi::CLIENT")` — the
-   constant's *name*, not the object, because generated source spells it
-5. the app default: `GraphWeaver.client=`
+3. the client its [graph](getting_started.md#more-than-one-schema) names
+4. the app default: `GraphWeaver.client=`
 
-The mode replaces what codegen baked in, not what your example said — 1 and 2
-still win. Nothing set anywhere raises, naming the two you'd usually reach for:
+The mode replaces what the graph says, not what your example said — 1 still
+wins. Nothing set anywhere raises, naming the two you'd usually reach for:
 `no client configured — set GraphWeaver.client= or pass a client`.
 
+**A [parsed](generated_modules.md#dynamic-mode) module isn't in that list**: it generates no
+file, so it has no graph, and it runs against whatever parsed it —
+`client.parse(query)`, `load_queries!`, or `GraphWeaver.parse(client:)`. That
+binding sits directly under the per-call `client:`, above even a test mode's
+stand-in, and is the only one there is: `MyQuery.client` reads back what a
+module would execute through, but there is no setter for it. A module's client
+comes from its graph, its parser, or the call.
+
 ## Retries
 
 A url client retries when you give it a count; the rest of the options sit beside

data/docs/upgrading.md

@@ -1,10 +1,11 @@
 # Upgrading
 
 [Regenerate](#regenerate-on-every-upgrade) whichever version you're on, then read
-the one section that is yours: from [0.7.0](#upgrading-from-070) or from
-[0.6.1](#upgrading-from-061). Coming from 0.6.0 or older, the path is that
-version's own upgrade notes — read them at the tag they shipped under
-(`git show v0.7.1:docs/upgrading.md`), then this page from 0.6.1 down.
+the one section that is yours: from [0.7.1](#upgrading-from-071), from
+[0.7.0](#upgrading-from-070) or from [0.6.1](#upgrading-from-061). Coming from
+0.6.0 or older, the path is that version's own upgrade notes — read them at the
+tag they shipped under (`git show v0.7.1:docs/upgrading.md`), then this page from
+0.6.1 down.
 
 ## Regenerate on every upgrade
 
@@ -22,6 +23,28 @@ That's the reminder working, not a false alarm. Generation is deterministic, so
 the diff is exactly what the new version emits differently and nothing else —
 worth reading rather than rubber-stamping.
 
+## Upgrading from 0.7.1
+
+A patch release, and one change with a shape: a generated module no longer
+carries a client of its own — the graph it belongs to resolves one. Read the
+left column and skip what isn't yours; the [changelog](../CHANGELOG.md) says why
+each one moved.
+
+| applies if you… | what changed |
+|---|---|
+| call `generate!`, `verify_generated!`, `Codegen.new` or `Codegen.generate` yourself — `grep -rn "client:" config lib Rakefile` | the `client:` kwarg is gone, and the call raises `unknown keyword: :client`. Say it once on the graph (`client` in a `GraphWeaver.graph` block), or as the app default (`GraphWeaver.client =`) for modules in no declared graph. `Graph#client` answers that object now, not the name of the constant holding it |
+| assign a generated module's client — `grep -rn "\.client *=" app config lib` (a hit on `GraphWeaver.client =` is the app default, and still fine) | the writer is private, and `MyQuery.client = …` raises `NoMethodError`. A module's client comes from its graph, from `client:` on the call, or — for a module you parsed — from `GraphWeaver.parse(client:)`, which `client.parse` and `load_queries!` already pass |
+
+Then regenerate, and the gate:
+
+```sh
+# generated files no longer carry a DEFAULT_CLIENT
+rake graph_weaver:generate
+
+# red while any checked-in file is still what 0.7.1 wrote
+rake graph_weaver:verify
+```
+
 ## Upgrading from 0.7.0
 
 A patch release of fixes, and a typical app ticks none of these. Read the left
@@ -167,7 +190,7 @@ only one here that shows up in production rather than in your code.
 - **A `graphql:` tag reaches a module generated with `client:`.** The baked client
   used to sit above the slot a tag swaps, so a bound module ran against its real
   endpoint under `graphql: :fake`. **If a spec relied on that**, pass `client:` on
-  the call, set `MyQuery.client =`, or tag the example `graphql: :live`.
+  the call, or tag the example `graphql: :live`.
 - **`config.context`, `config.schema` and `config.router` are suite setup.**
   Setting any of the three once an example is running refuses, naming the
   per-example helper (`graphql_context`, `graphql_fake(schema:)`,

data/examples/github/generated/star_mutation.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-# Generated by GraphWeaver 0.7.0 — do not edit.
+# Generated by GraphWeaver 0.7.2 — do not edit.
 
 module StarMutation
   extend T::Sig
@@ -79,11 +79,11 @@ module StarMutation
     end
   end
 
-  # client / client= — see GraphWeaver::QueryModule
+  # client — see GraphWeaver::QueryModule
   extend GraphWeaver::QueryModule
 
-  # the graph this module was generated from — what a test mode builds
-  # its stand-in client from
+  # the graph this module was generated from — whose client it runs
+  # against, and what a test mode builds its stand-in from
   GRAPH = T.let(:github, Symbol)
   private_constant :GRAPH
 

data/examples/github/generated/stargazers_query.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-# Generated by GraphWeaver 0.7.0 — do not edit.
+# Generated by GraphWeaver 0.7.2 — do not edit.
 
 require "time"
 
@@ -183,11 +183,11 @@ module StargazersQuery
     end
   end
 
-  # client / client= — see GraphWeaver::QueryModule
+  # client — see GraphWeaver::QueryModule
   extend GraphWeaver::QueryModule
 
-  # the graph this module was generated from — what a test mode builds
-  # its stand-in client from
+  # the graph this module was generated from — whose client it runs
+  # against, and what a test mode builds its stand-in from
   GRAPH = T.let(:github, Symbol)
   private_constant :GRAPH
 

data/examples/github/generated/starred_query.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-# Generated by GraphWeaver 0.7.0 — do not edit.
+# Generated by GraphWeaver 0.7.2 — do not edit.
 
 module StarredQuery
   extend T::Sig
@@ -103,11 +103,11 @@ module StarredQuery
     end
   end
 
-  # client / client= — see GraphWeaver::QueryModule
+  # client — see GraphWeaver::QueryModule
   extend GraphWeaver::QueryModule
 
-  # the graph this module was generated from — what a test mode builds
-  # its stand-in client from
+  # the graph this module was generated from — whose client it runs
+  # against, and what a test mode builds its stand-in from
   GRAPH = T.let(:github, Symbol)
   private_constant :GRAPH
 

data/lib/graph_weaver/client.rb

@@ -77,6 +77,10 @@ class GraphWeaver::Client
       # a live schema class doubles as an in-process transport; a loaded
       # dump has no resolvers, so it is type information only
       @schema = source.is_a?(Module) ? source : GraphWeaver::SchemaLoader.load(source)
+      # A supergraph's routing table lives in the file, not in the loaded
+      # schema, so the path is the only thing that can name one later. Told
+      # from SDL by its extension, as SchemaLoader tells it.
+      @schema_source = source if !source.is_a?(Module) && GraphWeaver::SchemaLoader.dump_path?(source)
 
       if context && !(source.is_a?(Module) && transport.nil?)
         # nothing would ever read it — a dump has no resolvers, and an
@@ -122,6 +126,10 @@ class GraphWeaver::Client
   # schema-dump clients (type information only).
   attr_reader :transport
 
+  # The dump this client's schema was read from, or nil for a url, a schema
+  # class, or inline SDL. What a graph named by this client is named by.
+  attr_reader :schema_source
+
   # transport, when this client must be able to execute
   private def transport!
     transport or raise GraphWeaver::Error,

data/lib/graph_weaver/codegen/emit.rb

@@ -456,22 +456,16 @@ class GraphWeaver::Codegen
     end
 
     def emit_execute(out, variables)
-      # client/client= carry no per-query types, so they live in the gem
-      out << "  # client / client= — see GraphWeaver::QueryModule"
+      # client carries no per-query types, so it lives in the gem
+      out << "  # client — see GraphWeaver::QueryModule"
       out << "  extend GraphWeaver::QueryModule"
       if @graph_name
         out << ""
-        out << "  # the graph this module was generated from — what a test mode builds"
-        out << "  # its stand-in client from"
+        out << "  # the graph this module was generated from — whose client it runs"
+        out << "  # against, and what a test mode builds its stand-in from"
         out << "  GRAPH = T.let(#{@graph_name.inspect}, Symbol)"
-        out << "  private_constant :GRAPH"
-      end
-      if @client_const
-        out << ""
-        out << "  # the baked default client, resolved on first use"
-        out << "  DEFAULT_CLIENT = T.let(-> { #{@client_const} }, T.proc.returns(T.untyped))"
         # QueryModule reads it with const_get, which privacy doesn't block
-        out << "  private_constant :DEFAULT_CLIENT"
+        out << "  private_constant :GRAPH"
       end
       out << ""
 

data/lib/graph_weaver/codegen.rb

@@ -59,15 +59,10 @@ class GraphWeaver::Codegen
 
   attr_reader :name
 
-  # A client is anything responding to `execute(query, variables:)`
-  # whose result `to_h`s into {"data" => ..., "errors" => ...} — a
-  # GraphWeaver::Client, a transport, a schema class, a fake.
-  #
-  # client: (a constant, or its name as a string) becomes the generated
-  # module's baked default; when omitted, generated code falls back to
-  # the app default (GraphWeaver.client=). graph_name: is the graph the
-  # module belongs to, baked in so a test mode can build its stand-in from
-  # the right schema. name: is the module the file
+  # graph_name: is the graph the module belongs to, baked in because it is
+  # the one thing a module can't be told at call time: it decides which
+  # client the module runs against (GraphWeaver::QueryModule) and which
+  # schema a test mode fabricates from. name: is the module the file
   # defines, defaulting to the operation's own name; default_name: is
   # parse's container-scoped fallback (file generation stays strict — a
   # checked-in file deserves a deliberate name). types_namespace: is the shared-types workflow (see
@@ -78,7 +73,7 @@ class GraphWeaver::Codegen
   # whole-union field spread as one of them resolves to a canonical type in the
   # shared module (see used_union_names). path: is the file the query was read
   # from, named alongside line and column in validation errors.
-  def initialize(schema:, query:, name: nil, client: nil, default_name: nil,
+  def initialize(schema:, query:, name: nil, default_name: nil,
     types_namespace: nil, hoistable_unions: nil, path: nil, module_name: nil,
     graph_name: nil, registry: GraphWeaver::Codegen.registry)
     renamed!(module_name)
@@ -96,28 +91,10 @@ class GraphWeaver::Codegen
     @used_unions = []
     # scalars this generation had no registration for (see report_untyped_scalars)
     @untyped_scalars = []
-    @client_const = CLIENT_CONST.call(client)
-    # the graph this module belongs to, baked in beside the client: a test
-    # mode builds its stand-in from the module's own schema, and only the
-    # module can say whose that is (GraphWeaver::Internal::TestClients).
-    # A Symbol, as GraphWeaver.graph makes it — the name is the identity.
+    # the graph this module belongs to: its client and, under a test mode,
+    # its stand-in are both read off it, and only the module can say whose
+    # it is. A Symbol, as GraphWeaver.graph makes it — the name is the identity.
     @graph_name = graph_name&.to_sym
-
-    if client && @client_const.nil?
-      # a live object can't be spelled in generated source — parse can
-      # set one via the module's writer, but file generation cannot
-      raise ArgumentError, "client: must be a named constant or String (got #{client.inspect}) — " \
-        "put the object in a constant and name it, client: \"MyApi::CLIENT\"; pass live objects to parse"
-    end
-    # The String is written into the module verbatim, so anything that isn't a
-    # constant path emits source that doesn't parse. A url is the way to get
-    # here — it is where the endpoint is spelled everywhere else — so the fix
-    # names the value that was passed.
-    if @client_const && !@client_const.match?(CONSTANT_NAME)
-      raise ArgumentError, "client: #{@client_const.inspect} isn't a constant — generated source " \
-        "spells this name, so it has to be one: CLIENT = GraphWeaver.new(#{@client_const.inspect}), " \
-        "then client \"CLIENT\""
-    end
   end
 
   # 0.5 spelled it module_name:, in two of the three doors. One knob, one
@@ -129,33 +106,19 @@ class GraphWeaver::Codegen
   end
   private :renamed!
 
-  # The constant name a client can be referenced by in generated
-  # source — nil when it can't be (live objects, anonymous modules).
-  # A lambda rather than a method: both `parse` and `initialize` need it,
-  # from the class and from an instance.
-  CLIENT_CONST = lambda do |client|
-    case client
-    when String then client
-    when Module then client.name
-    end
-  end
-  private_constant :CLIENT_CONST
-
   # one-step shorthand
-  def self.generate(schema:, query:, name: nil, client: nil, path: nil, module_name: nil)
-    new(schema:, query:, name:, client:, path:, module_name:).generate
+  def self.generate(schema:, query:, name: nil, path: nil, module_name: nil)
+    new(schema:, query:, name:, path:, module_name:).generate
   end
 
   # Development convenience: generate + eval in one step, no build
   # artifact or checked-in file. Same runtime semantics as the generated
   # file, but invisible to srb tc — use the build step for static typing.
-  # Evaluates into an anonymous container, so no global constants leak;
-  # client: additionally accepts a live object (set via .client=).
+  # Evaluates into an anonymous container, so no global constants leak.
+  # client: is the client the parsed module runs against — it has no graph to
+  # read one off — and a per-call `client:` still wins over it.
   def self.parse(schema:, query:, name: nil, client: nil, path: nil, module_name: nil, graph_name: nil)
-    client_const = CLIENT_CONST.call(client)
-
-    codegen = new(schema:, query:, name:, client: client_const, path:, module_name:, graph_name:,
-      default_name: "Query")
+    codegen = new(schema:, query:, name:, path:, module_name:, graph_name:, default_name: "Query")
     source = codegen.generate
 
     container = Module.new
@@ -167,9 +130,10 @@ class GraphWeaver::Codegen
     container.module_eval(source, "(graph_weaver)", 1)
     mod = container.const_get(codegen.name)
     GraphWeaver::Internal::Log.log(:debug) { "parsed #{codegen.name} (dynamic module, #{source.bytesize} bytes)" }
-    # live objects (or anonymous modules) can't be referenced from
-    # generated source — set them via the module's writer instead
-    mod.client = client if client && client_const.nil?
+    # a parsed module generates no file, so it has no graph to read a client
+    # off — client: binds one, whatever kind of object it is. The writer is
+    # private: parsing is the only thing that may bind one.
+    mod.send(:client=, client) if client
     mod
   end
 

data/lib/graph_weaver/graph.rb

@@ -65,7 +65,24 @@ module GraphWeaver
 
     def queries = @queries || GraphWeaver.queries_paths
     def output = @output || GraphWeaver.generated_paths.first
-    def client = @client
+
+    # The client this graph's modules call: the object `client` named, or the
+    # constant its name spells. nil when the graph names none — its modules
+    # go to GraphWeaver.client, like every other module.
+    #
+    # Resolved here, at call time, rather than spelled into generated source:
+    # renaming the constant is then an initializer edit and not a regeneration
+    # of every module, and a graph can name a live object.
+    def client
+      return @client unless @client.is_a?(String)
+
+      Object.const_get(@client)
+    rescue NameError
+      raise GraphWeaver::Error, "the client#{described} names #{@client.inspect} and nothing " \
+        "defines that constant, so its modules have no server to reach. Define it where the graph " \
+        "block can see it (config/initializers), or name the object itself: client " \
+        "GraphWeaver.new(\"https://api.example.com/graphql\")"
+    end
 
     # Every constant this graph generates lives under `namespace:` — the query
     # modules and the shared types module alike. Two schemas that each have a
@@ -95,7 +112,7 @@ module GraphWeaver
 
     # The dump this graph's schema was named by, when it was named by a file —
     # what a validation error's subgraph branding is read off. nil for a live
-    # class, a Client, or inline SDL.
+    # class, inline SDL, or a Client built from any of those.
     def dump_path
       path = named_dump_path
       path if path && File.exist?(path)
@@ -109,6 +126,9 @@ module GraphWeaver
       return GraphWeaver::SchemaLoader.locate_path unless @schema
 
       source = named_source
+      # a client built from a dump names that dump: the file is where a
+      # supergraph's routing table is, and the loaded schema is not
+      source = source.schema_source if source.respond_to?(:schema_source) && source.schema_source
       path = source.respond_to?(:to_path) ? source.to_path : source
       path if path.is_a?(String) && GraphWeaver::SchemaLoader.dump_path?(path)
     end
@@ -133,26 +153,16 @@ module GraphWeaver
       url || live_schema
     end
 
-    # The url this graph's modules post to, or nil. `client:` holds a constant
-    # or its name — codegen spells it into source — so a name is resolved here
-    # the way the generated DEFAULT_CLIENT lambda resolves it; a graph baking
-    # none posts to the app default, which is where its modules go too.
+    # The url this graph's modules post to, or nil — the graph's own client,
+    # else the app default, which is where its modules go too. What
+    # `schema:refresh` bootstraps a missing dump from, and what `rake
+    # graph_weaver:graphs` reports; a client with no url (a schema class
+    # running in-process) has none to report.
     def client_url
-      client = @client.is_a?(String) ? resolve_client! : @client
-      client ||= GraphWeaver.client
-      target = (client.transport if client.respond_to?(:transport)) || client
+      target = client || GraphWeaver.client
+      target = (target.transport if target.respond_to?(:transport)) || target
       target.url if target.respond_to?(:url)
     end
-    private :client_url
-
-    def resolve_client!
-      Object.const_get(@client)
-    rescue NameError
-      raise GraphWeaver::Error, "graph #{name.inspect} bakes client #{@client.inspect} into its " \
-        "modules and nothing defines that constant, so there is no endpoint to introspect " \
-        "#{named_dump_path} from"
-    end
-    private :resolve_client!
 
     # The composed supergraph this graph plans against, or nil — the dump it
     # names (for the default graph, the conventional one) when that dump
@@ -222,13 +232,12 @@ module GraphWeaver
       # The same three calls an app already writes at the top level, scoped here
       # to this graph alone.
       REGISTRATIONS = %i[register_scalar register_enum extend_type].freeze
-      # These three end up spelled in generated source, so each takes the
-      # constant or its name and stores the name.
-      CONSTANT_SETTINGS = %i[client namespace types_module].freeze
-      # …and these two are spelled as a `module` DEFINITION rather than a
-      # reference, which is why a root anchor is refused on them below.
+      # These two are spelled in generated source, as a `module` DEFINITION,
+      # so each takes the constant or its name and stores the name — and a
+      # root anchor is refused on them below. `client` isn't spelled anywhere:
+      # the graph resolves it at call time, so it takes the object.
       MODULE_SETTINGS = %i[namespace types_module].freeze
-      private_constant :CONSTANT_SETTINGS, :MODULE_SETTINGS
+      private_constant :MODULE_SETTINGS
 
       attr_reader :settings, :registrations
 
@@ -283,17 +292,18 @@ module GraphWeaver
       def respond_to_missing?(name, _private = false) = false
 
       # A Module where a constant's name goes says the same thing, and is what
-      # `client Billing::CLIENT` reads like. Anything else passes through:
-      # a schema is a path, SDL, a class, a Client, or a callable.
+      # `namespace Billing` reads like. Anything else passes through: a schema
+      # is a path, SDL, a class, a Client, or a callable, and a client is
+      # whatever object answers #execute.
       # On the singleton so the define_method setters above can reach it — srb
       # reads a define_method block's self as the class.
       def self.constant_name(setting, value)
-        return value unless CONSTANT_SETTINGS.include?(setting)
+        return value unless MODULE_SETTINGS.include?(setting)
 
         # Generated modules are defined at the top level, where a root anchor
         # says nothing — and `module ::A::B` is not a name const_get can spell,
         # so it used to surface as a verdict on the .graphql file's name.
-        if MODULE_SETTINGS.include?(setting) && value.is_a?(String) && value.start_with?("::")
+        if value.is_a?(String) && value.start_with?("::")
           raise ArgumentError, "#{setting} #{value.inspect}: drop the leading `::` — #{setting} " \
             "names a module generated source defines, and it defines it at the top level either way"
         end

data/lib/graph_weaver/internal/test_clients.rb

@@ -8,13 +8,12 @@ module GraphWeaver
     # a `graphql_*` helper writes to.
     #
     # A tag used to work by swapping GraphWeaver.client, which is the LAST
-    # place a module looks: one generated with `client:` reads its baked
-    # DEFAULT_CLIENT first and never got there, so the tag quietly didn't
-    # apply. The mode installs itself here instead, and QueryModule asks
-    # before it reads that constant — so a tag reaches every module the
-    # example runs, bound or not.
+    # place a module looks: one whose graph names a client of its own reads
+    # that first and never got there, so the tag quietly didn't apply. The
+    # mode installs itself here instead, and QueryModule asks before it reads
+    # the graph — so a tag reaches every module the example runs.
     #
-    # Keyed by the graph a module was generated from (its baked GRAPH), since
+    # Keyed by the graph a module was generated from (its GRAPH), since
     # the honest answer varies: :fake for a billing module has to fabricate
     # billing's shapes, not the other schema's. A helper names its graphs the
     # same way and lands in the same table, so what an example says applies to
@@ -254,11 +253,8 @@ module GraphWeaver
         # generated before its graph was declared, or by an older release —
         # and guessing would fake one schema's shapes at another's module.
         def graph_for!(mod)
-          graphs = GraphWeaver.graphs
-          return graphs.first if graphs.one?
-
           name = mod.const_defined?(:GRAPH, false) ? mod.const_get(:GRAPH) : nil
-          found = graphs.find { |graph| graph.name == name }
+          found = Util.graph_named(name)
           return found if found
 
           # Two doors produce a module, so the fix has two spellings: a file
@@ -268,7 +264,7 @@ module GraphWeaver
           raise GraphWeaver::Error, "#{mod} doesn't say which of this app's graphs " \
             "(#{declared_names}) it was generated from, so #{@mode.inspect} has nothing to run " \
             "it against — regenerate it (rake graph_weaver:generate), or, if it came from " \
-            "GraphWeaver.parse, say which there (graph: #{graphs.first.name.inspect})."
+            "GraphWeaver.parse, say which there (graph: #{GraphWeaver.graphs.first.name.inspect})."
         end
       end
     end

data/lib/graph_weaver/internal.rb

@@ -141,6 +141,21 @@ module GraphWeaver
           schema && GraphWeaver.graphs.find { |candidate| candidate.live_schema.equal?(schema) }
         end
 
+        # The declared graph `name` names, or nil — how a generated module
+        # finds the graph whose client it runs against, and whose schema a
+        # test mode fabricates from.
+        #
+        # One graph in an app is the answer whatever a module calls it: a
+        # module generated before its graph was named, or by an older release,
+        # still belongs to the only graph there is. With several, guessing
+        # would send one schema's query to another's endpoint.
+        def graph_named(name)
+          graphs = GraphWeaver.graphs
+          return graphs.first if graphs.one?
+
+          graphs.find { |graph| graph.name == name }
+        end
+
         # Where generated modules are READ from: the configured patterns, plus
         # any graph writing somewhere they don't already cover. generated_paths'
         # default glob (app/graphql/*/generated) covers the conventional layout,

data/lib/graph_weaver/query_module.rb

@@ -12,21 +12,21 @@ 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.
+  # GraphWeaver::QueryModule` supplies `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 =`)
-  # → a test mode's stand-in (Internal::TestClients) → the module's baked
-  # DEFAULT_CLIENT → `GraphWeaver.client`.
+  # 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
+  # module runs against whatever parsed it (GraphWeaver.parse(client:)),
+  # which is a property of parsing rather than a per-module override.
   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
+    # What this module would execute through, right now — the client a parse
+    # bound it to, else the order above. A diagnostic, and what `execute`
+    # reads when the call names none.
     sig { returns(T.untyped) }
     def client
       @client || default_client
@@ -34,6 +34,13 @@ module GraphWeaver
 
     private
 
+    # Bound by GraphWeaver.parse, which is the only caller: a parsed module
+    # generates no file, so it has no graph to read a client off. Private
+    # because a generated module's client comes from its graph — one way to
+    # say a thing.
+    sig { params(client: T.untyped).void }
+    attr_writer :client
+
     # The one call a generated `execute` makes: resolve the client, run this
     # module's own operation, hand the raw response back for from_response to
     # wrap. Here rather than emitted, so what has to BRACKET a request — the
@@ -55,9 +62,7 @@ module GraphWeaver
       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
-      graph = mod.const_defined?(:GRAPH, false) ? mod.const_get(:GRAPH) : nil
-
-      GraphWeaver::Internal::Log.with_graph(graph) do
+      GraphWeaver::Internal::Log.with_graph(graph_name) do
         client_for(client).execute(mod.const_get(:QUERY), variables:,
           operation_name: mod.const_get(:OPERATION_NAME))
       end
@@ -79,20 +84,28 @@ module GraphWeaver
         "#{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.
+    # A module knows which graph it belongs to, and the graph knows how to
+    # reach it: the client that graph names, else the app default. Read at
+    # call time, so renaming the constant a graph names is an initializer
+    # edit rather than a regeneration of every module.
     #
-    # A test mode stands in for it: what codegen baked in is exactly what a
-    # `graphql:` tag means to replace, so a bound module is covered by the
-    # tag like every other one.
+    # A test mode stands in ahead of it: the graph's client is exactly what a
+    # `graphql:` tag means to replace, so a tagged example reaches a module
+    # whose graph names a client like every other one.
     sig { returns(T.untyped) }
     def default_client
-      mod = T.unsafe(self)
-      stand_in = GraphWeaver::Internal::TestClients.for(mod)
+      stand_in = GraphWeaver::Internal::TestClients.for(T.unsafe(self))
       return stand_in if stand_in
 
-      mod.const_defined?(:DEFAULT_CLIENT, false) ? mod.const_get(:DEFAULT_CLIENT).call : GraphWeaver.client!
+      GraphWeaver::Internal::Util.graph_named(graph_name)&.client || GraphWeaver.client!
+    end
+
+    # The graph codegen baked in, by name — nil for a module generated before
+    # graphs existed, or by a GraphWeaver.parse that named none.
+    sig { returns(T.untyped) }
+    def graph_name
+      mod = T.unsafe(self)
+      mod.const_defined?(:GRAPH, false) ? mod.const_get(:GRAPH) : nil
     end
   end
 end

data/lib/graph_weaver/rspec.rb

@@ -255,13 +255,12 @@ module GraphWeaver
       def self.unserve!(stub) = WebMock::StubRegistry.instance.request_stubs.delete(stub)
 
       # Every endpoint an example's modules can post to, each with the graph
-      # whose resolvers belong behind it: the client each graph bakes into its
-      # modules, or GraphWeaver.client for a graph baking none. One graph per
-      # endpoint — an app whose graphs all bake clients needs no app default
-      # at all.
+      # whose resolvers belong behind it: the client each graph names, or
+      # GraphWeaver.client for a graph naming none. One graph per endpoint —
+      # an app whose graphs all name clients needs no app default at all.
       def self.wire_targets
         targets = GraphWeaver.graphs.filter_map do |graph|
-          client = baked_client(graph) || GraphWeaver.client
+          client = graph.client || GraphWeaver.client
           [endpoint!(client, graph), graph] if client
         end
         refuse_shared_endpoint!(targets)
@@ -283,24 +282,10 @@ module GraphWeaver
         raise GraphWeaver::Error, "#{TAG}: :wire serves one schema at each endpoint, and graphs " \
           "#{names} post to the same one (#{url}) — whichever were served there would answer the " \
           "others' queries, as fields its schema doesn't define. Give each graph a client of its " \
-          "own (client: in the graph block), or tag the example #{TAG}: :in_process or " \
+          "own (`client` in the graph block), or tag the example #{TAG}: :in_process or " \
           "#{TAG}: :router, which run above the wire."
       end
 
-      # The client a graph's generated modules call. `client:` holds a
-      # constant or its name — codegen writes it into source — so a name is
-      # resolved here the way the generated DEFAULT_CLIENT lambda resolves it.
-      def self.baked_client(graph)
-        named = graph.client
-        return named unless named.is_a?(String)
-
-        Object.const_get(named)
-      rescue NameError
-        raise GraphWeaver::Error, "#{TAG}: graph #{graph.name.inspect} bakes client: " \
-          "#{named.inspect} into its modules and nothing defines that constant, so :wire can't " \
-          "find the endpoint they post to."
-      end
-
       # The endpoint a client posts to: a transport, a Retry around one, or a
       # Client that built one. `graph` says whose client it is, when it isn't
       # the app's own.
@@ -316,12 +301,16 @@ module GraphWeaver
           "#{TAG}: :in_process or #{TAG}: :router — they run above the wire."
       end
 
-      # which client posts to nothing — the app's, or one graph's
+      # which client posts to nothing — the app's, or one graph's. A schema
+      # class in a client slot is named by ITS name: `client.class` is the
+      # word "Class", which names nothing anyone wrote.
       def self.whose_client(client, graph)
         return "GraphWeaver.client isn't set" unless client
-        return "GraphWeaver.client is #{client.class}, which posts to none" unless graph&.name
 
-        "graph #{graph.name.inspect} bakes client: #{client.class}, which posts to none"
+        named = client.is_a?(Module) ? client : client.class
+        return "GraphWeaver.client is #{named}, which posts to none" unless graph&.name
+
+        "graph #{graph.name.inspect} names client #{named}, which posts to none"
       end
 
       def self.webmock!
@@ -353,7 +342,7 @@ module GraphWeaver
         !WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP.equal?(Net::HTTP)
       end
 
-      private_class_method :wire_targets, :refuse_shared_endpoint!, :baked_client, :whose_client,
+      private_class_method :wire_targets, :refuse_shared_endpoint!, :whose_client,
         :webmock!, :webmock_enabled?, :disclose!, :served, :unnamed_schemas, :loaded_schemas
 
       # Included into every example group, so graphql_context is there

data/lib/graph_weaver/tasks.rb

@@ -273,9 +273,17 @@ namespace :graph_weaver do
       puts "#{name}  #{Array(graph.queries).join(", ")} -> #{GraphWeaver::Internal::Util.relative(graph.output)}"
       puts "  namespace: #{graph.namespace}" if graph.namespace
       # which server a graph's modules call — the one thing this task couldn't
-      # say. A graph that bakes none falls back to GraphWeaver.client, which is
+      # say. A graph that names none falls back to GraphWeaver.client, which is
       # an app-wide setting and not this task's subject.
-      puts "  client: #{graph.client}" if graph.client
+      #
+      # Reported rather than raised: this is the task you run to find out why a
+      # graph is wrong, so a client whose constant is missing is the answer,
+      # not a reason to stop listing the others.
+      begin
+        puts "  client: #{graph.client_url || graph.client}" if graph.client
+      rescue GraphWeaver::Error => e
+        puts "  client: #{e.message}"
+      end
       # a registration is scoped to one graph, and nothing else says which
       GraphWeaver::Internal::Tasks.registrations(graph).each { |line| puts line }
     end

data/lib/graph_weaver/testing.rb

@@ -221,9 +221,10 @@ module GraphWeaver
       # warn line as it is constructed, and a predicate that raised to say
       # "no" put a refusal that never happened in the log of every :wire
       # example. The one that graph names, else config.router[:supergraph],
-      # else the conventional dump when that's what it is. A client can't
-      # supply one — its schema is the API schema a router serves, with the
-      # @join__* routing table stripped out.
+      # else the conventional dump when that's what it is, else the dump the
+      # app's own client was built from. A client's *schema* can't supply one
+      # — it is the API schema a router serves, with the @join__* routing
+      # table stripped out — but the file behind it carries the table.
       private def supergraph_for(graph)
         # named_schema?, so a graph that declared no schema of its own falls
         # through to config.router rather than past it to the conventional dump
@@ -232,7 +233,14 @@ module GraphWeaver
         return @router[:supergraph] if @router&.key?(:supergraph)
 
         path = GraphWeaver::SchemaLoader.locate_path
-        path if path && GraphWeaver::Internal::Util.composed?(path)
+        return path if path && GraphWeaver::Internal::Util.composed?(path)
+
+        # Last, because codegen for the default graph reads the conventional
+        # dump, and the router must plan against what the modules were typed
+        # against.
+        client = GraphWeaver.client
+        source = client.schema_source if client.respond_to?(:schema_source)
+        source if source && GraphWeaver::Internal::Util.composed?(source)
       end
 
       # what to do about it, which differs by who asked: a graph in no

data/lib/graph_weaver/version.rb

@@ -1,3 +1,3 @@
 module GraphWeaver
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 end

data/lib/graph_weaver.rb

@@ -65,8 +65,8 @@ module GraphWeaver
     #
     # Anything satisfying the execute contract — a Client, a schema class,
     # a transport, a fake (testing's graphql: tag swaps one in per
-    # example). Generated modules resolve per call -> per module
-    # (MyQuery.client=) -> baked constant -> here.
+    # example). Generated modules resolve per call -> a test mode's stand-in
+    # -> the client their graph names -> here.
     attr_accessor :client
 
     # the default client, when one is required
@@ -389,7 +389,7 @@ module GraphWeaver
     # (see #changed_files). Generated files the plan no longer produces are deleted
     # (see #orphaned), so renaming or dropping a .graphql leaves nothing
     # behind. Pair with a freshness spec (docs/generated_modules.md).
-    def generate!(schema: nil, queries: nil, output: nil, client: nil, types_module: nil)
+    def generate!(schema: nil, queries: nil, output: nil, types_module: nil)
       @changed_files = []
       @unmatched_registrations = []
       @untyped_scalars_by_graph = {}
@@ -399,7 +399,7 @@ module GraphWeaver
       # tree exactly as it was — the railtie's watch mode regenerates on a
       # request and promises a failed save changes nothing, and that promise
       # was true within a graph and false across them.
-      planned = graphs_for(schema:, queries:, output:, client:, types_module:).map do |graph|
+      planned = graphs_for(schema:, queries:, output:, types_module:).map do |graph|
         if Internal::Util.query_files(graph.queries).empty?
           # a brand-new app legitimately has none; a mistyped queries_paths looks
           # exactly the same, and prints nothing either way
@@ -488,11 +488,11 @@ module GraphWeaver
     #      it "generated queries are current" do
     #        GraphWeaver.verify_generated!
     #      end
-    def verify_generated!(schema: nil, queries: nil, output: nil, client: nil, types_module: nil)
+    def verify_generated!(schema: nil, queries: nil, output: nil, types_module: nil)
       @unmatched_registrations = []
       @untyped_scalars_by_graph = {}
       seen = new_seen
-      graphs = graphs_for(schema:, queries:, output:, client:, types_module:)
+      graphs = graphs_for(schema:, queries:, output:, types_module:)
 
       # The dump is checked in too, and everything below reads it — so a
       # stale one is answered before staleness downstream of it, because
@@ -860,7 +860,6 @@ module GraphWeaver
           schema:,
           query: Codegen.inline_fragments(source, shared, path),
           name:,
-          client: graph.client,
           graph_name: graph.name,
           types_namespace: graph.types_module,
           hoistable_unions: Codegen.shared_fragment_spreads(source, shared, path),
@@ -1082,8 +1081,10 @@ module GraphWeaver
     # name derived from the file name and the operation — see #module_name) or
     # a raw query string (name derived from the operation name, falling back to
     # "Query" for anonymous operations — collisions are impossible since each
-    # parse gets its own container). Pass name: to override, client: to bake
-    # the module's default client/transport.
+    # parse gets its own container). Pass name: to override, client: to say
+    # what the module runs against — a parsed module generates no file, so it
+    # has no graph to read one off, and this is the only time one is bound
+    # (a per-call `client:` still wins).
     #
     # graph: names the graph this module belongs to, which is what a test mode
     # runs it against in an app with more than one — the same thing generation

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graph_weaver
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Daniel Pepper
@@ -363,7 +363,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/dpep/graph_weaver/issues
-  changelog_uri: https://github.com/dpep/graph_weaver/blob/v0.7.1/CHANGELOG.md
+  changelog_uri: https://github.com/dpep/graph_weaver/blob/v0.7.2/CHANGELOG.md
   documentation_uri: https://github.com/dpep/graph_weaver/tree/main/docs
   rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/dpep/graph_weaver