jpie 0.1.0 → 0.3.0

data/lib/json_api/support/collection_query.rb

@@ -1,406 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  class CollectionQuery
-    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
-      # Apply filtering
-      @scope = apply_filtering
-
-      # Get total count before sorting (for virtual attributes, we need to load records)
-      # If we have virtual attribute sorting, we'll recalculate after sorting
-      has_virtual_sort = sort_params.any? { |sort_field| virtual_attribute_sort?(sort_field) }
-      @total_count = @scope.count unless has_virtual_sort
-
-      # Apply sorting (may convert scope to array if virtual attributes are involved)
-      @scope = apply_sorting(@scope)
-
-      # Recalculate total count if we converted to array for virtual sorting
-      @total_count = @scope.count if has_virtual_sort && @scope.is_a?(Array)
-
-      # Apply pagination
-      @scope = apply_pagination
-
-      self
-    end
-
-    private
-
-    attr_reader :definition, :model_class, :filter_params, :sort_params, :page_params
-
-    def apply_filtering
-      # Apply nested relationship filters first (they require joins)
-      scope = apply_nested_relationship_filters(@scope)
-
-      # Then apply regular filters (column-aware operators or model scopes)
-      apply_regular_filters(scope)
-    end
-
-    def apply_sorting(scope)
-      return scope if sort_params.empty?
-
-      # Check if any sort fields are virtual attributes
-      has_virtual_sorts = sort_params.any? { |sort_field| virtual_attribute_sort?(sort_field) }
-
-      if has_virtual_sorts
-        # Convert to array and sort by all fields (both DB and virtual) in Ruby
-        records = scope.to_a
-        records = apply_mixed_sorting(records, sort_params)
-        scope = records
-      else
-        # All sorts are database columns - use ActiveRecord ordering
-        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
-      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)
-
-        # Get values - use DB column if available, otherwise use definition getter
-        value_a = fetch_sort_value(record_a, field)
-        value_b = fetch_sort_value(record_b, field)
-
-        # Compare values
-        comparison = compare_values(value_a, value_b)
-        next if comparison.zero? # Equal, check next sort field
-
-        # Apply direction
-        return direction == :desc ? -comparison : comparison
-      end
-
-      0 # All fields equal
-    end
-
-    def fetch_sort_value(record, field)
-      # Try database column first
-      if model_class.column_names.include?(field.to_s)
-        # Use public_send to get the attribute value (handles both string and symbol access)
-        if record.respond_to?(field.to_sym)
-          record.public_send(field.to_sym)
-        elsif record.respond_to?(:attributes) && record.attributes.is_a?(Hash)
-          record.attributes[field.to_s] || record.attributes[field.to_sym]
-        end
-      else
-        # Use definition getter for virtual attributes
-        definition_instance = definition.new(record, {})
-        fetch_virtual_value(definition_instance, field)
-      end
-    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)
-      # Handle nil values
-      return 0 if value_a.nil? && value_b.nil?
-      return -1 if value_a.nil?
-      return 1 if value_b.nil?
-
-      # Compare using standard Ruby comparison
-      value_a <=> value_b
-    end
-
-    def apply_regular_filters(scope)
-      return scope if filter_params.empty?
-
-      # Exclude nested relationship filters (already applied)
-      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
-
-    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)
-      column_name = column_filter[:column]
-      operator = column_filter[:operator]
-
-      column = model_class.column_for_attribute(column_name)
-      return scope unless column
-
-      value = normalize_filter_value(column, raw_value)
-      return scope if value.nil?
-
-      condition = build_condition(column, value, operator)
-      return scope unless condition
-
-      apply_condition(scope, condition)
-    rescue ArgumentError, TypeError, StandardError => e
-      # If casting fails or any other error occurs, skip filter
-      Rails.logger.warn("Filter error for #{column_filter[:column]}_#{operator}: #{e.class} - #{e.message}") if defined?(Rails.logger)
-      scope
-    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 build_condition(column, value, operator)
-      attr = model_class.arel_table[column.name]
-
-      case operator
-      when :eq
-        attr.eq(value)
-      when :lt
-        attr.lt(value)
-      when :lte
-        attr.lteq(value)
-      when :gt
-        attr.gt(value)
-      when :gte
-        attr.gteq(value)
-      when :match
-        pattern = "%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%"
-        lower_attr = Arel::Nodes::NamedFunction.new("LOWER", [attr])
-        lower_attr.matches(pattern.downcase)
-      end
-    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)
-      attr = model.arel_table[column.name]
-
-      case operator
-      when :eq
-        attr.eq(value)
-      when :lt
-        attr.lt(value)
-      when :lte
-        attr.lteq(value)
-      when :gt
-        attr.gt(value)
-      when :gte
-        attr.gteq(value)
-      when :match
-        pattern = "%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%"
-        lower_attr = Arel::Nodes::NamedFunction.new("LOWER", [attr])
-        lower_attr.matches(pattern.downcase)
-      end
-    end
-
-    def apply_condition(scope, condition)
-      scope.where(condition)
-    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
-
-    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
-
-    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
-
-      current_model = model_class
-      current_definition = definition
-
-      relationship_chain.each do |relationship_name|
-        association = current_model.reflect_on_association(relationship_name.to_sym)
-        return scope unless association
-
-        if association.polymorphic?
-          attributes = { leaf_filter => filter_value }
-          return apply_polymorphic_nested_filters(scope, association, relationship_name, attributes)
-        end
-
-        current_model = association.klass
-        current_definition = JSONAPI::Resource.resource_for_model(current_model)
-        return scope unless current_definition
-      end
-
-      join_hash = build_join_hash_for_chain(relationship_chain)
-      scope = scope.joins(join_hash) if join_hash.present?
-
-      apply_filter_on_model(scope, current_model, current_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 filter_value.respond_to?(:empty?) ? filter_value.empty? : filter_value.nil?
-
-      column_filter = parse_column_filter(filter_name)
-      if column_filter
-        column = target_model.column_for_attribute(column_filter[:column])
-        if column
-          value = normalize_filter_value_for_model(target_model, column, filter_value)
-          condition = build_condition_for_model(target_model, column, value, column_filter[:operator]) if value
-          return apply_condition(scope, condition) if condition
-        end
-      end
-
-      if target_model.column_names.include?(filter_name)
-        table_name = target_model.table_name
-        return scope.where(table_name => { filter_name => filter_value })
-      end
-
-      if target_model.respond_to?(filter_name.to_sym)
-        begin
-          return scope.merge(target_model.public_send(filter_name.to_sym, filter_value))
-        rescue ArgumentError, NoMethodError
-          # Fall through to return scope
-        end
-      end
-
-      if target_resource &&
-         target_resource.permitted_filters.map(&:to_s).include?(filter_name) &&
-         target_model.respond_to?(filter_name.to_sym)
-        begin
-          return scope.merge(target_model.public_send(filter_name.to_sym, filter_value))
-        rescue ArgumentError, NoMethodError
-          # Fall through to return scope
-        end
-      end
-
-      scope
-    end
-
-    def apply_polymorphic_nested_filters(scope, association, _relationship_name, attributes)
-      foreign_key = association.foreign_key
-      foreign_type = association.foreign_type
-      fk_column = model_class.column_for_attribute(foreign_key)
-      type_value = attributes["type"] || attributes["type_eq"]
-
-      attributes.each do |attr_name, attr_value|
-        next if attr_value.respond_to?(:empty?) ? attr_value.empty? : attr_value.nil?
-        next if attr_name == "type"
-
-        column_filter = parse_column_filter(attr_name)
-        if column_filter && column_filter[:column] == "id" && fk_column
-          value = normalize_filter_value_for_model(model_class, fk_column, attr_value)
-          condition = build_condition_for_model(model_class, fk_column, value, column_filter[:operator]) if value
-          scope = apply_condition(scope, condition) if condition
-        elsif attr_name == "id"
-          scope = scope.where(foreign_key => attr_value)
-        end
-
-        if foreign_type && association.options[:class_name]
-          scope = scope.where(foreign_type => association.options[:class_name])
-        elsif foreign_type && type_value
-          scope = scope.where(foreign_type => type_value)
-        end
-      end
-
-      if foreign_type && association.options[:class_name].nil? && type_value
-        scope = scope.where(foreign_type => type_value)
-      end
-
-      scope
-    end
-
-    def apply_pagination
-      return @scope if page_params.empty?
-
-      number = page_params["number"]&.to_i || 1
-      size = page_params["size"]&.to_i || JSONAPI.configuration.default_page_size
-
-      # Enforce max page size
-      size = [size, JSONAPI.configuration.max_page_size].min
-
-      offset = (number - 1) * size
-
-      # Handle array (after virtual attribute sorting) vs ActiveRecord relation
-      if @scope.is_a?(Array)
-        @scope.slice(offset, size) || []
-      else
-        @scope.offset(offset).limit(size)
-      end
-    end
-  end
-end

data/lib/json_api/support/instrumentation.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module Instrumentation
-    def self.enabled?
-      defined?(Rails) && Rails.respond_to?(:event) && Rails.event.respond_to?(:notify)
-    end
-
-    def self.resource_event(action:, resource_type:, resource_id:, changes: {})
-      return unless enabled?
-
-      Rails.event.tagged("jsonapi") do
-        Rails.event.notify(
-          "jsonapi.#{resource_type}.#{action}",
-          resource_type:,
-          resource_id:,
-          changes: changes.compact
-        )
-      end
-    end
-
-    def self.relationship_event(action:, resource_type:, resource_id:, relationship_name:, related_ids: nil,
-                                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
-
-      Rails.event.tagged("jsonapi", "relationship") do
-        Rails.event.notify(
-          "jsonapi.#{resource_type}.relationship.#{action}",
-          payload
-        )
-      end
-    end
-  end
-end

data/lib/json_api/support/param_helpers.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "cgi"
-
-module JSONAPI
-  module ParamHelpers
-    module_function
-
-    def flatten_filter_hash(hash, parent_key = nil, accumulator = {})
-      hash.each do |key, value|
-        next unless key
-
-        full_key = parent_key ? "#{parent_key}.#{key}" : key.to_s
-
-        if value.is_a?(Hash)
-          flatten_filter_hash(value, full_key, accumulator)
-        else
-          accumulator[full_key] = value
-        end
-      end
-
-      accumulator
-    end
-
-    def deep_symbolize_params(params)
-      if params.is_a?(ActionController::Parameters)
-        params.to_unsafe_h.deep_symbolize_keys
-      else
-        params.to_h.deep_symbolize_keys
-      end
-    end
-
-    def build_query_string(query_params)
-      query_parts = []
-      query_params.each do |key, value|
-        query_parts.concat(build_query_parts_for_param(key, value))
-      end
-      query_parts.join("&")
-    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)}"]
-      end
-    end
-  end
-end

data/lib/json_api/support/relationship_guard.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "json_api/errors/parameter_not_allowed"
-
-module JSONAPI
-  module RelationshipGuard
-    module_function
-
-    def ensure_writable!(association, error_target, readonly: false)
-      return unless association
-      return unless readonly
-
-      raise JSONAPI::Exceptions::ParameterNotAllowed, [error_target]
-    end
-  end
-end

data/lib/json_api/support/relationship_helpers.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module RelationshipHelpers
-    module_function
-
-    # Delegate to TypeConversion
-    def type_to_class_name(type)
-      TypeConversion.type_to_class_name(type)
-    end
-
-    def model_type_name(model_class)
-      TypeConversion.model_type_name(model_class)
-    end
-
-    def resource_type_name(definition_class)
-      TypeConversion.resource_type_name(definition_class)
-    end
-
-    # Delegate to SortParsing
-    def extract_sort_field_name(sort_field)
-      SortParsing.extract_sort_field_name(sort_field)
-    end
-
-    def extract_sort_direction(sort_field)
-      SortParsing.extract_sort_direction(sort_field)
-    end
-
-    # Delegate to ResourceIdentifier
-    def serialize_resource_identifier(
-      record, association: nil, resource_class: nil, use_instance_class: false, base_resource_class: nil
-    )
-      ResourceIdentifier.serialize_identifier(
-        record,
-        association:,
-        definition: resource_class,
-        use_instance_class:
-      )
-    end
-
-    def extract_id_from_identifier(identifier)
-      ResourceIdentifier.extract_id(identifier)
-    end
-
-    def extract_type_from_identifier(identifier)
-      ResourceIdentifier.extract_type(identifier)
-    end
-
-    def resolve_and_find_related_resource(identifier, association:, resource_class:, relationship_name:)
-      ResourceIdentifier.resolve_and_find_related_record(
-        identifier,
-        association:,
-        definition: resource_class,
-        relationship_name:
-      )
-    end
-
-    def polymorphic_association?(definition, relationship_name)
-      ResourceIdentifier.polymorphic_association?(definition, relationship_name)
-    end
-
-    def sti_subclass?(instance_class, association_class)
-      ResourceIdentifier.sti_subclass?(instance_class, association_class)
-    end
-
-    def polymorphic_association_for_association?(association, definition)
-      ResourceIdentifier.polymorphic_association_for_association?(association, definition)
-    end
-
-    def find_relationship_definition(definition, relationship_name)
-      definition.relationship_definitions.find { |r| r[:name].to_s == relationship_name.to_s }
-    end
-  end
-end

data/lib/json_api/support/resource_identifier.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module ResourceIdentifier
-    module_function
-
-    def serialize_identifier(record, association:, definition:, use_instance_class: false)
-      model_class = determine_model_class(record, association:, definition:,
-                                                  use_instance_class:)
-      related_definition = JSONAPI::ResourceLoader.find_for_model(model_class)
-      related_type = TypeConversion.resource_type_name(related_definition)
-
-      { type: related_type, id: record.id.to_s }
-    end
-
-    def extract_id(identifier)
-      identifier[:id].to_s.presence
-    end
-
-    def extract_type(identifier)
-      identifier[:type]
-    end
-
-    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)
-
-      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
-
-      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
-    end
-
-    def polymorphic_association?(definition, relationship_name)
-      relationship_def = definition.relationship_definitions.find do |r|
-        r[:name].to_s == relationship_name.to_s
-      end
-      return false unless relationship_def
-
-      relationship_def[:options][:polymorphic] == true
-    end
-
-    def sti_subclass?(instance_class, association_class)
-      return false unless instance_class.respond_to?(:base_class)
-
-      instance_class.base_class == association_class && instance_class != association_class
-    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
-    end
-
-    def polymorphic_association_for_association?(association, definition)
-      return false unless definition
-
-      relationship_name = association.name
-      polymorphic_association?(definition, relationship_name)
-    end
-  end
-end