graphiti 2.0.0.beta.10 → 2.0.0.beta.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1e331ab2dea47987ea47260eb0890c9a953d3435bba2e7ef37cbfbbc83fe5ab
-  data.tar.gz: 13a7483ead9f4ad5ed69390ff6a4a122a819813c2147c0a56dceebdfebc57e17
+  metadata.gz: a639e421891e5d5e650d2d8131a75905cb9ffd0fb40cdfd15239ca5caf29d12f
+  data.tar.gz: 95172bbff224d598c959d5acc93c30861e01c50540fdea871ea5029473bf5259
 SHA512:
-  metadata.gz: cca252389b52b5a2983407b4eff7cf7fe8b49759b478228f9d78303522bc40f2948a1784d6c863373f10521dc80b61d35f201009e830d8a968cc989b37d2ad81
-  data.tar.gz: 3fdfda722d09ddea6c366ca4102258bdea6d36c923be729ae141063e7e62b43ae0730f30a6422ae4448f858a5c1d4269f80180279d7939ce050c88008613cedb
+  metadata.gz: 24c275cfcaecdba9ced126b7970b37962998673a3a8609c885a69befc53adba646ec2c7d9517198509e358ebba5300f3b336c86f02df98af9d18a6f4a4c306c3
+  data.tar.gz: e7d2fd4e0d0ff74b68ea4d3673399d1b72897ad7c8647fa38835ff2b58c850d58ba95a1145a52f55893e88e36eb0aa90bece72a2e6e593173661d16100666edc

data/.github/workflows/release.yml

@@ -13,6 +13,8 @@ jobs:
         uses: actions/checkout@v5
         with:
           persist-credentials: false
+          # semantic-release reads the tag history to work out the next version
+          fetch-depth: 0
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:

data/.tool-versions

@@ -1 +1 @@
-ruby 3.3.4
+ruby 4.0.6

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 graphiti changelog
 
+# [2.0.0-beta.11](https://github.com/graphiti-api/graphiti/compare/v2.0.0-beta.10...v2.0.0-beta.11) (2026-08-27)
+
+
+### Bug Fixes
+
+* always render included when the client asked to include ([8691b3f](https://github.com/graphiti-api/graphiti/commit/8691b3fd08f3cae0481ba72839911fdc71ef5634))
+* autolink = true no longer clobbers an inherited :on_demand ([2d26f8c](https://github.com/graphiti-api/graphiti/commit/2d26f8cb567e82a16918345de9114b8ceef64523))
+* read the links param from the query, not the context object ([3b934cb](https://github.com/graphiti-api/graphiti/commit/3b934cb25be049e1e80ba400123da944cfd23d04))
+* stop assigning the same child twice when a resource repeats in the include path ([588503b](https://github.com/graphiti-api/graphiti/commit/588503b109508495d8170373d80019c6971f7d9c))
+
+
+### Features
+
+* omit relationships that render no ids and no link ([916aa8c](https://github.com/graphiti-api/graphiti/commit/916aa8c9c596c5d9b6c802c5ab13b766a13d1e70))
+
+
+### Performance Improvements
+
+* memoize whether a belongs_to renders ids from its foreign key ([dcb60b2](https://github.com/graphiti-api/graphiti/commit/dcb60b2096c414756ccff534773d2e45594f0144))
+* only deduplicate resources that two include paths can both reach ([744f014](https://github.com/graphiti-api/graphiti/commit/744f014249382bc25d5ea43f692778ad7adc25c3))
+* resolve a lone sideload inline rather than through the pool ([3415592](https://github.com/graphiti-api/graphiti/commit/3415592d75900389a8f11f53b65ab399e297e4a9))
+* reuse the resolved data and proxies when building cache keys ([8a17350](https://github.com/graphiti-api/graphiti/commit/8a17350542ba0062fdcddd115afe8041b62198c7))
+* skip the on-demand link strip when no relationship renders links on demand ([cf86a8c](https://github.com/graphiti-api/graphiti/commit/cf86a8c249077d9f9d5a13de49989d102bbaed04))
+
 # [2.0.0-beta.10](https://github.com/graphiti-api/graphiti/compare/v2.0.0-beta.9...v2.0.0-beta.10) (2026-08-24)
 
 

data/Rakefile

@@ -11,31 +11,36 @@ RSpec::Core::RakeTask.new(:spec) do |t|
   end
 end
 
+# Allocations mean the same anywhere and timings do not, so the history has a
+# reference CPU, named on every row, and recording timings refuses to mix them.
 namespace :performance do
   # Shelling out keeps a failure to the script's own message, with no rake backtrace on top.
   def measure(*arguments)
     exit(1) unless system("bundle", "exec", "ruby", "spec/performance/measure_releases.rb", *arguments)
   end
 
-  desc "Compare the working tree to the last release, and plot it"
-  task :current do
-    measure
+  desc "Read a change: measure the working tree, print the comparison and plot it"
+  task :read do
+    measure("--read")
   end
 
-  desc "Plot the release history plus the working tree to tmp/performance.html and open it"
-  task :page do
-    exit(1) unless system("bundle", "exec", "ruby", "spec/performance/chart_page.rb")
+  desc "Open the recorded history as a chart. Any machine, measures nothing"
+  task :chart do
+    exit(1) unless system("bundle", "exec", "ruby", "spec/performance/chart_page.rb", "--no-current")
   end
 
-  desc "Measure one release and record it (TAG=v2.0.0-beta.9)"
+  desc "Fill in the history. Missing releases by default, TAG=v2.0.0-beta.9 for one, ALL=1 for every. Reference CPU"
   task :record do
-    tag = ENV["TAG"] or abort "pass the release to record, e.g. rake performance:record TAG=v2.0.0-beta.9"
-    measure(tag)
+    measure(*(if ENV["TAG"]
+                [ENV["TAG"]]
+              else
+                ENV["ALL"] ? ["--all"] : ["--missing"]
+              end))
   end
 
-  desc "Re-record every release for this ruby, replacing its rows"
-  task :record_all do
-    measure("--all")
+  desc "Measure the working tree for the release to name, and commit it. Reference CPU"
+  task :pending do
+    measure("--pending")
   end
 end
 

data/lib/graphiti/adapters/abstract.rb

@@ -371,10 +371,11 @@ module Graphiti
           activerecord_adapter.associate \
             parent, child, association_name, association_type
         elsif [:has_many, :many_to_many].include?(association_type)
-          if parent.send(:"#{association_name}").nil?
+          associated = parent.send(:"#{association_name}")
+          if associated.nil?
             parent.send(:"#{association_name}=", [child])
-          else
-            parent.send(:"#{association_name}") << child
+          elsif associated.none? { |existing| existing.equal?(child) }
+            associated << child
           end
         else
           parent.send(:"#{association_name}=", child)

data/lib/graphiti/errors.rb

@@ -719,11 +719,11 @@ module Graphiti
 
       def message
         <<~MSG
-          #{@resource_class.name}: #{@attribute} must be one of :as_literal, :as_nil, or :reject. Got #{@value.inspect}.
+          #{@resource_class.name}: #{@attribute} must be one of :literal, :null, or :rejected. Got #{@value.inspect}.
 
-            :as_literal - "null" and "" reach the filter as strings (default)
-            :as_nil     - "null" becomes nil, so the filter can query for NULL
-            :reject     - a blank value raises InvalidFilterValue
+            :literal  - "null" and "" reach the filter as strings (default)
+            :null     - "null" becomes nil, so the filter can query for NULL
+            :rejected - a blank value raises InvalidFilterValue
         MSG
       end
     end

data/lib/graphiti/query.rb

@@ -39,10 +39,37 @@ module Graphiti
       @entity_map
     end
 
+    # Deduplication exists for a row two include paths both resolve, so a
+    # resource class sitting at one node has nothing to collide with.
+    def repeated_resource_classes
+      return root.repeated_resource_classes unless root == self
+
+      @repeated_resource_classes ||= begin
+        counts = Hash.new(0)
+        walk = [self]
+        while (query = walk.pop)
+          counts[query.resource.class] += 1
+          query.sideloads.each_pair do |name, sideload_query|
+            walk << sideload_query
+            sideload = query.resource.class.sideload(name)
+            next unless sideload.respond_to?(:children)
+
+            # A polymorphic child resolves under a class no node names.
+            sideload.children.each_value { |child| counts[child.resource.class] += 2 }
+          end
+        end
+        counts.select { |_, count| count > 1 }.keys.to_set
+      end
+    end
+
     def top_level?
       !association?
     end
 
+    def includes_requested?
+      @include_param.present?
+    end
+
     def links_requested?
       return @links_requested if defined?(@links_requested)
 

data/lib/graphiti/renderer.rb

@@ -13,8 +13,11 @@ module Graphiti
       @records ||= @proxy.data
     end
 
+    # JSON:API requires the key even when the include turns up nothing.
     def to_jsonapi
-      render(self.class.jsonapi_renderer).to_json
+      rendered = render(self.class.jsonapi_renderer)
+      rendered[:included] ||= [] if proxy.query.includes_requested?
+      rendered.to_json
     end
 
     def as_graphql

data/lib/graphiti/resource/configuration.rb

@@ -6,7 +6,7 @@ module Graphiti
       DEFAULT_MAX_PAGE_SIZE = 1_000
       LINK_MODES = [true, false, :on_demand].freeze
       BELONGS_TO_RESOURCE_IDS_MODES = [:foreign_key, :always, :never].freeze
-      BLANK_MODES = [:as_literal, :as_nil, :reject].freeze
+      BLANK_MODES = [:literal, :null, :rejected].freeze
 
       # Grouped for the ApplicationResource the install generator writes.
       SETTING_GROUPS = { # :nodoc:
@@ -21,6 +21,7 @@ module Graphiti
         relationships: {
           relationships_readable_by_default: {default: true},
           relationships_writable_by_default: {default: true},
+          relationship_placeholders: {default: false, note: "render placeholders for relationships with no ids and no link"},
           belongs_to_resource_ids_by_default: {
             default: :foreign_key,
             values: BELONGS_TO_RESOURCE_IDS_MODES,
@@ -28,10 +29,10 @@ module Graphiti
           }
         },
         filters: {
-          filters_blanks_by_default: {
-            default: :as_literal,
+          filter_blanks_treated_as: {
+            default: :literal,
             values: BLANK_MODES,
-            invalid: ->(klass, value) { Errors::InvalidFilterBlanks.new(klass, :filters_blanks_by_default, value) }
+            invalid: ->(klass, value) { Errors::InvalidFilterBlanks.new(klass, :filter_blanks_treated_as, value) }
           }
         },
         sorting: {
@@ -194,21 +195,21 @@ module Graphiti
       end
 
       class_methods do
-        # Deprecated. Both folded into filters_blanks_by_default. Remove in 3.0.
+        # Deprecated. Both folded into filter_blanks_treated_as. Remove in 3.0.
         def filters_accept_nil_by_default
-          filters_blanks_by_default == :as_nil
+          filter_blanks_treated_as == :null
         end
 
         def filters_accept_nil_by_default=(val)
-          self.filters_blanks_by_default = val ? :as_nil : :as_literal
+          self.filter_blanks_treated_as = val ? :null : :literal
         end
 
         def filters_deny_empty_by_default
-          filters_blanks_by_default == :reject
+          filter_blanks_treated_as == :rejected
         end
 
         def filters_deny_empty_by_default=(val)
-          self.filters_blanks_by_default = val ? :reject : :as_literal
+          self.filter_blanks_treated_as = val ? :rejected : :literal
         end
 
         # Deprecated. Renamed to the page_ family. Remove in 3.0.
@@ -416,7 +417,7 @@ module Graphiti
       end
     end
 
-    blanks_msg = "Use `self.filters_blanks_by_default` (:as_literal, :as_nil, or :reject)"
+    blanks_msg = "Use `self.filter_blanks_treated_as` (:literal, :null, or :rejected)"
     page_msg = "Use `self.page_default_size`, `self.page_max_size` and `self.page_cursors`"
     DEPRECATOR.deprecate_methods(Configuration::ClassMethods,
       filters_accept_nil_by_default: blanks_msg,

data/lib/graphiti/resource/dsl.rb

@@ -208,16 +208,16 @@ module Graphiti
 
         def blanks_for(name, opts)
           if opts.key?(:deny_empty)
-            DEPRECATOR.warn("The deny_empty: filter option is deprecated. Use blanks: :reject.")
-            return :reject if opts[:deny_empty]
+            DEPRECATOR.warn("The deny_empty: filter option is deprecated. Use blanks: :rejected.")
+            return :rejected if opts[:deny_empty]
           end
 
           if opts.key?(:allow_nil)
-            DEPRECATOR.warn("The allow_nil: filter option is deprecated. Use blanks: :as_nil.")
-            return opts[:allow_nil] ? :as_nil : :as_literal
+            DEPRECATOR.warn("The allow_nil: filter option is deprecated. Use blanks: :null.")
+            return opts[:allow_nil] ? :null : :literal
           end
 
-          blanks = opts.fetch(:blanks, filters_blanks_by_default)
+          blanks = opts.fetch(:blanks, filter_blanks_treated_as)
           unless Resource::BLANK_MODES.include?(blanks)
             raise Errors::InvalidFilterBlanks.new(self, name, blanks)
           end

data/lib/graphiti/resource/links.rb

@@ -39,7 +39,10 @@ module Graphiti
         relationship_links != false
       end
 
+      # true cannot express :on_demand, so it leaves an inherited on-demand mode alone.
       def autolink=(val)
+        return if val && relationship_links == :on_demand
+
         self.relationship_links = val ? true : false
       end
 

data/lib/graphiti/scope.rb

@@ -59,6 +59,9 @@ module Graphiti
       @query = query
       @opts = opts
 
+      @resolved_sideload_proxies = {}
+      @resolved_sideload_proxies_lock = Mutex.new
+
       @object = @resource.around_scoping(@object, @query.hash) { |scope|
         apply_scoping(scope, opts)
       }
@@ -67,7 +70,7 @@ module Graphiti
     def resolve(&blk)
       # The caller blocks on .value! either way, so concurrency only benefits parallel sideloads
       # See https://github.com/graphiti-api/graphiti/issues/505
-      if self.class.resolve_synchronously? || !applicable_sideloads?
+      if self.class.resolve_synchronously? || !overlapping_sideloads?
         sync_resolve(&blk)
       else
         future_resolve(&blk).value!
@@ -140,9 +143,6 @@ 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(&blk)
       return [] if @query.zero_results?
 
@@ -151,14 +151,15 @@ module Graphiti
       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 == []
 
-      each_applicable_sideload do |sideload, sideload_query|
+      reset_captured_sideload_proxies
+      each_applicable_sideload do |name, sideload, sideload_query|
         Graphiti.config.before_sideload&.call(Graphiti.context)
-        sideload.resolve(results, sideload_query, @resource)
+        sideload.sync_resolve(results, sideload_query, @resource) do |proxy|
+          capture_sideload_proxy(name, proxy)
+        end
       end
     end
 
@@ -176,7 +177,7 @@ module Graphiti
       assign_serializer(resolved)
       yield resolved if block_given?
       @opts[:after_resolve]&.call(resolved)
-      resolved
+      @resolved_records = resolved
     end
 
     # Must run before sideloads assign, so every include path populates the
@@ -198,6 +199,8 @@ module Graphiti
 
     # A customized sideload can load a record another path would not, so it keeps its own instances.
     def deduplicable?
+      return false unless @query.repeated_resource_classes.include?(@resource.class)
+
       sideload = @opts[:sideload]
       return true unless sideload
 
@@ -207,9 +210,15 @@ module Graphiti
         sideload.primary_key == :id
     end
 
-    # Nothing to post to the pool means the future would wrap work already done.
-    def applicable_sideloads?
-      each_applicable_sideload { return true }
+    # One sideload has nothing to run beside it, so the pool would hand the work
+    # to another thread and wait for it. A chain is one at every level. A
+    # polymorphic sideload counts as its children, which do run beside each other.
+    def overlapping_sideloads?
+      found = 0
+      each_applicable_sideload do |_, sideload, _|
+        found += sideload.respond_to?(:children) ? sideload.children.size : 1
+        return true if found > 1
+      end
       false
     end
 
@@ -218,18 +227,34 @@ module Graphiti
         sideload = @resource.class.sideload(name)
         next if sideload.nil? || sideload.shared_remote?
 
-        yield sideload, sideload_query
+        yield name, sideload, sideload_query
+      end
+    end
+
+    # The write path resolves sideloads twice on one scope, which would double every proxy in the cache key.
+    def reset_captured_sideload_proxies
+      @resolved_sideload_proxies_lock.synchronize { @resolved_sideload_proxies.clear }
+    end
+
+    # A proxy built while resolving is already resolved all the way down.
+    def capture_sideload_proxy(name, proxy)
+      @resolved_sideload_proxies_lock.synchronize do
+        captured = (@resolved_sideload_proxies[name] ||= [])
+        captured << proxy unless proxy.nil? || proxy == []
       end
     end
 
     def future_resolve_sideloads(results)
       return Concurrent::Promises.fulfilled_future(nil, self.class.global_thread_pool_executor) if results == []
 
+      reset_captured_sideload_proxies
       sideload_promises = []
-      each_applicable_sideload do |sideload, sideload_query|
+      each_applicable_sideload do |name, 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, future_query, parent_resource)
+          sideload.future_resolve(parent_results, future_query, parent_resource) do |proxy|
+            capture_sideload_proxy(name, proxy)
+          end
         end
         sideload_promises << promise.flat
       end
@@ -361,15 +386,19 @@ module Graphiti
 
     def sideload_resource_proxies
       @sideload_resource_proxies ||= begin
-        @object = @resource.before_resolve(@object, @query)
-        results = @resource.resolve(@object)
+        # Reached after the response resolved, where resolving again re-applies before_resolve to a mutated scope.
+        results = @resolved_records
+        if results.nil?
+          @object = @resource.before_resolve(@object, @query)
+          results = @resource.resolve(@object)
+        end
 
         [].tap do |proxies|
-          unless @query.sideloads.empty?
-            @query.sideloads.each_pair do |name, q|
-              sideload = @resource.class.sideload(name)
-              next if sideload.nil? || sideload.shared_remote?
-
+          each_applicable_sideload do |name, sideload, q|
+            captured = @resolved_sideload_proxies[name]
+            if captured
+              proxies.concat(captured)
+            else
               proxies << sideload.build_resource_proxy(results, q, parent_resource)
             end
           end

data/lib/graphiti/scoping/filter.rb

@@ -209,7 +209,7 @@ module Graphiti
     end
 
     def parse_string_null(filter, value)
-      return value unless filter[:blanks] == :as_nil
+      return value unless filter[:blanks] == :null
       return value.map { |item| (item == "null") ? nil : item } if value.is_a?(Array)
       return if value == "null"
 
@@ -217,7 +217,7 @@ module Graphiti
     end
 
     def check_blank_filters!(resource, filter, value)
-      return unless filter.values[0][:blanks] == :reject
+      return unless filter.values[0][:blanks] == :rejected
 
       if value.nil? || value.empty? || value == "null"
         raise Errors::InvalidFilterValue.new(resource, filter, "(empty)")

data/lib/graphiti/serializer.rb

@@ -1,7 +1,5 @@
 module Graphiti
   class Serializer < JSONAPI::Serializable::Resource
-    UNREQUESTED_LINKS = [false, nil, "false"].freeze
-
     include Graphiti::Extensions::BooleanAttribute
     include Graphiti::Extensions::ExtraAttribute
     include Graphiti::SerializableHash
@@ -26,6 +24,16 @@ module Graphiti
     self.relationship_condition_blocks ||= {}
     self.relationship_sideloads ||= {}
 
+    # Keyed on the sideloads hash itself, which is reassigned whenever a
+    # relationship is applied, so the answer is recomputed exactly then.
+    def self.on_demand_links?
+      sideloads = relationship_sideloads
+      return @on_demand_links.last if @on_demand_links&.first.equal?(sideloads)
+
+      @on_demand_links = [sideloads, sideloads.each_value.any? { |sideload| sideload.link_mode == :on_demand }]
+      @on_demand_links.last
+    end
+
     def self.inherited(klass)
       super
       klass.class_eval do
@@ -76,7 +84,7 @@ module Graphiti
 
     def as_jsonapi(kwargs = {})
       super(**kwargs).tap do |hash|
-        strip_relationships!(hash) if strip_relationships?
+        strip_relationships!(hash)
         add_links!(hash)
       end
     end
@@ -102,21 +110,29 @@ module Graphiti
       hash[:links] = @resource.links(@object) if @resource.links?
     end
 
-    # A relationship whose only content would be an unrequested on-demand link
-    # serializes as an empty stub, which JSON:API forbids.
+    # The meta: {included: false} stub is jsonapi-serializable's filler, not JSON:API.
     def strip_relationships!(hash)
+      placeholders = relationship_placeholders?
+      return if placeholders && !strip_on_demand_relationships?
+
       hash[:relationships]&.reject! do |name, payload|
         next false if payload.key?(:data) || payload.key?(:links)
+        next true unless placeholders
 
         self.class.relationship_sideloads[name]&.link_mode == :on_demand
       end
     end
 
-    def strip_relationships?
-      context = Graphiti.context[:object]
-      params = context.params if context.respond_to?(:params)
+    # A remote resource exposes a stand-in object rather than a Resource.
+    def relationship_placeholders?
+      resource_class = @resource.class
+      return Resource.relationship_placeholders unless resource_class.respond_to?(:relationship_placeholders)
+
+      resource_class.relationship_placeholders
+    end
 
-      UNREQUESTED_LINKS.include?(params && params[:links])
+    def strip_on_demand_relationships?
+      self.class.on_demand_links? && !@proxy&.query&.render_link?(:on_demand)
     end
   end
 end

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -107,18 +107,18 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
     end
   end
 
-  def resolve(parents, query, graph_parent)
+  def resolve(parents, query, graph_parent, &proxy_block)
     if ::Graphiti::Scope.resolve_synchronously?
-      sync_resolve(parents, query, graph_parent)
+      sync_resolve(parents, query, graph_parent, &proxy_block)
     else
-      future_resolve(parents, query, graph_parent).value!
+      future_resolve(parents, query, graph_parent, &proxy_block).value!
     end
   end
 
-  def future_resolve(parents, query, graph_parent)
+  def future_resolve(parents, query, graph_parent, &proxy_block)
     promises = []
     each_resolvable_group(parents, query) do |child, group, child_query|
-      promises << child.future_resolve(group, child_query, graph_parent)
+      promises << child.future_resolve(group, child_query, graph_parent, &proxy_block)
     end
     return promises.first if promises.one?
 
@@ -130,14 +130,14 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
       end
   end
 
-  private
-
-  def sync_resolve(parents, query, graph_parent)
+  def sync_resolve(parents, query, graph_parent, &proxy_block)
     each_resolvable_group(parents, query) do |child, group, child_query|
-      child.resolve(group, child_query, graph_parent)
+      child.sync_resolve(group, child_query, graph_parent, &proxy_block)
     end
   end
 
+  private
+
   # Group parents by their polymorphic type and yield each group's child
   # sideload alongside a query pruned to the sideloads that child supports.
   def each_resolvable_group(parents, query)

data/lib/graphiti/sideload.rb

@@ -152,8 +152,12 @@ module Graphiti
       !!@polymorphic_as
     end
 
+    # Every check behind the blocker is static sideload configuration, and this
+    # is asked once per rendered record per relationship.
     def resource_ids_from_foreign_key?
-      resource_ids_blocker.nil?
+      return @resource_ids_from_foreign_key unless @resource_ids_from_foreign_key.nil?
+
+      @resource_ids_from_foreign_key = resource_ids_blocker.nil?
     end
 
     def resource_ids_blocker
@@ -285,14 +289,20 @@ module Graphiti
       proxy
     end
 
-    def load(parents, query, graph_parent)
+    def load(parents, query, graph_parent, &proxy_block)
       if Scope.resolve_synchronously?
-        build_resource_proxy(parents, query, graph_parent).to_a
+        sync_load(parents, query, graph_parent, &proxy_block)
       else
-        future_load(parents, query, graph_parent).value!
+        future_load(parents, query, graph_parent, &proxy_block).value!
       end
     end
 
+    def sync_load(parents, query, graph_parent, &proxy_block)
+      proxy = build_resource_proxy(parents, query, graph_parent)
+      proxy_block&.call(proxy)
+      proxy.to_a
+    end
+
     # Override in subclass
     def infer_foreign_key
       model = parent_resource_class.model
@@ -340,15 +350,30 @@ module Graphiti
       children.replace(associated) if track_associated
     end
 
-    def resolve(parents, query, graph_parent)
+    def resolve(parents, query, graph_parent, &proxy_block)
       if Scope.resolve_synchronously?
-        sync_resolve(parents, query, graph_parent)
+        sync_resolve(parents, query, graph_parent, &proxy_block)
+      else
+        future_resolve(parents, query, graph_parent, &proxy_block).value!
+      end
+    end
+
+    # Called by a scope that already decided to stay inline, so it must not consult the pool again.
+    # A scope_proc builds a Scope rather than a proxy, and that nested scope decides for itself.
+    def sync_resolve(parents, query, graph_parent, &proxy_block)
+      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
-        future_resolve(parents, query, graph_parent).value!
+        sync_load(parents, query, graph_parent, &proxy_block)
       end
     end
 
-    def future_resolve(parents, query, graph_parent)
+    # A scope_proc builds a Scope rather than a proxy, and a Scope's cache key omits what a proxy's carries.
+    def future_resolve(parents, query, graph_parent, &proxy_block)
       assert_singular!(parents)
 
       if self.class.scope_proc
@@ -356,7 +381,7 @@ module Graphiti
           fire_assign(parents, sideload_results)
         end
       else
-        future_load(parents, query, graph_parent)
+        future_load(parents, query, graph_parent, &proxy_block)
       end
     end
 
@@ -420,21 +445,6 @@ module Graphiti
 
     private
 
-    # Synchronous counterpart to #future_resolve, used when concurrency is off.
-    # Resolves inline via the synchronous Scope#resolve / #load paths (no
-    # promises). See Scope#sync_resolve_sideloads.
-    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)
@@ -451,8 +461,9 @@ module Graphiti
         default_paginate: false
     end
 
-    def future_load(parents, query, graph_parent)
+    def future_load(parents, query, graph_parent, &proxy_block)
       proxy = build_resource_proxy(parents, query, graph_parent)
+      proxy_block&.call(proxy)
       proxy.respond_to?(:future_resolve_data) ? proxy.future_resolve_data : Concurrent::Promises.fulfilled_future(proxy)
     end
 

data/lib/graphiti/spec_helpers/matchers.rb

@@ -186,7 +186,7 @@ module Graphiti
       # @param [Symbol] type
       #
       # @example expect(subject).to filter_attribute(:name, :string)
-      # @example expect(subject).to filter_attribute(:name, :string).with_options(blanks: :as_nil)
+      # @example expect(subject).to filter_attribute(:name, :string).with_options(blanks: :null)
       # @example expect(subject).not_to filter_attribute(:name, :string)
       def filter_attribute(attribute, type)
         FilterAttributeMatcher.new(attribute, type)

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "2.0.0.beta.10"
+  VERSION = "2.0.0.beta.11"
 end

data/package.json

@@ -142,7 +142,7 @@
       [
         "@semantic-release/exec",
         {
-          "prepareCmd": "bundle exec ruby spec/performance/measure_releases.rb --pending v${nextRelease.version}"
+          "prepareCmd": "bundle exec ruby spec/performance/measure_releases.rb --promote v${nextRelease.version}"
         }
       ],
       [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta.10
+  version: 2.0.0.beta.11
 platform: ruby
 authors:
 - Lee Richmond