graphiti 2.0.0.beta.9 → 2.0.0.beta.11

data/lib/graphiti/serializer.rb

@@ -24,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
@@ -59,7 +69,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
 
@@ -74,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
@@ -100,17 +110,29 @@ module Graphiti
       hash[:links] = @resource.links(@object) if @resource.links?
     end
 
+    # The meta: {included: false} stub is jsonapi-serializable's filler, not JSON:API.
     def strip_relationships!(hash)
-      hash[:relationships]&.select! do |name, payload|
-        payload.key?(:data)
+      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?
-      return false unless Graphiti.config.links_on_demand
-      params = Graphiti.context[:object]&.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
 
-      [false, nil, "false"].include?(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

@@ -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__)
@@ -148,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
@@ -166,14 +174,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)
@@ -279,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
@@ -334,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).value!
+        future_resolve(parents, query, graph_parent, &proxy_block).value!
       end
     end
 
-    def future_resolve(parents, query, graph_parent)
+    # 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
+        sync_load(parents, query, graph_parent, &proxy_block)
+      end
+    end
+
+    # 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
@@ -350,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
 
@@ -414,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)
@@ -445,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

@@ -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: :null)
       # @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,7 +57,6 @@ module Graphiti
       private
 
       def block
-        link_ref = link?
         sideload_ref = @sideload
         resource_class_ref = @resource_class
         data_proc_ref = data_proc
@@ -93,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
@@ -162,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
@@ -192,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.9"
+  VERSION = "2.0.0.beta.11"
 end

data/lib/graphiti.rb

@@ -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
 

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.9
+  version: 2.0.0.beta.11
 platform: ruby
 authors:
 - Lee Richmond