graphiti 1.13.3 → 1.13.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f75003b9d958879d44777f39f94e8221224b3826d80a8fe6e420e510ea4dd163
-  data.tar.gz: 0d0dda07deaefcc5fdfc7c91f44b3b7677b82ed950770ddb08cf24d49ea5e10e
+  metadata.gz: 7f23c59b6750dc9a8dcaefaba6d6250a9deac2676c33b01930b0c715767b85a1
+  data.tar.gz: 2252b0e870042723a30af9844d6006d8587f14228d82bc3eafd36c4b72b2fc8c
 SHA512:
-  metadata.gz: 57117fb28dc6f0434c91b57e8b7960caeb5bdb33d2d2768009138ec66f10d7d057c472c696e07debeb4af149e5de4ddfcffb30741b473810d4b589a7ac4adc8e
-  data.tar.gz: 394c4e38acfc68b78c966ecf3cb7dbd73a5038a5163c8c72045e185eb02a9ed4f919c20ee2598b015cfc27f04b749d1fc7f5b306856befd13d006cb81d0a73af
+  metadata.gz: '0579733a14742e30623cb686c0ba0c925f34458501ee6a7b322da2a6aa0fe7a85a4ccc422bf969858ed5eae306e65f3c2fb4e554995db51b7437910bd46237b6'
+  data.tar.gz: aa3fcd0b1e671594e23bb006d126e55366633038b48c53332940f1ba5cfbf4782995cd4556867ad707bb9b13440d045208cc51b66d24b2bc070019d9eb9e108b

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 graphiti changelog
 
+## [1.13.4](https://github.com/graphiti-api/graphiti/compare/v1.13.3...v1.13.4) (2026-08-20)
+
+
+### Bug Fixes
+
+* resolve inline when already on a sideload pool thread ([2757dde](https://github.com/graphiti-api/graphiti/commit/2757ddee5728224540c7a3bfa33583fe71c64703))
+* scope debugger chunks to the request rather than the class ([be1d833](https://github.com/graphiti-api/graphiti/commit/be1d83346e4303eaa700c0cbda6b4c60ddf587e7))
+
 ## [1.13.3](https://github.com/graphiti-api/graphiti/compare/v1.13.2...v1.13.3) (2026-08-09)
 
 

data/lib/graphiti/debugger.rb

@@ -4,11 +4,22 @@
 module Graphiti
   class Debugger
     class << self
-      attr_accessor :enabled, :chunks, :debug_models, :preserve, :pry
+      attr_accessor :enabled, :debug_models, :preserve, :pry
     end
-    self.chunks = []
+
+    CHUNKS = :__graphiti_debugger_chunks
+    private_constant :CHUNKS
 
     class << self
+      # Pool threads inherit this through the thread-local copy Scope#future_with_context makes, so their chunks reach the right request.
+      def chunks
+        Thread.current[CHUNKS] ||= Concurrent::Array.new
+      end
+
+      def chunks=(value)
+        Thread.current[CHUNKS] = value
+      end
+
       def on_data(name, start, stop, id, payload)
         return [] unless enabled
 
@@ -179,14 +190,15 @@ module Graphiti
       end
 
       def graph_statements
-        @chunks.each do |chunk|
+        statements = chunks
+        statements.each do |chunk|
           if (parent = chunk[:parent])
-            relevant = chunks.find { |c| c[:resource] == parent }
+            relevant = statements.find { |c| c[:resource] == parent }
             relevant[:children].unshift(chunk) if relevant
           end
         end
-        @chunks.reject! { |c| !!c[:parent] }
-        @chunks
+        statements.reject! { |c| !!c[:parent] }
+        statements
       end
 
       def chunk_to_hash(chunk)

data/lib/graphiti/scope.rb

@@ -31,6 +31,28 @@ module Graphiti
       end
     end
 
+    POOL_THREAD = :__graphiti_pool_thread
+    private_constant :POOL_THREAD
+
+    # A pool thread that waits on the pool deadlocks, since the task it waits for cannot start until the waiting thread frees its slot.
+    def self.resolve_synchronously?
+      !Graphiti.config.concurrency || on_pool_thread?
+    end
+
+    # TODO: move to Fiber[] once the floor is Ruby 3.2
+    def self.on_pool_thread?
+      Thread.current[POOL_THREAD] == true
+    end
+
+    # Restores rather than clears because :caller_runs may have run the task on a request thread.
+    def self.marking_pool_thread
+      previous = Thread.current[POOL_THREAD]
+      Thread.current[POOL_THREAD] = true
+      yield
+    ensure
+      Thread.current[POOL_THREAD] = previous
+    end
+
     def initialize(object, resource, query, opts = {})
       @object = object
       @resource = resource
@@ -48,29 +70,25 @@ module Graphiti
       # Thread/Fiber storage snapshots, and Rails executor wrappers on every
       # request purely to drive a thread pool that is intentionally synchronous.
       # See https://github.com/graphiti-api/graphiti/issues/505
-      return sync_resolve(&blk) unless Graphiti.config.concurrency
-
-      future_resolve.value!
+      if self.class.resolve_synchronously?
+        sync_resolve(&blk)
+      else
+        future_resolve(&blk).value!
+      end
     end
 
     def resolve_sideloads(results)
-      return sync_resolve_sideloads(results) unless Graphiti.config.concurrency
-
-      future_resolve_sideloads(results).value!
+      if self.class.resolve_synchronously?
+        sync_resolve_sideloads(results)
+      else
+        future_resolve_sideloads(results).value!
+      end
     end
 
-    def future_resolve
+    def future_resolve(&blk)
       return Concurrent::Promises.fulfilled_future([], self.class.global_thread_pool_executor) if @query.zero_results?
 
-      resolved = broadcast_data { |payload|
-        @object = @resource.before_resolve(@object, @query)
-        payload[:results] = @resource.resolve(@object)
-        payload[:results]
-      }
-      resolved.compact!
-      assign_serializer(resolved)
-      yield resolved if block_given?
-      @opts[:after_resolve]&.call(resolved)
+      resolved = resolve_primary_data(&blk)
       sideloaded = @query.parents.any?
       close_adapter = Graphiti.config.concurrency && sideloaded
       if close_adapter
@@ -122,12 +140,29 @@ module Graphiti
 
     private
 
-    # Synchronous counterpart to #future_resolve, used when concurrency is off.
-    # Resolves the resource and its sideloads inline without any promise
-    # machinery. See #resolve.
-    def sync_resolve
+    def sync_resolve(&blk)
       return [] if @query.zero_results?
 
+      resolved = resolve_primary_data(&blk)
+      sync_resolve_sideloads(resolved)
+      resolved
+    end
+
+    def sync_resolve_sideloads(results)
+      return if results == []
+
+      each_applicable_sideload do |sideload, sideload_query|
+        Graphiti.config.before_sideload&.call(Graphiti.context)
+        sideload.resolve(results, sideload_query, @resource)
+      end
+
+      # resolve_sideloads is public, and without this it would return @query.sideloads itself, 
+      # where a delete would silently drop that sideload from the cache key.
+      nil
+    end
+
+    # Runs inline on the calling thread in both the sync and future paths.
+    def resolve_primary_data
       resolved = broadcast_data { |payload|
         @object = @resource.before_resolve(@object, @query)
         payload[:results] = @resource.resolve(@object)
@@ -137,40 +172,28 @@ module Graphiti
       assign_serializer(resolved)
       yield resolved if block_given?
       @opts[:after_resolve]&.call(resolved)
-      sync_resolve_sideloads(resolved) unless @query.sideloads.empty?
       resolved
     end
 
-    # Synchronous counterpart to #future_resolve_sideloads, used when
-    # concurrency is off. Resolves each sideload inline. See #resolve_sideloads.
-    def sync_resolve_sideloads(results)
-      return if results == []
-
-      @query.sideloads.each_pair do |name, q|
+    def each_applicable_sideload
+      @query.sideloads.each_pair do |name, sideload_query|
         sideload = @resource.class.sideload(name)
         next if sideload.nil? || sideload.shared_remote?
 
-        Graphiti.config.before_sideload&.call(Graphiti.context)
-        sideload.resolve(results, q, @resource)
+        yield sideload, sideload_query
       end
-
-      # Match pre-1.8 semantics: the non-concurrent resolve_sideloads returned
-      # nil (not the sideloads Hash). Callers don't rely on the return value.
-      nil
     end
 
     def future_resolve_sideloads(results)
       return Concurrent::Promises.fulfilled_future(nil, self.class.global_thread_pool_executor) if results == []
 
-      sideload_promises = @query.sideloads.filter_map do |name, q|
-        sideload = @resource.class.sideload(name)
-        next if sideload.nil? || sideload.shared_remote?
-
-        p = future_with_context(results, q, @resource) do |parent_results, sideload_query, parent_resource|
+      sideload_promises = []
+      each_applicable_sideload do |sideload, sideload_query|
+        promise = future_with_context(results, sideload_query, @resource) do |parent_results, future_query, parent_resource|
           Graphiti.config.before_sideload&.call(Graphiti.context)
-          sideload.future_resolve(parent_results, sideload_query, parent_resource)
+          sideload.future_resolve(parent_results, future_query, parent_resource)
         end
-        p.flat
+        sideload_promises << promise.flat
       end
 
       Concurrent::Promises.zip_futures_on(self.class.global_thread_pool_executor, *sideload_promises)
@@ -181,7 +204,10 @@ module Graphiti
     end
 
     def future_with_context(*args)
+      # TODO: we only need Fiber.storage after Ruby 3.2 is the floor
       thread_storage = Thread.current.keys.each_with_object({}) do |key, memo|
+        next if key == POOL_THREAD
+
         memo[key] = Thread.current[key]
       end
       fiber_storage =
@@ -194,11 +220,13 @@ module Graphiti
       Concurrent::Promises.future_on(
         self.class.global_thread_pool_executor, Thread.current.object_id, thread_storage, fiber_storage, *args
       ) do |thread_id, thread_storage, fiber_storage, *args|
-        wrap_in_rails_executor do
-          with_thread_locals(thread_storage) do
-            with_fiber_locals(fiber_storage) do
-              Graphiti.broadcast(:global_thread_pool_task_run, self.class.global_thread_pool_stats) do
-                yield(*args)
+        self.class.marking_pool_thread do
+          wrap_in_rails_executor do
+            with_thread_locals(thread_storage) do
+              with_fiber_locals(fiber_storage) do
+                Graphiti.broadcast(:global_thread_pool_task_run, self.class.global_thread_pool_stats) do
+                  yield(*args)
+                end
               end
             end
           end

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -108,40 +108,42 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
   end
 
   def resolve(parents, query, graph_parent)
-    return future_resolve(parents, query, graph_parent).value! if Graphiti.config.concurrency
+    if ::Graphiti::Scope.resolve_synchronously?
+      sync_resolve(parents, query, graph_parent)
+    else
+      future_resolve(parents, query, graph_parent).value!
+    end
+  end
 
-    parents.group_by(&grouper.field_name).each_pair do |group_name, group|
-      next if group_name.nil? || grouper.ignore?(group_name)
+  def future_resolve(parents, query, graph_parent)
+    promises = []
+    each_resolvable_group(parents, query) do |child, group, child_query|
+      promises << child.future_resolve(group, child_query, graph_parent)
+    end
+    Concurrent::Promises.zip(*promises)
+  end
 
-      match = ->(c) { c.group_name == group_name.to_sym }
-      if (sideload = children.values.find(&match))
-        duped = remove_invalid_sideloads(sideload.resource, query)
-        sideload.resolve(group, duped, graph_parent)
-      else
-        err = ::Graphiti::Errors::PolymorphicSideloadChildNotFound
-        raise err.new(self, group_name)
-      end
+  private
+
+  def sync_resolve(parents, query, graph_parent)
+    each_resolvable_group(parents, query) do |child, group, child_query|
+      child.resolve(group, child_query, graph_parent)
     end
   end
 
-  def future_resolve(parents, query, graph_parent)
-    promises = parents.group_by(&grouper.field_name).filter_map do |(group_name, group)|
+  def each_resolvable_group(parents, query)
+    parents.group_by(&grouper.field_name).each_pair do |group_name, group|
       next if group_name.nil? || grouper.ignore?(group_name)
 
-      match = ->(c) { c.group_name == group_name.to_sym }
-      if (sideload = children.values.find(&match))
-        duped = remove_invalid_sideloads(sideload.resource, query)
-        sideload.future_resolve(group, duped, graph_parent)
-      else
-        err = ::Graphiti::Errors::PolymorphicSideloadChildNotFound
-        raise err.new(self, group_name)
+      child = children.values.find { |candidate| candidate.group_name == group_name.to_sym }
+      unless child
+        raise ::Graphiti::Errors::PolymorphicSideloadChildNotFound.new(self, group_name)
       end
+
+      yield child, group, remove_invalid_sideloads(child.resource, query)
     end
-    Concurrent::Promises.zip(*promises)
   end
 
-  private
-
   # We may be requesting a relationship that some subclasses support,
   # but not others. Remove anything we don't support.
   # TODO: spec to ensure this dupe logic doesn't mutate the original

data/lib/graphiti/sideload.rb

@@ -240,9 +240,11 @@ module Graphiti
     end
 
     def load(parents, query, graph_parent)
-      return build_resource_proxy(parents, query, graph_parent).to_a unless Graphiti.config.concurrency
-
-      future_load(parents, query, graph_parent).value!
+      if Scope.resolve_synchronously?
+        build_resource_proxy(parents, query, graph_parent).to_a
+      else
+        future_load(parents, query, graph_parent).value!
+      end
     end
 
     # Override in subclass
@@ -292,48 +294,19 @@ module Graphiti
       children.replace(associated) if track_associated
     end
 
-    # Synchronous counterpart to #future_resolve, used when concurrency is off.
-    # Mirrors #future_resolve but resolves inline via the synchronous
-    # Scope#resolve / #load paths (no promises). See Scope#sync_resolve_sideloads.
     def resolve(parents, query, graph_parent)
-      return future_resolve(parents, query, graph_parent).value! if Graphiti.config.concurrency
-
-      if single? && parents.length > 1
-        raise Errors::SingularSideload.new(self, parents.length)
-      end
-
-      if self.class.scope_proc
-        sideload_scope = fire_scope(parents)
-        sideload_scope = Scope.new sideload_scope,
-          resource,
-          query,
-          parent: graph_parent,
-          sideload: self,
-          sideload_parent_length: parents.length,
-          default_paginate: false
-        sideload_scope.resolve do |sideload_results|
-          fire_assign(parents, sideload_results)
-        end
+      if Scope.resolve_synchronously?
+        sync_resolve(parents, query, graph_parent)
       else
-        load(parents, query, graph_parent)
+        future_resolve(parents, query, graph_parent).value!
       end
     end
 
     def future_resolve(parents, query, graph_parent)
-      if single? && parents.length > 1
-        raise Errors::SingularSideload.new(self, parents.length)
-      end
+      assert_singular!(parents)
 
       if self.class.scope_proc
-        sideload_scope = fire_scope(parents)
-        sideload_scope = Scope.new sideload_scope,
-          resource,
-          query,
-          parent: graph_parent,
-          sideload: self,
-          sideload_parent_length: parents.length,
-          default_paginate: false
-        sideload_scope.future_resolve do |sideload_results|
+        build_sideload_scope(parents, query, graph_parent).future_resolve do |sideload_results|
           fire_assign(parents, sideload_results)
         end
       else
@@ -401,6 +374,34 @@ module Graphiti
 
     private
 
+    def sync_resolve(parents, query, graph_parent)
+      assert_singular!(parents)
+
+      if self.class.scope_proc
+        build_sideload_scope(parents, query, graph_parent).resolve do |sideload_results|
+          fire_assign(parents, sideload_results)
+        end
+      else
+        load(parents, query, graph_parent)
+      end
+    end
+
+    def assert_singular!(parents)
+      if single? && parents.length > 1
+        raise Errors::SingularSideload.new(self, parents.length)
+      end
+    end
+
+    def build_sideload_scope(parents, query, graph_parent)
+      Scope.new fire_scope(parents),
+        resource,
+        query,
+        parent: graph_parent,
+        sideload: self,
+        sideload_parent_length: parents.length,
+        default_paginate: false
+    end
+
     def future_load(parents, query, graph_parent)
       proxy = build_resource_proxy(parents, query, graph_parent)
       proxy.respond_to?(:future_resolve_data) ? proxy.future_resolve_data : Concurrent::Promises.fulfilled_future(proxy)

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.13.3"
+  VERSION = "1.13.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.13.3
+  version: 1.13.4
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-09 00:00:00.000000000 Z
+date: 2026-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable