jpie 1.5.1 → 2.0.1

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

@@ -4,33 +4,31 @@ module JSONAPI
   module ResourceActions
     module Serialization
       extend ActiveSupport::Concern
+      include IncludePreloading
 
       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)
+        preload_included_resource_associations(resources_array, includes)
+
+        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
 
@@ -71,21 +69,6 @@ module JSONAPI
 
         result
       end
-
-      def run_preload_hook(records)
-        return unless resource_class.respond_to?(:preload_for_serialization)
-
-        preloaded = resource_class.preload_for_serialization(records, jsonapi_context)
-        resource_class.preloaded_data = preloaded if preloaded.present?
-      end
-
-      def clear_preload_data
-        resource_class.clear_preloaded_data! if resource_class.respond_to?(:clear_preloaded_data!)
-      end
-
-      def jsonapi_context
-        { current_user: respond_to?(:current_user) ? current_user : nil }
-      end
     end
   end
 end

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

@@ -2,7 +2,8 @@
 
 require_relative "resource_actions/filter_validation"
 require_relative "resource_actions/field_validation"
-require_relative "resource_actions/preloading"
+require_relative "resource_actions/include_validation"
+require_relative "resource_actions/include_preloading"
 require_relative "resource_actions/serialization"
 require_relative "resource_actions/pagination"
 require_relative "resource_actions/type_validation"
@@ -15,7 +16,7 @@ module JSONAPI
     include ActiveStorageSupport
     include FilterValidation
     include FieldValidation
-    include Preloading
+    include IncludeValidation
     include Serialization
     include Pagination
     include TypeValidation
@@ -30,11 +31,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 +42,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 +53,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 +65,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 +76,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_detection.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "prosopite"
+
+module JSONAPI
+  module Rack
+    class N1Detection
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless JSONAPI.configuration.n1_detection_enabled
+        return @app.call(env) unless jsonapi_request?(env)
+        return @app.call(env) unless postgres?
+
+        Thread.current[:jpie_request_env] = env
+        Prosopite.custom_logger = JSONAPI::Support::ProsopiteInstrumentationLogger.new
+
+        result = Prosopite.scan { @app.call(env) }
+        result
+      ensure
+        Prosopite.finish
+        Thread.current[:jpie_request_env] = nil
+      end
+
+      private
+
+      def jsonapi_request?(env)
+        env["HTTP_ACCEPT"].to_s.include?("application/vnd.api+json")
+      end
+
+      def postgres?
+        return false unless defined?(ActiveRecord) && ActiveRecord::Base.connection_db_config
+
+        adapter = ActiveRecord::Base.connection_db_config.adapter
+        adapter.to_s.include?("postgresql")
+      end
+    end
+  end
+end

data/lib/json_api/rack/query_tracking.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Rack
+    class QueryTracking
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless JSONAPI.configuration.query_tracking_enabled
+        return @app.call(env) unless jsonapi_request?(env)
+
+        call_with_tracking(env)
+      ensure
+        emit_excessive_queries_if_needed
+        Thread.current[:jpie_query_tracking] = nil
+        Thread.current[:jpie_warnings] = nil
+      end
+
+      private
+
+      def call_with_tracking(env)
+        Thread.current[:jpie_query_tracking] = { count: 0, queries: [], env: env }
+        Thread.current[:jpie_warnings] = [] if JSONAPI.configuration.jpie_headers_enabled
+
+        status, headers, body = @app.call(env)
+        add_jpie_headers(headers) if JSONAPI.configuration.jpie_headers_enabled
+
+        [status, headers, body]
+      end
+
+      def jsonapi_request?(env)
+        env["HTTP_ACCEPT"].to_s.include?("application/vnd.api+json")
+      end
+
+      def emit_excessive_queries_if_needed
+        tracking = Thread.current[:jpie_query_tracking]
+        return if tracking.nil?
+
+        count = tracking[:count]
+        threshold = JSONAPI.configuration.query_count_threshold
+        return if count <= threshold
+        return unless defined?(Rails) && Rails.respond_to?(:event)
+
+        notify_excessive_queries(tracking, count, threshold)
+      end
+
+      def notify_excessive_queries(tracking, count, threshold)
+        cap = JSONAPI.configuration.query_tracking_queries_cap
+        queries = tracking[:queries].first(cap)
+        payload = build_excessive_queries_payload(tracking[:env], count, threshold, queries)
+
+        Rails.event.tagged("jsonapi", "excessive_queries") do
+          Rails.event.notify("jpie.excessive_queries_detected", payload)
+        end
+      end
+
+      def build_excessive_queries_payload(env, count, threshold, queries)
+        build_payload(env).merge(
+          query_count: count,
+          threshold: threshold,
+          queries: queries,
+        )
+      end
+
+      def build_payload(env)
+        base = env.nil? ? {} : request_payload_from_env(env)
+        base.merge(correlation_id: JSONAPI::Support::CorrelationId.resolve)
+      end
+
+      def request_payload_from_env(env)
+        req = ActionDispatch::Request.new(env)
+        params = req.params
+        {
+          path: req.path,
+          method: req.request_method,
+          include: params[:include],
+          resource_type: params[:resource_type],
+          resource_id: params[:id],
+        }
+      end
+
+      def add_jpie_headers(headers)
+        tracking = Thread.current[:jpie_query_tracking]
+        return if tracking.nil?
+
+        count = tracking[:count]
+        headers["X-JPie-Query-Count"] = count.to_s
+
+        warning_str = build_performance_warning_header(count)
+        headers["X-JPie-Performance-Warning"] = warning_str if warning_str.present?
+      end
+
+      def build_performance_warning_header(count)
+        warnings = (Thread.current[:jpie_warnings] || []).dup
+        warnings << "excessive_queries" if count > JSONAPI.configuration.query_count_threshold
+        warnings.uniq.join(",").presence
+      end
+    end
+  end
+end

data/lib/json_api/railtie.rb

@@ -16,14 +16,45 @@ module JSONAPI
       Mime::Type.register "application/vnd.api+json", :jsonapi
     end
 
+    initializer "json_api.n1_log_subscriber", after: "action_dispatch.configure" do
+      if Rails.respond_to?(:event) && JSONAPI.configuration.n1_detection_enabled
+        Rails.event.subscribe(JSONAPI::Support::N1LogSubscriber.new)
+      end
+    end
+
+    initializer "json_api.n1_detection_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::N1Detection
+      else
+        app.config.middleware.use JSONAPI::Rack::N1Detection
+      end
+    end
+
+    initializer "json_api.query_tracking_subscriber", after: "action_dispatch.configure" do
+      ActiveSupport::Notifications.subscribe("sql.active_record", JSONAPI::Support::QueryTrackingSubscriber.new)
+    end
+
+    initializer "json_api.query_tracking_log_subscriber", after: "action_dispatch.configure" do
+      if Rails.respond_to?(:event) && JSONAPI.configuration.query_tracking_enabled
+        Rails.event.subscribe(JSONAPI::Support::QueryTrackingLogSubscriber.new)
+      end
+    end
+
+    initializer "json_api.header_warning_subscriber", after: "action_dispatch.configure" do
+      if Rails.respond_to?(:event) && JSONAPI.configuration.jpie_headers_enabled
+        Rails.event.subscribe(JSONAPI::Support::HeaderWarningSubscriber.new)
+      end
+    end
+
+    initializer "json_api.query_tracking_middleware", after: "json_api.n1_detection_middleware" do |app|
+      app.config.middleware.insert_after JSONAPI::Rack::N1Detection, JSONAPI::Rack::QueryTracking
+    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)