jpie 1.0.0 → 1.0.2

data/lib/json_api/support/concerns/polymorphic_filters.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module PolymorphicFilters
+      def apply_polymorphic_nested_filters(scope, association, _relationship_name, attributes)
+        context = build_polymorphic_filter_context(association, attributes)
+
+        attributes.each do |attr_name, attr_value|
+          scope = apply_polymorphic_attribute_filter(scope, attr_name, attr_value, context)
+        end
+
+        apply_final_type_filter(scope, context)
+      end
+
+      private
+
+      def build_polymorphic_filter_context(association, attributes)
+        {
+          foreign_key: association.foreign_key,
+          foreign_type: association.foreign_type,
+          fk_column: model_class.column_for_attribute(association.foreign_key),
+          type_value: attributes["type"] || attributes["type_eq"],
+          class_name: association.options[:class_name],
+        }
+      end
+
+      def apply_polymorphic_attribute_filter(scope, attr_name, attr_value, context)
+        return scope if empty_filter_value?(attr_value)
+        return scope if attr_name == "type"
+
+        scope = apply_polymorphic_id_filter(scope, attr_name, attr_value, context)
+        apply_polymorphic_type_filter(scope, context)
+      end
+
+      def apply_polymorphic_id_filter(scope, attr_name, attr_value, context)
+        column_filter = parse_column_filter(attr_name)
+        return apply_polymorphic_fk_filter(scope, attr_value, column_filter, context) if polymorphic_fk_filter?(
+          column_filter, context,
+        )
+        return scope.where(context[:foreign_key] => attr_value) if attr_name == "id"
+
+        scope
+      end
+
+      def polymorphic_fk_filter?(column_filter, context)
+        column_filter && column_filter[:column] == "id" && context[:fk_column]
+      end
+
+      def apply_polymorphic_fk_filter(scope, attr_value, column_filter, context)
+        value = normalize_filter_value_for_model(model_class, context[:fk_column], attr_value)
+        return scope unless value
+
+        condition = build_condition_for_model(model_class, context[:fk_column], value, column_filter[:operator])
+        condition ? apply_condition(scope, condition) : scope
+      end
+
+      def apply_polymorphic_type_filter(scope, context)
+        return scope unless context[:foreign_type]
+        return scope.where(context[:foreign_type] => context[:class_name]) if context[:class_name]
+        return scope.where(context[:foreign_type] => context[:type_value]) if context[:type_value]
+
+        scope
+      end
+
+      def apply_final_type_filter(scope, context)
+        return scope unless context[:foreign_type]
+        return scope if context[:class_name]
+        return scope unless context[:type_value]
+
+        scope.where(context[:foreign_type] => context[:type_value])
+      end
+    end
+  end
+end

data/lib/json_api/support/concerns/regular_filters.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module RegularFilters
+      def apply_regular_filters(scope)
+        return scope if filter_params.empty?
+
+        regular_filters = filter_params.reject { |k, _v| k.to_s.include?(".") }
+        return scope if regular_filters.empty?
+
+        regular_filters.reduce(scope) do |current_scope, (filter_name, filter_value)|
+          apply_regular_filter(current_scope, filter_name.to_s, filter_value)
+        end
+      end
+
+      private
+
+      def apply_regular_filter(scope, filter_name, filter_value)
+        return scope if filter_value.respond_to?(:empty?) ? filter_value.empty? : filter_value.nil?
+
+        column_filter = parse_column_filter(filter_name)
+        if column_filter
+          apply_column_filter(scope, column_filter, filter_value)
+        else
+          apply_scope_fallback(scope, filter_name, filter_value)
+        end
+      end
+
+      def parse_column_filter(filter_name)
+        match = filter_name.match(/\A(.+)_(eq|match|lt|lte|gt|gte)\z/)
+        return nil unless match
+
+        column_name = match[1]
+        operator = match[2].to_sym
+
+        { column: column_name, operator: }
+      end
+
+      def apply_column_filter(scope, column_filter, raw_value)
+        condition = build_column_condition(column_filter, raw_value)
+        condition ? apply_condition(scope, condition) : scope
+      rescue StandardError => e
+        log_filter_error(column_filter, column_filter[:operator], e)
+        scope
+      end
+
+      def build_column_condition(column_filter, raw_value)
+        column = model_class.column_for_attribute(column_filter[:column])
+        return nil unless column
+
+        value = normalize_filter_value(column, raw_value)
+        return nil if value.nil?
+
+        build_condition(column, value, column_filter[:operator])
+      end
+
+      def log_filter_error(column_filter, operator, error)
+        return unless defined?(Rails.logger)
+
+        Rails.logger.warn("Filter error for #{column_filter[:column]}_#{operator}: #{error.class} - #{error.message}")
+      end
+
+      def normalize_filter_value(column, raw_value)
+        value = raw_value.is_a?(Array) ? raw_value.first : raw_value
+        return nil if value.nil?
+
+        type = model_class.type_for_attribute(column.name)
+        type.cast(value)
+      end
+
+      def apply_scope_fallback(scope, filter_name, filter_value)
+        return scope unless model_class.respond_to?(filter_name.to_sym)
+
+        scope.public_send(filter_name.to_sym, filter_value)
+      rescue ArgumentError, NoMethodError
+        scope
+      end
+    end
+  end
+end

data/lib/json_api/support/concerns/sorting.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module Sorting
+      def apply_sorting(scope)
+        return scope if sort_params.empty?
+
+        has_virtual_sorts = sort_params.any? { |sort_field| virtual_attribute_sort?(sort_field) }
+        has_virtual_sorts ? apply_virtual_sorting(scope) : apply_db_sorting(scope)
+      end
+
+      private
+
+      def apply_virtual_sorting(scope)
+        records = scope.to_a
+        apply_mixed_sorting(records, sort_params)
+      end
+
+      def apply_db_sorting(scope)
+        sort_params.each do |sort_field|
+          direction = RelationshipHelpers.extract_sort_direction(sort_field)
+          field = RelationshipHelpers.extract_sort_field_name(sort_field)
+          scope = scope.order(field => direction)
+        end
+        scope
+      end
+
+      def virtual_attribute_sort?(sort_field)
+        field = RelationshipHelpers.extract_sort_field_name(sort_field)
+        !model_class.column_names.include?(field.to_s)
+      end
+
+      def apply_mixed_sorting(records, all_sorts)
+        records.sort do |a, b|
+          compare_by_sort_criteria(a, b, all_sorts)
+        end
+      end
+
+      def compare_by_sort_criteria(record_a, record_b, all_sorts)
+        all_sorts.each do |sort_field|
+          direction = RelationshipHelpers.extract_sort_direction(sort_field)
+          field = RelationshipHelpers.extract_sort_field_name(sort_field)
+          value_a = fetch_sort_value(record_a, field)
+          value_b = fetch_sort_value(record_b, field)
+          comparison = compare_values(value_a, value_b)
+          next if comparison.zero?
+
+          return direction == :desc ? -comparison : comparison
+        end
+        0
+      end
+
+      def fetch_sort_value(record, field)
+        return fetch_column_value(record, field) if model_class.column_names.include?(field.to_s)
+
+        fetch_virtual_attribute_value(record, field)
+      end
+
+      def fetch_column_value(record, field)
+        return record.public_send(field.to_sym) if record.respond_to?(field.to_sym)
+        return nil unless record.respond_to?(:attributes) && record.attributes.is_a?(Hash)
+
+        record.attributes[field.to_s] || record.attributes[field.to_sym]
+      end
+
+      def fetch_virtual_attribute_value(record, field)
+        definition_instance = definition.new(record, {})
+        fetch_virtual_value(definition_instance, field)
+      end
+
+      def fetch_virtual_value(definition_instance, field)
+        field_sym = field.to_sym
+        return definition_instance.public_send(field_sym) if definition_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
+    end
+  end
+end

data/lib/json_api/support/instrumentation.rb

@@ -14,7 +14,7 @@ module JSONAPI
           "jsonapi.#{resource_type}.#{action}",
           resource_type:,
           resource_id:,
-          changes: changes.compact
+          changes: changes.compact,
         )
       end
     end
@@ -23,19 +23,20 @@ module JSONAPI
                                 related_type: nil)
       return unless enabled?
 
-      payload = {
-        resource_type:,
-        resource_id:,
-        relationship_name:
-      }
-      payload[:related_type] = related_type if related_type
-      payload[:related_ids] = Array(related_ids) if related_ids
+      payload = build_relationship_payload(resource_type, resource_id, relationship_name, related_type, related_ids)
+      notify_relationship(action, resource_type, payload)
+    end
+
+    def self.build_relationship_payload(resource_type, resource_id, relationship_name, related_type, related_ids)
+      { resource_type:, resource_id:, relationship_name: }.tap do |p|
+        p[:related_type] = related_type if related_type
+        p[:related_ids] = Array(related_ids) if related_ids
+      end
+    end
 
+    def self.notify_relationship(action, resource_type, payload)
       Rails.event.tagged("jsonapi", "relationship") do
-        Rails.event.notify(
-          "jsonapi.#{resource_type}.relationship.#{action}",
-          payload
-        )
+        Rails.event.notify("jsonapi.#{resource_type}.relationship.#{action}", payload)
       end
     end
   end

data/lib/json_api/support/param_helpers.rb

@@ -39,13 +39,16 @@ module JSONAPI
     end
 
     def build_query_parts_for_param(key, value)
-      if value.is_a?(Hash)
-        value.map { |k, v| "#{CGI.escape(key.to_s)}[#{CGI.escape(k.to_s)}]=#{CGI.escape(v.to_s)}" }
-      elsif value.is_a?(Array)
-        value.map { |v| "#{CGI.escape(key.to_s)}=#{CGI.escape(v.to_s)}" }
-      else
-        ["#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"]
+      encoded_key = CGI.escape(key.to_s)
+      case value
+      when Hash then value.map { |k, v| "#{encoded_key}[#{esc(k)}]=#{esc(v)}" }
+      when Array then value.map { |v| "#{encoded_key}=#{esc(v)}" }
+      else ["#{encoded_key}=#{esc(value)}"]
       end
     end
+
+    def esc(val)
+      CGI.escape(val.to_s)
+    end
   end
 end

data/lib/json_api/support/relationship_helpers.rb

@@ -27,14 +27,16 @@ module JSONAPI
     end
 
     # Delegate to ResourceIdentifier
+    # rubocop:disable Lint/UnusedMethodArgument
     def serialize_resource_identifier(
       record, association: nil, resource_class: nil, use_instance_class: false, base_resource_class: nil
     )
+      # rubocop:enable Lint/UnusedMethodArgument
       ResourceIdentifier.serialize_identifier(
         record,
         association:,
         definition: resource_class,
-        use_instance_class:
+        use_instance_class:,
       )
     end
 
@@ -51,7 +53,7 @@ module JSONAPI
         identifier,
         association:,
         definition: resource_class,
-        relationship_name:
+        relationship_name:,
       )
     end
 

data/lib/json_api/support/resource_identifier.rb

@@ -6,7 +6,7 @@ module JSONAPI
 
     def serialize_identifier(record, association:, definition:, use_instance_class: false)
       model_class = determine_model_class(record, association:, definition:,
-                                                  use_instance_class:)
+                                                  use_instance_class:,)
       related_definition = JSONAPI::ResourceLoader.find_for_model(model_class)
       related_type = TypeConversion.resource_type_name(related_definition)
 
@@ -24,31 +24,34 @@ module JSONAPI
     def resolve_and_find_related_record(identifier, association:, definition:, relationship_name:)
       type = extract_type(identifier)
       id = extract_id(identifier)
-
       raise ArgumentError, "Missing type or id in relationship data" unless type && id
 
       is_polymorphic = polymorphic_association?(definition, relationship_name)
+      validate_relationship_type!(type, association) unless is_polymorphic
 
-      unless is_polymorphic
-        expected_type = TypeConversion.model_type_name(association.klass)
-        if type != expected_type
-          raise ArgumentError, "Invalid relationship type: expected #{expected_type}, got #{type}"
-        end
-      end
+      find_related_record(type, id, association, is_polymorphic)
+    end
 
-      begin
-        related_model_class = if is_polymorphic
-                                TypeConversion.type_to_class_name(type).constantize
-                              else
-                                association.klass
-                              end
-
-        related_model_class.find(id)
-      rescue ActiveRecord::RecordNotFound
-        raise ArgumentError, "Related resource not found: #{type} with id #{id}"
-      rescue NameError
-        raise ArgumentError, "Invalid relationship type: #{type} does not correspond to a valid model class"
-      end
+    def validate_relationship_type!(type, association)
+      expected_type = TypeConversion.model_type_name(association.klass)
+      return if type == expected_type
+
+      raise ArgumentError, "Invalid relationship type: expected #{expected_type}, got #{type}"
+    end
+
+    def find_related_record(type, id, association, is_polymorphic)
+      related_model_class = resolve_related_model_class(type, association, is_polymorphic)
+      related_model_class.find(id)
+    rescue ActiveRecord::RecordNotFound
+      raise ArgumentError, "Related resource not found: #{type} with id #{id}"
+    rescue NameError
+      raise ArgumentError, "Invalid relationship type: #{type} does not correspond to a valid model class"
+    end
+
+    def resolve_related_model_class(type, association, is_polymorphic)
+      return TypeConversion.type_to_class_name(type).constantize if is_polymorphic
+
+      association.klass
     end
 
     def polymorphic_association?(definition, relationship_name)
@@ -67,14 +70,11 @@ module JSONAPI
     end
 
     def determine_model_class(record, association:, definition:, use_instance_class:)
-      if association && (polymorphic_association_for_association?(association, definition) ||
-                         (use_instance_class && sti_subclass?(record.class, association.klass)))
-        record.class
-      elsif association
-        association.klass
-      else
-        record.class
-      end
+      return record.class if association.nil?
+      return record.class if polymorphic_association_for_association?(association, definition)
+      return record.class if use_instance_class && sti_subclass?(record.class, association.klass)
+
+      association.klass
     end
 
     def polymorphic_association_for_association?(association, definition)

data/lib/json_api/support/responders.rb

@@ -22,9 +22,9 @@ module JSONAPI
           {
             status: "415",
             title: "Unsupported Media Type",
-            detail: "Content-Type must be application/vnd.api+json"
-          }
-        ]
+            detail: "Content-Type must be application/vnd.api+json",
+          },
+        ],
       }, status: :unsupported_media_type
     end
 
@@ -59,7 +59,7 @@ module JSONAPI
         [nil],
         title: "Not Acceptable",
         detail_proc: ->(_) { "Accept header must include application/vnd.api+json or be omitted" },
-        status: :not_acceptable
+        status: :not_acceptable,
       )
     end
 
@@ -82,7 +82,7 @@ module JSONAPI
       errors = Array(values).map do |value|
         error = {
           title:,
-          detail: detail_proc.call(value)
+          detail: detail_proc.call(value),
         }
         error[:source] = source_proc.call(value) if source_proc
         error

data/lib/json_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONAPI
-  VERSION = "1.0.0"
+  VERSION = "1.0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jpie
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Emil Kampp
@@ -57,6 +57,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".cursor/rules/release.mdc"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -77,19 +78,61 @@ files:
 - lib/json_api/configuration.rb
 - lib/json_api/controllers/base_controller.rb
 - lib/json_api/controllers/concerns/controller_helpers.rb
+- lib/json_api/controllers/concerns/controller_helpers/authorization.rb
+- lib/json_api/controllers/concerns/controller_helpers/document_meta.rb
+- lib/json_api/controllers/concerns/controller_helpers/error_rendering.rb
+- lib/json_api/controllers/concerns/controller_helpers/parsing.rb
+- lib/json_api/controllers/concerns/controller_helpers/resource_setup.rb
+- lib/json_api/controllers/concerns/relationships/active_storage_removal.rb
+- lib/json_api/controllers/concerns/relationships/events.rb
+- lib/json_api/controllers/concerns/relationships/removal.rb
+- lib/json_api/controllers/concerns/relationships/response_helpers.rb
+- lib/json_api/controllers/concerns/relationships/serialization.rb
+- lib/json_api/controllers/concerns/relationships/sorting.rb
+- lib/json_api/controllers/concerns/relationships/updating.rb
 - lib/json_api/controllers/concerns/resource_actions.rb
+- lib/json_api/controllers/concerns/resource_actions/crud_helpers.rb
+- lib/json_api/controllers/concerns/resource_actions/field_validation.rb
+- lib/json_api/controllers/concerns/resource_actions/filter_validation.rb
+- lib/json_api/controllers/concerns/resource_actions/pagination.rb
+- lib/json_api/controllers/concerns/resource_actions/preloading.rb
+- lib/json_api/controllers/concerns/resource_actions/resource_loading.rb
+- lib/json_api/controllers/concerns/resource_actions/serialization.rb
+- lib/json_api/controllers/concerns/resource_actions/type_validation.rb
 - lib/json_api/controllers/relationships_controller.rb
 - lib/json_api/controllers/resources_controller.rb
 - lib/json_api/errors/parameter_not_allowed.rb
 - lib/json_api/railtie.rb
 - lib/json_api/resources/active_storage_blob_resource.rb
+- lib/json_api/resources/concerns/attributes_dsl.rb
+- lib/json_api/resources/concerns/filters_dsl.rb
+- lib/json_api/resources/concerns/meta_dsl.rb
+- lib/json_api/resources/concerns/model_class_helpers.rb
+- lib/json_api/resources/concerns/relationships_dsl.rb
+- lib/json_api/resources/concerns/sortable_fields_dsl.rb
 - lib/json_api/resources/resource.rb
 - lib/json_api/resources/resource_loader.rb
 - lib/json_api/routing.rb
+- lib/json_api/serialization/concerns/attributes_deserialization.rb
+- lib/json_api/serialization/concerns/attributes_serialization.rb
+- lib/json_api/serialization/concerns/deserialization_helpers.rb
+- lib/json_api/serialization/concerns/includes_serialization.rb
+- lib/json_api/serialization/concerns/links_serialization.rb
+- lib/json_api/serialization/concerns/meta_serialization.rb
+- lib/json_api/serialization/concerns/model_attributes_transformation.rb
+- lib/json_api/serialization/concerns/relationship_processing.rb
+- lib/json_api/serialization/concerns/relationships_deserialization.rb
+- lib/json_api/serialization/concerns/relationships_serialization.rb
 - lib/json_api/serialization/deserializer.rb
 - lib/json_api/serialization/serializer.rb
 - lib/json_api/support/active_storage_support.rb
 - lib/json_api/support/collection_query.rb
+- lib/json_api/support/concerns/condition_building.rb
+- lib/json_api/support/concerns/nested_filters.rb
+- lib/json_api/support/concerns/pagination.rb
+- lib/json_api/support/concerns/polymorphic_filters.rb
+- lib/json_api/support/concerns/regular_filters.rb
+- lib/json_api/support/concerns/sorting.rb
 - lib/json_api/support/instrumentation.rb
 - lib/json_api/support/param_helpers.rb
 - lib/json_api/support/relationship_guard.rb