sanger-jsonapi-resources 0.1.1 → 0.2.0

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -1,5 +1,7 @@
-require 'csv'
+# frozen_string_literal: true
 
+require 'csv'
+require_relative 'compatibility_helper'
 module JSONAPI
   module ActsAsResourceController
     MEDIA_TYPE_MATCHER = /.+".+"[^,]*|[^,]+/
@@ -9,9 +11,12 @@ module JSONAPI
       base.extend ClassMethods
       base.include Callbacks
       base.cattr_reader :server_error_callbacks
-      base.define_jsonapi_resources_callbacks :process_operations
+      base.define_jsonapi_resources_callbacks :process_operations,
+                                              :transaction
     end
 
+    attr_reader :response_document, :jsonapi_request
+
     def index
       process_request
     end
@@ -25,22 +30,18 @@ module JSONAPI
     end
 
     def create
-      return unless verify_content_type_header
       process_request
     end
 
     def create_relationship
-      return unless verify_content_type_header
       process_request
     end
 
     def update_relationship
-      return unless verify_content_type_header
       process_request
     end
 
     def update
-      return unless verify_content_type_header
       process_request
     end
 
@@ -52,59 +53,100 @@ module JSONAPI
       process_request
     end
 
-    def get_related_resource
+    def show_related_resource
       process_request
     end
 
-    def get_related_resources
+    def index_related_resources
       process_request
     end
 
-    def process_request
-      return unless verify_accept_header
+    def get_related_resource
+      # :nocov:
+      JSONAPI::CompatibilityHelper.deprecation_warn("In #{self.class.name} you exposed a `get_related_resource`"\
+                                      " action. Please use `show_related_resource` instead.")
+      show_related_resource
+      # :nocov:
+    end
 
-      @request = JSONAPI::RequestParser.new(params, context: context,
-                                            key_formatter: key_formatter,
-                                            server_error_callbacks: (self.class.server_error_callbacks || []))
+    def get_related_resources
+      # :nocov:
+      JSONAPI::CompatibilityHelper.deprecation_warn("In #{self.class.name} you exposed a `get_related_resources`"\
+                                      " action. Please use `index_related_resources` instead.")
+      index_related_resources
+      # :nocov:
+    end
 
-      unless @request.errors.empty?
-        render_errors(@request.errors)
-      else
-        operations = @request.operations
-        unless JSONAPI.configuration.resource_cache.nil?
-          operations.each {|op| op.options[:cache_serializer] = resource_serializer }
-        end
-        results = process_operations(operations)
-        render_results(results)
+    def process_request
+      begin
+        setup_response_document
+        verify_content_type_header
+        verify_accept_header
+        parse_request
+        execute_request
+      rescue => e
+        handle_exceptions(e)
       end
-    rescue => e
-      handle_exceptions(e)
+      render_response_document
     end
 
-    def process_operations(operations)
-      run_callbacks :process_operations do
-        operation_dispatcher.process(operations)
-      end
+    def setup_response_document
+      @response_document = create_response_document
     end
 
-    def transaction
-      lambda { |&block|
-        ActiveRecord::Base.transaction do
-          block.yield
+    def parse_request
+      @jsonapi_request = JSONAPI::Request.new(
+        params,
+        context: context,
+        key_formatter: key_formatter,
+        server_error_callbacks: (self.class.server_error_callbacks || []))
+      fail JSONAPI::Exceptions::Errors.new(@jsonapi_request.errors) if @jsonapi_request.errors.any?
+    end
+
+    def execute_request
+      process_operations(jsonapi_request.transactional?) do
+        run_callbacks :process_operations do
+          jsonapi_request.operations.each do |op|
+            op.options[:serializer] = resource_serializer_klass.new(
+              op.resource_klass,
+              include_directives: op.options[:include_directives],
+              fields: op.options[:fields],
+              base_url: base_url,
+              key_formatter: key_formatter,
+              route_formatter: route_formatter,
+              serialization_options: serialization_options,
+              controller: self
+            )
+            op.options[:cache_serializer_output] = !JSONAPI.configuration.resource_cache.nil?
+
+            process_operation(op)
+          end
         end
-      }
+        if response_document.has_errors?
+          raise ActiveRecord::Rollback
+        end
+      end
     end
 
-    def rollback
-      lambda {
-        fail ActiveRecord::Rollback
-      }
+    def process_operations(transactional)
+      if transactional
+        run_callbacks :transaction do
+          ActiveRecord::Base.transaction do
+            yield
+          end
+        end
+      else
+        begin
+          yield
+        rescue ActiveRecord::Rollback
+          # Can't rollback without transaction, so just ignore it
+        end
+      end
     end
 
-    def operation_dispatcher
-      @operation_dispatcher ||= JSONAPI::OperationDispatcher.new(transaction: transaction,
-                                                                 rollback: rollback,
-                                                                 server_error_callbacks: @request.server_error_callbacks)
+    def process_operation(operation)
+      result = operation.process
+      response_document.add_result(result, operation)
     end
 
     private
@@ -117,21 +159,8 @@ module JSONAPI
       @resource_serializer_klass ||= JSONAPI::ResourceSerializer
     end
 
-    def resource_serializer
-      @resource_serializer ||= resource_serializer_klass.new(
-        resource_klass,
-        include_directives: @request ? @request.include_directives : nil,
-        fields: @request ? @request.fields : {},
-        base_url: base_url,
-        key_formatter: key_formatter,
-        route_formatter: route_formatter,
-        serialization_options: serialization_options
-      )
-      @resource_serializer
-    end
-
     def base_url
-      @base_url ||= request.protocol + request.host_with_port
+      @base_url ||= "#{request.protocol}#{request.host_with_port}#{Rails.application.config.relative_url_root}"
     end
 
     def resource_klass_name
@@ -139,32 +168,25 @@ module JSONAPI
     end
 
     def verify_content_type_header
-      unless request.content_type == JSONAPI::MEDIA_TYPE
-        fail JSONAPI::Exceptions::UnsupportedMediaTypeError.new(request.content_type)
+      if ['create', 'create_relationship', 'update_relationship', 'update'].include?(params[:action])
+        unless request.media_type == JSONAPI::MEDIA_TYPE
+          fail JSONAPI::Exceptions::UnsupportedMediaTypeError.new(request.media_type)
+        end
       end
-      true
-    rescue => e
-      handle_exceptions(e)
-      false
     end
 
     def verify_accept_header
       unless valid_accept_media_type?
         fail JSONAPI::Exceptions::NotAcceptableError.new(request.accept)
       end
-      true
-    rescue => e
-      handle_exceptions(e)
-      false
     end
 
     def valid_accept_media_type?
       media_types = media_types_for('Accept')
 
-      media_types.blank? ||
-        media_types.any? do |media_type|
-          (media_type == JSONAPI::MEDIA_TYPE || media_type.start_with?(ALL_MEDIA_TYPES))
-        end
+      media_types.blank? || media_types.any? do |media_type|
+        (media_type == JSONAPI::MEDIA_TYPE || media_type.start_with?(ALL_MEDIA_TYPES))
+      end
     end
 
     def media_types_for(header)
@@ -202,57 +224,43 @@ module JSONAPI
     end
 
     def base_meta
-      if @request.nil? || @request.warnings.empty?
-        base_response_meta
-      else
-        base_response_meta.merge(warnings: @request.warnings)
-      end
+      base_response_meta
     end
 
     def base_response_links
       {}
     end
 
-    def render_errors(errors)
-      operation_results = JSONAPI::OperationResults.new
-      result = JSONAPI::ErrorsOperationResult.new(errors[0].status, errors)
-      operation_results.add_result(result)
-
-      render_results(operation_results)
-    end
-
-    def render_results(operation_results)
-      response_doc = create_response_document(operation_results)
-      content = response_doc.contents
+    def render_response_document
+      content = response_document.contents
 
       render_options = {}
-      if operation_results.has_errors?
+      if response_document.has_errors?
         render_options[:json] = content
       else
-        # Bypasing ActiveSupport allows us to use CompiledJson objects for cached response fragments
+        # Bypassing ActiveSupport allows us to use CompiledJson objects for cached response fragments
         render_options[:body] = JSON.generate(content)
-      end
 
-      render_options[:location] = content[:data]["links"][:self] if (
-        response_doc.status == :created && content[:data].class != Array
-      )
+        if (response_document.status == 201 && content[:data].class != Array) &&
+            content['data'] && content['data']['links'] && content['data']['links']['self']
+          render_options[:location] = content['data']['links']['self']
+        end
+      end
 
       # For whatever reason, `render` ignores :status and :content_type when :body is set.
       # But, we can just set those values directly in the Response object instead.
-      response.status = response_doc.status
+      response.status = response_document.status
       response.headers['Content-Type'] = JSONAPI::MEDIA_TYPE
 
       render(render_options)
     end
 
-    def create_response_document(operation_results)
+    def create_response_document
       JSONAPI::ResponseDocument.new(
-        operation_results,
-        operation_results.has_errors? ? nil : resource_serializer,
-        key_formatter: key_formatter,
-        base_meta: base_meta,
-        base_links: base_response_links,
-        request: @request
+          key_formatter: key_formatter,
+          base_meta: base_meta,
+          base_links: base_response_links,
+          request: request
       )
     end
 
@@ -260,21 +268,30 @@ module JSONAPI
     # Note: Be sure to either call super(e) or handle JSONAPI::Exceptions::Error and raise unhandled exceptions
     def handle_exceptions(e)
       case e
-      when JSONAPI::Exceptions::Error
-        render_errors(e.errors)
-      else
-        if JSONAPI.configuration.exception_class_whitelisted?(e)
-          fail e
+        when JSONAPI::Exceptions::Error
+          errors = e.errors
+        when ActionController::ParameterMissing
+          errors = JSONAPI::Exceptions::ParameterMissing.new(e.param).errors
         else
-          (self.class.server_error_callbacks || []).each { |callback|
-            safe_run_callback(callback, e)
-          }
+          if JSONAPI.configuration.exception_class_allowed?(e)
+            raise e
+          else
+            if self.class.server_error_callbacks
+              self.class.server_error_callbacks.each { |callback|
+                safe_run_callback(callback, e)
+              }
+            end
 
-          internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
-          Rails.logger.error { "Internal Server Error: #{e.message} #{e.backtrace.join("\n")}" }
-          render_errors(internal_server_error.errors)
-        end
+            # Store exception for other middlewares
+            request.env['action_dispatch.exception'] ||= e
+
+            internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
+            Rails.logger.error { "Internal Server Error: #{e.message} #{e.backtrace.join("\n")}" }
+            errors = internal_server_error.errors
+          end
       end
+
+      response_document.add_result(JSONAPI::ErrorsOperationResult.new(errors[0].status, errors), nil)
     end
 
     def safe_run_callback(callback, error)
@@ -283,7 +300,7 @@ module JSONAPI
       rescue => e
         Rails.logger.error { "Error in error handling callback: #{e.message} #{e.backtrace.join("\n")}" }
         internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
-        render_errors(internal_server_error.errors)
+        return JSONAPI::ErrorsOperationResult.new(internal_server_error.errors[0].code, internal_server_error.errors)
       end
     end
 
@@ -291,7 +308,7 @@ module JSONAPI
     # caught that is not a JSONAPI::Exceptions::Error
     # Useful for additional logging or notification configuration that
     # would normally depend on rails catching and rendering an exception.
-    # Ignores whitelist exceptions from config
+    # Ignores allowlist exceptions from config
 
     module ClassMethods