jsonapi-resources 0.9.12 → 0.10.0.beta1

data/lib/jsonapi/active_relation_resource_finder/join_tree.rb

@@ -0,0 +1,126 @@
+module JSONAPI
+  module ActiveRelationResourceFinder
+    class JoinTree
+      # Stores relationship paths starting from the resource_klass. This allows consolidation of duplicate paths from
+      # relationships, filters and sorts. This enables the determination of table aliases as they are joined.
+
+      attr_reader :resource_klass, :options, :source_relationship
+
+      def initialize(resource_klass:, options: {}, source_relationship: nil, filters: nil, sort_criteria: nil)
+        @resource_klass = resource_klass
+        @options = options
+        @source_relationship = source_relationship
+
+        @join_relationships = {}
+
+        add_sort_criteria(sort_criteria)
+        add_filters(filters)
+      end
+
+      # A hash of joins that can be used to create the required joins
+      def get_joins
+        walk_relation_node(@join_relationships)
+      end
+
+      def add_filters(filters)
+        return if filters.blank?
+        filters.each_key do |filter|
+          # Do not add joins for filters with an apply callable. This can be overridden by setting perform_joins to true
+          next if resource_klass._allowed_filters[filter].try(:[], :apply) &&
+              !resource_klass._allowed_filters[filter].try(:[], :perform_joins)
+
+          add_join(filter)
+        end
+      end
+
+      def add_sort_criteria(sort_criteria)
+        return if sort_criteria.blank?
+
+        sort_criteria.each do |sort|
+          add_join(sort[:field], :left)
+        end
+      end
+
+      private
+
+      def add_join_relationship(parent_joins, join_name, relation_name, type)
+        parent_joins[join_name] ||= {relation_name: relation_name, relationship: {}, type: type}
+        if parent_joins[join_name][:type] == :left && type == :inner
+          parent_joins[join_name][:type] = :inner
+        end
+        parent_joins[join_name][:relationship]
+      end
+
+      def add_join(path, default_type = :inner)
+        relationships, _field = resource_klass.parse_relationship_path(path)
+
+        current_joins = @join_relationships
+
+        terminated = false
+
+        relationships.each do |relationship|
+          if terminated
+            # ToDo: Relax this, if possible
+            # :nocov:
+            warn "Can not nest joins under polymorphic join"
+            # :nocov:
+          end
+
+          if relationship.polymorphic?
+            relation_names = relationship.polymorphic_relations
+            relation_names.each do |relation_name|
+              join_name = "#{relationship.name}[#{relation_name}]"
+              add_join_relationship(current_joins, join_name, relation_name, :left)
+            end
+            terminated = true
+          else
+            join_name = relationship.name
+            current_joins = add_join_relationship(current_joins, join_name, relationship.relation_name(options), default_type)
+          end
+        end
+      end
+
+      # Create a nested set of hashes from an array of path components. This will be used by the `join` methods.
+      # [post, comments] => { post: { comments: {} }
+      def relation_join_hash(path, path_hash = {})
+        relation = path.shift
+        if relation
+          path_hash[relation] = {}
+          relation_join_hash(path, path_hash[relation])
+        end
+        path_hash
+      end
+
+      # Returns the paths from shortest to longest, allowing the capture of the table alias for earlier paths. For
+      # example posts, posts.comments and then posts.comments.author joined in that order will alow each
+      # alias to be determined whereas just joining posts.comments.author will only record the author alias.
+      # ToDo: Dependence on this specialized logic should be removed in the future, if possible.
+      def walk_relation_node(node, paths = {}, current_relation_path = [], current_relationship_path = [])
+        node.each do |key, value|
+          if current_relation_path.empty? && source_relationship
+            current_relation_path << source_relationship.relation_name(options)
+          end
+
+          current_relation_path << value[:relation_name].to_s
+          current_relationship_path << key.to_s
+
+          rel_path = current_relationship_path.join('.')
+          paths[rel_path] ||= {
+              alias: nil,
+              join_type: value[:type],
+              relation_join_hash: relation_join_hash(current_relation_path.dup)
+          }
+
+          walk_relation_node(value[:relationship],
+                             paths,
+                             current_relation_path,
+                             current_relationship_path)
+
+          current_relation_path.pop
+          current_relationship_path.pop
+        end
+        paths
+      end
+    end
+  end
+end

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -9,9 +9,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
+
     def index
       process_request
     end
@@ -25,22 +28,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 +51,93 @@ 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
-
-      @request = JSONAPI::RequestParser.new(params, context: context,
-                                            key_formatter: key_formatter,
-                                            server_error_callbacks: (self.class.server_error_callbacks || []))
+    def get_related_resource
+      # :nocov:
+    ActiveSupport::Deprecation.warn "In #{self.class.name} you exposed a `get_related_resource`"\
+                                      " action. Please use `show_related_resource` instead."
+      show_related_resource
+      # :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)
-      end
-    rescue => e
-      handle_exceptions(e)
+    def get_related_resources
+      # :nocov:
+      ActiveSupport::Deprecation.warn "In #{self.class.name} you exposed a `get_related_resources`"\
+                                      " action. Please use `index_related_resource` instead."
+      index_related_resources
+      # :nocov:
     end
 
-    def process_operations(operations)
-      run_callbacks :process_operations do
-        operation_dispatcher.process(operations)
+    def process_request
+      @response_document = create_response_document
+
+      unless verify_content_type_header && verify_accept_header
+        render_response_document
+        return
       end
-    end
 
-    def transaction
-      lambda { |&block|
-        ActiveRecord::Base.transaction do
-          block.yield
+      request_parser = JSONAPI::RequestParser.new(
+          params,
+          context: context,
+          key_formatter: key_formatter,
+          server_error_callbacks: (self.class.server_error_callbacks || []))
+
+      transactional = request_parser.transactional?
+
+      begin
+        process_operations(transactional) do
+          run_callbacks :process_operations do
+            request_parser.each(response_document) 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
+              )
+              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
-      }
+      rescue => e
+        handle_exceptions(e)
+      end
+      render_response_document
     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,20 +150,6 @@ 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,
-        controller: self
-      )
-      @resource_serializer
-    end
-
     def base_url
       @base_url ||= request.protocol + request.host_with_port
     end
@@ -140,8 +159,10 @@ 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.content_type == JSONAPI::MEDIA_TYPE
+          fail JSONAPI::Exceptions::UnsupportedMediaTypeError.new(request.content_type)
+        end
       end
       true
     rescue => e
@@ -162,13 +183,12 @@ module JSONAPI
     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)
+  def media_types_for(header)
       (request.headers[header] || '')
         .scan(MEDIA_TYPE_MATCHER)
         .to_a
@@ -203,57 +223,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 && content[:data]["links"]
-      )
+        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
 
@@ -261,21 +267,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_whitelisted?(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)
@@ -284,7 +299,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