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

data/lib/graphiti/error_serializers/deprecated_constants.rb

@@ -0,0 +1,48 @@
+# The graphiti_errors gem was absorbed into graphiti in 2.0. Only its
+# serializers survived, as Graphiti::ErrorSerializers. The rest of it (the
+# GraphitiErrors controller mixin and its exception handlers) is replaced by
+# rescue_registry rather than renamed, so there is deliberately nothing here to
+# alias it to. A custom error renderer reaching for one of the serializers gets
+# pointed at the new name instead of a bare NameError. Remove in 3.0.
+module GraphitiErrors
+  # `include GraphitiErrors` in ApplicationController was this gem's headline
+  # usage. Including an empty module succeeds, so without this an upgraded app
+  # boots clean and then serves Rails' default HTML error pages instead of
+  # JSON:API ones, with nothing to indicate why.
+  def self.included(klass)
+    raise <<~MSG
+      GraphitiErrors was merged into graphiti as of 2.0 and `include GraphitiErrors`
+      no longer does anything.
+
+      Exception handling now goes through rescue_registry. Replace it with:
+
+        include Graphiti::Rails::Controller
+
+      which registers Graphiti's own handlers. Your own go alongside them with
+      `register_exception`, available on every controller.
+    MSG
+  end
+
+  module Validation; end
+
+  module InvalidRequest; end
+
+  module ConflictRequest; end
+
+  module Serializers; end
+end
+
+{
+  "GraphitiErrors::Validation::Serializer" => "Graphiti::ErrorSerializers::Validation",
+  "GraphitiErrors::InvalidRequest::Serializer" => "Graphiti::ErrorSerializers::InvalidRequest",
+  "GraphitiErrors::ConflictRequest::Serializer" => "Graphiti::ErrorSerializers::ConflictRequest",
+  # Graphiti 1.0.x referenced this spelling
+  "GraphitiErrors::Serializers::Validation" => "Graphiti::ErrorSerializers::Validation"
+}.each do |old_name, new_name|
+  namespace, _, constant = old_name.rpartition("::")
+
+  Object.const_get(namespace).const_set(
+    constant,
+    ActiveSupport::Deprecation::DeprecatedConstantProxy.new(old_name, new_name, Graphiti::DEPRECATOR)
+  )
+end

data/lib/graphiti/error_serializers/invalid_request.rb

@@ -0,0 +1,56 @@
+module Graphiti
+  module ErrorSerializers
+    class InvalidRequest
+      STATUS = 400
+
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      def status
+        self.class::STATUS
+      end
+
+      def errors
+        [].tap do |payload|
+          source.details.each_pair do |attribute, attribute_errors|
+            attribute_errors.each_with_index do |error, index|
+              message = source.messages[attribute][index]
+
+              payload << {
+                code: code,
+                status: status.to_s,
+                title: title,
+                detail: source.full_message(attribute, message),
+                source: {pointer: pointer_for(attribute)},
+                meta: {
+                  attribute: attribute,
+                  message: message,
+                  code: error[:error]
+                }
+              }
+            end
+          end
+        end
+      end
+
+      private
+
+      def code
+        "bad_request"
+      end
+
+      def title
+        "Request Error"
+      end
+
+      # "filter.foo[0]" describes a path into the payload, not an attribute
+      # name, so it becomes a JSON pointer.
+      def pointer_for(attribute)
+        attribute.to_s.tr(".", "/").gsub(/\[(\d+)\]/, '/\1')
+      end
+    end
+  end
+end

data/lib/graphiti/error_serializers/validation.rb

@@ -0,0 +1,143 @@
+module Graphiti
+  module ErrorSerializers
+    # Walks into related objects so nested writes report against the record
+    # that actually failed.
+    class Validation
+      attr_reader :object
+
+      def initialize(object, relationship_payloads = {}, relationship_meta = {})
+        @object = object
+        @relationship_payloads = relationship_payloads
+        @relationship_meta = relationship_meta
+      end
+
+      def attribute_errors
+        [].tap do |errors|
+          each_error do |attribute, message, code|
+            errors << {
+              code: "unprocessable_entity",
+              status: "422",
+              title: "Validation Error",
+              detail: detail_for(attribute, message),
+              source: {pointer: pointer_for(object, attribute)},
+              meta: meta_for(attribute, message, code, @relationship_meta)
+            }
+          end
+        end
+      end
+
+      def errors
+        return [] unless object.respond_to?(:errors)
+
+        attribute_errors | relationship_errors(object, @relationship_payloads)
+      end
+
+      private
+
+      def each_error
+        object.errors.messages.each_pair do |attribute, messages|
+          details = object.errors.details.find { |k, _| k == attribute }[1]
+
+          messages.each_with_index do |message, index|
+            yield attribute, message, details[index][:error]
+          end
+        end
+      end
+
+      def relationship?(name)
+        relationship_names = []
+        if activerecord?
+          relationship_names = object.class
+            .reflect_on_all_associations.map(&:name)
+        elsif object.respond_to?(:relationship_names)
+          relationship_names = object.relationship_names
+        end
+
+        relationship_names.include?(name)
+      end
+
+      def attribute?(name)
+        object.respond_to?(name)
+      end
+
+      def meta_for(attribute, message, code, relationship_meta)
+        meta = {
+          attribute: attribute,
+          message: message,
+          code: code
+        }
+
+        unless relationship_meta.empty?
+          meta = {relationship: meta.merge(relationship_meta)}
+        end
+
+        meta
+      end
+
+      def detail_for(attribute, message)
+        detail = object.errors.full_message(attribute, message)
+        detail = message if attribute.to_s.downcase == "base"
+        detail
+      end
+
+      # @richmolj: Keeping this to support ember-data, but I hate the concept.
+      def pointer_for(object, name)
+        if relationship?(name)
+          "/data/relationships/#{name}"
+        elsif attribute?(name)
+          "/data/attributes/#{name}"
+        elsif name == :base
+          nil
+        else
+          # Probably a nested relation, like post.comments
+          "/data/relationships/#{name}"
+        end
+      end
+
+      def activerecord?
+        object.class.respond_to?(:reflect_on_all_associations)
+      end
+
+      def traverse_relationships(model, relationship_params)
+        return unless relationship_params
+
+        relationship_params.each_pair do |name, payload|
+          relationship_objects = Array(model.send(name))
+
+          relationship_objects.each do |relationship_object|
+            related_payload = payload
+            if payload.is_a?(Array)
+              related_payload = payload.find { |p|
+                temp_id = relationship_object
+                  .instance_variable_get(:@_jsonapi_temp_id)
+                p[:meta][:temp_id] === temp_id ||
+                  p[:meta][:id] == relationship_object.id.to_s
+              }
+            end
+
+            yield name, relationship_object, related_payload
+            relationship_errors(relationship_object, related_payload[:relationships])
+          end
+        end
+      end
+
+      def relationship_errors(model, relationship_payloads)
+        errors = []
+        traverse_relationships(model, relationship_payloads) do |name, related, payload|
+          meta = {}.tap do |hash|
+            hash[:name] = name
+            hash[:type] = payload[:meta][:jsonapi_type]
+            if (temp_id = related.instance_variable_get(:@_jsonapi_temp_id))
+              hash[:"temp-id"] = temp_id
+            else
+              hash[:id] = related.id
+            end
+          end
+
+          errors |= self.class.new(related, payload[:relationships], meta).errors
+        end
+        errors
+      end
+    end
+  end
+end

data/lib/graphiti/errors.rb

@@ -84,25 +84,6 @@ module Graphiti
       end
     end
 
-    class AssignedModelNotSupported < Base
-      def initialize(resource_class, method_name)
-        @resource_class = resource_class
-        @method_name = method_name
-      end
-
-      def message
-        <<~MSG
-          #{@resource_class}: the model was already assigned via #assign_attributes (or #data before save), but ##{@method_name} is overridden without a parameter to receive it, so changes made to the unsaved model would be silently lost.
-
-          Accept and use the assigned model in your override:
-
-            def #{@method_name}(attributes, meta = nil, assigned_model: nil)
-
-          or persist with #save alone, without inspecting the model first. See UPGRADING.md.
-        MSG
-      end
-    end
-
     class RemoteWrite < Base
       def initialize(resource_class)
         @resource_class = resource_class
@@ -289,7 +270,7 @@ module Graphiti
           #{@resource_class.name}: error occurred while sideloading "#{@sideload_name}"!
 
           The error was raised while attempting to build query parameters for the associated Resource.
-          Read more about sideload scoping here: www.graphiti.dev/guides/concepts/resources#customizing-scope
+          Read more about sideload scoping here: www.graphiti.dev/concepts/relationships#customizing-scope
 
           A good way to debug is to put a debugger within the 'params' block.
 
@@ -313,7 +294,7 @@ module Graphiti
 
           The error was raised while attempting to build the scope for the associated Resource.
 
-          Read more about sideload scoping here: www.graphiti.dev/guides/concepts/resources#customizing-scope
+          Read more about sideload scoping here: www.graphiti.dev/concepts/relationships#customizing-scope
 
           Here's the original, underlying error:
 
@@ -334,7 +315,7 @@ module Graphiti
           #{@resource_class.name}: error occurred while sideloading "#{@sideload_name}"!
 
           The error was raised while attempting to assign relevant model instances. Read
-          more about sideload assignment here: www.graphiti.dev/guides/concepts/resources#customizing-assignment
+          more about sideload assignment here: www.graphiti.dev/concepts/relationships#customizing-assignment
 
           A good way to debug is to put a debugger within the 'assign' block.
 
@@ -468,7 +449,7 @@ module Graphiti
 
           self.validate_endpoints = false
 
-          See https://www.graphiti.dev/guides/concepts/links for more information.
+          See https://www.graphiti.dev/concepts/links for more information.
 
           The current endpoints allowed for this resource are: #{@resource_class.endpoints.inspect}
         MSG

data/lib/graphiti/query.rb

@@ -209,7 +209,7 @@ module Graphiti
         allowlist = nil
         if @resource.context&.respond_to?(:sideload_allowlist)
           allowlist = @resource.context.sideload_allowlist
-          allowlist = allowlist[@resource.context_namespace] if allowlist
+          allowlist = allowlist[@resource.current_action] if allowlist
         end
 
         scrubbed = allowlist ? Util::IncludeParams.scrub(requested, allowlist) : requested

data/lib/graphiti/rails/context.rb

@@ -0,0 +1,33 @@
+module Graphiti
+  module Rails
+    # Wraps controller actions in a [Graphiti Context](https://www.graphiti.dev/concepts/resources#context) which points to the
+    # controller instance by default.
+    module Context
+      def self.included(klass)
+        klass.class_eval do
+          include Graphiti::Context
+          around_action :wrap_graphiti_context
+        end
+      end
+
+      # Called by [`#around_action`](https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-around_action)
+      # to wrap the current action in a Graphiti context defined by {#graphiti_context}.
+      def wrap_graphiti_context
+        Graphiti.with_context(graphiti_context, action_name.to_sym) do
+          yield
+        end
+      end
+
+      # The context to use for Graphiti Resources. Defaults to the controller instance.
+      # Can be redefined for different behavior.
+      def graphiti_context
+        if respond_to?(:jsonapi_context)
+          DEPRECATOR.deprecation_warning("Overriding jsonapi_context", "Override #graphiti_context instead")
+          jsonapi_context
+        else
+          self
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/rails/controller.rb

@@ -0,0 +1,41 @@
+module Graphiti
+  module Rails
+    # Everything a controller needs to serve Graphiti resources. Include it in
+    # the controller your API inherits from:
+    #
+    #   class ApplicationController < ActionController::Base
+    #     include Graphiti::Rails::Controller
+    #   end
+    #
+    # Graphiti applied all of this to every controller in the application until
+    # 2.0, which meant wrapping unrelated actions in a Graphiti context and
+    # registering a catch-all exception handler on controllers that never touch
+    # Graphiti. Scoping it is now up to you.
+    module Controller
+      extend ActiveSupport::Concern
+
+      included do
+        include Graphiti::Rails::Context
+        include Graphiti::Rails::Debugging
+
+        # Broad, but the handler only renders formats listed in
+        # config.graphiti.handled_exception_formats and hands everything else
+        # back to Rails.
+        register_exception Exception,
+          status: :passthrough,
+          handler: Graphiti::Rails::FallbackHandler
+
+        register_exception Graphiti::Errors::InvalidRequest,
+          status: 400, handler: Graphiti::Rails::InvalidRequestHandler
+        register_exception Graphiti::Errors::ConflictRequest,
+          status: 409, handler: Graphiti::Rails::ConflictRequestHandler
+        register_exception Graphiti::Errors::RecordNotFound,
+          status: 404, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::RemoteWrite,
+          status: 400, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::SingularSideload,
+          status: 400, handler: Graphiti::Rails::ExceptionHandler
+      end
+    end
+  end
+end

data/lib/graphiti/rails/debugging.rb

@@ -0,0 +1,18 @@
+module Graphiti
+  module Rails
+    # Wraps controller actions in a [Graphiti Debugger](https://www.graphiti.dev/topics/debugging#debugger).
+    module Debugging
+      def self.included(klass)
+        klass.around_action :debug_graphiti
+      end
+
+      # Called by [`#around_action`](https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-around_action)
+      # to wrap the current action in a Graphiti Debugger.
+      def debug_graphiti
+        Debugger.debug do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/rails/exception_handlers.rb

@@ -0,0 +1,77 @@
+module Graphiti
+  module Rails
+    class ExceptionHandler < RescueRegistry::ExceptionHandler
+      # We've actually changed the signature here which is somewhat risky...
+      def build_payload(show_details: false, traces: nil, style: :rails)
+        case style
+        when :standard
+          super(show_details: show_details, traces: traces).tap do |payload|
+            if show_details
+              # For Vandal and Request Responses
+              payload[:__raw_error__] = {
+                message: exception.message,
+                debug: exception.instance_variable_get(:@__graphiti_debug),
+                backtrace: exception.backtrace
+              }
+            end
+          end
+        when :rails
+          # TODO: Find way to not duplicate RailsExceptionHandler
+          body = {
+            status: status_code,
+            error: title
+          }
+
+          if show_details
+            body[:exception] = exception.inspect
+            body[:traces] = traces if traces
+          end
+
+          body
+        else
+          raise ArgumentError, "unknown style #{style}"
+        end
+      end
+
+      def formatted_response(content_type, **options)
+        # We're relying on the fact that `formatted_response` passes through unknown options to `build_payload`
+        if Graphiti::Rails.handled_exception_formats.include?(content_type.to_sym)
+          options[:style] = :standard
+        end
+        super
+      end
+    end
+
+    class FallbackHandler < ExceptionHandler
+      # A nil response is what hands the exception back to the default Rails
+      # handler, so formats Graphiti does not claim render as they always did.
+      def formatted_response(content_type, **options)
+        return unless Graphiti::Rails.handled_exception_formats.include?(content_type.to_sym)
+
+        super
+      end
+    end
+
+    class InvalidRequestHandler < ExceptionHandler
+      # NOTE: `style` is ignored. A rejected request always reports which
+      # parameters were rejected and why.
+      def build_payload(show_details: false, traces: nil, style: nil)
+        {errors: error_serializer.new(exception.errors).errors}
+      end
+
+      private
+
+      def error_serializer
+        Graphiti::ErrorSerializers::InvalidRequest
+      end
+    end
+
+    class ConflictRequestHandler < InvalidRequestHandler
+      private
+
+      def error_serializer
+        Graphiti::ErrorSerializers::ConflictRequest
+      end
+    end
+  end
+end

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