jpie 0.4.5 → 1.0.1

data/lib/json_api/serialization/deserializer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "json_api/support/relationship_guard"
+require_relative "concerns/attributes_deserialization"
+require_relative "concerns/relationships_deserialization"
+require_relative "concerns/model_attributes_transformation"
+require_relative "concerns/relationship_processing"
+require_relative "concerns/deserialization_helpers"
+
+module JSONAPI
+  class Deserializer
+    include ActiveStorageSupport
+    include Serialization::AttributesDeserialization
+    include Serialization::RelationshipsDeserialization
+    include Serialization::ModelAttributesTransformation
+    include Serialization::RelationshipProcessing
+    include Serialization::DeserializationHelpers
+
+    def initialize(params, model_class:, action: :create)
+      @params = ParamHelpers.deep_symbolize_params(params)
+      @model_class = model_class
+      @definition = ResourceLoader.find_for_model(model_class)
+      @action = action.to_sym
+    end
+  end
+end

data/lib/json_api/serialization/serializer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "concerns/attributes_serialization"
+require_relative "concerns/relationships_serialization"
+require_relative "concerns/links_serialization"
+require_relative "concerns/includes_serialization"
+require_relative "concerns/meta_serialization"
+
+module JSONAPI
+  class Serializer
+    include ActiveStorageSupport
+    include Serialization::AttributesSerialization
+    include Serialization::RelationshipsSerialization
+    include Serialization::LinksSerialization
+    include Serialization::IncludesSerialization
+    include Serialization::MetaSerialization
+
+    JSONAPI_VERSION = "1.1"
+
+    def self.jsonapi_object
+      obj = { version: JSONAPI_VERSION }
+      obj[:meta] = JSONAPI.configuration.jsonapi_meta if JSONAPI.configuration.jsonapi_meta
+      obj
+    end
+
+    def initialize(record, definition: nil, base_definition: nil)
+      @record = record
+      @definition = definition || ResourceLoader.find_for_model(record.class)
+      @base_definition = base_definition
+      @sti_subclass = nil
+    end
+
+    def to_hash(include: [], fields: {}, document_meta: nil)
+      {
+        jsonapi: jsonapi_object,
+        data: serialize_record(fields),
+        included: serialize_included(include, fields),
+        meta: document_meta,
+      }.compact
+    end
+
+    def serialize_record(fields = {})
+      {
+        type: record_type,
+        id: record_id,
+        attributes: serialize_attributes(fields),
+        relationships: serialize_relationships,
+        links: serialize_links,
+        meta: record_meta,
+      }.compact
+    end
+
+    private
+
+    attr_reader :record, :definition
+
+    def base_definition
+      @base_definition ||= definition
+    end
+
+    def record_type
+      if definition.name.end_with?("Resource")
+        RelationshipHelpers.resource_type_name(definition)
+      else
+        record.class.name.underscore.pluralize
+      end
+    end
+
+    def record_id
+      record.id.to_s
+    end
+
+    def jsonapi_object
+      self.class.jsonapi_object
+    end
+  end
+end

data/lib/json_api/support/active_storage_support.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module JSONAPI
+  module ActiveStorageSupport
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def active_storage_attachment?(association_name, model_class)
+        ActiveStorage::Detection.attachment?(association_name, model_class)
+      end
+
+      def active_storage_blob_type?(type)
+        ActiveStorage::Detection.blob_type?(type)
+      end
+    end
+
+    def active_storage_attachment?(association_name, model_class = nil)
+      resolved = model_class || resolve_model_class_for_attachment
+      self.class.active_storage_attachment?(association_name, resolved)
+    end
+
+    def resolve_model_class_for_attachment
+      return send(:model_class) if respond_to?(:model_class, true)
+      return send(:resource_model_class) if respond_to?(:resource_model_class, true)
+      return send(:resource).class if respond_to?(:resource, true) && send(:resource).respond_to?(:class)
+
+      raise NotImplementedError, "Must implement resource_model_class or provide model_class parameter"
+    end
+
+    def extract_active_storage_params_from_hash(params_hash, model_class)
+      ActiveStorage::Deserialization.extract_params_from_hash(params_hash, model_class)
+    end
+
+    def attach_active_storage_files(record, attachment_params, resource_class: nil)
+      ActiveStorage::Deserialization.attach_files(record, attachment_params, definition: resource_class)
+    end
+
+    def purge_on_nil_enabled?(attachment_name, resource_class)
+      ActiveStorage::Deserialization.purge_on_nil_enabled?(attachment_name, resource_class)
+    end
+
+    def append_only_enabled?(attachment_name, resource_class)
+      ActiveStorage::Deserialization.append_only_enabled?(attachment_name, resource_class)
+    end
+
+    def find_relationship_definition(attachment_name, resource_class)
+      ActiveStorage::Deserialization.find_relationship_definition(attachment_name, resource_class)
+    end
+
+    def filter_active_storage_from_includes(includes_hash, current_model_class)
+      ActiveStorage::Detection.filter_from_includes(includes_hash, current_model_class)
+    end
+
+    def filter_polymorphic_from_includes(includes_hash, current_model_class)
+      ActiveStorage::Detection.filter_polymorphic_from_includes(includes_hash, current_model_class)
+    end
+
+    def serialize_active_storage_relationship(attachment_name, record)
+      ActiveStorage::Serialization.serialize_relationship(attachment_name, record)
+    end
+
+    def serialize_blob_identifier(blob)
+      ActiveStorage::Serialization.serialize_blob_identifier(blob)
+    end
+
+    def process_active_storage_attachment(attrs, association_name, id_or_ids, singular:)
+      ActiveStorage::Deserialization.process_attachment(attrs, association_name, id_or_ids, singular:)
+    end
+
+    def find_blob_by_signed_id(signed_id)
+      ActiveStorage::Deserialization.find_blob_by_signed_id(signed_id)
+    end
+
+    private
+
+    def resource_model_class
+      raise NotImplementedError, "Must implement resource_model_class or override active_storage_attachment?"
+    end
+  end
+end

data/lib/json_api/support/collection_query.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "concerns/sorting"
+require_relative "concerns/regular_filters"
+require_relative "concerns/nested_filters"
+require_relative "concerns/polymorphic_filters"
+require_relative "concerns/condition_building"
+require_relative "concerns/pagination"
+
+module JSONAPI
+  class CollectionQuery
+    include Support::Sorting
+    include Support::RegularFilters
+    include Support::NestedFilters
+    include Support::PolymorphicFilters
+    include Support::ConditionBuilding
+    include Support::Pagination
+
+    attr_reader :scope, :total_count, :pagination_applied
+
+    def initialize(scope, definition:, model_class:, filter_params:, sort_params:, page_params:)
+      @scope = scope
+      @definition = definition
+      @model_class = model_class
+      @filter_params = filter_params
+      @sort_params = sort_params
+      @page_params = page_params
+      @pagination_applied = page_params.present?
+    end
+
+    def execute
+      @scope = apply_filtering
+      has_virtual_sort = sort_params.any? { |sort_field| virtual_attribute_sort?(sort_field) }
+      @total_count = @scope.count unless has_virtual_sort
+      @scope = apply_sorting(@scope)
+      @total_count = @scope.count if has_virtual_sort && @scope.is_a?(Array)
+      @scope = apply_pagination
+      self
+    end
+
+    private
+
+    attr_reader :definition, :model_class, :filter_params, :sort_params, :page_params
+
+    def apply_filtering
+      scope = apply_nested_relationship_filters(@scope)
+      apply_regular_filters(scope)
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module ConditionBuilding
+      private
+
+      def build_condition(column, value, operator)
+        build_arel_condition(model_class, column, value, operator)
+      end
+
+      def normalize_filter_value_for_model(model, column, raw_value)
+        return nil unless column
+
+        value = raw_value.is_a?(Array) ? raw_value.first : raw_value
+        return nil if value.nil?
+
+        type = model.type_for_attribute(column.name)
+        type.cast(value)
+      end
+
+      def build_condition_for_model(model, column, value, operator)
+        build_arel_condition(model, column, value, operator)
+      end
+
+      def build_arel_condition(model, column, value, operator)
+        attr = model.arel_table[column.name]
+        build_operator_condition(attr, value, operator)
+      end
+
+      def build_operator_condition(attr, value, operator)
+        case operator
+        when :eq then attr.eq(value)
+        when :lt then attr.lt(value)
+        when :lte then attr.lteq(value)
+        when :gt then attr.gt(value)
+        when :gte then attr.gteq(value)
+        when :match then build_match_condition(attr, value)
+        end
+      end
+
+      def build_match_condition(attr, value)
+        pattern = "%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%"
+        lower_attr = Arel::Nodes::NamedFunction.new("LOWER", [attr])
+        lower_attr.matches(pattern.downcase)
+      end
+
+      def apply_condition(scope, condition)
+        scope.where(condition)
+      end
+
+      def empty_filter_value?(filter_value)
+        filter_value.respond_to?(:empty?) ? filter_value.empty? : filter_value.nil?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module NestedFilters
+      def apply_nested_relationship_filters(scope)
+        return scope if filter_params.empty?
+
+        nested_filters = filter_params.select { |k, _v| k.to_s.include?(".") }
+        return scope if nested_filters.empty?
+
+        nested_filters.reduce(scope) do |current_scope, (filter_name, filter_value)|
+          apply_filter_for_path(current_scope, filter_name.to_s, filter_value)
+        end
+      end
+
+      private
+
+      def apply_filter_for_path(scope, filter_name, filter_value)
+        parts = filter_name.split(".")
+        return scope if parts.length < 2
+
+        relationship_chain = parts[0..-2]
+        leaf_filter = parts.last
+
+        result = traverse_relationship_chain(scope, relationship_chain, leaf_filter, filter_value)
+        return result[:scope] if result[:early_return]
+
+        apply_joined_filter(scope, result, relationship_chain:, leaf_filter:, filter_value:)
+      end
+
+      def traverse_relationship_chain(scope, relationship_chain, leaf_filter, filter_value)
+        current_model = model_class
+        current_definition = definition
+
+        relationship_chain.each do |relationship_name|
+          result = process_chain_step(scope, current_model, relationship_name, leaf_filter, filter_value)
+          return result if result[:early_return]
+
+          current_model = result[:model]
+          current_definition = result[:definition]
+        end
+
+        { model: current_model, definition: current_definition, early_return: false }
+      end
+
+      def process_chain_step(scope, current_model, relationship_name, leaf_filter, filter_value)
+        association = current_model.reflect_on_association(relationship_name.to_sym)
+        return { scope:, early_return: true } unless association
+
+        if association.polymorphic?
+          attributes = { leaf_filter => filter_value }
+          return { scope: apply_polymorphic_nested_filters(scope, association, relationship_name, attributes),
+                   early_return: true, }
+        end
+
+        next_definition = JSONAPI::Resource.resource_for_model(association.klass)
+        return { scope:, early_return: true } unless next_definition
+
+        { model: association.klass, definition: next_definition, early_return: false }
+      end
+
+      def apply_joined_filter(scope, result, relationship_chain:, leaf_filter:, filter_value:)
+        join_hash = build_join_hash_for_chain(relationship_chain)
+        scope = scope.joins(join_hash) if join_hash.present?
+        apply_filter_on_model(scope, result[:model], result[:definition], leaf_filter, filter_value)
+      end
+
+      def build_join_hash_for_chain(chain)
+        return nil if chain.empty?
+
+        chain.reverse.reduce(nil) do |acc, name|
+          if acc.nil?
+            name.to_sym
+          else
+            { name.to_sym => acc }
+          end
+        end
+      end
+
+      def apply_filter_on_model(scope, target_model, target_resource, filter_name, filter_value)
+        return scope if empty_filter_value?(filter_value)
+
+        apply_column_operator_filter(scope, target_model, filter_name, filter_value) ||
+          apply_direct_column_filter(scope, target_model, filter_name, filter_value) ||
+          apply_scope_method_filter(scope, target_model, target_resource, filter_name, filter_value) ||
+          scope
+      end
+
+      def apply_column_operator_filter(scope, target_model, filter_name, filter_value)
+        column_filter = parse_column_filter(filter_name)
+        return nil unless column_filter
+
+        column = target_model.column_for_attribute(column_filter[:column])
+        return nil unless column
+
+        value = normalize_filter_value_for_model(target_model, column, filter_value)
+        return nil unless value
+
+        condition = build_condition_for_model(target_model, column, value, column_filter[:operator])
+        condition ? apply_condition(scope, condition) : nil
+      end
+
+      def apply_direct_column_filter(scope, target_model, filter_name, filter_value)
+        return nil unless target_model.column_names.include?(filter_name)
+
+        scope.where(target_model.table_name => { filter_name => filter_value })
+      end
+
+      def apply_scope_method_filter(scope, target_model, target_resource, filter_name, filter_value)
+        if target_model.respond_to?(filter_name.to_sym)
+          return try_scope_method(scope, target_model, filter_name,
+                                  filter_value,)
+        end
+
+        return nil unless target_resource
+        return nil unless target_resource.permitted_filters.map(&:to_s).include?(filter_name)
+        return nil unless target_model.respond_to?(filter_name.to_sym)
+
+        try_scope_method(scope, target_model, filter_name, filter_value)
+      end
+
+      def try_scope_method(scope, target_model, filter_name, filter_value)
+        scope.merge(target_model.public_send(filter_name.to_sym, filter_value))
+      rescue ArgumentError, NoMethodError
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module Pagination
+      def apply_pagination
+        return @scope if page_params.empty?
+
+        offset, size = calculate_pagination_params
+        paginate_scope(offset, size)
+      end
+
+      private
+
+      def calculate_pagination_params
+        number = page_params["number"]&.to_i || 1
+        size = page_params["size"]&.to_i || JSONAPI.configuration.default_page_size
+        size = [size, JSONAPI.configuration.max_page_size].min
+        offset = (number - 1) * size
+        [offset, size]
+      end
+
+      def paginate_scope(offset, size)
+        return @scope.slice(offset, size) || [] if @scope.is_a?(Array)
+
+        @scope.offset(offset).limit(size)
+      end
+    end
+  end
+end

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