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

data/{deprecated_generators → lib/generators}/graphiti/templates/resource_reads_spec.rb.erb

@@ -7,7 +7,7 @@ RSpec.describe <%= resource_class %>, type: :resource do
     it 'works' do
       render
       data = jsonapi_data[0]
-      expect(data.id).to eq(<%= var %>.id)
+      expect(data.<%= id_or_rawid %>).to eq(<%= var %>.id)
       expect(data.jsonapi_type).to eq('<%= type %>')
       <%- attributes.each do |a| -%>
       <%- if [:created_at, :updated_at].include?(a.name.to_sym) -%>
@@ -31,7 +31,7 @@ RSpec.describe <%= resource_class %>, type: :resource do
 
       it 'works' do
         render
-        expect(d.map(&:id)).to eq([<%= var %>2.id])
+        expect(d.map(&:<%= id_or_rawid %>)).to eq([<%= var %>2.id])
       end
     end
   end
@@ -48,10 +48,10 @@ RSpec.describe <%= resource_class %>, type: :resource do
 
         it 'works' do
           render
-          expect(d.map(&:id)).to eq([
+          expect(d.map(&:<%= id_or_rawid %>)).to eq([
             <%= var %>1.id,
             <%= var %>2.id
-          ])
+          ]<%= sort_raw_ids %>)
         end
       end
 
@@ -62,10 +62,10 @@ RSpec.describe <%= resource_class %>, type: :resource do
 
         it 'works' do
           render
-          expect(d.map(&:id)).to eq([
+          expect(d.map(&:<%= id_or_rawid %>)).to eq([
             <%= var %>2.id,
             <%= var %>1.id
-          ])
+          ]<%= sort_raw_ids_descending %>)
         end
       end
     end

data/{deprecated_generators → lib/generators}/graphiti/templates/show_request_spec.rb.erb

@@ -15,7 +15,7 @@ RSpec.describe "<%= type %>#show", type: :request do
       make_request
       expect(response.status).to eq(200)
       expect(d.jsonapi_type).to eq('<%= type %>')
-      expect(d.id).to eq(<%= var %>.id)
+      expect(d.<%= id_or_rawid %>).to eq(<%= var %>.id)
     end
   end
 end

data/lib/graphiti/configuration.rb

@@ -55,7 +55,7 @@ module Graphiti
 
       @uri_decoder = infer_uri_decoder
 
-      # FIXME: Don't duplicate graphiti-rails efforts
+      # FIXME: Don't duplicate the Railtie's initializer
       if defined?(::Rails.root) && (root = ::Rails.root)
         config_file = root.join(".graphiticfg.yml")
         if config_file.exist?
@@ -132,6 +132,6 @@ module Graphiti
     end
   end
 
-  msg = "Use graphiti-rails's `config.graphiti.respond_to_formats`"
+  msg = "Use `config.graphiti.respond_to_formats`"
   DEPRECATOR.deprecate_methods(Configuration, respond_to: msg, "respond_to=": msg)
 end

data/lib/graphiti/error_serializers/conflict_request.rb

@@ -0,0 +1,19 @@
+module Graphiti
+  module ErrorSerializers
+    # graphiti_errors overrode only the status here, and so reported a 409
+    # alongside code "bad_request".
+    class ConflictRequest < InvalidRequest
+      STATUS = 409
+
+      private
+
+      def code
+        "conflict"
+      end
+
+      def title
+        "Conflict Error"
+      end
+    end
+  end
+end

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

@@ -270,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.
 
@@ -294,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:
 
@@ -315,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.
 
@@ -449,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