jpie 0.4.5 → 1.0.1

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

@@ -0,0 +1,43 @@
+# 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 = 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)
+      end
+    end
+  end
+end

data/lib/json_api/support/param_helpers.rb

@@ -0,0 +1,54 @@
+# 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)
+      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_guard.rb

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

@@ -0,0 +1,76 @@
+# 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
+    # 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:,
+      )
+    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

@@ -0,0 +1,87 @@
+# 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)
+      validate_relationship_type!(type, association) unless is_polymorphic
+
+      find_related_record(type, id, association, is_polymorphic)
+    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)
+      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:)
+      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)
+      return false unless definition
+
+      relationship_name = association.name
+      polymorphic_association?(definition, relationship_name)
+    end
+  end
+end

data/lib/json_api/support/responders.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "rack/utils"
+
+module JSONAPI
+  module Responders
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :ensure_jsonapi_content_type, if: -> { request.post? || request.patch? || request.put? }
+      before_action :ensure_jsonapi_accept_header
+    end
+
+    private
+
+    def ensure_jsonapi_content_type
+      return if request.content_type&.include?("application/vnd.api+json")
+
+      render json: {
+        errors: [
+          {
+            status: "415",
+            title: "Unsupported Media Type",
+            detail: "Content-Type must be application/vnd.api+json",
+          },
+        ],
+      }, status: :unsupported_media_type
+    end
+
+    def ensure_jsonapi_accept_header
+      # Allow requests without Accept header or with */* (browser defaults)
+      # Only validate when Accept header is explicitly set to non-JSON:API media types
+      accept_header = request.headers["Accept"]
+
+      # Allow blank Accept header (browser default)
+      return if accept_header.blank?
+
+      # Allow */* Accept header (browser default)
+      return if accept_header == "*/*"
+
+      # Check if request accepts */* (wildcard)
+      return if request.accepts.any? { |mime| mime.to_s == "*/*" }
+
+      # Check if JSON:API media type is explicitly requested
+      return if jsonapi_requested?
+
+      # If Accept header is present and doesn't include JSON:API, return 406
+      # This ensures we honor explicit Accept preferences while allowing defaults
+      render_not_acceptable_error
+    end
+
+    def jsonapi_requested?
+      request.accepts.any? { |mime| mime.to_s.include?("application/vnd.api+json") }
+    end
+
+    def render_not_acceptable_error
+      render_parameter_errors(
+        [nil],
+        title: "Not Acceptable",
+        detail_proc: ->(_) { "Accept header must include application/vnd.api+json or be omitted" },
+        status: :not_acceptable,
+      )
+    end
+
+    def render_jsonapi_error(status:, title:, detail: nil, source: nil)
+      render_jsonapi_errors([{ status:, title:, detail:, source: }], status:)
+    end
+
+    def render_jsonapi_errors(errors, status:)
+      normalized_errors = Array(errors).map do |error|
+        normalized = error.compact
+        normalized_status = normalized[:status] || status
+        normalized[:status] = status_code_for(normalized_status)
+        normalized
+      end
+
+      render json: { errors: normalized_errors }, status:
+    end
+
+    def render_parameter_errors(values, title:, detail_proc:, source_proc: nil, status: :bad_request)
+      errors = Array(values).map do |value|
+        error = {
+          title:,
+          detail: detail_proc.call(value),
+        }
+        error[:source] = source_proc.call(value) if source_proc
+        error
+      end
+
+      render_jsonapi_errors(errors, status:)
+    end
+
+    def status_code_for(status)
+      return status if status.is_a?(String) && status.match?(/\A\d+\z/)
+
+      Rack::Utils::SYMBOL_TO_STATUS_CODE.fetch(status, status).to_s
+    end
+  end
+end

data/lib/json_api/support/response_helpers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module ResponseHelpers
+    # Delegates to Serializer.jsonapi_object for backward compatibility
+    def self.jsonapi_object
+      JSONAPI::Serializer.jsonapi_object
+    end
+  end
+end

data/lib/json_api/support/sort_parsing.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module SortParsing
+    module_function
+
+    def parse_sort_field(sort_field)
+      descending = sort_field.start_with?("-")
+      field = descending ? sort_field[1..] : sort_field
+      { field:, direction: descending ? :desc : :asc }
+    end
+
+    def extract_sort_field_name(sort_field)
+      parse_sort_field(sort_field)[:field]
+    end
+
+    def extract_sort_direction(sort_field)
+      parse_sort_field(sort_field)[:direction]
+    end
+  end
+end

data/lib/json_api/support/type_conversion.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module TypeConversion
+    module_function
+
+    def type_to_class_name(type)
+      type.to_s.singularize.classify
+    end
+
+    def model_type_name(model_class)
+      model_class.name.underscore.pluralize
+    end
+
+    def resource_type_name(definition_class)
+      type_name = definition_class.name.sub(/Resource$/, "").underscore.pluralize
+      # Remove namespace prefix if present (e.g., "json_api/active_storage_blobs" -> "active_storage_blobs")
+      type_name.split("/").last
+    end
+  end
+end

data/lib/json_api/testing/test_helper.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Testing
+    # Test helper for Rails integration/request tests that provides consistent
+    # `as: :jsonapi` behavior across all HTTP methods.
+    #
+    # Usage in RSpec:
+    #   RSpec.configure do |config|
+    #     config.include JSONAPI::Testing::TestHelper, type: :request
+    #   end
+    #
+    # Then use `as: :jsonapi` in your tests:
+    #   get users_path, params: { filter: { active: true } }, headers:, as: :jsonapi
+    #   post users_path, params: payload, headers:, as: :jsonapi
+    #
+    # Behavior:
+    # - GET: Sets Accept header, params go to query string (no body encoding)
+    # - POST/PATCH/PUT/DELETE: Sets Content-Type and Accept headers, JSON-encodes body
+    #
+    module TestHelper
+      JSONAPI_MIME = "application/vnd.api+json"
+
+      def get(path, **options)
+        if options[:as] == :jsonapi
+          options = apply_jsonapi_headers(options, include_content_type: false)
+          options.delete(:as)
+        end
+        super
+      end
+
+      def post(path, **options)
+        options = apply_jsonapi_options_for_body(options) if options[:as] == :jsonapi
+        super
+      end
+
+      def patch(path, **options)
+        options = apply_jsonapi_options_for_body(options) if options[:as] == :jsonapi
+        super
+      end
+
+      def put(path, **options)
+        options = apply_jsonapi_options_for_body(options) if options[:as] == :jsonapi
+        super
+      end
+
+      def delete(path, **options)
+        options = apply_jsonapi_options_for_body(options) if options[:as] == :jsonapi
+        super
+      end
+
+      private
+
+      def apply_jsonapi_headers(options, include_content_type: true)
+        options = options.dup
+        headers = (options[:headers] || {}).dup
+
+        headers["Accept"] = JSONAPI_MIME
+        headers["Content-Type"] = JSONAPI_MIME if include_content_type
+
+        options[:headers] = headers
+        options
+      end
+
+      def apply_jsonapi_options_for_body(options)
+        options = apply_jsonapi_headers(options, include_content_type: true)
+        options.delete(:as)
+
+        # JSON-encode params for request body
+        options[:params] = options[:params].to_json if options[:params].is_a?(Hash)
+
+        options
+      end
+    end
+  end
+end

data/lib/json_api/testing.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "testing/test_helper"

data/lib/{jpie → json_api}/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module JPie
-  VERSION = '0.4.5'
+module JSONAPI
+  VERSION = "1.0.1"
 end

data/lib/json_api.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json_api/version"
+require "json_api/configuration"
+
+module JSONAPI
+  class Error < StandardError; end
+  class AuthorizationError < Error; end
+end
+
+require "json_api/errors/parameter_not_allowed"
+
+module JSONAPI
+  # Rebuild BaseController and RelationshipsController to reflect the current
+  # base_controller_class configuration. Safe to call repeatedly.
+  def self.rebuild_base_controllers!
+    remove_const(:BaseController) if const_defined?(:BaseController)
+    load "json_api/controllers/base_controller.rb"
+
+    remove_const(:RelationshipsController) if const_defined?(:RelationshipsController)
+    load "json_api/controllers/relationships_controller.rb"
+  end
+end
+
+require "json_api/resources/resource"
+require "json_api/resources/resource_loader"
+require "json_api/support/type_conversion"
+require "json_api/support/sort_parsing"
+require "json_api/support/resource_identifier"
+require "json_api/support/relationship_helpers"
+require "json_api/support/param_helpers"
+require "json_api/active_storage/detection"
+require "json_api/active_storage/serialization"
+require "json_api/active_storage/deserialization"
+require "json_api/support/active_storage_support"
+require "json_api/support/collection_query"
+require "json_api/routing"
+require "json_api/support/responders"
+require "json_api/support/instrumentation"
+require "json_api/serialization/serializer"
+require "json_api/serialization/deserializer"
+require "json_api/support/response_helpers"
+require "json_api/controllers/concerns/controller_helpers"
+require "json_api/controllers/concerns/resource_actions"
+require "json_api/controllers/base_controller"
+require "json_api/controllers/resources_controller"
+require "json_api/controllers/relationships_controller"
+require "json_api/resources/active_storage_blob_resource" if defined?(ActiveStorage)
+
+require "json_api/railtie" if defined?(Rails)