jpie 0.4.5 → 1.0.1

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module ControllerHelpers
+    module Parsing
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :parse_jsonapi_body, if: -> { modifying_request? }
+      end
+
+      protected
+
+      def parse_jsonapi_body
+        return unless jsonapi_content_type?
+        return if params[:data].present?
+
+        parse_and_apply_json_body
+      rescue JSON::ParserError
+        # Invalid JSON - will be handled by validation
+      end
+
+      def modifying_request?
+        request.post? || request.patch? || request.put? || request.delete?
+      end
+
+      def jsonapi_content_type?
+        request.content_type&.include?("application/vnd.api+json")
+      end
+
+      def parse_and_apply_json_body
+        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
+      end
+
+      def jsonapi_params
+        data = params.require(:data)
+        return data if data.is_a?(Array)
+
+        permitted = data.permit(:type, :id, attributes: {})
+        permitted[:relationships] = permit_relationships(data) if data[:relationships].present?
+        permitted
+      end
+
+      def permit_relationships(data)
+        result = {}
+        data[:relationships].each do |key, value|
+          result[key] = value.permit(data: %i[type id]) if value.is_a?(ActionController::Parameters)
+        end
+        result
+      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 parse_page_param
+        return {} unless params[:page]
+
+        params[:page].permit(:number, :size).to_h
+      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)
+        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
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module ControllerHelpers
+    module ResourceSetup
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :resource_class, :model_class
+      end
+
+      protected
+
+      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]}'",
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +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
+    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