graphiti 1.12.0 → 1.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ffd673e5dc4ec50d5b5aeb01abcb192894c6451cd9bfd54eca081f76bdf1d49
-  data.tar.gz: 45ed5cf75d703bd9b573015cd7f798cdc8fe1d5606d198bbdbda09d8e9dd7383
+  metadata.gz: 96af714433c7faece37e74ab67dad245d5e03396ec391be80cec77622d231faf
+  data.tar.gz: 34ce7b027042cd3cda4cf656ba8d96a05908dc0edbe9104ee4fb3597c5970971
 SHA512:
-  metadata.gz: 1472ab72a4ba8982a06a99d4959460ddae1e350ac6f1ce579dbe694c9c2cac6901e46d74b61532895f248e29848361aa311f39320201cb94f002874d64b34386
-  data.tar.gz: 44d3d9fbb1f78c6ba6a1fe005dc19a9f64a7b15236075b224571d585754928352d032a5acccd7f6165695990ff5a66750868a13ebd87fec9d33e9446e599fb97
+  metadata.gz: 3d0c414812bbccef7567e2e8e48e6b6353582d7801aa71a893f368eb12c71906e1420a1f40dd6d18c8ad6e5d43e3585983340d409742303112dd2737810a26d1
+  data.tar.gz: 59774b04ced36164343ddb12a7f2aa2026d2981b0c9df1b6bb92f127abb856467403e64cf72ec15bfde012511f1fa5908bf38bbbecea1becc2527d61df346d72

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 graphiti changelog
 
+## [1.12.1](https://github.com/graphiti-api/graphiti/compare/v1.12.0...v1.12.1) (2026-07-29)
+
+
+### Performance Improvements
+
+* skip promise machinery when concurrency is disabled ([#510](https://github.com/graphiti-api/graphiti/issues/510)) ([b2e5f37](https://github.com/graphiti-api/graphiti/commit/b2e5f37428f7628b9fadd03823bd68552e125af0)), closes [#472](https://github.com/graphiti-api/graphiti/issues/472) [#497](https://github.com/graphiti-api/graphiti/issues/497) [#505](https://github.com/graphiti-api/graphiti/issues/505)
+
 # [1.12.0](https://github.com/graphiti-api/graphiti/compare/v1.11.1...v1.12.0) (2026-07-29)
 
 

data/lib/graphiti/scope.rb

@@ -42,11 +42,20 @@ module Graphiti
       }
     end
 
-    def resolve
+    def resolve(&blk)
+      # When concurrency is disabled, take a synchronous path that mirrors the
+      # pre-1.8 semantics. This avoids allocating Concurrent::Promises futures,
+      # 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!
     end
 
     def resolve_sideloads(results)
+      return sync_resolve_sideloads(results) unless Graphiti.config.concurrency
+
       future_resolve_sideloads(results).value!
     end
 
@@ -113,6 +122,43 @@ 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
+      return [] 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)
+      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|
+        sideload = @resource.class.sideload(name)
+        next if sideload.nil? || sideload.shared_remote?
+
+        Graphiti.config.before_sideload&.call(Graphiti.context)
+        sideload.resolve(results, q, @resource)
+      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 == []
 

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -108,7 +108,20 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
   end
 
   def resolve(parents, query, graph_parent)
-    future_resolve(parents, query, graph_parent).value!
+    return future_resolve(parents, query, graph_parent).value! if Graphiti.config.concurrency
+
+    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.resolve(group, duped, graph_parent)
+      else
+        err = ::Graphiti::Errors::PolymorphicSideloadChildNotFound
+        raise err.new(self, group_name)
+      end
+    end
   end
 
   def future_resolve(parents, query, graph_parent)

data/lib/graphiti/sideload.rb

@@ -240,6 +240,8 @@ 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!
     end
 
@@ -290,6 +292,33 @@ 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
+      else
+        load(parents, query, graph_parent)
+      end
+    end
+
     def future_resolve(parents, query, graph_parent)
       if single? && parents.length > 1
         raise Errors::SingularSideload.new(self, parents.length)

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.12.0"
+  VERSION = "1.12.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.12.0
+  version: 1.12.1
 platform: ruby
 authors:
 - Lee Richmond