jpie 1.0.0 → 1.0.1

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Relationships
+    module Updating
+      extend ActiveSupport::Concern
+
+      private
+
+      def update_relationship(relationship_data)
+        association = @resource.class.reflect_on_association(@relationship_name)
+        raise ArgumentError, "Association not found: #{@relationship_name}" unless association
+
+        ensure_relationship_writable!(association)
+        apply_relationship_update(association, relationship_data)
+      end
+
+      def apply_relationship_update(association, relationship_data)
+        if association.collection?
+          update_to_many_relationship(association, relationship_data)
+        else
+          update_to_one_relationship(association, relationship_data)
+        end
+      end
+
+      def update_to_many_relationship(association, relationship_data)
+        if relationship_data.nil? || empty_array?(relationship_data)
+          @resource.public_send("#{@relationship_name}=", [])
+          return
+        end
+
+        raise ArgumentError, "Expected array for to-many relationship" unless relationship_data.is_a?(Array)
+
+        related_resources = resolve_related_resources(relationship_data, association)
+        @resource.public_send("#{@relationship_name}=", related_resources)
+      end
+
+      def empty_array?(data)
+        data.is_a?(Array) && data.empty?
+      end
+
+      def resolve_related_resources(relationship_data, association)
+        relationship_data.map { |identifier| find_related_resource(identifier, association) }
+      end
+
+      def update_to_one_relationship(association, relationship_data)
+        if relationship_data.nil?
+          @resource.public_send("#{@relationship_name}=", nil)
+          return
+        end
+
+        validate_single_identifier!(relationship_data)
+        related_resource = find_related_resource(relationship_data, association)
+        @resource.public_send("#{@relationship_name}=", related_resource)
+      end
+
+      def validate_single_identifier!(relationship_data)
+        return unless relationship_data.is_a?(Array)
+
+        raise ArgumentError, "Expected single resource identifier for to-one relationship"
+      end
+
+      def find_related_resource(identifier, association)
+        RelationshipHelpers.resolve_and_find_related_resource(
+          identifier,
+          association:,
+          resource_class: @resource_class,
+          relationship_name: @relationship_name,
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module RelationshipsController
+    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 do |identifier|
+          extract_blob_id_from_identifier(identifier)
+        end
+      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_controller/events.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module RelationshipsController
+    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_controller/removal.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "active_storage_removal"
+
+module JSONAPI
+  module RelationshipsController
+    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_controller/response_helpers.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module RelationshipsController
+    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_controller/serialization.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module RelationshipsController
+    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_controller/sorting.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module RelationshipsController
+    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

data/lib/json_api/controllers/concerns/relationships_controller/updating.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module RelationshipsController
+    module Updating
+      extend ActiveSupport::Concern
+
+      private
+
+      def update_relationship(relationship_data)
+        association = @resource.class.reflect_on_association(@relationship_name)
+        raise ArgumentError, "Association not found: #{@relationship_name}" unless association
+
+        ensure_relationship_writable!(association)
+        apply_relationship_update(association, relationship_data)
+      end
+
+      def apply_relationship_update(association, relationship_data)
+        if association.collection?
+          update_to_many_relationship(association, relationship_data)
+        else
+          update_to_one_relationship(association, relationship_data)
+        end
+      end
+
+      def update_to_many_relationship(association, relationship_data)
+        if relationship_data.nil? || empty_array?(relationship_data)
+          @resource.public_send("#{@relationship_name}=", [])
+          return
+        end
+
+        raise ArgumentError, "Expected array for to-many relationship" unless relationship_data.is_a?(Array)
+
+        related_resources = resolve_related_resources(relationship_data, association)
+        @resource.public_send("#{@relationship_name}=", related_resources)
+      end
+
+      def empty_array?(data)
+        data.is_a?(Array) && data.empty?
+      end
+
+      def resolve_related_resources(relationship_data, association)
+        relationship_data.map { |identifier| find_related_resource(identifier, association) }
+      end
+
+      def update_to_one_relationship(association, relationship_data)
+        if relationship_data.nil?
+          @resource.public_send("#{@relationship_name}=", nil)
+          return
+        end
+
+        validate_single_identifier!(relationship_data)
+        related_resource = find_related_resource(relationship_data, association)
+        @resource.public_send("#{@relationship_name}=", related_resource)
+      end
+
+      def validate_single_identifier!(relationship_data)
+        return unless relationship_data.is_a?(Array)
+
+        raise ArgumentError, "Expected single resource identifier for to-one relationship"
+      end
+
+      def find_related_resource(identifier, association)
+        RelationshipHelpers.resolve_and_find_related_resource(
+          identifier,
+          association:,
+          resource_class: @resource_class,
+          relationship_name: @relationship_name,
+        )
+      end
+    end
+  end
+end

data/lib/json_api/controllers/concerns/resource_actions/crud_helpers.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module ResourceActions
+    module CrudHelpers
+      extend ActiveSupport::Concern
+
+      private
+
+      def prepare_create_params(sti_class)
+        hash = deserialize_params(:create, model_class: sti_class)
+        attachments = extract_active_storage_params_from_hash(hash, sti_class)
+        clean_params(hash, attachments)
+        apply_sti_type(sti_class, hash)
+        [hash, attachments]
+      end
+
+      def prepare_update_params
+        hash = deserialize_params(:update)
+        attachments = extract_active_storage_params_from_hash(hash, model_class)
+        clean_params(hash, attachments)
+        [hash, attachments]
+      end
+
+      def clean_params(hash, attachments)
+        attachments.each_key { |k| hash.delete(k.to_s) }
+        hash.delete("type")
+        hash.delete(:type)
+      end
+
+      def apply_sti_type(klass, params)
+        return unless sti_base_with_type_column?(klass)
+
+        params["type"] = klass.name
+      end
+
+      def sti_base_with_type_column?(klass)
+        klass.respond_to?(:base_class) && klass.base_class == klass && klass.column_names.include?("type")
+      end
+
+      def save_created(resource)
+        return render_validation_errors(resource) unless resource.save
+
+        emit_resource_event(:created, resource)
+        render json: serialize_resource(resource), status: :created, location: resource_url(resource)
+      end
+
+      def save_updated(params_hash, attachments)
+        return render_validation_errors(@resource) unless @resource.update(params_hash)
+
+        attach_active_storage_files(@resource, attachments, resource_class: @resource_class)
+        emit_resource_event(:updated, @resource)
+        render json: serialize_resource(@resource), status: :ok
+      end
+
+      def render_create_error(error)
+        if error.message.match?(/invalid.*subtype/i)
+          render_invalid_subtype_error(error)
+        else
+          render_invalid_relationship_error(error)
+        end
+      end
+
+      def render_update_error(error)
+        if error.is_a?(ActiveSupport::MessageVerifier::InvalidSignature)
+          render_signed_id_error(error)
+        else
+          render_invalid_relationship_error(error)
+        end
+      end
+
+      def render_signed_id_error(error)
+        render_jsonapi_error(
+          status: 400,
+          title: "Invalid Signed ID",
+          detail: "Invalid signed blob ID provided: #{error.message}",
+        )
+      end
+
+      def determine_sti_class
+        JSONAPI::ResourceLoader.find(jsonapi_type || resource_type).model_class
+      rescue JSONAPI::ResourceLoader::MissingResourceClass
+        model_class
+      end
+
+      def determine_sti_resource_class
+        JSONAPI::ResourceLoader.find(jsonapi_type || resource_type)
+      rescue JSONAPI::ResourceLoader::MissingResourceClass
+        @resource_class
+      end
+    end
+  end
+end