jpie 1.5.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be60282bbba362a7ac36dca3370a4733981bce7a949352513244879bc76546a7
-  data.tar.gz: 6c391beea011b7fd348f8a2439130ba174dd31fa7b8f9f4ea6eaef5c9fd916ee
+  metadata.gz: 1a598f58a7c0f80730e852f069276ea9d3066d3c7622a8faec599f1b58039f0e
+  data.tar.gz: 33292a3d2e2b98c09fb9868972b2936738ebf00b6ec0a1b7baf46ec51b017369
 SHA512:
-  metadata.gz: 13f21d51760a269d54d1bcd46a9be3916506bae8c25af82eaabea8dc7a214d2f3d39b29437ca0703141a794444d13b7ab20ba26ac4f35f4fe3a8ca15207d1630
-  data.tar.gz: 35e11173e5942bc01059217acf3a5028f5980108b2c76e88b33fe03c9c2ae00a4a6a9c0051328e491a257d83700f02f6a206c7a34406cde968af1a6698ac63fd
+  metadata.gz: 5b3830b35c1fc6690c755c5f90ad7568ffc6c57d7b8ad0516fdf368f476a15223a0489694acb5ac288d2c5f8f9f8889c154f5e0f09915dfac276b876ed437858
+  data.tar.gz: 0cdc51e099411e4f27342783e3e47bf5e34ff983308758fa904819009df8f23364521a7d1b32a634827fdcba7f4302501202ef4f0c193d119e97b9f9daaf7990

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jpie (1.5.1)
+    jpie (2.0.0)
       actionpack (~> 8.0, >= 8.0.0)
       rails (~> 8.0, >= 8.0.0)
 

data/README.md

@@ -1,4 +1,4 @@
-# JSONAPI
+# JPie
 
 A Rails 8+ gem that provides JSON:API compliant routing DSL and generic JSON:API controllers for producing and consuming JSON:API resources.
 
@@ -659,6 +659,27 @@ JSONAPI.configure do |config|
 end
 ```
 
+### N+1 Query Warning
+
+When clients omit the `include` parameter for nested relationships, the API may execute N+1 queries. The gem detects high query counts and:
+
+1. **Logs** a warning to `Rails.logger` with path, include param, and query count
+2. **Adds response headers** so clients can detect and fix their requests:
+   - `X-JPie-Query-Count` – number of DB queries executed
+   - `Server-Timing` – W3C standard header with query count in `desc`
+   - `X-JPie-Performance-Warning` – when count exceeds threshold, suggests adding `include` param
+
+Configure in an initializer:
+
+```ruby
+JSONAPI.configure do |config|
+  config.n1_query_threshold = 20   # Warn when queries exceed this (default: 20)
+  config.n1_warning_enabled = true # Set false to disable (default: true)
+end
+```
+
+Clients can read `X-JPie-Query-Count` or `Server-Timing` to monitor performance and add appropriate `include` values when the warning header appears.
+
 ### Base Controller Class
 
 By default, `JSONAPI::BaseController` inherits from `ActionController::API`. You can configure it to inherit from a different base class (e.g., `ActionController::Base` or a custom base controller):

data/lib/json_api/configuration.rb

@@ -4,19 +4,11 @@ module JSONAPI
   class Configuration
     attr_accessor :default_page_size, :max_page_size, :jsonapi_meta, :authorization_handler,
                   :authorization_scope, :document_meta_resolver,
-                  :namespace_type_format, :namespace_model_mapping, :namespace_fallback
+                  :namespace_type_format, :namespace_model_mapping, :namespace_fallback,
+                  :n1_query_threshold, :n1_warning_enabled
 
     def initialize
-      @default_page_size = 25
-      @max_page_size = 100
-      @jsonapi_meta = nil
-      @authorization_handler = nil
-      @authorization_scope = nil
-      @document_meta_resolver = ->(controller:) { {} } # rubocop:disable Lint/UnusedBlockArgument
-      @base_controller_class = "ActionController::API"
-      @namespace_type_format = :flat
-      @namespace_model_mapping = :same_namespace
-      @namespace_fallback = true
+      set_defaults
     end
 
     def base_controller_class=(value)
@@ -49,6 +41,39 @@ module JSONAPI
     def base_controller_overridden?
       @base_controller_class != "ActionController::API"
     end
+
+    private
+
+    def set_defaults
+      set_pagination_defaults
+      set_n1_defaults
+      set_nil_defaults
+      @document_meta_resolver = ->(controller:) { {} } # rubocop:disable Lint/UnusedBlockArgument
+      @base_controller_class = "ActionController::API"
+      set_namespace_defaults
+    end
+
+    def set_pagination_defaults
+      @default_page_size = 25
+      @max_page_size = 100
+    end
+
+    def set_n1_defaults
+      @n1_query_threshold = 20
+      @n1_warning_enabled = true
+    end
+
+    def set_nil_defaults
+      @jsonapi_meta = nil
+      @authorization_handler = nil
+      @authorization_scope = nil
+    end
+
+    def set_namespace_defaults
+      @namespace_type_format = :flat
+      @namespace_model_mapping = :same_namespace
+      @namespace_fallback = true
+    end
   end
 
   def self.configuration

data/lib/json_api/controllers/concerns/controller_helpers/error_rendering.rb

@@ -7,17 +7,16 @@ module JSONAPI
 
       protected
 
+      def render_not_found_error(title:, detail:)
+        render_jsonapi_error(status: 404, title:, detail:)
+      end
+
       def render_resource_not_found_error(message)
-        render_jsonapi_error(
-          status: 404,
-          title: "Resource Not Found",
-          detail: message,
-        )
+        render_not_found_error(title: "Resource Not Found", detail: message)
       end
 
       def render_model_not_found_error(error)
-        render_jsonapi_error(
-          status: 404,
+        render_not_found_error(
           title: "Resource Not Found",
           detail: "Model class for '#{@resource_name}' not found: #{error.message}",
         )

data/lib/json_api/controllers/concerns/controller_helpers/resource_setup.rb

@@ -30,10 +30,9 @@ module JSONAPI
       end
 
       def set_resource
-        @resource = @preloaded_resource || model_class.find(params[:id])
+        @resource = @resource_class.records.find(params[:id])
       rescue ActiveRecord::RecordNotFound
-        render_jsonapi_error(
-          status: 404,
+        render_not_found_error(
           title: "Record Not Found",
           detail: "Could not find #{@resource_name} with id '#{params[:id]}'",
         )

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

@@ -16,12 +16,53 @@ module JSONAPI
       end
 
       def fetch_related_data(association)
-        related = @resource.public_send(@relationship_name)
+        related = fetch_related_through_resource_records(association)
         return related unless association.collection? && related.respond_to?(:order)
 
         apply_sorting_to_relationship(related, association)
       end
 
+      def fetch_related_through_resource_records(association)
+        if association.polymorphic?
+          fetch_polymorphic_related_through_resource_records(association)
+        else
+          fetch_non_polymorphic_related_through_resource_records(association)
+        end
+      end
+
+      def fetch_polymorphic_related_through_resource_records(association)
+        type_value = @resource.read_attribute(association.foreign_type)
+        id_value = @resource.read_attribute(association.foreign_key)
+
+        return fetch_blank_polymorphic(association) if type_value.blank? || id_value.blank?
+
+        related_model_class = type_value.constantize
+        related_resource_class = JSONAPI::ResourceLoader.find_for_model(related_model_class)
+        record = related_resource_class.records.find(id_value)
+
+        association.collection? ? Array(record) : record
+      end
+
+      def fetch_blank_polymorphic(association)
+        return nil unless association.collection?
+
+        fetch_polymorphic_has_many_through_resource_records(association)
+      end
+
+      def fetch_polymorphic_has_many_through_resource_records(association)
+        association_instance = @resource.association(@relationship_name)
+        related_resource_class = JSONAPI::ResourceLoader.find_for_model(association.klass)
+        related_resource_class.records.merge(association_instance.scope)
+      end
+
+      def fetch_non_polymorphic_related_through_resource_records(association)
+        association_instance = @resource.association(@relationship_name)
+        related_resource_class = JSONAPI::ResourceLoader.find_for_model(association.klass)
+        scope = related_resource_class.records.merge(association_instance.scope)
+
+        association.collection? ? scope : scope.first
+      end
+
       def serialize_related(related, association)
         return serialize_collection_relationship(related, association) if association.collection?
 

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

@@ -24,7 +24,7 @@ module JSONAPI
       end
 
       def update_to_many_relationship(association, relationship_data)
-        if relationship_data.nil? || empty_array?(relationship_data)
+        if relationship_data.nil? || ParamHelpers.empty_array?(relationship_data)
           @resource.public_send("#{@relationship_name}=", [])
           return
         end
@@ -35,10 +35,6 @@ module JSONAPI
         @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

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

@@ -61,14 +61,6 @@ module JSONAPI
         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,

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

@@ -4,6 +4,7 @@ module JSONAPI
   module ResourceActions
     module FilterValidation
       extend ActiveSupport::Concern
+      include JSONAPI::Support::FilterParsing
 
       def validate_filter_param
         filters = parse_filter_param
@@ -69,13 +70,8 @@ module JSONAPI
       def polymorphic_filter_valid?(parts)
         return false if parts.empty? || parts.length > 1
 
-        m = parts.first.match(/\A(.+)_(eq|match|lt|lte|gt|gte)\z/)
-        %w[id type].include?(m ? m[1] : parts.first)
-      end
-
-      def parse_column_filter(name)
-        m = name.match(/\A(.+)_(eq|match|lt|lte|gt|gte)\z/)
-        m ? { column: m[1], operator: m[2].to_sym } : nil
+        col_filter = parse_column_filter(parts.first)
+        %w[id type].include?(col_filter ? col_filter[:column] : parts.first)
       end
 
       def render_filter_errors(invalid)

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

@@ -28,12 +28,12 @@ module JSONAPI
       def load_resource_record
         return unless params[:id] && @resource_class
 
-        @resource = @resource_class.records.find(params[:id])
+        scope = scope_with_includes(@resource_class.records)
+        @resource = scope.find(params[:id])
       end
 
       def render_record_not_found
-        render_jsonapi_error(
-          status: 404,
+        render_not_found_error(
           title: "Record Not Found",
           detail: "Could not find #{@resource_name} with id '#{params[:id]}'",
         )

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

@@ -6,31 +6,26 @@ module JSONAPI
       extend ActiveSupport::Concern
 
       def serialize_resource(resource)
-        run_preload_hook([resource])
         JSONAPI::Serializer.new(resource).to_hash(
           include: parse_include_param,
           fields: parse_fields_param,
           document_meta: jsonapi_document_meta,
         )
-      ensure
-        clear_preload_data
       end
 
       def serialize_collection(resources)
+        includes = parse_include_param
+        fields = parse_fields_param
+        resources = scope_with_includes(resources)
         resources_array = resources.to_a
-        run_preload_hook(resources_array)
 
-        data, all_included = serialize_resources_with_includes(resources_array)
+        data, all_included = serialize_resources_with_includes(resources_array, includes, fields)
         build_collection_response(data, all_included)
-      ensure
-        clear_preload_data
       end
 
       private
 
-      def serialize_resources_with_includes(resources)
-        includes = parse_include_param
-        fields = parse_fields_param
+      def serialize_resources_with_includes(resources, includes, fields)
         all_included = []
         processed = Set.new
 
@@ -61,30 +56,52 @@ module JSONAPI
         processed.add(key)
       end
 
-      def build_collection_response(data, all_included)
-        result = { jsonapi: JSONAPI::Serializer.jsonapi_object, data: }
-        result[:included] = all_included if all_included.any?
+      def includes_to_hash(paths)
+        hash = paths.each_with_object({}) do |path, h|
+          path.split(".").reduce(h) { |cur, part| cur[part.to_sym] ||= {} }
+        end
+        filter_includable(hash, model_class)
+      end
 
-        pagination_meta = @pagination_applied ? build_pagination_meta : {}
-        result[:links] = build_pagination_links if @pagination_applied
-        result[:meta] = jsonapi_document_meta(pagination_meta)
+      # Preloads associations from the include param so the serializer avoids N+1 queries
+      # when walking include paths (association.loaded? is true). Used by both show and index.
+      def scope_with_includes(scope)
+        includes = parse_include_param
+        return scope unless includes.any?
 
-        result
+        inc_hash = includes_to_hash(includes)
+        hash_contains_polymorphic?(inc_hash, model_class) ? scope.preload(inc_hash) : scope.includes(inc_hash)
       end
 
-      def run_preload_hook(records)
-        return unless resource_class.respond_to?(:preload_for_serialization)
+      def filter_includable(hash, klass)
+        hash.each_with_object({}) do |(key, value), filtered|
+          assoc = klass.reflect_on_association(key)
+          next unless assoc
 
-        preloaded = resource_class.preload_for_serialization(records, jsonapi_context)
-        resource_class.preloaded_data = preloaded if preloaded.present?
+          filtered[key] = value.empty? || assoc.polymorphic? ? value : filter_includable(value, assoc.klass)
+        end
+      end
+
+      def hash_contains_polymorphic?(hash, klass)
+        hash.any? { |key, value| polymorphic_in_hash_entry?(key, value, klass) }
       end
 
-      def clear_preload_data
-        resource_class.clear_preloaded_data! if resource_class.respond_to?(:clear_preloaded_data!)
+      def polymorphic_in_hash_entry?(key, value, klass)
+        assoc = klass.reflect_on_association(key)
+        return false unless assoc
+
+        assoc.polymorphic? || (value.present? && hash_contains_polymorphic?(value, assoc.klass))
       end
 
-      def jsonapi_context
-        { current_user: respond_to?(:current_user) ? current_user : nil }
+      def build_collection_response(data, all_included)
+        result = { jsonapi: JSONAPI::Serializer.jsonapi_object, data: }
+        result[:included] = all_included if all_included.any?
+
+        pagination_meta = @pagination_applied ? build_pagination_meta : {}
+        result[:links] = build_pagination_links if @pagination_applied
+        result[:meta] = jsonapi_document_meta(pagination_meta)
+
+        result
       end
     end
   end

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

@@ -2,7 +2,6 @@
 
 require_relative "resource_actions/filter_validation"
 require_relative "resource_actions/field_validation"
-require_relative "resource_actions/preloading"
 require_relative "resource_actions/serialization"
 require_relative "resource_actions/pagination"
 require_relative "resource_actions/type_validation"
@@ -15,7 +14,6 @@ module JSONAPI
     include ActiveStorageSupport
     include FilterValidation
     include FieldValidation
-    include Preloading
     include Serialization
     include Pagination
     include TypeValidation
@@ -30,11 +28,10 @@ module JSONAPI
       before_action :validate_include_param, only: %i[index show]
       before_action :validate_resource_type!, only: %i[create update]
       before_action :validate_resource_id!, only: [:update]
-      before_action :preload_includes, only: %i[index show]
     end
 
     def index
-      scope = apply_authorization_scope(@preloaded_resources || resource_class.records, action: :index)
+      scope = apply_authorization_scope(@resource_class.records, action: :index)
       query = build_query(scope)
       @total_count = query.total_count
       @pagination_applied = query.pagination_applied
@@ -42,9 +39,8 @@ module JSONAPI
     end
 
     def show
-      resource = @preloaded_resource || @resource
-      authorize_resource_action!(resource, action: :show)
-      render json: serialize_resource(resource), status: :ok
+      authorize_resource_action!(@resource, action: :show)
+      render json: serialize_resource(@resource), status: :ok
     end
 
     def create
@@ -54,7 +50,7 @@ module JSONAPI
       save_created(resource)
     rescue ArgumentError => e
       render_create_error(e)
-    rescue JSONAPI::Exceptions::ParameterNotAllowed, ActiveSupport::MessageVerifier::InvalidSignature => e
+    rescue JSONAPI::Errors::ParameterNotAllowed, ActiveSupport::MessageVerifier::InvalidSignature => e
       handle_create_exception(e)
     end
 
@@ -66,7 +62,7 @@ module JSONAPI
 
     def handle_create_exception(error)
       case error
-      when JSONAPI::Exceptions::ParameterNotAllowed then render_parameter_not_allowed_error(error)
+      when JSONAPI::Errors::ParameterNotAllowed then render_parameter_not_allowed_error(error)
       when ActiveSupport::MessageVerifier::InvalidSignature then render_signed_id_error(error)
       end
     end
@@ -77,7 +73,7 @@ module JSONAPI
       save_updated(params_hash, attachments)
     rescue ArgumentError => e
       render_invalid_relationship_error(e)
-    rescue JSONAPI::Exceptions::ParameterNotAllowed => e
+    rescue JSONAPI::Errors::ParameterNotAllowed => e
       render_parameter_not_allowed_error(e)
     rescue ActiveSupport::MessageVerifier::InvalidSignature => e
       render_signed_id_error(e)

data/lib/json_api/controllers/relationships_controller.rb

@@ -26,7 +26,6 @@ module JSONAPI
     before_action :set_relationship_name
     before_action :validate_relationship_exists
     before_action :validate_sort_param, only: [:show]
-    skip_before_action :validate_resource_type!, :validate_resource_id!
 
     def show
       authorize_resource_action!(@resource, action: :show, context: { relationship: @relationship_name })
@@ -40,7 +39,7 @@ module JSONAPI
       save_and_render_relationship(relationship_data)
     rescue ArgumentError => e
       render_invalid_relationship_error(e)
-    rescue JSONAPI::Exceptions::ParameterNotAllowed => e
+    rescue JSONAPI::Errors::ParameterNotAllowed => e
       render_parameter_not_allowed_error(e)
     end
 
@@ -53,7 +52,7 @@ module JSONAPI
       finalize_relationship_removal(relationship_data)
     rescue ArgumentError => e
       render_invalid_relationship_error(e)
-    rescue JSONAPI::Exceptions::ParameterNotAllowed => e
+    rescue JSONAPI::Errors::ParameterNotAllowed => e
       render_parameter_not_allowed_error(e)
     end
 

data/lib/json_api/errors/parameter_not_allowed.rb

@@ -11,9 +11,4 @@ module JSONAPI
       end
     end
   end
-
-  # Backward compatibility alias
-  module Exceptions
-    ParameterNotAllowed = Errors::ParameterNotAllowed
-  end
 end

data/lib/json_api/rack/n1_warning.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Rack
+    class N1Warning
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless JSONAPI.configuration.n1_warning_enabled
+        return @app.call(env) unless jsonapi_request?(env)
+
+        result = nil
+        query_count = JSONAPI::QueryCounter.count_queries { result = @app.call(env) }
+        status, headers, body = result
+        headers = add_n1_headers(headers, query_count, env)
+        [status, headers, body]
+      end
+
+      private
+
+      def add_n1_headers(headers, query_count, env)
+        headers = headers.dup
+        headers["X-JPie-Query-Count"] = query_count.to_s
+        headers["Server-Timing"] = append_server_timing(headers["Server-Timing"].to_s, query_count)
+        add_perf_warning_if_needed!(headers, query_count, env)
+        headers
+      end
+
+      def add_perf_warning_if_needed!(headers, query_count, env)
+        threshold = JSONAPI.configuration.n1_query_threshold
+        return unless query_count > threshold
+
+        warning_msg = n1_warning_message(query_count, threshold)
+        headers["X-JPie-Performance-Warning"] = warning_msg
+        headers["Server-Timing"] = [headers["Server-Timing"], perf_warning_metric(warning_msg)].join(", ")
+        log_n1_warning(env, query_count, threshold)
+      end
+
+      def append_server_timing(existing, query_count)
+        db_metric = "db;desc=\"#{query_count} queries\""
+        [existing, db_metric].reject(&:empty?).join(", ")
+      end
+
+      def n1_warning_message(query_count, threshold)
+        "N+1 possible (#{query_count} queries, threshold #{threshold}) - " \
+          "add include param for nested relationships"
+      end
+
+      def perf_warning_metric(warning_msg)
+        safe_desc = warning_msg.tr('"', "'")
+        "perf-warning;desc=\"#{safe_desc}\""
+      end
+
+      def jsonapi_request?(env)
+        env["HTTP_ACCEPT"].to_s.include?("application/vnd.api+json")
+      end
+
+      def log_n1_warning(env, count, threshold)
+        return unless defined?(Rails) && Rails.logger
+
+        req = ActionDispatch::Request.new(env)
+        Rails.logger.warn(
+          "[JPie] N+1 query warning: #{count} queries (threshold #{threshold}) " \
+          "path=#{req.path} include=#{req.params[:include].inspect} " \
+          "resource=#{req.params[:resource_type]}",
+        )
+      end
+    end
+  end
+end

data/lib/json_api/railtie.rb

@@ -16,14 +16,19 @@ module JSONAPI
       Mime::Type.register "application/vnd.api+json", :jsonapi
     end
 
+    initializer "json_api.n1_warning_middleware", after: "action_dispatch.configure" do |app|
+      if app.config.respond_to?(:server_timing) && app.config.server_timing
+        app.config.middleware.insert_after ActionDispatch::ServerTiming, JSONAPI::Rack::N1Warning
+      else
+        app.config.middleware.use JSONAPI::Rack::N1Warning
+      end
+    end
+
     initializer "json_api.routes" do |_app|
       require "json_api/routing"
       ActionDispatch::Routing::Mapper.include JSONAPI::Routing
     end
 
-    # Removed eager_load_namespaces registration - JSONAPI module doesn't implement eager_load!
-    # Controllers and resources are autoloaded via Zeitwerk
-
     initializer "json_api.parameter_parsing", after: "action_dispatch.configure" do |_app|
       ActionDispatch::Request.parameter_parsers[:jsonapi] = lambda do |raw_post|
         ActiveSupport::JSON.decode(raw_post)

data/lib/json_api/resources/resource.rb

@@ -6,8 +6,6 @@ require_relative "concerns/sortable_fields_dsl"
 require_relative "concerns/relationships_dsl"
 require_relative "concerns/meta_dsl"
 require_relative "concerns/model_class_helpers"
-require_relative "concerns/eager_load_dsl"
-require_relative "concerns/preload_dsl"
 
 module JSONAPI
   class Resource
@@ -17,8 +15,6 @@ module JSONAPI
     include Resources::RelationshipsDsl
     include Resources::MetaDsl
     include Resources::ModelClassHelpers
-    include Resources::EagerLoadDsl
-    include Resources::PreloadDsl
 
     class << self
       attr_accessor :type_format

data/lib/json_api/serialization/concerns/include_filtering.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Serialization
+    module IncludeFiltering
+      def filter_loaded_records(association, related_klass)
+        loaded_array = association.target.respond_to?(:to_a) ? association.target.to_a : Array(association.target)
+        return [] if loaded_array.empty?
+
+        resource_scope = ResourceLoader.find_for_model(related_klass).records
+        return loaded_array if resource_scope.where_clause.empty?
+
+        filter_by_where_hash(loaded_array, resource_scope, related_klass)
+      end
+
+      def filter_by_where_hash(loaded_array, resource_scope, related_klass)
+        hash = where_values_hash_for_scope(resource_scope, related_klass)
+        return filter_by_query(loaded_array, resource_scope) if hash.blank?
+
+        loaded_array.select { |r| record_matches_where_hash?(r, hash) }
+      end
+
+      def where_values_hash_for_scope(resource_scope, related_klass)
+        resource_scope.where_values_hash(related_klass.table_name)
+      rescue StandardError
+        {}
+      end
+
+      def record_matches_where_hash?(record, hash)
+        hash.all? do |attr, val|
+          r_val = record.read_attribute(attr)
+          val.is_a?(Array) ? val.include?(r_val) : r_val == val
+        end
+      end
+
+      def filter_by_query(loaded_array, resource_scope)
+        valid_ids = resource_scope.where(id: loaded_array.filter_map(&:id)).pluck(:id).to_set
+        loaded_array.select { |r| valid_ids.include?(r.id) }
+      end
+    end
+  end
+end

data/lib/json_api/serialization/concerns/includes_serialization.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "include_filtering"
+
 module JSONAPI
   module Serialization
     IncludeContext = Struct.new(:fields, :included_records, :processed, :all_includes, keyword_init: true)
@@ -9,6 +11,7 @@ module JSONAPI
 
     module IncludesSerialization
       include IncludePathHelpers
+      include IncludeFiltering
 
       def serialize_included(includes, fields = {})
         all_includes = normalize_include_paths(includes)
@@ -84,21 +87,16 @@ module JSONAPI
         related_klass = association.klass
         return [] if related_klass.blank?
 
-        scope = build_scoped_relation(related_klass, association)
-        association.loaded? ? scope_loaded_to_records_scope(association, scope) : scope.to_a
-      end
-
-      def scope_loaded_to_records_scope(association, scope)
-        loaded_array = association.target.respond_to?(:to_a) ? association.target.to_a : Array(association.target)
-        loaded_ids = loaded_array.filter_map(&:id)
-        return [] if loaded_ids.empty?
-
-        scope.where(id: loaded_ids).to_a
+        if association.loaded?
+          filter_loaded_records(association, related_klass)
+        else
+          build_scoped_relation(related_klass, association).to_a
+        end
       end
 
       def build_scoped_relation(related_klass, association)
         related_base_scope = ResourceLoader.find_for_model(related_klass).records
-        related_base_scope.merge(association.scope)
+        association.scope.merge(related_base_scope)
       end
 
       def get_active_storage_records(current_record, association_name)

data/lib/json_api/serialization/concerns/links_serialization.rb

@@ -22,17 +22,25 @@ module JSONAPI
       end
 
       def variant_or_blob_path
-        return rails_blob_path unless parent_record && association_name && record.content_type&.start_with?("image/")
+        return rails_blob_path unless image_blob_with_parent?
 
-        parent_definition = ResourceLoader.find_for_model(parent_record.class)
-        rel_def = RelationshipHelpers.find_relationship_definition(parent_definition, association_name)
-        variant_opts = rel_def&.dig(:options, :variant)
+        variant_opts = variant_options_for_parent_association
         return rails_blob_path unless variant_opts.present?
 
         representation = record.representation(**variant_opts.symbolize_keys)
         Rails.application.routes.url_helpers.rails_representation_path(representation, only_path: true)
       end
 
+      def image_blob_with_parent?
+        parent_record && association_name && record.content_type&.start_with?("image/")
+      end
+
+      def variant_options_for_parent_association
+        parent_definition = ResourceLoader.find_for_model(parent_record.class)
+        rel_def = RelationshipHelpers.find_relationship_definition(parent_definition, association_name)
+        rel_def&.dig(:options, :variant)
+      end
+
       def rails_blob_path
         Rails.application.routes.url_helpers.rails_blob_path(record, only_path: true)
       end

data/lib/json_api/serialization/concerns/relationship_processing.rb

@@ -11,7 +11,7 @@ module JSONAPI
         ensure_relationship_writable!(association_name)
 
         return handle_null_relationship(attrs, param_name, association_name) if data.nil?
-        return handle_empty_array_relationship(attrs, param_name, association_name) if empty_array?(data)
+        return handle_empty_array_relationship(attrs, param_name, association_name) if ParamHelpers.empty_array?(data)
 
         validate_relationship_data_format!(data, association_name)
         process_relationship_data(attrs, association_name, param_name, data)
@@ -27,10 +27,6 @@ module JSONAPI
         value_hash[:data]
       end
 
-      def empty_array?(data)
-        data.is_a?(Array) && data.empty?
-      end
-
       def handle_null_relationship(attrs, param_name, association_name)
         if active_storage_attachment?(association_name)
           attrs[association_name.to_s] = nil

data/lib/json_api/support/collection_query.rb

@@ -44,8 +44,7 @@ module JSONAPI
       return unless pagination_applied
 
       has_virtual_sort = sort_params.any? { |sort_field| virtual_attribute_sort?(sort_field) }
-      @total_count = @scope.count unless has_virtual_sort
-      @total_count = @scope.count if has_virtual_sort && @scope.is_a?(Array)
+      @total_count = @scope.count if !has_virtual_sort || @scope.is_a?(Array)
     end
 
     def apply_filtering

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

@@ -3,10 +3,13 @@
 module JSONAPI
   module Support
     module ConditionBuilding
+      include Support::FilterParsing
+
       private
 
-      def build_condition(column, value, operator)
-        build_arel_condition(model_class, column, value, operator)
+      def build_condition(model, column, value, operator)
+        attr = model.arel_table[column.name]
+        build_operator_condition(attr, value, operator)
       end
 
       def normalize_filter_value_for_model(model, column, raw_value)
@@ -19,15 +22,6 @@ module JSONAPI
         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)
@@ -48,10 +42,6 @@ module JSONAPI
       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

@@ -97,7 +97,7 @@ module JSONAPI
         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 = build_condition(target_model, column, value, column_filter[:operator])
         condition ? apply_condition(scope, condition) : nil
       end
 

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

@@ -51,7 +51,7 @@ module JSONAPI
         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 = build_condition(model_class, context[:fk_column], value, column_filter[:operator])
         condition ? apply_condition(scope, condition) : scope
       end
 

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

@@ -17,7 +17,7 @@ module JSONAPI
       private
 
       def apply_regular_filter(scope, filter_name, filter_value)
-        return scope if filter_value.respond_to?(:empty?) ? filter_value.empty? : filter_value.nil?
+        return scope if empty_filter_value?(filter_value)
 
         column_filter = parse_column_filter(filter_name)
         if column_filter
@@ -27,16 +27,6 @@ module JSONAPI
         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
@@ -49,10 +39,10 @@ module JSONAPI
         column = model_class.column_for_attribute(column_filter[:column])
         return nil unless column
 
-        value = normalize_filter_value(column, raw_value)
+        value = normalize_filter_value_for_model(model_class, column, raw_value)
         return nil if value.nil?
 
-        build_condition(column, value, column_filter[:operator])
+        build_condition(model_class, column, value, column_filter[:operator])
       end
 
       def log_filter_error(column_filter, operator, error)
@@ -61,14 +51,6 @@ module JSONAPI
         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)
 

data/lib/json_api/support/filter_parsing.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module FilterParsing
+      module_function
+
+      def parse_column_filter(filter_name)
+        m = filter_name.to_s.match(/\A(.+)_(eq|match|lt|lte|gt|gte)\z/)
+        m ? { column: m[1], operator: m[2].to_sym } : nil
+      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/param_helpers.rb

@@ -50,5 +50,9 @@ module JSONAPI
     def esc(val)
       CGI.escape(val.to_s)
     end
+
+    def empty_array?(data)
+      data.is_a?(Array) && data.empty?
+    end
   end
 end

data/lib/json_api/support/query_counter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module QueryCounter
+    SKIP_PATTERN = /\A(\s*(BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE\s+SAVEPOINT)\b)/i
+    SCHEMA_PATTERN = /\A(\s*(CREATE|ALTER|DROP)\s+(TABLE|INDEX|DATABASE))/i
+    PRAGMA_PATTERN = /\APRAGMA\b/i
+    SQLITE_MASTER_PATTERN = /sqlite_master|sqlite_temp_master/i
+
+    def self.count(&)
+      queries = []
+      counter = ->(_name, _start, _finish, _id, payload) { count_sql(queries, payload) }
+      ActiveSupport::Notifications.subscribed(counter, "sql.active_record", &)
+      queries
+    end
+
+    def self.count_queries(&)
+      count(&).size
+    end
+
+    def self.count_sql(queries, payload)
+      sql = payload[:sql]
+      return if sql.nil?
+      return if SKIP_PATTERN.match?(sql)
+      return if SCHEMA_PATTERN.match?(sql)
+      return if PRAGMA_PATTERN.match?(sql)
+      return if SQLITE_MASTER_PATTERN.match?(sql)
+
+      queries << sql
+    end
+  end
+end

data/lib/json_api/support/relationship_guard.rb

@@ -10,7 +10,7 @@ module JSONAPI
       return unless association
       return unless readonly
 
-      raise JSONAPI::Exceptions::ParameterNotAllowed, [error_target]
+      raise JSONAPI::Errors::ParameterNotAllowed, [error_target]
     end
   end
 end

data/lib/json_api/support/resource_identifier.rb

@@ -58,7 +58,8 @@ module JSONAPI
 
     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)
+      resource_class = JSONAPI::ResourceLoader.find_for_model(related_model_class)
+      resource_class.records.find(id)
     rescue ActiveRecord::RecordNotFound
       raise ArgumentError, "Related resource not found: #{type} with id #{id}"
     rescue NameError

data/lib/json_api/support/responders.rb

@@ -94,7 +94,7 @@ module JSONAPI
     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
+      ::Rack::Utils::SYMBOL_TO_STATUS_CODE.fetch(status, status).to_s
     end
   end
 end

data/lib/json_api/version.rb

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

data/lib/json_api.rb

@@ -33,13 +33,15 @@ 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/filter_parsing"
 require "json_api/support/collection_query"
+require "json_api/support/query_counter"
+require "json_api/rack/n1_warning"
 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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jpie
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Emil Kampp
@@ -95,21 +95,19 @@ files:
 - 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/rack/n1_warning.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/eager_load_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/preload_dsl.rb
 - lib/json_api/resources/concerns/relationships_dsl.rb
 - lib/json_api/resources/concerns/sortable_fields_dsl.rb
 - lib/json_api/resources/resource.rb
@@ -118,6 +116,7 @@ files:
 - 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/include_filtering.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
@@ -136,13 +135,14 @@ files:
 - 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/filter_parsing.rb
 - lib/json_api/support/instrumentation.rb
 - lib/json_api/support/param_helpers.rb
+- lib/json_api/support/query_counter.rb
 - lib/json_api/support/relationship_guard.rb
 - lib/json_api/support/relationship_helpers.rb
 - lib/json_api/support/resource_identifier.rb
 - lib/json_api/support/responders.rb
-- lib/json_api/support/response_helpers.rb
 - lib/json_api/support/sort_parsing.rb
 - lib/json_api/support/type_conversion.rb
 - lib/json_api/testing.rb

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module ResourceActions
-    module Preloading
-      extend ActiveSupport::Concern
-
-      def preload_includes
-        includes_hash = build_combined_includes_hash
-        return if includes_hash.empty?
-
-        preload_resources(includes_hash)
-      rescue ActiveRecord::RecordNotFound
-        # Will be handled by set_resource
-      end
-
-      private
-
-      def build_combined_includes_hash
-        param_includes = parse_include_param
-        dsl_includes = resource_eager_load_associations
-
-        combined = dsl_includes.map(&:to_s)
-        combined.concat(param_includes)
-        combined.uniq!
-
-        build_includes_hash(combined)
-      end
-
-      def resource_eager_load_associations
-        return [] unless resource_class.respond_to?(:eager_load_associations)
-
-        resource_class.eager_load_associations
-      end
-
-      def build_includes_hash(includes)
-        includes.each_with_object({}) do |path, hash|
-          merge_include_path(hash, path)
-        end
-      end
-
-      def merge_include_path(hash, path)
-        parts = path.to_s.split(".")
-        current = hash
-
-        parts.each_with_index do |part, i|
-          sym = part.to_sym
-          current[sym] ||= {}
-          current = current[sym] if i < parts.length - 1
-        end
-      end
-
-      def preload_resources(includes_hash)
-        filtered = filter_includes_for_preload(includes_hash)
-
-        case action_name
-        when "index" then @preloaded_resources = preload_collection(filtered)
-        when "show" then @preloaded_resource = preload_single(filtered)
-        end
-      end
-
-      def filter_includes_for_preload(hash)
-        filtered = filter_active_storage_from_includes(hash, model_class)
-        filter_polymorphic_from_includes(filtered, model_class)
-      end
-
-      def preload_collection(includes)
-        return resource_class.records if includes.empty?
-
-        resource_class.records.includes(includes)
-      end
-
-      def preload_single(includes)
-        return resource_class.records.find(params[:id]) if includes.empty?
-
-        resource_class.records.includes(includes).find(params[:id])
-      end
-    end
-  end
-end

data/lib/json_api/resources/concerns/eager_load_dsl.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module Resources
-    module EagerLoadDsl
-      extend ActiveSupport::Concern
-
-      class_methods do
-        # Declare associations to always eager-load for this resource
-        # @param associations [Array<Symbol>] list of association names to eager-load
-        def eager_load(*associations)
-          @declared_eager_loads ||= []
-          @declared_eager_loads.concat(associations.map(&:to_sym))
-          reset_eager_load_associations!
-        end
-
-        # Get all eager-load associations including inherited ones
-        # @return [Array<Symbol>] frozen array of association names
-        def eager_load_associations
-          return @eager_load_associations if defined?(@eager_load_associations)
-
-          @eager_load_associations = build_eager_load_associations.freeze
-        end
-
-        def reset_eager_load_associations!
-          remove_instance_variable(:@eager_load_associations) if defined?(@eager_load_associations)
-        end
-      end
-
-      module EagerLoadHelperMethods
-        def build_eager_load_associations
-          own_associations = @declared_eager_loads || []
-          inherited = inherit_eager_load_associations
-          (inherited + own_associations).uniq
-        end
-
-        def inherit_eager_load_associations
-          return [] unless superclass.respond_to?(:eager_load_associations)
-          return [] if superclass == JSONAPI::Resource
-
-          superclass.eager_load_associations
-        end
-      end
-
-      included do
-        extend EagerLoadHelperMethods
-      end
-    end
-  end
-end

data/lib/json_api/resources/concerns/preload_dsl.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module Resources
-    module PreloadDsl
-      extend ActiveSupport::Concern
-
-      class_methods do
-        # Override this method in resource subclasses to preload data before serialization.
-        # This is called once with all records before serialization starts.
-        # Use this to batch-load data needed by meta methods to avoid N+1 queries.
-        #
-        # @param records [Array<ActiveRecord::Base>] the records that will be serialized
-        # @param context [Hash] optional context (e.g., current user, request params)
-        # @return [Hash] a hash of preloaded data keyed by record id
-        #
-        # @example
-        #   class WorkstreamResource < ApplicationResource
-        #     def self.preload_for_serialization(records, context = {})
-        #       stats = Preloaders::StatsPreloader.call(records: records)
-        #       { stats: stats }
-        #     end
-        #
-        #     def meta(...)
-        #       preloaded = self.class.preloaded_data[record.id]
-        #       super.merge(loading: preloaded[:stats])
-        #     end
-        #   end
-        def preload_for_serialization(_records, _context = {})
-          # Default implementation does nothing - override in subclasses
-          {}
-        end
-
-        # Storage for preloaded data (request-scoped via Thread.current)
-        def preloaded_data
-          Thread.current["#{name}_preloaded_data"] ||= {}
-        end
-
-        def preloaded_data=(data)
-          Thread.current["#{name}_preloaded_data"] = data
-        end
-
-        def clear_preloaded_data!
-          Thread.current["#{name}_preloaded_data"] = nil
-        end
-      end
-    end
-  end
-end

data/lib/json_api/support/response_helpers.rb

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