jpie 1.0.0 → 1.0.2

data/lib/json_api/controllers/concerns/controller_helpers.rb

@@ -1,223 +1,19 @@
 # frozen_string_literal: true
 
+require_relative "controller_helpers/parsing"
+require_relative "controller_helpers/error_rendering"
+require_relative "controller_helpers/resource_setup"
+require_relative "controller_helpers/authorization"
+require_relative "controller_helpers/document_meta"
+
 module JSONAPI
   module ControllerHelpers
     extend ActiveSupport::Concern
     include Responders
-
-    included do
-      attr_reader :resource_class, :model_class
-
-      before_action :parse_jsonapi_body, if: -> { request.post? || request.patch? || request.put? || request.delete? }
-    end
-
-    protected
-
-    def parse_jsonapi_body
-      return unless request.content_type&.include?("application/vnd.api+json")
-      return if params[:data].present?
-
-      body = request.body.read
-      request.body.rewind
-      return if body.blank?
-
-      parsed = JSON.parse(body)
-      parsed.deep_transform_keys!(&:to_sym)
-      request.env["action_dispatch.request.request_parameters"] = parsed
-    rescue JSON::ParserError
-      # Invalid JSON - will be handled by validation
-    end
-
-    def jsonapi_params
-      data = params.require(:data)
-
-      # Relationship requests may send an array of resource identifier objects.
-      return data if data.is_a?(Array)
-
-      permitted = data.permit(:type, :id, attributes: {})
-
-      # Manually permit relationships with nested data structures
-      if data[:relationships].present?
-        permitted[:relationships] = {}
-        data[:relationships].each do |key, value|
-          permitted[:relationships][key] = value.permit(data: %i[type id]) if value.is_a?(ActionController::Parameters)
-        end
-      end
-
-      permitted
-    end
-
-    def jsonapi_attributes
-      (jsonapi_params[:attributes] || {}).to_h
-    end
-
-    def jsonapi_relationships
-      jsonapi_params[:relationships] || {}
-    end
-
-    def jsonapi_type
-      data = jsonapi_params
-      return data.first[:type] if data.is_a?(Array)
-
-      data[:type]
-    end
-
-    def jsonapi_id
-      data = jsonapi_params
-      return data.first[:id].to_s.presence if data.is_a?(Array)
-
-      data[:id].to_s.presence
-    end
-
-    def parse_include_param
-      return [] unless params[:include]
-
-      params[:include].to_s.split(",").map(&:strip)
-    end
-
-    def parse_fields_param
-      return {} unless params[:fields]
-
-      params[:fields].permit!.to_h.each_with_object({}) do |(type, fields), hash|
-        hash[type.to_sym] = fields.to_s.split(",").map(&:strip)
-      end
-    end
-
-    def parse_filter_param
-      return {} unless params[:filter]
-
-      raw_filters = params[:filter].permit!.to_h
-      JSONAPI::ParamHelpers.flatten_filter_hash(raw_filters)
-    end
-
-    def parse_sort_param
-      return [] unless params[:sort]
-
-      params[:sort].to_s.split(",").map(&:strip)
-    end
-
-    def invalid_sort_fields_for_columns(sorts, available_columns)
-      sorts.filter_map do |sort_field|
-        field = JSONAPI::RelationshipHelpers.extract_sort_field_name(sort_field)
-        field unless available_columns.include?(field.to_s)
-      end
-    end
-
-    def valid_sort_fields_for_resource(resource_class, model_class)
-      # Include both database columns and resource-defined sortable fields
-      # (attributes + sort-only fields via permitted_sortable_fields)
-      model_columns = model_class.column_names.map(&:to_sym)
-      resource_sortable_fields = resource_class.permitted_sortable_fields.map(&:to_sym)
-      (model_columns + resource_sortable_fields).uniq.map(&:to_s)
-    end
-
-    def parse_page_param
-      return {} unless params[:page]
-
-      params[:page].permit(:number, :size).to_h
-    end
-
-    def set_resource_name
-      @resource_name = params[:resource_type].to_s.singularize
-    end
-
-    def set_resource_class
-      @resource_class = JSONAPI::ResourceLoader.find(params[:resource_type])
-      @model_class = @resource_class.model_class
-    rescue JSONAPI::ResourceLoader::MissingResourceClass => e
-      render_resource_not_found_error(e.message)
-    rescue NameError => e
-      render_model_not_found_error(e)
-    end
-
-    def set_resource
-      @resource = @preloaded_resource || model_class.find(params[:id])
-    rescue ActiveRecord::RecordNotFound
-      render_jsonapi_error(
-        status: 404,
-        title: "Record Not Found",
-        detail: "Could not find #{@resource_name} with id '#{params[:id]}'"
-      ) and return
-    end
-
-    def render_resource_not_found_error(message)
-      render_jsonapi_error(
-        status: 404,
-        title: "Resource Not Found",
-        detail: message
-      ) and return
-    end
-
-    def render_model_not_found_error(error)
-      render_jsonapi_error(
-        status: 404,
-        title: "Resource Not Found",
-        detail: "Model class for '#{@resource_name}' not found: #{error.message}"
-      ) and return
-    end
-
-    def render_invalid_relationship_error(error)
-      render_jsonapi_error(
-        status: 400,
-        title: "Invalid Relationship",
-        detail: error.message
-      ) and return
-    end
-
-    def render_validation_errors(resource)
-      errors = resource.errors.map do |error|
-        {
-          status: "422",
-          title: "Validation Error",
-          detail: error.full_message,
-          source: { pointer: "/data/attributes/#{error.attribute}" }
-        }
-      end
-
-      render json: { errors: }, status: :unprocessable_entity
-    end
-
-    def render_parameter_not_allowed_error(error)
-      params = error.respond_to?(:params) ? error.params : []
-
-      render json: {
-        errors: [
-          {
-            status: "400",
-            code: "parameter_not_allowed",
-            title: "Parameter Not Allowed",
-            detail: params.present? ? params.join(", ") : "Relationship or attribute is read-only"
-          }
-        ]
-      }, status: :bad_request
-    end
-
-    def apply_authorization_scope(scope, action:)
-      handler = JSONAPI.configuration.authorization_scope
-      return scope unless handler
-
-      handler.call(controller: self, scope:, action:, model_class:)
-    end
-
-    def authorize_resource_action!(record, action:, context: nil)
-      handler = JSONAPI.configuration.authorization_handler
-      return unless handler
-
-      handler.call(controller: self, record:, action:, context:)
-    end
-
-    def current_user
-      nil
-    end
-    public :current_user
-
-    def jsonapi_document_meta(extra_meta = {})
-      resolver = JSONAPI.configuration.document_meta_resolver
-      base_meta = resolver ? resolver.call(controller: self) : {}
-      meta = base_meta.merge(extra_meta || {})
-      return {} if meta.empty?
-
-      meta
-    end
+    include ControllerHelpers::Parsing
+    include ControllerHelpers::ErrorRendering
+    include ControllerHelpers::ResourceSetup
+    include ControllerHelpers::Authorization
+    include ControllerHelpers::DocumentMeta
   end
 end

data/lib/json_api/controllers/concerns/relationships/active_storage_removal.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Relationships
+    module ActiveStorageRemoval
+      extend ActiveSupport::Concern
+
+      private
+
+      def remove_active_storage_relationship(relationship_data)
+        reflection = @resource.class.reflect_on_attachment(@relationship_name)
+        if reflection&.macro == :has_many_attached
+          remove_many_active_storage_attachments(relationship_data)
+        else
+          remove_one_active_storage_attachment(relationship_data)
+        end
+      end
+
+      def remove_many_active_storage_attachments(relationship_data)
+        raise ArgumentError, "Expected array for to-many relationship removal" unless relationship_data.is_a?(Array)
+        return if relationship_data.empty?
+
+        attachment_proxy = @resource.public_send(@relationship_name)
+        return unless attachment_proxy.attached?
+
+        blob_ids = extract_blob_ids(relationship_data)
+        attachments = attachment_proxy.attachments.where(blob_id: blob_ids)
+        attachments.each(&:purge)
+      end
+
+      def remove_one_active_storage_attachment(relationship_data)
+        validate_single_removal_identifier!(relationship_data)
+        return if relationship_data.nil?
+
+        attachment_proxy = @resource.public_send(@relationship_name)
+        return unless attachment_proxy.attached?
+
+        blob_id = extract_single_blob_id(relationship_data)
+        attachment = attachment_proxy.attachments.find_by(blob_id:)
+        attachment&.purge
+      end
+
+      def extract_blob_ids(relationship_data)
+        relationship_data.map { |identifier| extract_blob_id_from_identifier(identifier) }
+      end
+
+      def extract_single_blob_id(relationship_data)
+        extract_blob_id_from_identifier(relationship_data)
+      end
+
+      def extract_blob_id_from_identifier(identifier)
+        type = RelationshipHelpers.extract_type_from_identifier(identifier)
+        id = RelationshipHelpers.extract_id_from_identifier(identifier)
+        validate_blob_type!(type)
+        id.to_i
+      end
+
+      def validate_blob_type!(type)
+        return if self.class.active_storage_blob_type?(type)
+
+        raise ArgumentError, "Expected active_storage_blobs type, got #{type}"
+      end
+    end
+  end
+end

data/lib/json_api/controllers/concerns/relationships/events.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Relationships
+    module Events
+      extend ActiveSupport::Concern
+
+      private
+
+      def emit_relationship_event(action, relationship_data)
+        resource_type_name = params[:resource_type] || @resource_name.pluralize
+
+        JSONAPI::Instrumentation.relationship_event(
+          action:,
+          resource_type: resource_type_name,
+          resource_id: @resource.id,
+          relationship_name: @relationship_name.to_s,
+          related_ids: extract_related_ids(relationship_data),
+          related_type: extract_related_type(relationship_data),
+        )
+      end
+
+      def extract_related_ids(relationship_data)
+        return nil if relationship_data.nil?
+
+        if relationship_data.is_a?(Array)
+          relationship_data.filter_map { |item| item[:id] }
+        else
+          [relationship_data[:id]].compact
+        end
+      end
+
+      def extract_related_type(relationship_data)
+        return nil if relationship_data.nil?
+
+        if relationship_data.is_a?(Array)
+          relationship_data.first&.dig(:type)
+        else
+          relationship_data[:type]
+        end
+      end
+    end
+  end
+end

data/lib/json_api/controllers/concerns/relationships/removal.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "active_storage_removal"
+
+module JSONAPI
+  module Relationships
+    module Removal
+      extend ActiveSupport::Concern
+      include ActiveStorageRemoval
+
+      private
+
+      def remove_relationship(relationship_data)
+        if active_storage_attachment?(@relationship_name, @resource.class)
+          return remove_active_storage_relationship(relationship_data)
+        end
+
+        remove_association_relationship(relationship_data)
+      rescue ActiveRecord::NotNullViolation, ActiveRecord::RecordInvalid => e
+        raise ArgumentError, "Cannot remove relationship: #{e.message}"
+      end
+
+      def remove_association_relationship(relationship_data)
+        association = @resource.class.reflect_on_association(@relationship_name)
+        raise ArgumentError, "Association not found: #{@relationship_name}" unless association
+
+        ensure_relationship_writable!(association)
+        dispatch_relationship_removal(association, relationship_data)
+      end
+
+      def dispatch_relationship_removal(association, relationship_data)
+        if association.collection?
+          remove_from_many_relationship(association, relationship_data)
+        else
+          remove_from_one_relationship(association, relationship_data)
+        end
+      end
+
+      def remove_from_many_relationship(association, relationship_data)
+        raise ArgumentError, "Expected array for to-many relationship removal" unless relationship_data.is_a?(Array)
+        return if relationship_data.empty?
+
+        remove_from_collection(association, relationship_data)
+      end
+
+      def remove_from_collection(association, relationship_data)
+        collection_ids = @resource.public_send(@relationship_name).pluck(:id)
+        foreign_key = association.foreign_key
+
+        ActiveRecord::Base.transaction do
+          relationship_data.each do |identifier|
+            remove_resource_from_collection(identifier, association, collection_ids, foreign_key)
+          end
+        end
+      end
+
+      def remove_resource_from_collection(identifier, association, collection_ids, foreign_key)
+        resource = RelationshipHelpers.resolve_and_find_related_resource(
+          identifier,
+          association:,
+          resource_class: @resource_class,
+          relationship_name: @relationship_name,
+        )
+        return unless collection_ids.include?(resource.id)
+
+        resource.update!(foreign_key => nil)
+      end
+
+      def remove_from_one_relationship(association, relationship_data)
+        validate_single_removal_identifier!(relationship_data)
+        return if relationship_data.nil?
+
+        remove_single_association(association, relationship_data)
+      end
+
+      def validate_single_removal_identifier!(relationship_data)
+        return unless relationship_data.is_a?(Array)
+
+        raise ArgumentError, "Expected single resource identifier for to-one relationship"
+      end
+
+      def remove_single_association(association, relationship_data)
+        related_resource = find_related_resource(relationship_data, association)
+        current_resource = @resource.public_send(@relationship_name)
+        return unless current_resource == related_resource
+
+        @resource.public_send("#{@relationship_name}=", nil)
+        @resource.save!
+      end
+    end
+  end
+end

data/lib/json_api/controllers/concerns/relationships/response_helpers.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Relationships
+    module ResponseHelpers
+      extend ActiveSupport::Concern
+
+      private
+
+      def build_show_response
+        response_data = { data: serialize_relationship_data, links: serialize_relationship_links }
+        meta = serialize_relationship_meta
+        response_data[:meta] = meta if meta.present?
+        response_data
+      end
+
+      def save_and_render_relationship(relationship_data)
+        if @resource.save
+          emit_relationship_event(:updated, relationship_data)
+          render_relationship_response
+        else
+          render_validation_errors(@resource)
+        end
+      end
+
+      def render_relationship_response
+        render json: {
+          data: serialize_relationship_data,
+          links: serialize_relationship_links,
+          meta: serialize_relationship_meta,
+        }.compact, status: :ok
+      end
+
+      def finalize_relationship_removal(relationship_data)
+        association = @resource.class.reflect_on_association(@relationship_name)
+        return emit_and_respond_no_content(relationship_data) unless association && !association.collection?
+
+        save_to_one_removal(relationship_data)
+      end
+
+      def save_to_one_removal(relationship_data)
+        if @resource.save
+          emit_and_respond_no_content(relationship_data)
+        else
+          render_validation_errors(@resource)
+        end
+      end
+
+      def emit_and_respond_no_content(relationship_data)
+        emit_relationship_event(:removed, relationship_data)
+        head :no_content
+      end
+    end
+  end
+end

data/lib/json_api/controllers/concerns/relationships/serialization.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Relationships
+    module Serialization
+      extend ActiveSupport::Concern
+
+      private
+
+      def serialize_relationship_data
+        association = @resource.class.reflect_on_association(@relationship_name)
+        return nil unless association
+
+        related = fetch_related_data(association)
+        serialize_related(related, association)
+      end
+
+      def fetch_related_data(association)
+        related = @resource.public_send(@relationship_name)
+        return related unless association.collection? && related.respond_to?(:order)
+
+        apply_sorting_to_relationship(related, association)
+      end
+
+      def serialize_related(related, association)
+        return serialize_collection_relationship(related, association) if association.collection?
+
+        serialize_single_relationship(related, association) if related
+      end
+
+      def serialize_collection_relationship(related, association)
+        return [] if related.nil?
+
+        related.map { |r| serialize_resource_identifier(r, association) }
+      end
+
+      def serialize_single_relationship(related, association)
+        serialize_resource_identifier(related, association)
+      end
+
+      def serialize_resource_identifier(resource_instance, association)
+        RelationshipHelpers.serialize_resource_identifier(
+          resource_instance,
+          association:,
+          resource_class: @resource_class,
+        )
+      end
+
+      def serialize_relationship_links
+        {
+          self: relationship_self_url,
+          related: relationship_related_url,
+        }
+      end
+
+      def relationship_self_url
+        "/#{params[:resource_type]}/#{params[:id]}/relationships/#{params[:relationship_name]}"
+      end
+
+      def relationship_related_url
+        "/#{params[:resource_type]}/#{params[:id]}/#{params[:relationship_name]}"
+      end
+
+      def serialize_relationship_meta
+        relationship_def = find_relationship_definition
+        return nil unless relationship_def
+
+        relationship_def[:meta]
+      end
+    end
+  end
+end

data/lib/json_api/controllers/concerns/relationships/sorting.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Relationships
+    module Sorting
+      extend ActiveSupport::Concern
+
+      private
+
+      def apply_sorting_to_relationship(related, association)
+        sorts = parse_sort_param
+        return related if sorts.empty?
+
+        related_model = association.klass
+        db_sorts, virtual_sorts = partition_sorts_by_type(sorts, related_model)
+
+        related = apply_db_sorts(related, db_sorts)
+        apply_virtual_sorts_if_needed(related, virtual_sorts, related_model)
+      end
+
+      def partition_sorts_by_type(sorts, related_model)
+        sorts.partition do |sort_field|
+          field = RelationshipHelpers.extract_sort_field_name(sort_field)
+          related_model.column_names.include?(field.to_s)
+        end
+      end
+
+      def apply_db_sorts(related, db_sorts)
+        db_sorts.each do |sort_field|
+          direction = RelationshipHelpers.extract_sort_direction(sort_field)
+          field = RelationshipHelpers.extract_sort_field_name(sort_field)
+          related = related.order(field => direction)
+        end
+        related
+      end
+
+      def apply_virtual_sorts_if_needed(related, virtual_sorts, related_model)
+        return related unless virtual_sorts.any?
+
+        resource_class = ResourceLoader.find_for_model(related_model)
+        sort_records_by_virtual_attributes(related.to_a, virtual_sorts, resource_class)
+      end
+
+      def sort_records_by_virtual_attributes(records, virtual_sorts, resource_class)
+        records.sort do |a, b|
+          compare_records(a, b, virtual_sorts, resource_class)
+        end
+      end
+
+      def compare_records(record_a, record_b, virtual_sorts, resource_class)
+        virtual_sorts.each do |sort_field|
+          comparison = compare_by_field(record_a, record_b, sort_field, resource_class)
+          return comparison unless comparison.zero?
+        end
+        0
+      end
+
+      def compare_by_field(record_a, record_b, sort_field, resource_class)
+        direction = RelationshipHelpers.extract_sort_direction(sort_field)
+        field = RelationshipHelpers.extract_sort_field_name(sort_field)
+
+        value_a = get_virtual_value(record_a, field, resource_class)
+        value_b = get_virtual_value(record_b, field, resource_class)
+
+        comparison = compare_values(value_a, value_b)
+        direction == :desc ? -comparison : comparison
+      end
+
+      def get_virtual_value(record, field, resource_class)
+        resource_instance = resource_class.new(record, {})
+        field_sym = field.to_sym
+        return resource_instance.public_send(field_sym) if resource_instance.respond_to?(field_sym, false)
+
+        nil
+      end
+
+      def compare_values(value_a, value_b)
+        return 0 if value_a.nil? && value_b.nil?
+        return -1 if value_a.nil?
+        return 1 if value_b.nil?
+
+        value_a <=> value_b
+      end
+
+      def validate_sort_param
+        sorts = parse_sort_param
+        return if sorts.empty?
+
+        association = @resource.class.reflect_on_association(@relationship_name)
+        return unless association&.collection?
+
+        validate_sort_fields_for_association(sorts, association)
+      end
+
+      def validate_sort_fields_for_association(sorts, association)
+        resource_class = ResourceLoader.find_for_model(association.klass)
+        valid_fields = valid_sort_fields_for_resource(resource_class, association.klass)
+        invalid_fields = invalid_sort_fields_for_columns(sorts, valid_fields)
+        return if invalid_fields.empty?
+
+        render_invalid_sort_fields(invalid_fields)
+      end
+
+      def render_invalid_sort_fields(invalid_fields)
+        render_parameter_errors(
+          invalid_fields,
+          title: "Invalid Sort Field",
+          detail_proc: ->(field) { "Invalid sort field requested: #{field}" },
+          source_proc: ->(_field) { { parameter: "sort" } },
+        )
+      end
+    end
+  end
+end