graph_weaver 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cb0372c9f8505bec490fbb13344cbd586da68cb4932cbce0f86de2467d0eaf4
-  data.tar.gz: 6bc17449eea717c8cb145c159a2395f61f484a2f585c016ee31521f979f1a6d6
+  metadata.gz: 653ecbcc2215bf5358e34bc83d701ded874a6ee1910ceeca18f0ed205a44798f
+  data.tar.gz: 2d1e49f247e84347c7bd86123b54b1b9d31d8978bc2a6a8f8d9538342c3ab67d
 SHA512:
-  metadata.gz: 63670eee3838644725166822028b4816164450c853e24d74dd6ce47212e4e18c2bda7309d5549f8830e709d547e73678425ae9984d960a5367b97f5102613f5c
-  data.tar.gz: d7b30350095090f9c69e7b5316137ac5324b60965a242ffe5c9be4a893812a48351a172bde26f36000797d830eb01c3e15ea0352eea8ecda9ac775f55b12ac82
+  metadata.gz: 220c5d9ab87c671a602b226b2789fee65307e3b8a85407fa5c979eb272cde0e27d551e0a6d5ef32ad2714a6eec211fcf0657d1a2b7eb7a53c33d063756d8e82c
+  data.tar.gz: 650c62d1ca107aaaccfa03ddd4686475c15ad68c0cf421be67379a7b88212af8366681da61208dee39ee2a68a468ca792f8cc9fee54c8982087924f927c2a2d1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graph_weaver (0.7.2)
+    graph_weaver (0.7.3)
       graphql (>= 2.6.7)
       sorbet-runtime
 
@@ -195,16 +195,16 @@ GEM
     rubydex (0.2.7-x86_64-darwin)
     rubydex (0.2.7-x86_64-linux)
     securerandom (0.4.1)
-    simplecov (1.2.0)
-    sorbet (0.6.13485)
-      sorbet-static (= 0.6.13485)
-    sorbet-runtime (0.6.13485)
-    sorbet-static (0.6.13485-aarch64-linux)
-    sorbet-static (0.6.13485-universal-darwin)
-    sorbet-static (0.6.13485-x86_64-linux)
-    sorbet-static-and-runtime (0.6.13485)
-      sorbet (= 0.6.13485)
-      sorbet-runtime (= 0.6.13485)
+    simplecov (1.3.0)
+    sorbet (0.6.13498)
+      sorbet-static (= 0.6.13498)
+    sorbet-runtime (0.6.13498)
+    sorbet-static (0.6.13498-aarch64-linux)
+    sorbet-static (0.6.13498-universal-darwin)
+    sorbet-static (0.6.13498-x86_64-linux)
+    sorbet-static-and-runtime (0.6.13498)
+      sorbet (= 0.6.13498)
+      sorbet-runtime (= 0.6.13498)
     spoom (1.8.3)
       erubi (>= 1.10.0)
       prism (>= 0.28.0)
@@ -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.2)
+  graph_weaver (0.7.3)
   graphql (2.6.10) sha256=9b7c8633767f516ff9d48a8d6305b2a00a2101c82aa871b92e69086944f9f83e
   hashdiff (1.2.1) sha256=9c079dbc513dfc8833ab59c0c2d8f230fa28499cc5efb4b8dd276cf931457cd1
   i18n (1.15.2) sha256=00f9eb62412fe593b2a65a97daa75300d37abb8f7202ec748e94b6d46a9dd1b5
@@ -350,13 +350,13 @@ CHECKSUMS
   rubydex (0.2.7-x86_64-darwin) sha256=b002b259d118ac69de44470eff1597143318402c45630c47371f9542631447dc
   rubydex (0.2.7-x86_64-linux) sha256=dacfade9fa42ce4469618da6dac07e69d5f3ac6a313b4caced5234c8f052419a
   securerandom (0.4.1) sha256=cc5193d414a4341b6e225f0cb4446aceca8e50d5e1888743fac16987638ea0b1
-  simplecov (1.2.0) sha256=ea6acd05eece5a41990e2a5171c57d15700d329326c7666c85ee8c6a0dd0977e
-  sorbet (0.6.13485) sha256=b885d6a2fcde57bc46c3cdd597b9014b82619dee0f811a6fdf36f57c8f82c380
-  sorbet-runtime (0.6.13485) sha256=2982504e662eb424e515b3aa1c8139070451a014b6c1af2302250ed82495b4cc
-  sorbet-static (0.6.13485-aarch64-linux) sha256=5d802793633363442f189615fdb6c6d1be726b402d78a3d63eab96ca74b98d40
-  sorbet-static (0.6.13485-universal-darwin) sha256=6c7c4551872d556b37bf1f1a3495509b9fd9479b4a080bd57f9c5db0e8116658
-  sorbet-static (0.6.13485-x86_64-linux) sha256=e22d88df0bba5a97e664a329a2212ea59e6a2020626597a162c60c5ddfb4f9b4
-  sorbet-static-and-runtime (0.6.13485) sha256=b893346f9e1a244133071ad3c3d06b8ddf70c1b8246bb594c9aaa5cfc778df5f
+  simplecov (1.3.0) sha256=d9886307863c1ead47657dcbed869bfffd82318808b09014d8f0ff77dcfe7492
+  sorbet (0.6.13498) sha256=cb5279f6a9dbfc8d526bc9fb71d05020afb8043c40708e4aff2244ba329ce224
+  sorbet-runtime (0.6.13498) sha256=2da4627f9341a1fc6e4148cc891989b7b108106c206c46ca69940e10a21e9133
+  sorbet-static (0.6.13498-aarch64-linux) sha256=cbee732c49379d38029f295b45edaeb5757ab180d308d8383dc79f03fd4991be
+  sorbet-static (0.6.13498-universal-darwin) sha256=4cc97aa0da3dd175b8278e1617954d6dd9ba1f5aeb62981f21616b9ec791fb75
+  sorbet-static (0.6.13498-x86_64-linux) sha256=75d02e8af7d6c1081d4693e2ebefe679760327f1304377519970784faf9f913d
+  sorbet-static-and-runtime (0.6.13498) sha256=5f5686869dceae893b4171b05e3db159fe12f1aadf04aa8c2bf9dfa3edc0d902
   spoom (1.8.3) sha256=32871fa189bbfa49cf557a50f819f23cc9a6ceefd0346caa7a6adc193becd5dd
   tapioca (0.19.2) sha256=938731b07811aee8d23871b1aee8861d464fbaf2cfffbf79a62b0c869a5120ec
   thor (1.5.0) sha256=e3a9e55fe857e44859ce104a84675ab6e8cd59c650a49106a05f55f136425e73

data/docs/generated_modules.md

@@ -678,8 +678,9 @@ spot a *schema* change for you — `schema:diff`, `schema:refresh`, `queries:che
 ### Loading what it wrote
 
 In Rails, loading is automatic — the Railtie requires every generated file at
-boot from a `to_prepare` block, after your initializers and after any
-registrations of your own in one. Elsewhere it's explicit, factory_bot-style:
+the end of boot, after your initializers and after any registrations of your own
+in a `to_prepare` block, and again after each development reload. Elsewhere it's
+explicit, factory_bot-style:
 `GraphWeaver.load_generated!` requires every file under `generated_paths`.
 
 **Outside Rails, four things have to agree**, and nothing wires them together for

data/docs/getting_started.md

@@ -99,8 +99,9 @@ What it wrote:
 
 Rake needs no wiring: in Rails the `graph_weaver:*` tasks register themselves and
 depend on `:environment`, so your initializer runs first. The generated modules
-load at boot from a `to_prepare` block, so a helper or enum you registered is
-already in place when the file that names it loads.
+load at the end of boot, after your initializers and after any `to_prepare`
+block of yours, so a helper or enum you registered is already in place when the
+file that names it loads.
 
 All of that describes **one** schema, which is the usual case; an app with a
 second one declares each as a graph ([more than one

data/examples/github/generated/star_mutation.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-# Generated by GraphWeaver 0.7.2 — do not edit.
+# Generated by GraphWeaver 0.7.3 — do not edit.
 
 module StarMutation
   extend T::Sig

data/examples/github/generated/stargazers_query.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-# Generated by GraphWeaver 0.7.2 — do not edit.
+# Generated by GraphWeaver 0.7.3 — do not edit.
 
 require "time"
 

data/examples/github/generated/starred_query.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-# Generated by GraphWeaver 0.7.2 — do not edit.
+# Generated by GraphWeaver 0.7.3 — do not edit.
 
 module StarredQuery
   extend T::Sig

data/lib/graph_weaver/railtie.rb

@@ -7,16 +7,25 @@
 #   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 once every registration has run —
-#   both the initializer kind and the to_prepare kind, since a generated
-#   file `include`s the type helper it was generated with and that
-#   constant must resolve. load_generated! stays idempotent, so calling
-#   it yourself too is harmless.
+# - generated modules: required once every registration has run — both the
+#   initializer kind and the to_prepare kind, since a generated file
+#   `include`s the type helper it was generated with and that constant must
+#   resolve. 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.
 # - watch mode: in development, editing a .graphql regenerates before the
 #   next request, the way editing a route or a locale takes effect.
+#
+# All of that is hung off Rails' lifecycle HOOKS — before_initialize,
+# after_initialize, the reloader — rather than off initializers with
+# `after:`/`before:` edges naming other railties' initializers. Rails
+# topologically sorts every railtie's initializers together, so such an edge
+# constrains the whole app's boot order and tsort is free to satisfy it by
+# moving initializers that aren't ours: a real app failed to boot with
+# graph_weaver in the Gemfile and every one of these bodies neutered. A hook
+# has a fixed place in boot and adds no edge. See DECISIONS.md.
 class GraphWeaver::Railtie < Rails::Railtie
   # config.graph_weaver.watch — false to never regenerate during a request.
   # Default: development only. Every other setting is a top-level one, and an
@@ -62,94 +71,87 @@ class GraphWeaver::Railtie < Rails::Railtie
   config.graph_weaver = Options.new
 
   class << self
-    # The file watcher, so the to_prepare block below can ask it whether a
-    # query changed. nil when not watching.
+    # The file watcher, so the prepare hook below can ask it whether a query
+    # changed. nil when not watching.
     attr_accessor :watcher
 
-    # What ignore_generated actually hid, resolved. Zeitwerk only reads its
+    # What has been hidden from Zeitwerk, resolved. Zeitwerk only reads its
     # ignore list at setup, so anything that arrives later isn't hidden by
     # calling ignore again — check_generated_ignored! refuses instead.
     attr_accessor :ignored_dirs
+
+    # Whether hiding an output right now would actually hide it: false until
+    # the initializer below has swept (it picks up anything declared so far),
+    # and false again from the moment Zeitwerk sets the main autoloader up.
+    attr_accessor :hiding_outputs
   end
 
   rake_tasks do
     require "graph_weaver/tasks"
   end
 
-  # The two auto-wires an app gets for free, and the only two it can turn off
-  # by assigning nil. They are declared FIRST, and `before:
-  # :load_config_initializers`, and both of those are load-bearing:
+  # ONE initializer, and it declares no `after:` — see the note on the class.
+  # The `before:` that is left is inert: it only says "not after Zeitwerk's
+  # setup", and this is emitted at its own place in the railties block anyway,
+  # so nothing moves. It records the deadline.
   #
-  # Rails gives an initializer an implicit `after:` of the previous one in the
-  # same railtie (Initializable#initializer: `opts[:after] ||=
-  # initializers.last&.name`). Declared after ignore_generated, which is
-  # `after: :load_config_initializers`, these two inherited that position —
-  # they ran AFTER config/initializers, so the `if nil?` fallback overwrote an
-  # app that had just said nil and the documented PII opt-out did nothing,
-  # silently, while queries and variables kept reaching a debug Rails.logger.
-  # Adding the `before:` without moving them is a TSort::Cyclic at boot, since
-  # the implicit `after:` would then point through ignore_generated.
-  #
-  # Rails.logger, unless the app already chose one (set
-  # GraphWeaver.logger = nil in an initializer to silence)
-  initializer "graph_weaver.logger", before: :load_config_initializers do
-    GraphWeaver.logger = Rails.logger if GraphWeaver.logger.nil?
+  # What it sweeps is what config/application.rb configured. A graph declared
+  # in config/initializers is later than this and hides its own output as it is
+  # declared (ignore_output!) — which is where that knowledge arrives, and so
+  # needs no edge to wait for.
+  initializer "graph_weaver.ignore_generated", before: :setup_main_autoloader do
+    GraphWeaver::Railtie.hide_generated!
   end
 
-  # An APM sees every GraphQL call without the app configuring anything:
-  # the ActiveSupport::Notifications adapter from docs/logging.md, plus the
-  # LogSubscriber that turns its event into one line. Measured at ~4.5µs per
-  # execution all told (0.13µs of that ActiveSupport::Notifications itself
-  # with nothing subscribed; the rest is its Event machinery) — 0.05% of a
-  # 10ms round trip, so there is nothing to weigh.
-  #
-  # An instrumenter the app set is never replaced: assigned before this (in
-  # config/application.rb) the nil check leaves it, and config/initializers now
-  # genuinely runs later, so one assigned there wins on its own — including
-  # `GraphWeaver.instrumenter = nil` to opt out.
-  initializer "graph_weaver.instrumentation", before: :load_config_initializers do
-    next unless defined?(ActiveSupport::Notifications)
-
-    if GraphWeaver.instrumenter.nil?
-      GraphWeaver.instrumenter = lambda do |event, payload, &block|
-        ActiveSupport::Notifications.instrument(event, payload, &block)
-      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. prepare_generated! requires them instead.
+  def self.hide_generated!
+    self.ignored_dirs = []
+    self.hiding_outputs = true
+    GraphWeaver::Internal::Util.generated_dirs.each { |path| ignore_output!(path) }
+
+    # Zeitwerk reads its ignore list once, at setup, and nothing in Rails
+    # announces that moment — Zeitwerk itself does. With no such signal, shut
+    # the window here: an ignore registered after setup hides nothing, and
+    # check_generated_ignored! has to be the one to say so.
+    main = Rails.autoloaders.main if Rails.autoloaders.respond_to?(:main)
+    if main.respond_to?(:on_setup)
+      main.on_setup { GraphWeaver::Railtie.hiding_outputs = false }
+    else
+      self.hiding_outputs = false
     end
-
-    # ActiveSupport::LogSubscriber is one of ActiveSupport's own eager
-    # autoloads, so naming it is enough — no require of theirs needed
-    require "graph_weaver/log_subscriber"
-    # idempotent — Subscriber.add_event_subscriber skips a pattern it already has
-    GraphWeaver::LogSubscriber.attach_to :graph_weaver
   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.
+  # Hide one output from Zeitwerk, the moment it is named — a graph declared in
+  # config/initializers says where it writes long after the sweep above ran.
+  # Waiting for it instead is what `after: :load_config_initializers` used to
+  # buy, at the cost of the whole app's boot order.
   #
-  # after: :load_config_initializers as well as before Zeitwerk's setup — a
-  # graph's output: is only known once the app has declared its graphs, and
-  # with only the `before:` constraint this ran ~20 initializers too early, so
-  # an output outside the conventional glob was eager loaded on top of
-  # load_generated! and died on a redefined enum.
-  initializer "graph_weaver.ignore_generated",
-    after: :load_config_initializers, before: :setup_main_autoloader do
-    # patterns, not paths — generated_paths may be globs, and Zeitwerk
-    # expands its own at setup (which is what this runs before)
-    dirs = GraphWeaver::Internal::Util.generated_dirs.map { GraphWeaver::Railtie.autoload_path(_1) }
-    GraphWeaver::Railtie.check_autoload_once!(dirs)
-    GraphWeaver::Railtie.ignored_dirs = dirs
-    Rails.autoloaders.each { |loader| dirs.each { |path| loader.ignore(path) } }
+  # Outside the window this is a no-op on purpose: before it, the sweep will
+  # pick the path up; after it, calling Zeitwerk's `ignore` would only teach
+  # check_generated_ignored! a lie.
+  def self.ignore_output!(path)
+    return unless hiding_outputs
+
+    # patterns, not paths — generated_paths may be globs, and Zeitwerk expands
+    # its own at setup, which is what the window stays open until
+    dir = autoload_path(path)
+    return if ignored_dirs.include?(dir)
+
+    check_autoload_once!([dir])
+    ignored_dirs << dir
+    Rails.autoloaders.each { |loader| loader.ignore(dir) }
   end
 
-  # The `once` autoloader is set up in bootstrap, and Zeitwerk reads its ignore
-  # list only at setup — so the `loader.ignore` above, which runs after
-  # config/initializers, hides nothing from it however the output is spelled.
-  # The generic advice ("name it in GraphWeaver.generated_paths from
-  # config/initializers") produced byte-identical output for this one, so it
-  # gets its own refusal, naming the place that is still early enough.
+  # The `once` autoloader is set up in bootstrap, before any of this — and
+  # Zeitwerk reads its ignore list only at setup, so `loader.ignore` hides
+  # nothing from it however the output is spelled. The generic advice ("name it
+  # in GraphWeaver.generated_paths from config/initializers") produced
+  # byte-identical output for this one, so it gets its own refusal, naming the
+  # place that is still early enough.
   def self.check_autoload_once!(dirs)
     return unless Rails.respond_to?(:autoloaders) && Rails.autoloaders.respond_to?(:once)
 
@@ -232,13 +234,64 @@ class GraphWeaver::Railtie < Rails::Railtie
     end
   end
 
+  # The two auto-wires an app gets for free, and the only two it can turn off
+  # by assigning nil.
+  #
+  # before_initialize runs in Rails' own :bootstrap_hook — after
+  # :initialize_logger and before the first railtie initializer, so the default
+  # is in place for anything that boots, and config/initializers still runs
+  # later and still wins. That timing used to be a `before:
+  # :load_config_initializers` edge, and getting it wrong shipped: declared
+  # without one, these ran AFTER config/initializers, so the `if nil?` fallback
+  # overwrote an app that had just said nil — the documented PII opt-out did
+  # nothing, silently, while queries and variables kept reaching a debug
+  # Rails.logger.
+  config.before_initialize { GraphWeaver::Railtie.default_logger! }
+
+  # Rails.logger, unless the app already chose one (set GraphWeaver.logger =
+  # nil in an initializer to silence)
+  def self.default_logger!
+    GraphWeaver.logger = Rails.logger if GraphWeaver.logger.nil?
+  end
+
+  # An APM sees every GraphQL call without the app configuring anything:
+  # the ActiveSupport::Notifications adapter from docs/logging.md, plus the
+  # LogSubscriber that turns its event into one line. Measured at ~4.5µs per
+  # execution all told (0.13µs of that ActiveSupport::Notifications itself
+  # with nothing subscribed; the rest is its Event machinery) — 0.05% of a
+  # 10ms round trip, so there is nothing to weigh.
+  #
+  # An instrumenter the app set is never replaced: assigned before this (in
+  # config/application.rb) the nil check leaves it, and config/initializers runs
+  # later, so one assigned there wins on its own — including
+  # `GraphWeaver.instrumenter = nil` to opt out.
+  config.before_initialize { GraphWeaver::Railtie.default_instrumenter! }
+
+  def self.default_instrumenter!
+    return unless defined?(ActiveSupport::Notifications)
+
+    if GraphWeaver.instrumenter.nil?
+      GraphWeaver.instrumenter = lambda do |event, payload, &block|
+        ActiveSupport::Notifications.instrument(event, payload, &block)
+      end
+    end
+
+    # ActiveSupport::LogSubscriber is one of ActiveSupport's own eager
+    # autoloads, so naming it is enough — no require of theirs needed
+    require "graph_weaver/log_subscriber"
+    # idempotent — Subscriber.add_event_subscriber skips a pattern it already has
+    GraphWeaver::LogSubscriber.attach_to :graph_weaver
+  end
+
   # The app already declared what is sensitive, so variables logged at debug
   # honour the same list as its request logs — including the Procs and dotted
-  # paths only ParameterFilter understands. after: :load_config_initializers,
-  # since filter_parameter_logging.rb is where an app adds to it.
-  initializer "graph_weaver.filter_parameters", after: :load_config_initializers do |app|
+  # paths only ParameterFilter understands. after_initialize, since
+  # filter_parameter_logging.rb is where an app adds to it.
+  config.after_initialize { |app| GraphWeaver::Railtie.adopt_filter_parameters!(app) }
+
+  def self.adopt_filter_parameters!(app)
     filters = app.config.filter_parameters
-    next if filters.empty? || GraphWeaver.filter_parameters != GraphWeaver::DEFAULT_FILTER_PARAMETERS
+    return if filters.empty? || GraphWeaver.filter_parameters != GraphWeaver::DEFAULT_FILTER_PARAMETERS
 
     GraphWeaver.filter_parameters = ActiveSupport::ParameterFilter.new(filters)
   end
@@ -246,41 +299,31 @@ class GraphWeaver::Railtie < Rails::Railtie
   # Watch mode. A .graphql edit should reach the next request the way a route
   # or a locale change does, so the query directories and the schema dump
   # become one of Rails' own reloaders: a change there alone triggers a reload
-  # cycle, and the to_prepare below regenerates before it loads. Off with
+  # cycle, and the prepare hook below regenerates before it loads. Off with
   #
   #      config.graph_weaver.watch = false
   #
-  # after: :load_config_initializers — that's where an app moves
-  # queries_paths, and the finisher that reads app.reloaders runs later still.
-  #
-  # to_prepare, not the initializer itself: a graph declared from one of those
-  # (what the docs say to do when its block names an autoloaded constant) isn't
-  # declared until every initializer has run, and a watcher built before it
-  # watched the default queries_paths — an edit to that graph's .graphql
-  # silently never regenerated. to_prepare blocks run in registration order and
-  # an app registers its own during :load_config_initializers, which this is
-  # `after:`, so every graph is in by the time this runs; app.reloaders is read
-  # per request, so joining it this late still counts. Once, though: a dev
-  # reload re-runs to_prepare, and a second watcher is a second reloader over
-  # the same files.
-  initializer "graph_weaver.watch", after: :load_config_initializers do |app|
-    watched = false
-    app.config.to_prepare do
-      next if watched
-
-      watched = true
-      GraphWeaver::Railtie.watch!(app)
-    end
-  end
+  # after_initialize, because every graph has to be declared before the watcher
+  # is built: a graph declared from a to_prepare block (what the docs say to do
+  # when its block names an autoloaded constant) isn't declared until the
+  # prepare callbacks have run, and a watcher built before it watched the
+  # default queries_paths — an edit to that graph's .graphql silently never
+  # regenerated. app.reloaders is read per request, so joining it this late
+  # still counts.
+  config.after_initialize { |app| GraphWeaver::Railtie.watch!(app) }
 
   # Registers the watcher, and says so: this is the one thing GraphWeaver does
   # that writes a checked-in file outside a rake task. Returns it, or nil when
   # nothing is being watched.
   def self.watch!(app)
+    # exactly one watcher per app, however many times this is called — a second
+    # one is a second reloader polling the same files
+    app.reloaders.delete(watcher) if watcher
+
     watch = app.config.graph_weaver.watch
     watch = Rails.env.development? if watch.nil?
-    # with reloading off nothing re-runs to_prepare, so a watcher could only
-    # promise something it can't do
+    # with reloading off nothing re-runs the prepare hook, so a watcher could
+    # only promise something it can't do
     return self.watcher = nil unless watch && app.config.reloading_enabled?
 
     # a directory that doesn't exist yet is still watched — FileUpdateChecker
@@ -321,51 +364,63 @@ class GraphWeaver::Railtie < Rails::Railtie
   end
 
   # A generated file `include`s the type helper it was generated with, so it
-  # can't load until that constant resolves — and both Zeitwerk's setup and
-  # the app's own to_prepare blocks (where extend_type/register_enum are told
-  # to register, Codegen::AUTOLOAD_HINT) happen after config/initializers.
-  # to_prepare, not `after:` a finisher initializer: naming one there makes
-  # tsort hoist it ahead of the app's own config/initializers. Re-running on
-  # each dev reload is free — require is idempotent — and picks up a module
-  # generated since boot.
-  initializer "graph_weaver.load_generated", after: :load_config_initializers do |app|
-    app.config.to_prepare 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
-
-      # the app's own to_prepare blocks have run by now, so this is the first
-      # point that sees every graph — and the last before one of them loads
-      GraphWeaver::Railtie.check_generated_ignored!
-
-      # Regenerate first, then load — and here rather than in the watcher's own
-      # to_run, so an extend_type or register_enum the app registers in its own
-      # to_prepare is already in place (that block was registered at
-      # :load_config_initializers, so it has run by now). A run that
-      # regenerated has already reloaded what it wrote.
-      next if GraphWeaver::Railtie.watcher&.execute_if_updated
-
-      # entries may be globs, so Dir[] rather than Dir.exist?
-      generated = GraphWeaver::Internal::Util.generated_dirs.any? do |dir|
-        Dir[GraphWeaver::Internal::Util.resolve(dir)].any?
-      end
-      next unless generated
-
-      # `require` no-ops on a file it has already read — which is what we want,
-      # except when the constant that file defined is gone. A graph's
-      # `namespace:` is normally a module Zeitwerk owns (app/graphql/accounts/
-      # implies Accounts), and unloading it on a dev reload takes the generated
-      # module nested inside it with it; require then restores nothing and every
-      # request 500s on "uninitialized constant Accounts::PersonQuery" until a
-      # .graphql edit happens to trigger the watcher. An un-namespaced module
-      # defines a top-level constant Zeitwerk never manages, so it survives.
-      if GraphWeaver.graphs.any?(&:namespace)
-        GraphWeaver.reload_generated!
-      else
-        GraphWeaver.load_generated!
-      end
+  # can't load until that constant resolves — and both Zeitwerk's setup and the
+  # app's own to_prepare blocks (where extend_type/register_enum are told to
+  # register, Codegen::AUTOLOAD_HINT) happen after config/initializers.
+  # after_initialize is past all of them, and past the watcher above.
+  #
+  # Except where the app eager loads: an eager-loaded class may name a
+  # generated constant in its class body, and Zeitwerk can't resolve one (the
+  # directory is ignored, by design), so the modules have to be in place before
+  # Rails' :eager_load! rather than after it. before_eager_load is that point,
+  # and Rails only runs it when config.eager_load is on — which is exactly when
+  # after_initialize must not do the work a second time.
+  config.before_eager_load { GraphWeaver::Railtie.prepare_generated! }
+
+  config.after_initialize do |app|
+    GraphWeaver::Railtie.prepare_generated! unless app.config.eager_load
+    # and again on every dev reload, which picks up a module generated since
+    # boot and re-requires one whose namespace Zeitwerk just unloaded. On the
+    # reloader itself, not config.to_prepare: the :add_to_prepare_blocks
+    # finisher has already drained that list by now.
+    ActiveSupport::Reloader.to_prepare { GraphWeaver::Railtie.prepare_generated! }
+  end
+
+  def self.prepare_generated!
+    # 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.
+    return if GraphWeaver.skip_generated_load
+
+    # every graph is declared by now, and this is the last point before one of
+    # them loads
+    check_generated_ignored!
+
+    # Regenerate first, then load — and here rather than in the watcher's own
+    # to_run, so an extend_type or register_enum the app registers in its own
+    # to_prepare is already in place. A run that regenerated has already
+    # reloaded what it wrote.
+    return if watcher&.execute_if_updated
+
+    # entries may be globs, so Dir[] rather than Dir.exist?
+    generated = GraphWeaver::Internal::Util.generated_dirs.any? do |dir|
+      Dir[GraphWeaver::Internal::Util.resolve(dir)].any?
+    end
+    return unless generated
+
+    # `require` no-ops on a file it has already read — which is what we want,
+    # except when the constant that file defined is gone. A graph's
+    # `namespace:` is normally a module Zeitwerk owns (app/graphql/accounts/
+    # implies Accounts), and unloading it on a dev reload takes the generated
+    # module nested inside it with it; require then restores nothing and every
+    # request 500s on "uninitialized constant Accounts::PersonQuery" until a
+    # .graphql edit happens to trigger the watcher. An un-namespaced module
+    # defines a top-level constant Zeitwerk never manages, so it survives.
+    if GraphWeaver.graphs.any?(&:namespace)
+      GraphWeaver.reload_generated!
+    else
+      GraphWeaver.load_generated!
     end
   end
 end

data/lib/graph_weaver/version.rb

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

data/lib/graph_weaver.rb

@@ -195,6 +195,7 @@ module GraphWeaver
 
     def generated_paths=(paths)
       @generated_paths = paths && Array(paths)
+      hide_from_autoloading(generated_paths)
     end
 
     def fragments_paths=(paths)
@@ -287,9 +288,24 @@ module GraphWeaver
       # generate! reports in however many times the initializer has re-run
       existing = @graphs.index { |candidate| candidate.name == name }
       existing ? @graphs[existing] = graph : @graphs << graph
+      hide_from_autoloading([graph.output])
       graph
     end
 
+    # Rails only: where a graph writes is hidden from Zeitwerk the moment the
+    # graph says it. Knowing it any later needed an initializer edge waiting on
+    # config/initializers, and such an edge reorders the whole app's boot (see
+    # the Railtie). Registered first, so a refusal can name the graph.
+    def hide_from_autoloading(paths)
+      # by name, not spelled: the railtie is Rails-only and `typed: ignore`, so
+      # sorbet has no constant to resolve
+      return unless const_defined?(:Railtie, false)
+
+      railtie = const_get(:Railtie, false)
+      paths.each { |path| railtie.ignore_output!(path) }
+    end
+    private :hide_from_autoloading
+
     # Every graph an entry point walks: the declared ones, or the single graph
     # the top-level settings describe. Never empty.
     def graphs = @graphs&.dup || [default_graph]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graph_weaver
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.3
 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.2/CHANGELOG.md
+  changelog_uri: https://github.com/dpep/graph_weaver/blob/v0.7.3/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