graph_weaver 0.7.6 → 0.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a68eaeb8cd0f3139cc9e50b88d98a50e04acd0c2c94c7825233f04405d30c42
-  data.tar.gz: '08df5051075500cb81c710cd65705f387dec16bc29a626e2b8069bbf5c61b3a1'
+  metadata.gz: bd9b2703206fc3145399e11794cd488a5e3c3734584ca7a56fa0e4d2afed9a77
+  data.tar.gz: 0e247a7b925ff0a89cb5952ac962b31545af417f865342a22b8019dcbcdbd135
 SHA512:
-  metadata.gz: ee7b2971697409f7180e31d40569fd44108404c0f1d811b259bec6e000f7cf82142e7640de164510d1dbd253916392c6cc866619ee2d37e35e610b1ed0be9741
-  data.tar.gz: 9d219008a1db9bc353ef3b033b9c39f64657e58d1d2548fb074fc1a60973052e4abd0c1950d93622ad1cfc0414e7ca1219d9c770e32e445cedba287636f58a73
+  metadata.gz: 7310d664c88a34de5fbdf9768e6a697ca6565e5ccd4c407cfea31c772f0f44001ceb1145a7e1837d1a46bcc74c16902c55c88d2be014df9c423bb2355dc882a0
+  data.tar.gz: abc81fbb21a1f3f26d8a7c93f1f660347e9f68088a833b37b6a66dcf05f17e6bb0bec95fc9432c6e99192ac3682e7961936d9e08b3f518b4af9e013623ef3f6c

data/Gemfile.lock

@@ -1,16 +1,16 @@
 PATH
   remote: .
   specs:
-    graph_weaver (0.7.6)
+    graph_weaver (0.7.8)
       graphql (>= 2.6.7)
       sorbet-runtime
 
 GEM
   remote: https://rubygems.org/
   specs:
-    actionpack (8.1.3.1)
-      actionview (= 8.1.3.1)
-      activesupport (= 8.1.3.1)
+    actionpack (8.1.4)
+      actionview (= 8.1.4)
+      activesupport (= 8.1.4)
       nokogiri (>= 1.8.5)
       rack (>= 2.2.4)
       rack-session (>= 1.0.1)
@@ -18,13 +18,13 @@ GEM
       rails-dom-testing (~> 2.2)
       rails-html-sanitizer (~> 1.6)
       useragent (~> 0.16)
-    actionview (8.1.3.1)
-      activesupport (= 8.1.3.1)
+    actionview (8.1.4)
+      activesupport (= 8.1.4)
       builder (~> 3.1)
       erubi (~> 1.11)
       rails-dom-testing (~> 2.2)
       rails-html-sanitizer (~> 1.6)
-    activesupport (8.1.3.1)
+    activesupport (8.1.4)
       base64
       bigdecimal
       concurrent-ruby (~> 1.0, >= 1.3.1)
@@ -45,9 +45,9 @@ GEM
     ast (2.4.3)
     base64 (0.3.0)
     benchmark (0.5.0)
-    bigdecimal (4.1.2)
+    bigdecimal (4.1.3)
     builder (3.3.0)
-    concurrent-ruby (1.3.7)
+    concurrent-ruby (1.3.8)
     connection_pool (3.0.2)
     crack (1.0.1)
       bigdecimal
@@ -58,11 +58,11 @@ GEM
       reline (>= 0.3.8)
     diff-lcs (1.6.2)
     drb (2.2.3)
-    erb (6.0.4)
+    erb (6.0.7)
     erubi (1.13.1)
     faker (3.8.0)
       i18n (>= 1.8.11, < 2)
-    faraday (2.14.3)
+    faraday (2.14.4)
       faraday-net_http (>= 2.0, < 3.5)
       json
       logger
@@ -81,20 +81,20 @@ GEM
     google-protobuf (4.35.1-x86_64-linux-gnu)
       bigdecimal
       rake (~> 13.3)
-    graphql (2.6.10)
+    graphql (2.6.11)
       base64
       fiber-storage
       logger
     hashdiff (1.2.1)
     i18n (1.15.2)
       concurrent-ruby (~> 1.0)
-    io-console (0.8.2)
+    io-console (0.9.4)
     irb (1.18.0)
       pp (>= 0.6.0)
       prism (>= 1.3.0)
       rdoc (>= 4.0.0)
       reline (>= 0.4.2)
-    json (2.21.2)
+    json (3.0.2)
     logger (1.7.0)
     loofah (2.25.2)
       crass (~> 1.0.2)
@@ -124,7 +124,7 @@ GEM
       racc (~> 1.4)
     nokogiri (1.19.4-x86_64-linux-gnu)
       racc (~> 1.4)
-    parallel (2.1.0)
+    parallel (2.2.0)
     parser (3.3.12.0)
       ast (~> 2.4.1)
       racc
@@ -149,9 +149,9 @@ GEM
     rails-html-sanitizer (1.7.1)
       loofah (~> 2.25, >= 2.25.2)
       nokogiri (>= 1.15.7, != 1.16.7, != 1.16.6, != 1.16.5, != 1.16.4, != 1.16.3, != 1.16.2, != 1.16.1, != 1.16.0.rc1, != 1.16.0)
-    railties (8.1.3.1)
-      actionpack (= 8.1.3.1)
-      activesupport (= 8.1.3.1)
+    railties (8.1.4)
+      actionpack (= 8.1.4)
+      activesupport (= 8.1.4)
       irb (~> 1.13)
       rackup (>= 1.0.0)
       rake (>= 12.2)
@@ -159,23 +159,23 @@ GEM
       tsort (>= 0.2)
       zeitwerk (~> 2.6)
     rake (13.4.2)
-    rbi (0.3.14)
+    rbi (0.4.3)
       prism (~> 1.0)
       rbs (>= 4.0.1)
-    rbs (4.0.3)
+    rbs (4.2.0)
       logger
       prism (>= 1.6.0)
       tsort
-    rdoc (8.0.0)
+    rdoc (8.1.0)
       erb
       prism (>= 1.6.0)
       rbs (>= 4.0.0)
       tsort
     redcarpet (3.6.1)
     regexp_parser (2.12.0)
-    reline (0.6.3)
+    reline (0.7.0)
       io-console (~> 0.5)
-    require-hooks (0.4.0)
+    require-hooks (0.5.1)
     rexml (3.4.4)
     rspec (3.13.2)
       rspec-core (~> 3.13.0)
@@ -190,35 +190,35 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
     rspec-support (3.13.7)
-    rubydex (0.2.7-aarch64-linux)
-    rubydex (0.2.7-arm64-darwin)
-    rubydex (0.2.7-x86_64-darwin)
-    rubydex (0.2.7-x86_64-linux)
+    rubydex (0.4.1-aarch64-linux)
+    rubydex (0.4.1-arm64-darwin)
+    rubydex (0.4.1-x86_64-darwin)
+    rubydex (0.4.1-x86_64-linux)
     securerandom (0.4.1)
-    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)
+    simplecov (1.3.1)
+    sorbet (0.6.13508)
+      sorbet-static (= 0.6.13508)
+    sorbet-runtime (0.6.13508)
+    sorbet-static (0.6.13508-aarch64-linux)
+    sorbet-static (0.6.13508-universal-darwin)
+    sorbet-static (0.6.13508-x86_64-linux)
+    sorbet-static-and-runtime (0.6.13508)
+      sorbet (= 0.6.13508)
+      sorbet-runtime (= 0.6.13508)
+    spoom (1.8.7)
       erubi (>= 1.10.0)
       prism (>= 0.28.0)
-      rbi (>= 0.3.14)
+      rbi (>= 0.4.2)
       rbs (>= 4.0.0.dev.5)
       rexml (>= 3.2.6)
       sorbet-static-and-runtime (>= 0.5.10187)
       thor (>= 0.19.2)
-    tapioca (0.19.2)
+    tapioca (0.20.0)
       benchmark
       bundler (>= 2.2.25)
       netrc (>= 0.11.0)
       parallel (>= 1.21.0)
-      rbi (>= 0.3.7)
+      rbi (>= 0.4.1)
       require-hooks (>= 0.2.2)
       rubydex (>= 0.1.0.beta10)
       sorbet-static-and-runtime (>= 0.6.12698)
@@ -272,40 +272,40 @@ DEPENDENCIES
   yard
 
 CHECKSUMS
-  actionpack (8.1.3.1) sha256=974cb7154548e81f470b1b0f247b99cb38e87825899dca58610596e2817723d0
-  actionview (8.1.3.1) sha256=2da68b8414c47b43bfbed1ce69c5afe1c04f78c267aacb5660a4cab5ca12cfb6
-  activesupport (8.1.3.1) sha256=85458765f25ea48b9019c46b6bb3fa5683197bf4280d9f06710a6e8d7a831376
+  actionpack (8.1.4) sha256=245493cc51be195a7645e6fc184880fa7e5b32ff1a08e053ee31f58c76e30ea4
+  actionview (8.1.4) sha256=eff1efd07c4d969abad288322b423bcb67fdbab5e324c91ca37352b80f226076
+  activesupport (8.1.4) sha256=891dd3fe43c4fc8391934b237b1189bb1f661c932a84a840043db9d46a4e80df
   addressable (2.9.0) sha256=7fdf6ac3660f7f4e867a0838be3f6cf722ace541dd97767fa42bc6cfa980c7af
   apollo-federation (3.10.3) sha256=61e6d8e1fd695ee45bab5d84f86f586d99c296ad77a86c6f1e7b964ac17be3d7
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
   benchmark (0.5.0) sha256=465df122341aedcb81a2a24b4d3bd19b6c67c1530713fd533f3ff034e419236c
-  bigdecimal (4.1.2) sha256=53d217666027eab4280346fba98e7d5b66baaae1b9c3c1c0ffe89d48188a3fbd
+  bigdecimal (4.1.3) sha256=61ebe1e5e559bdc3cc6f2c0ee7f427321fc838f59611c294356eb04d6e21cf66
   builder (3.3.0) sha256=497918d2f9dca528fdca4b88d84e4ef4387256d984b8154e9d5d3fe5a9c8835f
-  concurrent-ruby (1.3.7) sha256=4412caec3a5ea2e5fdc52076724c071a81f2c0593d83b2ac8cbb8ca63b3151b0
+  concurrent-ruby (1.3.8) sha256=b2f1be836e968ccc78ccfce277ea79c72a88633f22306782c16ff23fb415d1e1
   connection_pool (3.0.2) sha256=33fff5ba71a12d2aa26cb72b1db8bba2a1a01823559fb01d29eb74c286e62e0a
   crack (1.0.1) sha256=ff4a10390cd31d66440b7524eb1841874db86201d5b70032028553130b6d4c7e
   crass (1.0.7) sha256=94868719948664c89ddcaf0a37c65048413dfcb1c869470a5f7a7ceb5390b295
   debug (1.11.1) sha256=2e0b0ac6119f2207a6f8ac7d4a73ca8eb4e440f64da0a3136c30343146e952b6
   diff-lcs (1.6.2) sha256=9ae0d2cba7d4df3075fe8cd8602a8604993efc0dfa934cff568969efb1909962
   drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
-  erb (6.0.4) sha256=38e3803694be357fe2bfe312487c74beaf9fb4e5beb3e22498952fe1645b95d9
+  erb (6.0.7) sha256=c5ca6dc25b0ef974a44dc8f59fe847577122483b1968a38dec305c60bf91ee92
   erubi (1.13.1) sha256=a082103b0885dbc5ecf1172fede897f9ebdb745a4b97a5e8dc63953db1ee4ad9
   faker (3.8.0) sha256=c147b308df73a90f27a4fc84f18d4c22ef0ad9c2a64b2b61c86fd0ca71753efc
-  faraday (2.14.3) sha256=1882247e6766615c8220b4392bf1d27f6ebb63d8e28267587cef1fb0bf37f278
+  faraday (2.14.4) sha256=9bb4408c44621b0dbaaaa39e5dbfc4dbe58cc6751b6eb94d16ae9e1f2f2fab6e
   faraday-net_http (3.4.4) sha256=0e78af151747ed1b00f33e25973b4bc220d7f16c00c39676817c8b12331eb588
   fiber-storage (1.0.1) sha256=f48e5b6d8b0be96dac486332b55cee82240057065dc761c1ea692b2e719240e1
   google-protobuf (4.35.1-aarch64-linux-gnu) sha256=50ca44d0eeff3f8475e630a1accdd974256f3510694d574e2c9d6119ea8bc9e1
   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.6)
-  graphql (2.6.10) sha256=9b7c8633767f516ff9d48a8d6305b2a00a2101c82aa871b92e69086944f9f83e
+  graph_weaver (0.7.8)
+  graphql (2.6.11) sha256=9a9cde910e805c4c08fdf8d22bf129e935affc9ca8b4f9b2ec26b4b63666b15d
   hashdiff (1.2.1) sha256=9c079dbc513dfc8833ab59c0c2d8f230fa28499cc5efb4b8dd276cf931457cd1
   i18n (1.15.2) sha256=00f9eb62412fe593b2a65a97daa75300d37abb8f7202ec748e94b6d46a9dd1b5
-  io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc
+  io-console (0.9.4) sha256=a403304f32928ee85e56d457b4612ca43f2703b561a3258844992bd24085fbb1
   irb (1.18.0) sha256=de9454a0703a54704b9811a5ef31a60c86949fbf4013fcf244fabc7c775248e3
-  json (2.21.2) sha256=1f1d3b7cf2b3ba1a69beca0bb6db13d5438b80bff3cd54cdaaa620b9b07c1c6a
+  json (3.0.2) sha256=8e6d7e7b11384c21230430cef90b71f14849a34a1f4452796670f7c981bd19df
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
   loofah (2.25.2) sha256=2007f746959ac65552456e04b433e83deb22759ab38c838b4445c70e43425918
   minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1
@@ -317,7 +317,7 @@ CHECKSUMS
   nokogiri (1.19.4-arm64-darwin) sha256=a46db9853286e6597b36ebc6953817d15acf3a299583eb3f89fdc6f91dd63527
   nokogiri (1.19.4-x86_64-darwin) sha256=7fd17057d3e1f00e9954a74b3cd76595d3d4a5ef233b7ed9599047c204f70551
   nokogiri (1.19.4-x86_64-linux-gnu) sha256=379fae440b28915e3f19d752ce2dcf8465ed2b2fbefd2a7ca0dd497bc981a06a
-  parallel (2.1.0) sha256=b35258865c2e31134c5ecb708beaaf6772adf9d5efae28e93e99260877b09356
+  parallel (2.2.0) sha256=e1059c5fd7b649558a0aec38a769f06a42942bdb40503d005a59c352fe011cd8
   parser (3.3.12.0) sha256=21a6d7f755d5a24dfbdc6e6b772e4e879a52e7631a88bc5a3a134606052c9828
   pp (0.6.4) sha256=dfcb0fce700c41456265922884f9fe195d7fbb0674a3578e6c0f69588e82b570
   prettyprint (0.2.0) sha256=2bc9e15581a94742064a3cc8b0fb9d45aae3d03a1baa6ef80922627a0766f193
@@ -330,35 +330,35 @@ CHECKSUMS
   rackup (2.3.1) sha256=6c79c26753778e90983761d677a48937ee3192b3ffef6bc963c0950f94688868
   rails-dom-testing (2.3.0) sha256=8acc7953a7b911ca44588bf08737bc16719f431a1cc3091a292bca7317925c1d
   rails-html-sanitizer (1.7.1) sha256=e797a7c9b01e567307e317c576b49ab4168017e63eea4dba9ce3cb587e2f22c2
-  railties (8.1.3.1) sha256=2388a232579a00cefea4487de66c8553c3408c1300abdc6cf1799d86ffb04487
+  railties (8.1.4) sha256=b5e7a8e8984e33114d68af62227971960aae1e6c02bd7c9d826ffad97fff583c
   rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
-  rbi (0.3.14) sha256=932ed904adbb5ca645c285c8b36da1b7ff6321ec1870d187d6325248cb637658
-  rbs (4.0.3) sha256=5a7bf70e2628549d9a1f44eae447b2cfe55968a9c60cfff52693a4bdcc020e14
-  rdoc (8.0.0) sha256=03bf8c08a9639658855a0cfd77c0abca8325c227693f7f33f82957811348c469
+  rbi (0.4.3) sha256=cc090ae62c3246412b992954f54077d6046c9b04f1537a4d24bfae8714503eac
+  rbs (4.2.0) sha256=51f7b886dcc05bc09e10b901daa6a81829f6adc03101d6ca9ea4aac6103e0674
+  rdoc (8.1.0) sha256=befc37880a5cfd36dcb176c748b5fd5ee39dd3536a75e81824e4972ce230f60a
   redcarpet (3.6.1) sha256=d444910e6aa55480c6bcdc0cdb057626e8a32c054c29e793fa642ba2f155f445
   regexp_parser (2.12.0) sha256=35a916a1d63190ab5c9009457136ae5f3c0c7512d60291d0d1378ba18ce08ebb
-  reline (0.6.3) sha256=1198b04973565b36ec0f11542ab3f5cfeeec34823f4e54cebde90968092b1835
-  require-hooks (0.4.0) sha256=005f4c6435b4edae73e358cdbaba48370a4121f9ce893d5d2a3c66fce855677d
+  reline (0.7.0) sha256=5b012d8e55dbf9d450f12bde2cf7d15ff546ae80b3f8f3b30e570d431815583d
+  require-hooks (0.5.1) sha256=49a6b14518b91c5b8006d0644ef257af0ca033df23625bd4e314a8c5282191d9
   rexml (3.4.4) sha256=19e0a2c3425dfbf2d4fc1189747bdb2f849b6c5e74180401b15734bc97b5d142
   rspec (3.13.2) sha256=206284a08ad798e61f86d7ca3e376718d52c0bc944626b2349266f239f820587
   rspec-core (3.13.6) sha256=a8823c6411667b60a8bca135364351dda34cd55e44ff94c4be4633b37d828b2d
   rspec-expectations (3.13.5) sha256=33a4d3a1d95060aea4c94e9f237030a8f9eae5615e9bd85718fe3a09e4b58836
   rspec-mocks (3.13.8) sha256=086ad3d3d17533f4237643de0b5c42f04b66348c28bf6b9c2d3f4a3b01af1d47
   rspec-support (3.13.7) sha256=0640e5570872aafefd79867901deeeeb40b0c9875a36b983d85f54fb7381c47c
-  rubydex (0.2.7-aarch64-linux) sha256=9a016039f7e94e55cd812e073d310de7effcce4cac560edd1185e1ce6b5b4eb0
-  rubydex (0.2.7-arm64-darwin) sha256=f0d28bbf4153568be79b671642424750053e0bea971b60ddf5cec19bf4563990
-  rubydex (0.2.7-x86_64-darwin) sha256=b002b259d118ac69de44470eff1597143318402c45630c47371f9542631447dc
-  rubydex (0.2.7-x86_64-linux) sha256=dacfade9fa42ce4469618da6dac07e69d5f3ac6a313b4caced5234c8f052419a
+  rubydex (0.4.1-aarch64-linux) sha256=abc1c9eb22479f60dd015fa81373163c5a71f2700b76bced1282631686bd6271
+  rubydex (0.4.1-arm64-darwin) sha256=d23720253876d88fb98954e5d3a1ef9696a269697acf50e3ab53cdfbb2b66b96
+  rubydex (0.4.1-x86_64-darwin) sha256=a9681db5bc9be6a62f226d96d6889b6b600d0b09e7576391702aafd29912145b
+  rubydex (0.4.1-x86_64-linux) sha256=4e2c8398c9fc585485b54edd28f5ecf76b5a02255e177b6f8402e9d2afffd51b
   securerandom (0.4.1) sha256=cc5193d414a4341b6e225f0cb4446aceca8e50d5e1888743fac16987638ea0b1
-  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
+  simplecov (1.3.1) sha256=b326d38e819053499aa2ebe35d544d8bd780eba143a50f48a624b450ad87feec
+  sorbet (0.6.13508) sha256=de67c75424731d39ac529639ff6849c3fe33d91c94608765d912d35efa5941a2
+  sorbet-runtime (0.6.13508) sha256=011ee266adead459077ebc0058d36aeb75d6c90968db8524916050ce3c62e526
+  sorbet-static (0.6.13508-aarch64-linux) sha256=1c54603399d40d78d6e73c853c5e0b6dcfc34105a92f6630f4a5329d1e6ed3c0
+  sorbet-static (0.6.13508-universal-darwin) sha256=65280392d193ca85828b13d07bb8eb90f41ad57f8d9bc79c5edcd078aa7dc308
+  sorbet-static (0.6.13508-x86_64-linux) sha256=57fd620b1a747baad432ef5c2bc2cd6218664e00626fc4e7fb5ed5f633e3a286
+  sorbet-static-and-runtime (0.6.13508) sha256=874d9fe5d98eebddd322629ee3d27021a6da32594edfa170295c0b4bcd285d66
+  spoom (1.8.7) sha256=81960502cdf23aa991f015988aa5dd43325e23ae4318b8e00d541299cbdb70f6
+  tapioca (0.20.0) sha256=b375ed7bf51d2c86c09543eafedd0de85513634187c0f7a062615af8bb9347a0
   thor (1.5.0) sha256=e3a9e55fe857e44859ce104a84675ab6e8cd59c650a49106a05f55f136425e73
   tsort (0.2.0) sha256=9650a793f6859a43b6641671278f79cfead60ac714148aabe4e3f0060480089f
   tzinfo (2.0.6) sha256=8daf828cc77bcf7d63b0e3bdb6caa47e2272dcfaf4fbfe46f8c3a9df087a829b

data/docs/generated_modules.md

@@ -142,7 +142,9 @@ file, and `verify` fails until you regenerate.
 **A graph's `namespace:` nests what it generates**, and is the answer when two
 schemas in one app each have a `person.graphql`: `namespace: "Billing"` makes
 that one `Billing::PersonQuery` in the same `person_query.rb`, and its shared
-types module `Billing::GraphQLTypes`. Nothing else about the rule changes. See
+types module `Billing::Types` (plain `Types` inside a namespace, where nothing
+collides with graphql-ruby's own `Types::`; `GraphQLTypes` without one). Nothing
+else about the rule changes. See
 [getting started](getting_started.md#more-than-one-schema).
 
 Parsing a raw query *string* has no file to name it after, so it uses the
@@ -833,10 +835,8 @@ has the other attributes it reads.
 
 ### Loading what it wrote
 
-In Rails, loading is automatic — the Railtie requires every generated file at
-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:
+In Rails, loading is automatic — [one rule](#the-rule-in-rails) decides whether
+Zeitwerk does it or the Railtie does. 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
@@ -865,11 +865,57 @@ list would name a dump nothing ever opens. A relative path resolves against
 `GraphWeaver.root` — `Rails.root` in a Rails app, the working directory otherwise
 — so where you started the process doesn't change which files it reads.
 
-Plain requires, not Zeitwerk: Zeitwerk would expect `Generated::PersonQuery` from
-`generated/person_query.rb`. In development a query edit regenerates and reloads
-before the next request; everywhere else generated code changes only on
-regeneration — restart, like a schema migration, or call
-`GraphWeaver.reload_generated!` after regenerating in another terminal.
+#### The rule in Rails
+
+**A generated tree Zeitwerk would name correctly is left to Zeitwerk; any other
+is hidden from it and required at boot.**
+
+The conventional layout is the second one: `generated/person_query.rb` defines
+`::PersonQuery` where Zeitwerk reads `Generated::PersonQuery` off the path. So
+the Railtie hides that directory from the autoloader and requires every file at
+the end of boot — after your initializers and after any `to_prepare`
+registrations of your own, and again after each development reload.
+
+A tree is named correctly when the graph's [`namespace`](getting_started.md#more-than-one-schema)
+is the constant its output path spells:
+
+```ruby
+GraphWeaver.graph :reports do
+  output    "app/graphql/queries/reports/generated"
+  namespace "Queries::Reports::Generated"
+end
+```
+
+`report_query.rb` then defines `Queries::Reports::Generated::ReportQuery`, which
+is exactly what Zeitwerk expects there — your own `inflect`/`acronym` rules
+included, since graph_weaver asks the loader rather than guessing. Nothing is
+hidden and nothing is required: the modules autoload on first reference and
+reload with the rest of the app, and **no part of the parent namespace chain is
+defined until a query is used**. Leave `types_module` unset for it — the shared
+manifest is `types.rb`, which Zeitwerk reads as `<Namespace>::Types`, and `Types`
+is what a namespaced graph already calls it.
+
+The Railtie says which side each graph fell on, one line apiece at debug, naming
+the constant that disagreed:
+
+```
+graph :reports's output app/graphql/queries/reports/generated is hidden from
+Zeitwerk and required at boot — types.rb defines …::GraphQLTypes, Zeitwerk
+expects …::Types
+```
+
+**The settings have two lifetimes.** `schema`, `queries`, `output` and
+`namespace` matter only when `generate`/`verify` runs. `extend_type`,
+`register_scalar` and `register_enum` are needed wherever generated code *loads*
+— which under autoloading is the first request that uses a query, long after
+boot. So generation settings can live wherever generation happens, and
+registrations belong in `config/initializers` or a `to_prepare` block, where
+every boot runs them.
+
+In development a query edit regenerates and reloads before the next request;
+everywhere else generated code changes only on regeneration — restart, like a
+schema migration, or call `GraphWeaver.reload_generated!` after regenerating in
+another terminal.
 
 ## Dynamic mode
 

data/docs/getting_started.md

@@ -466,6 +466,15 @@ db/schema.graphql records no source url and the graph names no server behind it
 still exits 1, because a gate that passes on having compared nothing is worse
 than one that says so.
 
+**A large dump costs nothing until something asks for it.** A client built from
+a file stats the path at construction — a typo fails at boot, naming it — and
+parses the file the first time anything wants the schema: codegen, a test mode,
+`check_query`. Executing a generated module never does, so a production boot
+never parses.
+
+Keep one client per server rather than building one per call — a client parses
+its dump once and keeps the schema.
+
 ## More than one schema
 
 The five steps above describe one graph — a schema, its queries, its output. An
@@ -496,7 +505,7 @@ plus `register_scalar`, `register_enum` and `extend_type`).
 | `output` | one directory — where this graph's generated Ruby is written |
 | `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`) |
+| `types_module` | a constant name for the shared types module (default: `Types` under a `namespace`, `GraphQLTypes` without one) |
 
 **Declaring graph two means declaring graph one.** A declared graph *replaces*
 the implicit one the top-level settings describe, so the moment any graph is
@@ -527,7 +536,10 @@ a bare `schema` reads back; there is no `schema = "x"` form, since the block is
 `Billing::PersonQuery` ([naming](generated_modules.md#naming)). Constants are
 global, so two schemas that both have a `person.graphql` would otherwise fight
 over one name; without a namespace the collision is refused at generation,
-naming both files. **The block's registrations reach that graph alone**, laid
+naming both files. **A namespace that is the constant the output path spells is
+also what makes the tree autoloadable** — graph_weaver then leaves it to Zeitwerk
+instead of hiding it and requiring it at boot
+([loading](generated_modules.md#the-rule-in-rails)). **The block's registrations reach that graph alone**, laid
 over the top-level ones — so `Money` is checked against the schema it was
 registered for, and against no other.
 

data/docs/upgrading.md

@@ -1,7 +1,9 @@
 # Upgrading
 
 [Regenerate](#regenerate-on-every-upgrade) whichever version you're on, then read
-the one section that is yours: from [0.7.5](#upgrading-from-075), from
+the one section that is yours: from [0.7.7](#upgrading-from-077), from
+[0.7.6](#upgrading-from-076), from
+[0.7.5](#upgrading-from-075), from
 [0.7.4](#upgrading-from-074), from [0.7.3](#upgrading-from-073), 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
@@ -24,6 +26,42 @@ 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.7
+
+A patch release about load time. Nothing in it reaches an app that reads its
+dump and generates; one edge moved, below. Read the left column and skip what
+isn't yours; the [changelog](../CHANGELOG.md) says why each one moved.
+
+| applies if you… | what changed |
+|---|---|
+| build a client from a schema dump — `GraphWeaver.new("schema.graphql")`, or a graph naming one | it is parsed on first use, not at construction, so a production boot never parses it. A missing or unreadable path still refuses at construction, naming it; a file that exists but isn't a schema refuses at the first `schema`, `parse` or `check_query`. `rake graph_weaver:verify` catches that one in CI |
+| call `client.check_query` per query against a supergraph client | the routing table is built once per file version rather than per call — nothing to change, ~200 ms back per call on a 2000-type supergraph |
+| generate anonymous operations whose comments carry non-ASCII text, or check out with CRLF | they generate under any parser graphql-ruby is configured with; nothing to change unless you had named an operation to dodge a "could not name the anonymous operation" refusal |
+
+Then regenerate, and the gate:
+
+```sh
+rake graph_weaver:generate
+rake graph_weaver:verify
+```
+
+## Upgrading from 0.7.6
+
+Read the left column and skip what isn't yours; the
+[changelog](../CHANGELOG.md) says why each one moved.
+
+| applies if you… | what changed |
+|---|---|
+| set `namespace:` on any graph — `rake graph_weaver:graphs` lists them | its shared types module is `<Namespace>::Types`, not `<Namespace>::GraphQLTypes`. **Regenerate**, then move app code naming `<Namespace>::GraphQLTypes::X` to `<Namespace>::Types::X` — `srb tc` finds every site. Keep the old name with `types_module "GraphQLTypes"` in that graph's block, at the cost of the autoloadable layout below |
+| run Rails, and have a graph whose `namespace:` is the constant its output path spells | that tree is [left to Zeitwerk](generated_modules.md#the-rule-in-rails) — autoloaded on first reference, reloaded with the app, and no longer required at boot, so booting stops defining its parent namespace chain. Nothing to do; the Railtie says which side each graph fell on at debug. Every other tree is hidden and required exactly as before |
+
+Then regenerate, and the gate:
+
+```sh
+rake graph_weaver:generate
+rake graph_weaver:verify
+```
+
 ## Upgrading from 0.7.5
 
 A patch release. The regenerate is what changes behaviour — every module gains

data/examples/github/generated/star_mutation.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-# Generated by GraphWeaver 0.7.6 — do not edit.
+# Generated by GraphWeaver 0.7.8 — 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.6 — do not edit.
+# Generated by GraphWeaver 0.7.8 — 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.6 — do not edit.
+# Generated by GraphWeaver 0.7.8 — do not edit.
 
 module StarredQuery
   extend T::Sig

data/lib/graph_weaver/client.rb

@@ -75,8 +75,18 @@ class GraphWeaver::Client
       end
 
       # 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)
+      # dump has no resolvers, so it is type information only — and it is
+      # read on first use, the rule a url client already follows. An app
+      # that builds one only to name its supergraph (what `graphql: :router`
+      # plans against) then never parses the file at all.
+      if source.is_a?(Module)
+        @schema = source
+      else
+        # a path is checked now — a stat, not a parse — so a wrong one
+        # refuses where it was written rather than at the first request
+        GraphWeaver::SchemaLoader.check_path!(source) unless GraphWeaver::SchemaLoader.content?(source)
+        @dump = source
+      end
       # 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.
@@ -147,8 +157,9 @@ class GraphWeaver::Client
   FAILURE_TTL = 1.0
   private_constant :FAILURE_TTL
 
-  # The schema, introspecting through the transport on first use (cached
-  # per the client's cache:/ttl:) unless one was given up front.
+  # The schema, on first use: a dump is read and built, a url is
+  # introspected through the transport (cached per the client's cache:/ttl:).
+  # A schema class is the schema, and was there all along.
   #
   # Locked because a cold Puma process serves its first requests
   # concurrently: a bare ||= there is one full introspection round trip per
@@ -156,6 +167,7 @@ class GraphWeaver::Client
   def schema
     @schema_lock.synchronize do
       next @schema if @schema
+      next @schema = GraphWeaver::SchemaLoader.load(@dump) if @dump
       raise @schema_error if @schema_error && Process.clock_gettime(Process::CLOCK_MONOTONIC) < @schema_error_until
 
       begin

data/lib/graph_weaver/codegen.rb

@@ -458,19 +458,51 @@ class GraphWeaver::Codegen
     declares!(named, name)
   end
 
-  # Where the operation starts in @query, in characters. graphql-ruby subtracts
-  # a CHARACTER line start from the lexer's BYTE position
-  # (Language::Parser#column_at over Lexer's @scanner.pos), so line start plus
-  # col is a byte offset — and col falls back to a whole-document offset for a
-  # token with no newline after it, which .strip guarantees for the last line,
-  # hence the copy that ends in one.
+  # What an operation definition opens with.
+  OPERATION_START = %i[QUERY MUTATION SUBSCRIPTION LCURLY].to_set.freeze
+  private_constant :OPERATION_START
+
+  # Where the operation starts in @query, in characters — lexed, not derived
+  # from a reported position, because no two parsers report the same one:
+  # graphql-ruby's own gives a BYTE position minus a CHARACTER line start
+  # (Language::Parser#column_at), its C parser gives a true column and counts
+  # \r\n as two lines. Language::Lexer is the same implementation whichever
+  # parser is default, and its #pos is an exact byte offset, so nothing here is
+  # left to interpret.
+  #
+  # The operation is the first one of those tokens outside every fragment
+  # definition, selection set and argument list — an argument's braces are
+  # not a body, and a fragment's body is not the operation's.
   def operation_offset
-    operation = sole_operation("#{@query}\n")
-    bytes = @query.lines.first(operation.line - 1).sum(&:length) + operation.col - 1
-    @query.byteslice(0, bytes).length
+    lexer = GraphQL::Language::Lexer.new(@query)
+    depth = 0
+    parens = 0
+    fragment = T.let(false, T::Boolean)
+
+    while (kind = lexer.advance)
+      parens += 1 if kind == :LPAREN
+      parens -= 1 if kind == :RPAREN
+      next unless parens.zero?
+
+      if depth.zero? && !fragment && OPERATION_START.include?(kind)
+        return @query.byteslice(0, lexer.pos).length
+      end
+
+      case kind
+      when :LCURLY
+        depth += 1
+        fragment = false
+      when :RCURLY then depth -= 1
+      when :FRAGMENT then fragment = true if depth.zero?
+      end
+    end
+
+    # The lexer and the parser disagree about what this document holds. Splice
+    # past the end, which declares! can only refuse.
+    @query.length
   end
 
-  # The splice above is arithmetic over a position graphql-ruby reports, so it
+  # The splice above lands on an offset this file worked out for itself, so it
   # can land wrong and still emit a module that looks fine — and OPERATION_NAME
   # would then be an operationName the document doesn't declare, which every
   # server rejects. Nothing else re-reads the query, so this is the only place

data/lib/graph_weaver/graph.rb

@@ -93,8 +93,19 @@ module GraphWeaver
     # constant; this is the one knob that settles both.
     def namespace = @namespace
 
+    # The shared types module. Inside a namespace the default is plain `Types`,
+    # so `namespace:` alone leaves a tree Zeitwerk names correctly — types.rb
+    # holds it, and Zeitwerk reads that file as `<Namespace>::Types`. At the top
+    # level it stays GraphQLTypes, where a bare ::Types would collide with
+    # graphql-ruby's own Types:: convention.
+    NESTED_TYPES_MODULE = "Types"
+    private_constant :NESTED_TYPES_MODULE
+
     def types_module
-      @types_module || (namespace ? "#{namespace}::#{GraphWeaver.types_module}" : GraphWeaver.types_module)
+      return @types_module if @types_module
+      return GraphWeaver.types_module unless namespace
+
+      "#{namespace}::#{GraphWeaver.types_module(NESTED_TYPES_MODULE)}"
     end
 
     # The graphql-ruby schema, however it was named: a class, a Client, a path

data/lib/graph_weaver/internal.rb

@@ -192,6 +192,23 @@ module GraphWeaver
           GraphWeaver.generated_paths | extra
         end
 
+        # The generated directories this process has to require ITSELF:
+        # generated_dirs, less any tree the Railtie left to Zeitwerk. Those
+        # load on first reference and reload with the app, and requiring them
+        # is the one thing an autoloadable layout exists to avoid.
+        def required_dirs
+          generated_dirs.reject { |dir| left_to_zeitwerk?(dir) }
+        end
+
+        # by name, not spelled: the railtie is Rails-only and `typed: ignore`,
+        # so sorbet has no constant to resolve. Outside Rails there is no
+        # autoloader and the answer is always no.
+        def left_to_zeitwerk?(path)
+          return false unless GraphWeaver.const_defined?(:Railtie, false)
+
+          GraphWeaver.const_get(:Railtie, false).left_to_zeitwerk?(path)
+        end
+
         # Every query document under these directories, sorted — the files
         # generate!, verify_generated!, check_queries and load_queries! read.
         def query_files(paths = GraphWeaver.queries_paths)
@@ -358,10 +375,24 @@ module GraphWeaver
           path = path.to_path if path.respond_to?(:to_path)
           return unless path&.end_with?(".graphql", ".gql")
 
-          sdl = File.read(path)
-          SchemaLoader.routing_table(sdl) if SchemaLoader.federation_sdl?(sdl)
+          # once per file version: check_query is called per query, and the
+          # table behind a 2000-type supergraph costs ~200 ms to read against
+          # a fraction of a millisecond to stat — mtime and size in the key
+          # are what let schema:refresh's rewrite be seen without a reload
+          stat = File.stat(path)
+          key = [File.expand_path(path), stat.mtime, stat.size]
+          TABLES.synchronize do
+            return TABLES_BY_FILE[key] if TABLES_BY_FILE.key?(key)
+
+            sdl = File.read(path)
+            TABLES_BY_FILE[key] = SchemaLoader.routing_table(sdl) if SchemaLoader.federation_sdl?(sdl)
+          end
         end
 
+        TABLES = Mutex.new
+        TABLES_BY_FILE = {}
+        private_constant :TABLES, :TABLES_BY_FILE
+
         private
 
         # Which subgraphs a validation error is about, on a federated schema:

data/lib/graph_weaver/railtie.rb

@@ -85,6 +85,12 @@ class GraphWeaver::Railtie < Rails::Railtie
     # calling ignore again — check_generated_ignored! refuses instead.
     attr_accessor :ignored_dirs
 
+    # The outputs left to Zeitwerk, resolved — the trees whose every module is
+    # the constant Zeitwerk infers from its path, so hiding them would be
+    # hiding code that already works. Decided beside the sweep, because it is
+    # what the sweep must not hide.
+    attr_accessor :autoloaded_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.
@@ -108,14 +114,24 @@ class GraphWeaver::Railtie < Rails::Railtie
     GraphWeaver::Railtie.hide_generated!
   end
 
+  # ONE rule: a generated tree Zeitwerk would name correctly is left to
+  # Zeitwerk; any other is hidden from it and required at boot.
+  #
   # 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.
+  # fine. prepare_generated! requires those instead. A graph whose `namespace:`
+  # is the constant its output path spells has no such mismatch, and requiring
+  # it at boot would define its whole parent chain before a query is ever used.
   def self.hide_generated!
     self.ignored_dirs = []
+    self.autoloaded_dirs = []
     self.hiding_outputs = true
+    # the aligned trees first: they are what the sweep must NOT hide, and
+    # generated_paths' own globs cover a graph's output (app/graphql/*/generated
+    # matches app/graphql/billing/generated)
+    GraphWeaver.graphs.each { |graph| consider_output!(graph) }
     GraphWeaver::Internal::Util.generated_dirs.each { |path| ignore_output!(path) }
 
     # Zeitwerk reads its ignore list once, at setup, and nothing in Rails
@@ -124,12 +140,189 @@ class GraphWeaver::Railtie < Rails::Railtie
     # 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 }
+      main.on_setup do
+        GraphWeaver::Railtie.hiding_outputs = false
+        GraphWeaver::Railtie.check_alignment!
+      end
     else
       self.hiding_outputs = false
     end
   end
 
+  # Which side of the rule one graph's output falls, and say so in a line at
+  # debug: a user who set `namespace:` and expected laziness learns here why
+  # they didn't get it. True when the tree is Zeitwerk's to load.
+  def self.consider_output!(graph)
+    dir = autoload_path(graph.output)
+    return true if autoloaded_dirs.include?(dir)
+    # already hidden by an earlier pass, and an ignore can't be taken back
+    return false if ignored_dirs.include?(dir)
+
+    reason = misalignment(graph, dir)
+    subject, = describe_output(dir)
+    if reason
+      GraphWeaver::Internal::Log.log(:debug) do
+        "#{subject} is hidden from Zeitwerk and required at boot — #{reason}"
+      end
+      # here rather than back in ignore_output!, so the decision is recorded
+      # the moment it is made and the sweep doesn't reach it a second time
+      hide!(dir)
+      return false
+    end
+
+    autoloaded_dirs << dir
+    # types.rb requires its own directory — one file per type, in the order the
+    # runtime needs — so Zeitwerk never autoloads those files one at a time.
+    # Only eager loading walks them, and it would want a constant name for each
+    # that the generator's own inflection doesn't promise: HTTPHeaderInput
+    # writes httpheader_input.rb, which Zeitwerk reads as HttpheaderInput.
+    # Loading types.rb is what loads them, and types.rb is eager loaded.
+    Rails.autoloaders.each { |loader| loader.do_not_eager_load(File.join(dir, "types")) }
+    GraphWeaver::Internal::Log.log(:debug) do
+      "#{subject} is left to Zeitwerk — every module it generates is the constant Zeitwerk reads " \
+        "off the path, so it autoloads on first reference and reloads with the app"
+    end
+    true
+  end
+
+  # Why Zeitwerk would NOT name what this graph generates the way its files do
+  # — nil when it would, which is the aligned case. The first disagreement is
+  # the whole answer: one namespace settles every file, so the fix for one is
+  # the fix for all of them.
+  def self.misalignment(graph, dir)
+    main = Rails.autoloaders.main if Rails.respond_to?(:autoloaders) && Rails.autoloaders.respond_to?(:main)
+    # 2.6.2 is where cpath_expected_at arrives, and with it the only answer
+    # that can confirm this one at setup — without it nothing is left to
+    # Zeitwerk, which is what every app got before.
+    unless main.respond_to?(:cpath_expected_at)
+      return "no autoloader here answers cpath_expected_at (Zeitwerk 2.6.2 and up does)"
+    end
+
+    if ignored_by_app?(dir)
+      return "it is already hidden from autoloading — a GraphWeaver.generated_paths pattern reaches " \
+        "it, or the app ignored it itself"
+    end
+
+    namespace = expected_cpath(dir)
+    return "it is not under an autoload path, so nothing but this would load it" unless namespace
+    unless namespace == graph.namespace
+      return "Zeitwerk reads that directory as #{namespace}, and this graph's constants are " \
+        "#{graph.namespace || "top-level"} (namespace #{namespace.inspect} makes them agree)"
+    end
+
+    types = expected_cpath(File.join(dir, "types.rb"))
+    return "types.rb defines #{graph.types_module}, Zeitwerk expects #{types}" unless types == graph.types_module
+
+    first_mismatch(graph, dir)
+  end
+
+  # The first query module whose name isn't the one Zeitwerk reads off its
+  # file. Only reached once the namespace agrees, so what is left is a file
+  # name the app's inflector camelizes differently from the generator.
+  def self.first_mismatch(graph, dir)
+    GraphWeaver::Internal::Util.query_files(graph.queries).each do |query|
+      name, filename = graph.generated_names(query, File.read(query))
+      expected = expected_cpath(File.join(dir, filename))
+      next if expected == name
+
+      return "#{filename} defines #{name}, Zeitwerk expects #{expected}"
+    end
+    nil
+  end
+
+  # The constant Zeitwerk will expect at an absolute path, or nil when nothing
+  # will autoload it.
+  #
+  # Zeitwerk answers this itself, with cpath_expected_at — but only once Rails
+  # has pushed the main loader's roots, and Rails does that INSIDE
+  # :setup_main_autoloader, whose start is the deadline for `ignore`. So the
+  # roots here are the list Rails is about to push, and every constant name
+  # comes from the loader's own inflector, which an app's `inflect`/`acronym`
+  # is already on. check_alignment! re-asks Zeitwerk the moment it can answer.
+  def self.expected_cpath(path)
+    main = Rails.autoloaders.main
+    roots = autoload_roots
+    cnames = []
+    dir = path
+    if path.end_with?(".rb")
+      cnames << main.inflector.camelize(File.basename(path, ".rb"), path)
+      dir = File.dirname(path)
+    end
+    until roots.key?(dir)
+      parent = File.dirname(dir)
+      return if parent == dir || ignored_by_app?(dir)
+
+      cnames << main.inflector.camelize(File.basename(dir), dir)
+      dir = parent
+    end
+    return if ignored_by_app?(dir)
+
+    [roots[dir], *cnames.reverse].compact.join("::")
+  end
+
+  # Every directory the main autoloader will have as a root, and the name of
+  # the namespace each sits under (nil for Object): the paths Rails is about to
+  # push, plus any the app pushed itself — which is the only way a root gets a
+  # namespace, and the one thing Rails leaves alone when it pushes the rest.
+  def self.autoload_roots
+    roots = {}
+    if defined?(ActiveSupport::Dependencies) && ActiveSupport::Dependencies.respond_to?(:autoload_paths)
+      once = Rails.autoloaders.respond_to?(:once) ? Rails.autoloaders.once.dirs : []
+      ActiveSupport::Dependencies.autoload_paths.each do |path|
+        path = path.to_s
+        # through autoload_path, so a root and an output under it are spelled
+        # the same way — a symlinked checkout (Capistrano's current/) otherwise
+        # has the root as Rails wrote it and the output as realpath saw it
+        roots[autoload_path(path)] = nil unless once.include?(path)
+      end
+    end
+    Rails.autoloaders.main.dirs(namespaces: true).each do |dir, namespace|
+      roots[autoload_path(dir)] = (namespace == Object) ? nil : namespace.name
+    end
+    roots
+  end
+
+  # An app that hid the directory itself has a tree Zeitwerk will not load
+  # however it is named — so it is one to require at boot, exactly as before.
+  def self.ignored_by_app?(dir)
+    asked = IGNORES.find { |name| Rails.autoloaders.main.respond_to?(name) }
+    asked && Rails.autoloaders.main.public_send(asked, dir)
+  end
+
+  # The prediction above, against the one answer that is authoritative. A
+  # `collapse` between the autoload root and the output, or a root pushed under
+  # its own namespace after this railtie looked, changes the name — and neither
+  # is readable before setup. Left unsaid, that surfaces as Zeitwerk's own
+  # error on the first eager load in production.
+  def self.check_alignment!
+    main = Rails.autoloaders.main
+    Array(autoloaded_dirs).each do |dir|
+      # the top level only: types/ is excluded from eager loading, so what
+      # Zeitwerk reads off those files never comes up
+      Dir[File.join(dir, "*.rb")].sort.each do |file|
+        expected = main.cpath_expected_at(file)
+        # nil is "I don't see that file" — which is what Zeitwerk answers for a
+        # path spelled through a symlink its own roots aren't, so it is not an
+        # answer to compare against
+        next if expected.nil? || expected == expected_cpath(file)
+
+        subject, short = describe_output(dir)
+        raise GraphWeaver::Error,
+          "#{subject} was left to Zeitwerk because the constants it generates are the ones its path " \
+          "spells — but Zeitwerk reads #{GraphWeaver::Internal::Util.relative(file)} as " \
+          "#{expected.inspect}, not #{expected_cpath(file).inspect}. A `collapse`, or an autoload root " \
+          "pushed under its own namespace, over #{short} changes that name: move the output out from " \
+          "under it, or set namespace: to what Zeitwerk reads."
+      end
+    end
+  end
+
+  # Whether this generated directory is one Zeitwerk is loading — what
+  # Internal::Util.required_dirs asks, so the boot-time require skips it.
+  def self.left_to_zeitwerk?(path)
+    Array(autoloaded_dirs).include?(autoload_path(path))
+  end
+
   # 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
@@ -141,9 +334,17 @@ class GraphWeaver::Railtie < Rails::Railtie
   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)
+    # a graph saying where it writes is also the moment the rule can be applied
+    # to it: config/initializers is later than the sweep above, so this is
+    # where an app's second graph is first heard of
+    graph = GraphWeaver.graphs.find { |candidate| autoload_path(candidate.output) == autoload_path(path) }
+    return if graph && consider_output!(graph)
+
+    hidden_for(path).each { |dir| hide!(dir) }
+  end
+
+  # Hide one resolved directory, once.
+  def self.hide!(dir)
     return if ignored_dirs.include?(dir)
 
     check_autoload_once!([dir])
@@ -151,6 +352,25 @@ class GraphWeaver::Railtie < Rails::Railtie
     Rails.autoloaders.each { |loader| loader.ignore(dir) }
   end
 
+  # What hiding one generated path means. Normally the pattern itself —
+  # generated_paths may be globs, and Zeitwerk expands its own at setup, so a
+  # directory a pattern will match is hidden however late it appears; that is
+  # what the window stays open until. The exception is a pattern that also
+  # covers a tree Zeitwerk is keeping (app/graphql/*/generated matches a
+  # namespaced graph's own output), since a glob can't say "all but this one":
+  # then it is expanded here and the aligned directories left out.
+  def self.hidden_for(path)
+    dir = autoload_path(path)
+    kept = Array(autoloaded_dirs)
+    return [dir] if kept.empty?
+
+    expanded = Dir[GraphWeaver::Internal::Util.resolve(path)]
+      .select { |found| File.directory?(found) }.map { |found| autoload_path(found) }
+    return [dir] if (expanded & kept).empty?
+
+    expanded - kept
+  end
+
   # 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
@@ -211,7 +431,9 @@ class GraphWeaver::Railtie < Rails::Railtie
   def self.describe_output(dir)
     graph = GraphWeaver.graphs.find { autoload_path(_1.output) == dir }
     short = GraphWeaver::Internal::Util.relative(GraphWeaver::Internal::Util.resolve(graph&.output || dir))
-    ["#{graph ? "graph :#{graph.name}'s output" : "generated path"} #{short}", short]
+    # the default graph has no name to say, and "graph :'s output" is worse
+    # than the path on its own
+    ["#{graph&.name ? "graph #{graph.name.inspect}'s output" : "generated path"} #{short}", short]
   end
 
   # A graph declared from to_prepare — what the docs say to do when its block
@@ -219,16 +441,20 @@ class GraphWeaver::Railtie < Rails::Railtie
   # Zeitwerk reads its ignore list only then. So an output that arrives that
   # late can't be hidden: its files load as ordinary autoloads and raise on the
   # constant they don't define, in a Zeitwerk error that blames a dropped
-  # extend_type. Refuse, and name what actually happened.
+  # extend_type. Refuse, and name what actually happened — unless the tree is
+  # one Zeitwerk names correctly, which needed no hiding at any point and is as
+  # true declared late as declared early.
   def self.check_generated_ignored!
     # no autoloaders, no Zeitwerk, nothing to refuse
     return unless Rails.respond_to?(:autoloaders)
 
-    late = GraphWeaver::Internal::Util.generated_dirs.map { autoload_path(_1) } - Array(ignored_dirs)
+    late = GraphWeaver::Internal::Util.generated_dirs.map { autoload_path(_1) } -
+      Array(ignored_dirs) - Array(autoloaded_dirs)
     return if late.empty?
 
     late.each do |dir|
       next unless Rails.autoloaders.any? { |loader| autoloaded?(loader, dir) }
+      next if aligned_late?(dir)
 
       subject, short = describe_output(dir)
       raise GraphWeaver::Error,
@@ -239,6 +465,17 @@ class GraphWeaver::Railtie < Rails::Railtie
     end
   end
 
+  # A graph declared after setup, whose tree Zeitwerk already names correctly:
+  # nothing had to be hidden, so nothing was missed. Recorded on the way past,
+  # so the boot-time require skips it too.
+  def self.aligned_late?(dir)
+    graph = GraphWeaver.graphs.find { autoload_path(_1.output) == dir }
+    return false unless graph && misalignment(graph, dir).nil?
+
+    self.autoloaded_dirs = Array(autoloaded_dirs) | [dir]
+    true
+  end
+
   # The two auto-wires an app gets for free, and the only two it can turn off
   # by assigning nil.
   #
@@ -408,8 +645,10 @@ class GraphWeaver::Railtie < Rails::Railtie
     # 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|
+    # entries may be globs, so Dir[] rather than Dir.exist?. required_dirs, not
+    # generated_dirs: a tree left to Zeitwerk loads on first reference, and not
+    # requiring its whole parent chain here is the point of leaving it there.
+    generated = GraphWeaver::Internal::Util.required_dirs.any? do |dir|
       Dir[GraphWeaver::Internal::Util.resolve(dir)].any?
     end
     return unless generated
@@ -422,7 +661,7 @@ class GraphWeaver::Railtie < Rails::Railtie
     # 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)
+    if GraphWeaver.graphs.any? { |graph| graph.namespace && !left_to_zeitwerk?(graph.output) }
       GraphWeaver.reload_generated!
     else
       GraphWeaver.load_generated!

data/lib/graph_weaver/schema_loader.rb

@@ -49,6 +49,14 @@ module GraphWeaver::SchemaLoader
     source.match?(SDL_CONTENT)
   end
 
+  # Schema content rather than a path: introspection JSON, SDL, or anything
+  # spanning lines (which `load` refuses as content it doesn't recognize).
+  def self.content?(source)
+    source = source.to_path if source.respond_to?(:to_path)
+    source = source.to_s
+    source.lstrip.start_with?("{") || sdl_content?(source) || source.include?("\n")
+  end
+
   def self.load_path(path)
     case File.extname(path)
     when ".json"
@@ -56,13 +64,33 @@ module GraphWeaver::SchemaLoader
     when ".graphql", ".gql"
       build_sdl(read_schema(path))
     else
-      raise GraphWeaver::Error, url_error(path) ||
-        "unsupported schema format: #{truncate(path)} — expected a .json (introspection) or " \
-        ".graphql/.gql (SDL) path, or the content itself"
+      unsupported_path!(path)
     end
   end
   private_class_method :load_path
 
+  # Fail fast on a path `load` would refuse later — the extension and a
+  # stat, no read and no parse. A client defers building the schema to first
+  # use, so this is what still refuses at the line that named the file: a
+  # wrong path is known at boot, a malformed file at first use.
+  def self.check_path!(path)
+    path = path.to_path if path.respond_to?(:to_path)
+    unsupported_path!(path) unless dump_path?(path)
+
+    resolved = GraphWeaver::Internal::Util.resolve(path)
+    File.stat(resolved)
+    raise GraphWeaver::Error, "can't read the schema at #{path}: permission denied" unless File.readable?(resolved)
+  rescue SystemCallError => e
+    raise GraphWeaver::Error, "can't read the schema at #{path}: #{e.message}"
+  end
+
+  def self.unsupported_path!(path)
+    raise GraphWeaver::Error, url_error(path) ||
+      "unsupported schema format: #{truncate(path)} — expected a .json (introspection) or " \
+      ".graphql/.gql (SDL) path, or the content itself"
+  end
+  private_class_method :unsupported_path!
+
   def self.read_schema(path)
     File.read(GraphWeaver::Internal::Util.resolve(path))
   rescue SystemCallError => e
@@ -123,10 +151,23 @@ module GraphWeaver::SchemaLoader
     else sdl
     end
 
-    build(kind) { GraphQL::Schema.from_definition(prepared) }
+    build(kind) { build_schema(prepared) }
   end
   private_class_method :build_sdl
 
+  # A supergraph arrives here as the AST strip_federation filtered, anything
+  # else as SDL text. `from_definition` is parse-then-build, so an AST takes
+  # the build half directly — printing it back and parsing it again is a
+  # round trip through text that can only cost. spec/schema_loader_spec.rb
+  # pins the entry point, so a graphql-ruby that moves it fails there rather
+  # than as a NoMethodError inside someone's load.
+  def self.build_schema(prepared)
+    return GraphQL::Schema.from_definition(prepared) if prepared.is_a?(String)
+
+    GraphQL::Schema::BuildFromDefinition.from_document(GraphQL::Schema, prepared, default_resolve: nil)
+  end
+  private_class_method :build_schema
+
   def self.build_introspection(result)
     build(:introspection) { GraphQL::Schema.from_introspection(result) }.tap do |schema|
       restore_one_of!(schema, result)
@@ -519,9 +560,9 @@ module GraphWeaver::SchemaLoader
   # join__*/link__* type and directive definitions, and every @join__*/@link
   # application on the types that remain. What's left is the merged graph's
   # ordinary type shapes — exactly what codegen reads. Parsing is lenient (it's
-  # schema *building* that rejects the join directives), so we parse, filter the
-  # AST, and reprint clean SDL for from_definition — no graphql-ruby monkeypatch
-  # and no join__* leaking into schema.types.
+  # schema *building* that rejects the join directives), so we parse and filter
+  # the AST, and hand that document to the builder — no graphql-ruby
+  # monkeypatch and no join__* leaking into schema.types.
   def self.strip_federation(sdl)
     doc = GraphQL.parse(sdl)
     ns = link_namespaces(doc)
@@ -535,7 +576,7 @@ module GraphWeaver::SchemaLoader
         "is the whole schema behind @inaccessible?"
     end
 
-    GraphQL::Language::Nodes::Document.new(definitions: defs).to_query_string
+    GraphQL::Language::Nodes::Document.new(definitions: defs)
   end
   private_class_method :strip_federation
 
@@ -1259,10 +1300,18 @@ module GraphWeaver::SchemaLoader
 
     # A @key/@requires/@provides field set is a selection set. Flattened to
     # dotted paths, so a nested one is recognizable as nested by its shape.
+    # Memoized on the text: a supergraph repeats the same few spellings
+    # thousands of times ("id" on every entity), and each was a parse.
     def self.parse_field_set(text)
-      flatten(GraphQL.parse("{ #{text} }").definitions.first.selections, [])
+      FIELD_SETS.synchronize do
+        FIELD_SETS_BY_TEXT[text] ||= flatten(GraphQL.parse("{ #{text} }").definitions.first.selections, []).freeze
+      end
     end
 
+    FIELD_SETS = Mutex.new
+    FIELD_SETS_BY_TEXT = {}
+    private_constant :FIELD_SETS, :FIELD_SETS_BY_TEXT
+
     def self.flatten(selections, prefix)
       selections.flat_map do |node|
         unless node.is_a?(GraphQL::Language::Nodes::Field)

data/lib/graph_weaver/version.rb

@@ -1,3 +1,3 @@
 module GraphWeaver
-  VERSION = "0.7.6"
+  VERSION = "0.7.8"
 end

data/lib/graph_weaver.rb

@@ -219,9 +219,15 @@ module GraphWeaver
     # from where you put the files: set it globally, or pass types_module: per
     # generate!. A multi-schema layout names it in the same initializer that
     # sets its paths.
+    #
+    # Unset, the default is whichever name is free where the constants land:
+    # GraphQLTypes at the top level, where a bare ::Types would collide with
+    # graphql-ruby's own Types:: convention, and plain Types inside a graph's
+    # namespace, where it can't — which is what leaves types.rb a file Zeitwerk
+    # names correctly (see Graph#types_module).
     attr_writer :types_module
 
-    def types_module = @types_module || "GraphQLTypes"
+    def types_module(default = "GraphQLTypes") = @types_module || default
 
     # Declare a second schema — and a third, and the rest. Everything a graph
     # knows is said inside its block, in call style:
@@ -703,12 +709,13 @@ module GraphWeaver
     #
     #      GraphWeaver.load_generated!
     #
-    # In Rails, prefer this over autoloading: Zeitwerk would expect
-    # Generated::PersonQuery from generated/person_query.rb, and
-    # generated code only changes on regeneration anyway (restart, like
-    # a schema migration).
+    # In Rails this is automatic, and a tree Zeitwerk already names correctly
+    # is skipped: it autoloads on first reference (see the Railtie). Everything
+    # else is required — Zeitwerk would expect Generated::PersonQuery from
+    # generated/person_query.rb, and generated code only changes on
+    # regeneration anyway (restart, like a schema migration).
     def load_generated!(path = nil)
-      paths = path ? [path] : Internal::Util.generated_dirs
+      paths = path ? [path] : Internal::Util.required_dirs
       files = paths.flat_map { |dir| Dir[File.join(Internal::Util.resolve(dir), "**/*.rb")].sort }.uniq
       files.each do |file|
         require file
@@ -761,7 +768,9 @@ module GraphWeaver
     # whose query was just deleted keeps its old constant until restart —
     # nothing on disk says what it was called any more.
     def reload_generated!
-      names = graphs.flat_map do |graph|
+      # a graph Zeitwerk owns unloads and reloads itself; undefining its
+      # constants here would only take them out from under it
+      names = graphs.reject { |graph| Internal::Util.left_to_zeitwerk?(graph.output) }.flat_map do |graph|
         modules = Internal::Util.query_files(graph.queries).map do |path|
           graph.generated_names(path, File.read(path)).first
         end
@@ -769,7 +778,7 @@ module GraphWeaver
       end
       names.each { |name| undefine(name) }
 
-      Internal::Util.generated_dirs.each do |dir|
+      Internal::Util.required_dirs.each do |dir|
         Dir[File.join(Internal::Util.resolve(dir), "**/*.rb")].each do |file|
           # require stores the realpath; the path load_generated! passed is
           # the other one under a symlinked checkout

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graph_weaver
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.7.8
 platform: ruby
 authors:
 - Daniel Pepper
@@ -364,7 +364,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.6/CHANGELOG.md
+  changelog_uri: https://github.com/dpep/graph_weaver/blob/v0.7.8/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