graphiti 2.0.0.beta.2 → 2.0.0.beta.4

data/lib/graphiti/rails.rb

@@ -1,38 +1,56 @@
+require "rescue_registry"
+require "graphiti"
+require "rails"
+
 module Graphiti
-  # Rails Integration. Mix this in to ApplicationController.
-  #
-  # * Mixes in Base
-  # * Adds a global around_action (see Base#wrap_context)
-  #
-  # @see Base#render_jsonapi
-  # @see Base#wrap_context
+  # Rails integration for Graphiti. See {file:README.md} for more details.
   module Rails
+    # Graphiti::Rails was a controller mixin before it became this namespace.
+    # Including a namespace is not an error, it just does nothing, so honour
+    # the old spelling rather than leave a controller silently without its
+    # context, debugger and exception handlers.
     def self.included(klass)
-      backtrace = ::Rails::VERSION::MAJOR == 4 ? caller(2) : caller_locations(2)
-      Graphiti::DEPRECATOR.deprecation_warning("Including Graphiti::Rails", "Use graphiti-rails instead. See https://www.graphiti.dev/guides/graphiti-rails-migration for details.", backtrace)
-
-      klass.class_eval do
-        include Graphiti::Context
-        include GraphitiErrors
-        around_action :wrap_context
-        around_action :debug
-      end
-    end
+      DEPRECATOR.deprecation_warning(
+        "Including Graphiti::Rails",
+        "include Graphiti::Rails::Controller instead"
+      )
 
-    def wrap_context
-      Graphiti.with_context(jsonapi_context, action_name.to_sym) do
-        yield
-      end
+      klass.include(Controller)
     end
 
-    def debug
-      Debugger.debug do
-        yield
-      end
-    end
+    # graphiti-rails had its own, and apps that silenced it by name still resolve.
+    DEPRECATOR = Graphiti::DEPRECATOR
 
-    def jsonapi_context
-      self
-    end
+    autoload :ConflictRequestHandler, "graphiti/rails/exception_handlers"
+    autoload :Context, "graphiti/rails/context"
+    autoload :Controller, "graphiti/rails/controller"
+    autoload :Debugging, "graphiti/rails/debugging"
+    autoload :ExceptionHandler, "graphiti/rails/exception_handlers"
+    autoload :FallbackHandler, "graphiti/rails/exception_handlers"
+    autoload :InvalidRequestHandler, "graphiti/rails/exception_handlers"
+    autoload :Responders, "graphiti/rails/responders"
+    autoload :TestHelpers, "graphiti/rails/test_helpers"
+
+    # @!attribute self.handled_exception_formats
+    # A list of formats as symbols whose exceptions will be handled by Graphiti. See {Railtie}.
+    cattr_accessor :handled_exception_formats, default: []
+
+    # @!attribute self.respond_to_formats
+    # A list of formats as symbols which will be available for Graphiti::Rails::Responders. See {Railtie}.
+    cattr_accessor :respond_to_formats, default: []
   end
+
+  # Deprecated. Was core's own responders mixin, superseded by the one that came
+  # in with graphiti-rails. Remove in 3.0.
+  Responders = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
+    "Graphiti::Responders",
+    "Graphiti::Rails::Responders",
+    DEPRECATOR
+  )
 end
+
+ActiveSupport.on_load(:active_record) do
+  require "graphiti/adapters/active_record"
+end
+
+require "graphiti/rails/railtie"

data/lib/graphiti/resource/configuration.rb

@@ -90,6 +90,7 @@ module Graphiti
           :attributes_schema_by_default,
           :relationships_readable_by_default,
           :relationships_writable_by_default,
+          :always_include_resource_ids_by_default,
           :filters_accept_nil_by_default,
           :filters_deny_empty_by_default,
           :graphql_entrypoint,

data/lib/graphiti/resource/interface.rb

@@ -84,8 +84,8 @@ module Graphiti
 
           if context&.respond_to?(:request)
             path = context.request.env["PATH_INFO"]
-            unless allow_request?(path, params, context_namespace)
-              raise Errors::InvalidEndpoint.new(self, path, context_namespace)
+            unless allow_request?(path, params, current_action)
+              raise Errors::InvalidEndpoint.new(self, path, current_action)
             end
           end
         end

data/lib/graphiti/resource/persistence.rb

@@ -93,11 +93,23 @@ module Graphiti
         model_instance
       end
 
+      # The model built by a prior ResourceProxy#assign_attributes, present
+      # for the duration of the save that persists it
+      attr_reader :assigned_model
+
+      # @api private
+      def with_assigned_model(model)
+        @assigned_model = model
+        yield
+      ensure
+        @assigned_model = nil
+      end
+
       # Attributes are assigned before the persistence callbacks fire, so
       # around_persistence receives the assigned model - its pre-yield
       # position is the last chance to touch the model before save, inside
       # the transaction. Modify attributes in before_attributes instead.
-      def create(create_params, meta = nil, assigned_model: nil)
+      def create(create_params, meta = nil)
         model_instance = assigned_model || assign(create_params, meta, :create)
 
         run_callbacks :persistence, :create, model_instance, meta do
@@ -111,7 +123,7 @@ module Graphiti
         model_instance
       end
 
-      def update(update_params, meta = nil, assigned_model: nil)
+      def update(update_params, meta = nil)
         model_instance = assigned_model || assign(update_params, meta, :update)
 
         run_callbacks :persistence, :update, model_instance, meta do

data/lib/graphiti/resource/remote.rb

@@ -38,8 +38,8 @@ module Graphiti
       # Forward all headers
       def request_headers
         {}.tap do |headers|
-          # TODO: Maybe handle this in graphiti-rails
-          if defined?(Rails) && context
+          # TODO: Maybe handle this in the Rails integration
+          if defined?(::Rails) && context
             raw = context.request.headers.to_h
             if (auth = raw["HTTP_AUTHORIZATION"])
               headers["Authorization"] = auth

data/lib/graphiti/resource/sideloading.rb

@@ -128,7 +128,7 @@ module Graphiti
         # If eager loading, ensure routes are loaded first, then apply
         # This happens in Railtie
         def eagerly_apply_sideload?(sideload)
-          # TODO: Maybe handle this in graphiti-rails
+          # TODO: Maybe handle this in the Rails integration
           if defined?(::Rails) && (app = ::Rails.application)
             app.config.eager_load ? false : true
           else

data/lib/graphiti/resource.rb

@@ -51,10 +51,22 @@ module Graphiti
       self.class.context
     end
 
-    def self.context_namespace
+    # Rails sets this from action_name, so it is whatever the controller action
+    # is called, not a fixed list. Persistence overrides it with :create/:update
+    # while saving, and :show while resolving sideloads afterwards.
+    def self.current_action
       Graphiti.context[:namespace]
     end
 
+    def current_action
+      self.class.current_action
+    end
+
+    def self.context_namespace
+      Graphiti::DEPRECATOR.deprecation_warning(:context_namespace, "Use #current_action instead")
+      current_action
+    end
+
     def context_namespace
       self.class.context_namespace
     end

data/lib/graphiti/responders.rb

@@ -1,21 +1,8 @@
-# If you're using Rails + responders gem to get respond_with
-module Graphiti
-  module Responders
-    extend ActiveSupport::Concern
+# Deprecated entry point. graphiti required this path itself in 1.x, so an
+# explicit require left behind would otherwise raise LoadError. Remove in 3.0.
+require "graphiti/rails"
 
-    included do
-      backtrace = ::Rails::VERSION::MAJOR == 4 ? caller(2) : caller_locations(2)
-      DEPRECATOR.deprecation_warning("Including Graphiti::Responders", "Use graphiti-rails instead. See https://www.graphiti.dev/guides/graphiti-rails-migration for details.", backtrace)
-      include ActionController::MimeResponds
-      respond_to(*Graphiti.config.respond_to)
-    end
-
-    # Override to avoid location url generation (for now)
-    def respond_with(*args, &blk)
-      opts = args.extract_options!
-      opts[:location] = nil
-      args << opts
-      super(*args, &blk)
-    end
-  end
-end
+Graphiti::DEPRECATOR.warn(
+  'require "graphiti/responders" is deprecated. Use "graphiti/rails" and include ' \
+  "Graphiti::Rails::Responders."
+)

data/lib/graphiti/schema.rb

@@ -3,7 +3,7 @@ module Graphiti
     attr_reader :resources
 
     def self.generate(resources = nil)
-      # TODO: Maybe handle this in graphiti-rails
+      # TODO: Maybe handle this in the Rails integration
       ::Rails.application.eager_load! if defined?(::Rails)
       resources ||= Graphiti.resources.reject(&:abstract_class?)
       resources.reject! { |r| r.name.nil? }
@@ -251,6 +251,10 @@ module Graphiti
             schema[:guard] = true
           end
 
+          if config.always_include_resource_ids?
+            schema[:linkage] = true
+          end
+
           r[name] = schema
         end
       end

data/lib/graphiti/schema_diff.rb

@@ -106,6 +106,10 @@ module Graphiti
           @errors << "#{old_resource[:name]}: relationship #{name.inspect} became guarded."
         end
 
+        if old_rel[:linkage] && !new_rel[:linkage]
+          @errors << "#{old_resource[:name]}: relationship #{name.inspect} no longer includes resource linkage."
+        end
+
         if new_rel[:resource] != old_rel[:resource]
           @errors << "#{old_resource[:name]}: relationship #{name.inspect} changed resource from #{old_rel[:resource]} to #{new_rel[:resource]}."
         end

data/lib/graphiti/scope.rb

@@ -48,29 +48,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 Graphiti.config.concurrency
+        future_resolve(&blk).value!
+      else
+        sync_resolve(&blk)
+      end
     end
 
     def resolve_sideloads(results)
-      return sync_resolve_sideloads(results) unless Graphiti.config.concurrency
-
-      future_resolve_sideloads(results).value!
+      if Graphiti.config.concurrency
+        future_resolve_sideloads(results).value!
+      else
+        sync_resolve_sideloads(results)
+      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
@@ -125,9 +121,33 @@ module Graphiti
     # 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
+
+    # 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|
+        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
+    # decorate the results. Shared by the sync and future paths — everything
+    # here runs inline on the calling thread in both modes.
+    def resolve_primary_data
       resolved = broadcast_data { |payload|
         @object = @resource.before_resolve(@object, @query)
         payload[:results] = @resource.resolve(@object)
@@ -137,40 +157,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)

data/lib/graphiti/serializer.rb

@@ -13,10 +13,16 @@ module Graphiti
     class_attribute :attributes_applied_via_resource
     class_attribute :extra_attributes_applied_via_resource
     class_attribute :relationship_condition_blocks
+    # Which sideload each generated relationship block was built for. A
+    # subclass inherits its parent's blocks, so this is how a redeclared
+    # relationship is told apart from one already applied, and from one the
+    # application wrote by hand.
+    class_attribute :relationship_sideloads
     self.attributes_applied_via_resource = []
     self.extra_attributes_applied_via_resource = []
     # See #requested_relationships
     self.relationship_condition_blocks ||= {}
+    self.relationship_sideloads ||= {}
 
     def self.inherited(klass)
       super

data/lib/graphiti/sideload/belongs_to.rb

@@ -1,13 +1,46 @@
 class Graphiti::Sideload::BelongsTo < Graphiti::Sideload
-  def initialize(name, opts)
-    opts = {always_include_resource_ids: false}.merge(opts)
-    super(name, opts)
-  end
-
   def type
     :belongs_to
   end
 
+  def default_include_resource_ids?
+    linkage_from_foreign_key?
+  end
+
+  # The parent already carries the foreign key, and for a plain belongs_to
+  # that key *is* the related id, so linkage costs nothing. Anything that can
+  # change which record the relationship resolves to, or what type it carries,
+  # has to load the association instead:
+  #
+  #   - a scope/params block or a base_scope can filter out the record the
+  #     foreign key points at, so the key would claim a relationship the API
+  #     would not actually return
+  #   - a polymorphic target takes its type from the record, not from the
+  #     relationship, so the key alone cannot say what type the id has
+  #   - a remote resource has no local foreign key to read
+  #   - a custom primary_key points the relationship at some other column, so
+  #     the key holds that column's value rather than the related id
+  def linkage_from_foreign_key?
+    # Ask before resolving #resource: an unreadable relationship renders
+    # nothing, and its resource class may not even be inferrable.
+    return false unless readable?
+    return false unless foreign_key_is_related_id?
+    return false if polymorphic_child?
+    return false if self.class.scope_proc || self.class.params_proc
+    return false if @base_scope
+    return false if remote?
+    return false if resource.class.polymorphic.present?
+
+    true
+  end
+
+  # The foreign key can stand in for the related id only when the two hold the
+  # same value. base_filter matches the key against primary_key, so pointing
+  # that at another column means the key holds that column instead.
+  def foreign_key_is_related_id?
+    primary_key == :id
+  end
+
   def load_params(parents, query)
     query.hash.tap do |hash|
       hash[:filter] ||= {}

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -108,40 +108,44 @@ 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.config.concurrency
+      future_resolve(parents, query, graph_parent).value!
+    else
+      sync_resolve(parents, query, graph_parent)
+    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)|
+  # 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)
+    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

@@ -122,8 +122,25 @@ module Graphiti
       !!@polymorphic_as
     end
 
+    # False everywhere but a plain belongs_to - see
+    # Sideload::BelongsTo#linkage_from_foreign_key?.
+    def linkage_from_foreign_key?
+      false
+    end
+
+    # nil at either of the first two levels means "not specified" rather
+    # than "false".
     def always_include_resource_ids?
-      !!@always_include_resource_ids
+      return !!@always_include_resource_ids unless @always_include_resource_ids.nil?
+
+      configured = parent_resource_class&.always_include_resource_ids_by_default
+      return !!configured unless configured.nil?
+
+      default_include_resource_ids?
+    end
+
+    def default_include_resource_ids?
+      false
     end
 
     def link?
@@ -292,48 +309,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 Graphiti.config.concurrency
+        future_resolve(parents, query, graph_parent).value!
       else
-        load(parents, query, graph_parent)
+        sync_resolve(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)
-      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 +389,37 @@ 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)
+      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)