graphiti 2.0.0.beta.8 → 2.0.0.beta.10

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
@@ -43,24 +65,24 @@ module Graphiti
     end
 
     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.
+      # The caller blocks on .value! either way, so concurrency only benefits parallel sideloads
       # See https://github.com/graphiti-api/graphiti/issues/505
-      if Graphiti.config.concurrency
-        future_resolve(&blk).value!
-      else
+      if self.class.resolve_synchronously? || !applicable_sideloads?
         sync_resolve(&blk)
+      else
+        future_resolve(&blk).value!
       end
     end
 
     def resolve_sideloads(results)
-      if Graphiti.config.concurrency
-        future_resolve_sideloads(results).value!
-      else
+      if self.class.resolve_synchronously?
         sync_resolve_sideloads(results)
+      else
+        future_resolve_sideloads(results).value!
       end
+
+      # Never return the sideloads hash, a caller mutating it would mess up the cache key
+      nil
     end
 
     def future_resolve(&blk)
@@ -138,10 +160,6 @@ module Graphiti
         Graphiti.config.before_sideload&.call(Graphiti.context)
         sideload.resolve(results, sideload_query, @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
 
     # Resolve this scope's own data: run hooks, resolve the resource, and
@@ -165,14 +183,36 @@ module Graphiti
     # canonical instance. The resource class in the key keeps two resources
     # serving the same model from sharing an instance and a serializer.
     def deduplicate_entities!(resolved)
+      return unless deduplicable?
+
+      # Nested maps are built once, a composite key meant a new array for every record
+      by_model = @query.entity_map.compute_if_absent(@resource.class) { Concurrent::Map.new }
+
       resolved.map! do |record|
         next record unless record.respond_to?(:id) && !record.id.nil?
 
-        key = [@resource.class, record.class, record.id]
-        @query.entity_map.compute_if_absent(key) { record }
+        by_id = by_model.compute_if_absent(record.class) { Concurrent::Map.new }
+        by_id.compute_if_absent(record.id) { record }
       end
     end
 
+    # A customized sideload can load a record another path would not, so it keeps its own instances.
+    def deduplicable?
+      sideload = @opts[:sideload]
+      return true unless sideload
+
+      sideload.scope_proc.nil? &&
+        sideload.params_proc.nil? &&
+        !sideload.customized_base_scope? &&
+        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 }
+      false
+    end
+
     def each_applicable_sideload
       @query.sideloads.each_pair do |name, sideload_query|
         sideload = @resource.class.sideload(name)
@@ -194,6 +234,8 @@ module Graphiti
         sideload_promises << promise.flat
       end
 
+      return sideload_promises.first if sideload_promises.one?
+
       Concurrent::Promises.zip_futures_on(self.class.global_thread_pool_executor, *sideload_promises)
         .rescue_on(self.class.global_thread_pool_executor) do |*reasons|
           first_error = reasons.find { |r| r.is_a?(Exception) }
@@ -202,7 +244,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 =
@@ -212,14 +257,22 @@ module Graphiti
           end
         end
 
+      current_attributes = current_attributes_snapshot
+
       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.global_thread_pool_executor, Thread.current.object_id, thread_storage, fiber_storage, current_attributes, *args
+      ) do |thread_id, thread_storage, fiber_storage, current_attributes, *args|
+        self.class.marking_pool_thread do
+          wrap_in_rails_executor do
+            with_thread_locals(thread_storage) do
+              with_fiber_locals(fiber_storage) do
+                with_current_attributes(current_attributes) do
+                  with_connection_pool_hint do
+                    Graphiti.broadcast(:global_thread_pool_task_run, self.class.global_thread_pool_stats) do
+                      yield(*args)
+                    end
+                  end
+                end
               end
             end
           end
@@ -227,6 +280,45 @@ module Graphiti
       end
     end
 
+    def current_attributes_snapshot
+      return unless defined?(ActiveSupport::CurrentAttributes)
+
+      snapshot = {}
+      klasses = ActiveSupport::CurrentAttributes.subclasses
+      while (klass = klasses.shift)
+        klasses.concat(klass.subclasses)
+        attributes = klass.attributes
+        snapshot[klass] = attributes.dup if attributes.any?
+      end
+      snapshot
+    end
+
+    # Restored inside the Rails executor, whose entry hands the pool thread a
+    # fresh Current. Restoring through set scopes the values to the block.
+    def with_current_attributes(snapshot, &block)
+      return yield if snapshot.nil? || snapshot.empty?
+
+      klass, attributes = snapshot.first
+      rest = snapshot.except(klass)
+      klass.set(attributes) { with_current_attributes(rest, &block) }
+    end
+
+    # A timeout inside a sideload task nearly always means database.yml's pool
+    # was not sized for the sideload threads, and the bare error does not say so.
+    def with_connection_pool_hint
+      yield
+    rescue => error
+      raise unless defined?(ActiveRecord::ConnectionTimeoutError) && error.is_a?(ActiveRecord::ConnectionTimeoutError)
+
+      hinted = error.exception(<<~MSG.strip)
+        #{error.message}
+
+        Raised while resolving a sideload concurrently. Each concurrent sideload holds its own database connection, so `pool` in database.yml must be at least web threads + concurrency_max_threads (#{Graphiti.config.concurrency_max_threads}) + 1. See graphiti.dev/concepts/resources#concurrency-pool-sizing.
+      MSG
+      hinted.set_backtrace(error.backtrace)
+      raise hinted
+    end
+
     def with_thread_locals(thread_locals)
       new_thread_locals = []
       thread_locals.each do |key, value|

data/lib/graphiti/scoping/filter.rb

@@ -62,7 +62,7 @@ module Graphiti
             value = parse_string_value(filter.values[0], value)
           end
 
-          check_deny_empty_filters!(resource, filter, value)
+          check_blank_filters!(resource, filter, value)
           value = parse_string_null(filter.values[0], value)
           validate_singular(resource, filter, value)
           value = coerce_types(filter.values[0], param_name.to_sym, value)
@@ -209,15 +209,15 @@ module Graphiti
     end
 
     def parse_string_null(filter, value)
-      return value unless filter[:allow_nil]
+      return value unless filter[:blanks] == :as_nil
       return value.map { |item| (item == "null") ? nil : item } if value.is_a?(Array)
       return if value == "null"
 
       value
     end
 
-    def check_deny_empty_filters!(resource, filter, value)
-      return unless filter.values[0][:deny_empty]
+    def check_blank_filters!(resource, filter, value)
+      return unless filter.values[0][:blanks] == :reject
 
       if value.nil? || value.empty? || value == "null"
         raise Errors::InvalidFilterValue.new(resource, filter, "(empty)")

data/lib/graphiti/scoping/paginate.rb

@@ -4,9 +4,9 @@ module Graphiti
     PARAMS = [:number, :size, :offset, :before, :after]
 
     def apply
-      if size > resource.max_page_size
+      if size > resource.page_max_size
         raise Graphiti::Errors::UnsupportedPageSize
-          .new(size, resource.max_page_size)
+          .new(size, resource.page_max_size)
       elsif requested? && @opts[:sideload_parent_length].to_i > 1
         raise Graphiti::Errors::UnsupportedPagination
       else
@@ -100,7 +100,7 @@ module Graphiti
     end
 
     def size
-      (page_param[:size] || resource.default_page_size || DEFAULT_PAGE_SIZE).to_i
+      (page_param[:size] || resource.page_default_size || DEFAULT_PAGE_SIZE).to_i
     end
   end
 end

data/lib/graphiti/serializer.rb

@@ -1,5 +1,7 @@
 module Graphiti
   class Serializer < JSONAPI::Serializable::Resource
+    UNREQUESTED_LINKS = [false, nil, "false"].freeze
+
     include Graphiti::Extensions::BooleanAttribute
     include Graphiti::Extensions::ExtraAttribute
     include Graphiti::SerializableHash
@@ -59,7 +61,7 @@ module Graphiti
       starting_offset = 0
       page_param = @proxy.query.pagination
       if (page_number = page_param[:number])
-        page_size = page_param[:size] || @resource.default_page_size
+        page_size = page_param[:size] || @resource.page_default_size
         starting_offset = (page_number - 1) * page_size
       end
 
@@ -100,17 +102,21 @@ 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.
     def strip_relationships!(hash)
-      hash[:relationships]&.select! do |name, payload|
-        payload.key?(:data)
+      hash[:relationships]&.reject! do |name, payload|
+        next false if payload.key?(:data) || payload.key?(:links)
+
+        self.class.relationship_sideloads[name]&.link_mode == :on_demand
       end
     end
 
     def strip_relationships?
-      return false unless Graphiti.config.links_on_demand
-      params = Graphiti.context[:object]&.params || {}
+      context = Graphiti.context[:object]
+      params = context.params if context.respond_to?(:params)
 
-      [false, nil, "false"].include?(params[:links])
+      UNREQUESTED_LINKS.include?(params && params[:links])
     end
   end
 end

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -108,10 +108,10 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
   end
 
   def resolve(parents, query, graph_parent)
-    if Graphiti.config.concurrency
-      future_resolve(parents, query, graph_parent).value!
-    else
+    if ::Graphiti::Scope.resolve_synchronously?
       sync_resolve(parents, query, graph_parent)
+    else
+      future_resolve(parents, query, graph_parent).value!
     end
   end
 
@@ -120,7 +120,14 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
     each_resolvable_group(parents, query) do |child, group, child_query|
       promises << child.future_resolve(group, child_query, graph_parent)
     end
-    Concurrent::Promises.zip(*promises)
+    return promises.first if promises.one?
+
+    executor = ::Graphiti::Scope.global_thread_pool_executor
+    Concurrent::Promises.zip_futures_on(executor, *promises)
+      .rescue_on(executor) do |*reasons|
+        first_error = reasons.find { |reason| reason.is_a?(Exception) }
+        raise first_error
+      end
   end
 
   private

data/lib/graphiti/sideload.rb

@@ -31,6 +31,9 @@ module Graphiti
       @writable = opts[:writable]
       @as = opts[:as]
       @link = opts[:link]
+      unless @link.nil? || Resource::LINK_MODES.include?(@link)
+        raise Errors::InvalidLinkRendering.new(@parent_resource_class, :"#{name} link", @link)
+      end
       @single = opts[:single]
       @remote = opts[:remote]
       apply_belongs_to_many_filter if type == :many_to_many
@@ -84,7 +87,8 @@ module Graphiti
         self.adapter = Graphiti::Adapters::GraphitiAPI
         self.model = OpenStruct
         self.remote = remote_url
-        self.validate_endpoints = false
+        self.validate_requests = false
+        self.validate_links = false
       }
       name = "#{parent_resource_class.name}.#{@name}.remote"
       klass.class_eval("def self.name;'#{name}';end", __FILE__, __LINE__)
@@ -166,14 +170,16 @@ module Graphiti
       false
     end
 
-    def link?
-      return true if link_proc
+    # A custom link block means the author wants the link, so a false default does not silence it.
+    def link_mode
+      return @link unless @link.nil?
 
-      if @link.nil?
-        !!@parent_resource_class.autolink
-      else
-        !!@link
-      end
+      default = @parent_resource_class.relationship_links
+      (link_proc && default == false) ? true : default
+    end
+
+    def link?
+      link_mode != false
     end
 
     def link_filter(parents)
@@ -280,9 +286,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
@@ -333,10 +341,10 @@ module Graphiti
     end
 
     def resolve(parents, query, graph_parent)
-      if Graphiti.config.concurrency
-        future_resolve(parents, query, graph_parent).value!
-      else
+      if Scope.resolve_synchronously?
         sync_resolve(parents, query, graph_parent)
+      else
+        future_resolve(parents, query, graph_parent).value!
       end
     end
 

data/lib/graphiti/spec_helpers/matchers.rb

@@ -140,7 +140,7 @@ module Graphiti
       end
 
       class FilterAttributeMatcher < ResourceDSLMatcher
-        GRAPHITI_OPTS = %i[allow deny single required allow_nil deny_empty].freeze
+        GRAPHITI_OPTS = %i[allow deny single required blanks].freeze
         GRAPHITI_CONFIG_KEY = :filters
         EXPECTED_ACTION = "filter"
       end
@@ -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(allow_nil: false)
+      # @example expect(subject).to filter_attribute(:name, :string).with_options(blanks: :as_nil)
       # @example expect(subject).not_to filter_attribute(:name, :string)
       def filter_attribute(attribute, type)
         FilterAttributeMatcher.new(attribute, type)

data/lib/graphiti/spec_helpers/rspec.rb

@@ -39,14 +39,17 @@ resource_testing = proc do
   let(:params) { {} }
 
   around do |e|
-    original = Graphiti::Resource.validate_endpoints
-    Graphiti::Resource.validate_endpoints = false
+    original_requests = Graphiti::Resource.validate_requests
+    original_links = Graphiti::Resource.validate_links
+    Graphiti::Resource.validate_requests = false
+    Graphiti::Resource.validate_links = false
 
     Graphiti.with_context graphiti_context do
       e.run
     end
   ensure
-    Graphiti::Resource.validate_endpoints = original
+    Graphiti::Resource.validate_requests = original_requests
+    Graphiti::Resource.validate_links = original_links
   end
 
   def graphiti_context

data/lib/graphiti/util/link.rb

@@ -47,7 +47,7 @@ module Graphiti
       end
 
       def on_demand_links(url)
-        return url unless Graphiti.config.links_on_demand
+        return url unless @sideload.resource.relationship_links == :on_demand
         return unless url
 
         url << if url.include?("?")

data/lib/graphiti/util/serializer_attributes.rb

@@ -30,7 +30,7 @@ module Graphiti
         @serializer.send(:"#{applied_method}=", [@name] | existing)
 
         @serializer.meta do
-          if !!@resource.try(:cursor_paginatable?) && !Graphiti.context[:graphql]
+          if !!@resource.try(:page_cursors?) && !Graphiti.context[:graphql]
             {cursor: cursor}
           end
         end
@@ -121,10 +121,11 @@ module Graphiti
 
       def default_proc
         name_ref = @name
+        resource_ref = @resource
         typecast_ref = typecast(Graphiti::Types[@attr[:type]][:read])
         ->(_) {
           val = @object.send(name_ref)
-          if Graphiti.config.typecast_reads
+          if resource_ref.typecast_reads
             typecast_ref.call(val)
           else
             val
@@ -133,10 +134,11 @@ module Graphiti
       end
 
       def wrap_proc(inner)
+        resource_ref = @resource
         typecast_ref = typecast(Graphiti::Types[@attr[:type]][:read])
         ->(serializer_instance = nil) {
           val = serializer_instance.instance_eval(&inner)
-          if Graphiti.config.typecast_reads
+          if resource_ref.typecast_reads
             typecast_ref.call(val)
           else
             val

data/lib/graphiti/util/serializer_relationships.rb

@@ -8,6 +8,8 @@ module Graphiti
       end
 
       def apply
+        return unless @serializer
+
         @sideloads.each_pair do |name, sideload|
           if apply?(sideload)
             SerializerRelationship
@@ -55,8 +57,8 @@ module Graphiti
       private
 
       def block
-        link_ref = link?
         sideload_ref = @sideload
+        resource_class_ref = @resource_class
         data_proc_ref = data_proc
         self_ref = self
         validate_link! if eagerly_validate_links?
@@ -71,7 +73,15 @@ module Graphiti
           if sideload_ref.resource_ids_from_foreign_key? &&
               !self_ref.send(:included_anywhere?, @proxy.query.include_hash, sideload_ref.name)
             linkage always: sideload_ref.render_resource_ids? do
-              foreign_key = @object.public_send(sideload_ref.foreign_key)
+              foreign_key = begin
+                @object.public_send(sideload_ref.foreign_key)
+              rescue NoMethodError => error
+                raise unless defined?(ActiveModel::MissingAttributeError) &&
+                  error.is_a?(ActiveModel::MissingAttributeError)
+
+                raise Errors::UnselectedForeignKey
+                  .new(resource_class_ref, sideload_ref, @object)
+              end
 
               unless foreign_key.nil?
                 {
@@ -84,13 +94,11 @@ module Graphiti
             linkage always: sideload_ref.render_resource_ids?
           end
 
-          if link_ref
-            if @proxy.query.links?
-              self_ref.send(:validate_link!) unless self_ref.send(:eagerly_validate_links?)
+          if @proxy.query.render_link?(sideload_ref.link_mode) && self_ref.send(:linkable?)
+            self_ref.send(:validate_link!) unless self_ref.send(:eagerly_validate_links?)
 
-              link(:related) do
-                ::Graphiti::Util::Link.new(sideload_ref, @object).generate
-              end
+            link(:related) do
+              ::Graphiti::Util::Link.new(sideload_ref, @object).generate
             end
           end
         end
@@ -153,8 +161,8 @@ module Graphiti
       end
 
       def validate_link!
-        return unless link?
-        return unless @resource_class.validate_endpoints?
+        return unless @sideload.link? && linkable?
+        return unless @resource_class.validate_links?
         return if @sideload.link_proc
 
         unless Graphiti.config.context_for_endpoint
@@ -183,14 +191,16 @@ module Graphiti
         self.class.validated_link_cache << cache_key
       end
 
-      def link?
-        return true if @sideload.link_proc
+      # Checked lazily so a sideload with no endpoint only raises when a link is actually wanted.
+      def linkable?
+        return @linkable if defined?(@linkable)
 
-        if @sideload.respond_to?(:children)
-          @sideload.link? &&
-            @sideload.children.values.all? { |c| !c.resource.endpoint.nil? }
+        @linkable = if @sideload.link_proc
+          true
+        elsif @sideload.respond_to?(:children)
+          @sideload.children.values.all? { |c| !c.resource.endpoint.nil? }
         else
-          !!(@sideload.link? && @sideload.resource.endpoint)
+          !@sideload.resource.endpoint.nil?
         end
       end
     end

data/lib/graphiti/version.rb

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

data/lib/graphiti.rb

@@ -33,7 +33,7 @@ require "jsonapi/serializable"
 # either way, whichever copy wins.
 {
   "graphiti_spec_helpers" => 'The "graphiti_spec_helpers/rspec" require and the GraphitiSpecHelpers namespace are unchanged.',
-  "graphiti-rails" => 'Graphiti::Rails and its config.graphiti options are unchanged. Drop the "graphiti-rails" require if you have one.',
+  "graphiti-rails" => 'Graphiti::Rails and its config.graphiti options are unchanged. Drop the "graphiti-rails" require if you have one, and add `include Graphiti::Rails::Controller` to controllers serving Graphiti resources. graphiti-rails installed that on every controller automatically. See graphiti.dev/upgrading.',
   "graphiti_errors" => "Exception handling now goes through rescue_registry. Remove `include GraphitiErrors` from your controllers — Graphiti registers its own handlers, and you can add yours with `register_exception`."
 }.each do |gem_name, guidance|
   next unless Gem.loaded_specs.key?(gem_name)
@@ -149,6 +149,11 @@ module Graphiti
     resources.each do |r|
       r.apply_sideloads_to_serializer
     end
+    @setup = true
+  end
+
+  def self.setup?
+    !!@setup
   end
 
   def self.cache=(val)

data/lib/tasks/graphiti.rake

@@ -22,6 +22,10 @@ namespace :graphiti do
     rows = Graphiti::Audit.run
     puts Graphiti::Audit::Report.new(rows)
 
+    if (advisory = helpers.connection_pool_advisory)
+      puts advisory
+    end
+
     exit 1 if rows.any?(&:error?)
   end