graphiti 2.0.0.beta.3 → 2.0.0.beta.5

data/lib/graphiti/rails/railtie.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Graphiti
+  module Rails
+    # This Railtie exposes some configuration options:
+    # * `config.graphiti.handled_exception_formats`, defaulting to `[:jsonapi]`.
+    #   Formats in this list will always have their exceptions handled by Graphiti.
+    # * `config.graphiti.respond_to_formats`, defaulting to `[:json, :jsonapi, :xml]`.
+    #   When {Graphiti::Rails::Responders} is included in a controller it will respond
+    #   to these mime types by default.
+    class Railtie < ::Rails::Railtie
+      config.graphiti = ActiveSupport::OrderedOptions.new
+
+      config.graphiti.handled_exception_formats = [:jsonapi]
+
+      old_respond_to_formats = Graphiti::DEPRECATOR.silence { Graphiti.config.try(:respond_to) }
+      config.graphiti.respond_to_formats = old_respond_to_formats || [:json, :jsonapi, :xml]
+
+      rake_tasks do
+        load File.expand_path("../../tasks/graphiti.rake", __dir__)
+      end
+
+      initializer "graphiti-rails.config" do |app|
+        Graphiti::Rails.handled_exception_formats = app.config.graphiti.handled_exception_formats
+        Graphiti::Rails.respond_to_formats = app.config.graphiti.respond_to_formats
+
+        root = ::Rails.root
+
+        config_file = root.join(".graphiticfg.yml")
+        if config_file.exist?
+          cfg = YAML.load_file(config_file)
+          Graphiti.config.schema_path = root.join("public#{cfg["namespace"]}/schema.json")
+        else
+          Graphiti.config.schema_path = root.join("public/schema.json")
+        end
+      end
+
+      initializer "graphti-rails.logger" do
+        config.after_initialize do
+          Graphiti.config.debug = ::Rails.logger.debug? && Graphiti.config.debug
+          Graphiti.logger = ::Rails.logger
+        end
+      end
+
+      initializer "graphiti-rails.init" do
+        if ::Rails.application.config.eager_load
+          config.after_initialize do |app|
+            ::Rails.application.reload_routes!
+            Graphiti.setup!
+          end
+        end
+
+        register_mime_type
+        register_parameter_parser
+        register_renderers
+        establish_concurrency
+        configure_endpoint_lookup
+      end
+
+      # from jsonapi-rails
+      MEDIA_TYPE = "application/vnd.api+json"
+
+      PARSER = lambda do |body|
+        data = JSON.parse(body)
+        data[:format] = :jsonapi
+        data.with_indifferent_access
+      end
+
+      def register_mime_type
+        Mime::Type.register(MEDIA_TYPE, :jsonapi)
+      end
+
+      def register_parameter_parser
+        ActionDispatch::Request.parameter_parsers[:jsonapi] ||= PARSER
+      end
+
+      def register_renderers
+        ActiveSupport.on_load(:action_controller) do
+          ::ActionController::Renderers.add(:jsonapi) do |proxy, options|
+            self.content_type ||= Mime[:jsonapi]
+
+            # opts = {}
+            # if respond_to?(:default_jsonapi_render_options)
+            #   opts = default_jsonapi_render_options
+            # end
+
+            if proxy.is_a?(Hash) # for destroy
+              render(options.merge(json: proxy))
+            else
+              proxy.to_jsonapi(options)
+            end
+          end
+        end
+
+        ActiveSupport.on_load(:action_controller) do
+          ActionController::Renderers.add(:jsonapi_errors) do |proxy, options|
+            self.content_type ||= Mime[:jsonapi]
+
+            validation = Graphiti::ErrorSerializers::Validation.new \
+              proxy.data, proxy.payload.relationships
+
+            render \
+              json: {errors: validation.errors},
+              status: :unprocessable_entity
+          end
+        end
+      end
+
+      # Only run concurrently if our environment supports it
+      def establish_concurrency
+        Graphiti.config.concurrency = !::Rails.env.test? &&
+          ::Rails.application.config.cache_classes
+      end
+
+      def configure_endpoint_lookup
+        Graphiti.config.context_for_endpoint = ->(path, action) {
+          method = :GET
+          case action
+          when :show then path = "#{path}/1"
+          when :create then method = :POST
+          when :update
+            path = "#{path}/1"
+            method = :PUT
+          when :destroy
+            path = "#{path}/1"
+            method = :DELETE
+          end
+
+          route = begin
+            ::Rails.application.routes.recognize_path(path.to_s, method: method)
+          rescue
+            nil
+          end
+          "#{route[:controller]}_controller".classify.safe_constantize if route
+        }
+      end
+    end
+  end
+end

data/lib/graphiti/rails/rake_helpers.rb

@@ -0,0 +1,42 @@
+require "graphiti/rails/test_helpers"
+
+module Graphiti
+  module Rails
+    # Rake's `namespace` takes a block, and a block does not open a new definee,
+    # so helpers defined inside one are defined on Object and turn up in every
+    # request spec in the host app. They live here to stay off that namespace.
+    module RakeHelpers
+      extend TestHelpers
+
+      module_function
+
+      # ::Rails throughout, because bare Rails resolves to Graphiti::Rails here.
+      def session
+        @session ||= ActionDispatch::Integration::Session.new(::Rails.application)
+      end
+
+      def setup_rails!
+        ::Rails.application.eager_load!
+        ::Rails.application.config.cache_classes = true
+        ::Rails.application.config.action_controller.perform_caching = false
+      end
+
+      def make_request(path, debug = false)
+        if path.split("/").length == 2
+          path = "#{ApplicationResource.endpoint_namespace}#{path}"
+        end
+        path << if path.include?("?")
+          "&cache=bust"
+        else
+          "?cache=bust"
+        end
+        path = "#{path}&debug=true" if debug
+        handle_request_exceptions do
+          headers = {Authorization: ENV["AUTHORIZATION_HEADER"]}.compact
+          session.get(path.to_s, headers: headers)
+        end
+        JSON.parse(session.response.body)
+      end
+    end
+  end
+end

data/lib/graphiti/rails/responders.rb

@@ -0,0 +1,21 @@
+# For use with the `responders` gem responders gem to get respond_with
+module Graphiti
+  module Rails
+    module Responders
+      extend ActiveSupport::Concern
+
+      included do
+        include ActionController::MimeResponds
+        respond_to(*Graphiti::Rails.respond_to_formats)
+      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
+end

data/lib/graphiti/rails/test_helpers.rb

@@ -0,0 +1,22 @@
+module Graphiti
+  module Rails
+    # Wrap a request in `handle_request_exceptions` to assert on the rendered
+    # error payload. Exceptions propagate untouched in tests otherwise.
+    module TestHelpers
+      include RescueRegistry::RailsTestHelpers
+
+      # rescue_registry sets action_dispatch.show_exceptions to true/false.
+      # Rails 7.1 replaced those with :all/:rescuable/:none, and Rails 8 dropped
+      # boolean handling altogether. ExceptionWrapper#show? now treats
+      # everything that is not :none as "show", so passing false would leave
+      # exception handling on and silently do nothing.
+      def handle_request_exceptions(handle = true, &block)
+        super(handle ? :all : :none, &block)
+      end
+
+      def handle_request_exceptions?
+        ::Rails.application.config.action_dispatch.show_exceptions != :none
+      end
+    end
+  end
+end

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/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] ||= {}