jpie 0.4.1 → 0.4.2

data/lib/jpie/controller/crud_actions.rb

@@ -39,7 +39,12 @@ module JPie
             resources = resource_class.scope(context)
             sort_fields = parse_sort_params
             resources = resource_class.sort(resources, sort_fields) if sort_fields.any?
-            render_jsonapi(resources)
+
+            pagination_params = parse_pagination_params
+            original_resources = resources
+            resources = apply_pagination(resources, pagination_params)
+
+            render_jsonapi(resources, pagination: pagination_params, original_scope: original_resources)
           end
         end
 
@@ -86,7 +91,12 @@ module JPie
         resources = resource_class.scope(context)
         sort_fields = parse_sort_params
         resources = resource_class.sort(resources, sort_fields) if sort_fields.any?
-        render_jsonapi(resources)
+
+        pagination_params = parse_pagination_params
+        original_resources = resources
+        resources = apply_pagination(resources, pagination_params)
+
+        render_jsonapi(resources, pagination: pagination_params, original_scope: original_resources)
       end
 
       def show
@@ -115,6 +125,17 @@ module JPie
         resource.destroy!
         head :no_content
       end
+
+      private
+
+      def apply_pagination(resources, pagination_params)
+        return resources unless pagination_params[:per_page]
+
+        page = pagination_params[:page] || 1
+        per_page = pagination_params[:per_page]
+
+        resources.limit(per_page).offset((page - 1) * per_page)
+      end
     end
   end
 end

data/lib/jpie/controller/error_handling/handler_setup.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module JPie
+  module Controller
+    module ErrorHandling
+      module HandlerSetup
+        extend ActiveSupport::Concern
+
+        class_methods do
+          # Allow applications to easily disable all JPie error handlers
+          def disable_jpie_error_handlers
+            self.jpie_error_handlers_enabled = false
+            # Remove any already-added handlers
+            remove_jpie_handlers
+          end
+
+          # Allow applications to enable specific handlers
+          def enable_jpie_error_handler(error_class, method_name = nil)
+            method_name ||= :"handle_#{error_class.name.demodulize.underscore}"
+            rescue_from error_class, with: method_name
+          end
+
+          # Check for application-defined error handlers
+          def rescue_handler?(exception_class)
+            # Use Rails' rescue_handlers method to check for existing handlers
+            return false unless respond_to?(:rescue_handlers, true)
+
+            begin
+              rescue_handlers.any? { |handler| handler.first == exception_class.name }
+            rescue NoMethodError
+              false
+            end
+          end
+
+          private
+
+          def setup_jpie_error_handlers
+            setup_jpie_specific_handlers
+          end
+
+          def setup_jpie_specific_handlers
+            setup_core_error_handlers
+            setup_activerecord_handlers
+            setup_json_api_compliance_handlers
+          end
+
+          def setup_core_error_handlers
+            return if rescue_handler?(JPie::Errors::Error)
+
+            rescue_from JPie::Errors::Error, with: :handle_jpie_error
+          end
+
+          def setup_activerecord_handlers
+            setup_not_found_handler
+            setup_invalid_record_handler
+          end
+
+          def setup_not_found_handler
+            return if rescue_handler?(ActiveRecord::RecordNotFound)
+
+            rescue_from ActiveRecord::RecordNotFound, with: :handle_record_not_found
+          end
+
+          def setup_invalid_record_handler
+            return if rescue_handler?(ActiveRecord::RecordInvalid)
+
+            rescue_from ActiveRecord::RecordInvalid, with: :handle_record_invalid
+          end
+
+          def setup_json_api_compliance_handlers
+            setup_json_api_request_handler
+            setup_include_handlers
+            setup_sort_handlers
+          end
+
+          def setup_json_api_request_handler
+            return if rescue_handler?(JPie::Errors::InvalidJsonApiRequestError)
+
+            rescue_from JPie::Errors::InvalidJsonApiRequestError, with: :handle_invalid_json_api_request
+          end
+
+          def setup_include_handlers
+            setup_unsupported_include_handler
+            setup_invalid_include_handler
+          end
+
+          def setup_unsupported_include_handler
+            return if rescue_handler?(JPie::Errors::UnsupportedIncludeError)
+
+            rescue_from JPie::Errors::UnsupportedIncludeError, with: :handle_unsupported_include
+          end
+
+          def setup_invalid_include_handler
+            return if rescue_handler?(JPie::Errors::InvalidIncludeParameterError)
+
+            rescue_from JPie::Errors::InvalidIncludeParameterError, with: :handle_invalid_include_parameter
+          end
+
+          def setup_sort_handlers
+            setup_unsupported_sort_handler
+            setup_invalid_sort_handler
+          end
+
+          def setup_unsupported_sort_handler
+            return if rescue_handler?(JPie::Errors::UnsupportedSortFieldError)
+
+            rescue_from JPie::Errors::UnsupportedSortFieldError, with: :handle_unsupported_sort_field
+          end
+
+          def setup_invalid_sort_handler
+            return if rescue_handler?(JPie::Errors::InvalidSortParameterError)
+
+            rescue_from JPie::Errors::InvalidSortParameterError, with: :handle_invalid_sort_parameter
+          end
+
+          def remove_jpie_handlers
+            # This is a placeholder - Rails doesn't provide an easy way to remove specific handlers
+            # In practice, applications should use the disable_jpie_error_handlers before including
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jpie/controller/error_handling/handlers.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module JPie
+  module Controller
+    module ErrorHandling
+      module Handlers
+        extend ActiveSupport::Concern
+
+        private
+
+        # Handle JPie-specific errors
+        def handle_jpie_error(error)
+          render_json_api_error(
+            status: error.status,
+            title: error.title,
+            detail: error.detail
+          )
+        end
+
+        # Handle ActiveRecord::RecordNotFound
+        def handle_record_not_found(error)
+          render_json_api_error(
+            status: 404,
+            title: 'Not Found',
+            detail: error.message
+          )
+        end
+
+        # Handle ActiveRecord::RecordInvalid
+        def handle_record_invalid(error)
+          errors = error.record.errors.full_messages.map do |message|
+            {
+              status: '422',
+              title: 'Validation Error',
+              detail: message
+            }
+          end
+
+          render json: { errors: errors }, status: :unprocessable_content
+        end
+
+        # Render a single JSON:API error
+        def render_json_api_error(status:, title:, detail:)
+          render json: {
+            errors: [{
+              status: status.to_s,
+              title: title,
+              detail: detail
+            }]
+          }, status: status
+        end
+
+        # Handle JSON:API compliance errors
+        def handle_invalid_json_api_request(error)
+          render_json_api_error(
+            status: error.status,
+            title: error.title || 'Invalid JSON:API Request',
+            detail: error.detail
+          )
+        end
+
+        def handle_unsupported_include(error)
+          render_json_api_error(
+            status: error.status,
+            title: error.title || 'Unsupported Include',
+            detail: error.detail
+          )
+        end
+
+        def handle_unsupported_sort_field(error)
+          render_json_api_error(
+            status: error.status,
+            title: error.title || 'Unsupported Sort Field',
+            detail: error.detail
+          )
+        end
+
+        def handle_invalid_sort_parameter(error)
+          render_json_api_error(
+            status: error.status,
+            title: error.title || 'Invalid Sort Parameter',
+            detail: error.detail
+          )
+        end
+
+        def handle_invalid_include_parameter(error)
+          render_json_api_error(
+            status: error.status,
+            title: error.title || 'Invalid Include Parameter',
+            detail: error.detail
+          )
+        end
+
+        # Backward compatibility aliases
+        alias jpie_handle_error handle_jpie_error
+        alias jpie_handle_not_found handle_record_not_found
+        alias jpie_handle_invalid handle_record_invalid
+
+        # Legacy method name aliases
+        alias render_jpie_error handle_jpie_error
+        alias render_jpie_not_found_error handle_record_not_found
+        alias render_jpie_validation_error handle_record_invalid
+        alias render_jsonapi_error handle_jpie_error
+        alias render_not_found_error handle_record_not_found
+        alias render_validation_error handle_record_invalid
+      end
+    end
+  end
+end

data/lib/jpie/controller/error_handling.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'error_handling/handler_setup'
+require_relative 'error_handling/handlers'
+
 module JPie
   module Controller
     module ErrorHandling
       extend ActiveSupport::Concern
 
+      include HandlerSetup
+      include Handlers
+
       included do
         # Use class_attribute to allow easy overriding
         class_attribute :jpie_error_handlers_enabled, default: true
@@ -12,181 +18,6 @@ module JPie
         # Set up default handlers unless explicitly disabled
         setup_jpie_error_handlers if jpie_error_handlers_enabled
       end
-
-      class_methods do
-        # Allow applications to easily disable all JPie error handlers
-        def disable_jpie_error_handlers
-          self.jpie_error_handlers_enabled = false
-          # Remove any already-added handlers
-          remove_jpie_handlers
-        end
-
-        # Allow applications to enable specific handlers
-        def enable_jpie_error_handler(error_class, method_name = nil)
-          method_name ||= :"handle_#{error_class.name.demodulize.underscore}"
-          rescue_from error_class, with: method_name
-        end
-
-        # Check for application-defined error handlers
-        def rescue_handler?(exception_class)
-          # Use Rails' rescue_handlers method to check for existing handlers
-          return false unless respond_to?(:rescue_handlers, true)
-
-          begin
-            rescue_handlers.any? { |handler| handler.first == exception_class.name }
-          rescue NoMethodError
-            false
-          end
-        end
-
-        private
-
-        def setup_jpie_error_handlers
-          setup_jpie_specific_handlers
-        end
-
-        def setup_jpie_specific_handlers
-          # Only add handlers if they don't already exist
-          rescue_from JPie::Errors::Error, with: :handle_jpie_error unless rescue_handler?(JPie::Errors::Error)
-          unless rescue_handler?(ActiveRecord::RecordNotFound)
-            rescue_from ActiveRecord::RecordNotFound,
-                        with: :handle_record_not_found
-          end
-          return if rescue_handler?(ActiveRecord::RecordInvalid)
-
-          rescue_from ActiveRecord::RecordInvalid,
-                      with: :handle_record_invalid
-
-          # JSON:API compliance error handlers
-          unless rescue_handler?(JPie::Errors::InvalidJsonApiRequestError)
-            rescue_from JPie::Errors::InvalidJsonApiRequestError,
-                        with: :handle_invalid_json_api_request
-          end
-
-          unless rescue_handler?(JPie::Errors::UnsupportedIncludeError)
-            rescue_from JPie::Errors::UnsupportedIncludeError,
-                        with: :handle_unsupported_include
-          end
-
-          unless rescue_handler?(JPie::Errors::UnsupportedSortFieldError)
-            rescue_from JPie::Errors::UnsupportedSortFieldError,
-                        with: :handle_unsupported_sort_field
-          end
-
-          unless rescue_handler?(JPie::Errors::InvalidSortParameterError)
-            rescue_from JPie::Errors::InvalidSortParameterError,
-                        with: :handle_invalid_sort_parameter
-          end
-
-          return if rescue_handler?(JPie::Errors::InvalidIncludeParameterError)
-
-          rescue_from JPie::Errors::InvalidIncludeParameterError,
-                      with: :handle_invalid_include_parameter
-        end
-
-        def remove_jpie_handlers
-          # This is a placeholder - Rails doesn't provide an easy way to remove specific handlers
-          # In practice, applications should use the disable_jpie_error_handlers before including
-        end
-      end
-
-      private
-
-      # Handle JPie-specific errors
-      def handle_jpie_error(error)
-        render_json_api_error(
-          status: error.status,
-          title: error.title,
-          detail: error.detail
-        )
-      end
-
-      # Handle ActiveRecord::RecordNotFound
-      def handle_record_not_found(error)
-        render_json_api_error(
-          status: 404,
-          title: 'Not Found',
-          detail: error.message
-        )
-      end
-
-      # Handle ActiveRecord::RecordInvalid
-      def handle_record_invalid(error)
-        errors = error.record.errors.full_messages.map do |message|
-          {
-            status: '422',
-            title: 'Validation Error',
-            detail: message
-          }
-        end
-
-        render json: { errors: errors }, status: :unprocessable_content
-      end
-
-      # Render a single JSON:API error
-      def render_json_api_error(status:, title:, detail:)
-        render json: {
-          errors: [{
-            status: status.to_s,
-            title: title,
-            detail: detail
-          }]
-        }, status: status
-      end
-
-      # Handle JSON:API compliance errors
-      def handle_invalid_json_api_request(error)
-        render_json_api_error(
-          status: error.status,
-          title: error.title || 'Invalid JSON:API Request',
-          detail: error.detail
-        )
-      end
-
-      def handle_unsupported_include(error)
-        render_json_api_error(
-          status: error.status,
-          title: error.title || 'Unsupported Include',
-          detail: error.detail
-        )
-      end
-
-      def handle_unsupported_sort_field(error)
-        render_json_api_error(
-          status: error.status,
-          title: error.title || 'Unsupported Sort Field',
-          detail: error.detail
-        )
-      end
-
-      def handle_invalid_sort_parameter(error)
-        render_json_api_error(
-          status: error.status,
-          title: error.title || 'Invalid Sort Parameter',
-          detail: error.detail
-        )
-      end
-
-      def handle_invalid_include_parameter(error)
-        render_json_api_error(
-          status: error.status,
-          title: error.title || 'Invalid Include Parameter',
-          detail: error.detail
-        )
-      end
-
-      # Backward compatibility aliases
-      alias jpie_handle_error handle_jpie_error
-      alias jpie_handle_not_found handle_record_not_found
-      alias jpie_handle_invalid handle_record_invalid
-
-      # Legacy method name aliases
-      alias render_jpie_error handle_jpie_error
-      alias render_jpie_not_found_error handle_record_not_found
-      alias render_jpie_validation_error handle_record_invalid
-      alias render_jsonapi_error handle_jpie_error
-      alias render_not_found_error handle_record_not_found
-      alias render_validation_error handle_record_invalid
     end
   end
 end

data/lib/jpie/controller/json_api_validation.rb

@@ -28,26 +28,34 @@ module JPie
 
       # Validate basic JSON:API request structure
       def validate_json_api_structure
+        request_body = read_request_body
+        return if request_body.blank?
+
+        parsed_body = parse_json_body(request_body)
+        validate_top_level_structure(parsed_body)
+        validate_data_structure(parsed_body['data'])
+      end
+
+      def read_request_body
         request_body = request.body.read
         request.body.rewind # Reset for later reading
+        request_body
+      end
 
-        return if request_body.blank?
-
-        begin
-          parsed_body = JSON.parse(request_body)
-        rescue JSON::ParserError => e
-          raise JPie::Errors::InvalidJsonApiRequestError.new(
-            detail: "Invalid JSON: #{e.message}"
-          )
-        end
+      def parse_json_body(request_body)
+        JSON.parse(request_body)
+      rescue JSON::ParserError => e
+        raise JPie::Errors::InvalidJsonApiRequestError.new(
+          detail: "Invalid JSON: #{e.message}"
+        )
+      end
 
-        unless parsed_body.is_a?(Hash) && parsed_body.key?('data')
-          raise JPie::Errors::InvalidJsonApiRequestError.new(
-            detail: 'JSON:API request must have a top-level "data" member'
-          )
-        end
+      def validate_top_level_structure(parsed_body)
+        return if parsed_body.is_a?(Hash) && parsed_body.key?('data')
 
-        validate_data_structure(parsed_body['data'])
+        raise JPie::Errors::InvalidJsonApiRequestError.new(
+          detail: 'JSON:API request must have a top-level "data" member'
+        )
       end
 
       # Validate the structure of the data member
@@ -102,30 +110,43 @@ module JPie
 
       # Validate a single include path
       def validate_include_path(include_path, supported_includes)
-        # Handle nested includes (e.g., "posts.comments")
         path_parts = include_path.split('.')
         current_level = supported_includes
 
         path_parts.each_with_index do |part, index|
-          unless current_level.include?(part.to_sym) || current_level.include?(part)
-            current_path = path_parts[0..index].join('.')
-            available_at_level = current_level.is_a?(Hash) ? current_level.keys : current_level
-
-            raise JPie::Errors::UnsupportedIncludeError.new(
-              include_path: current_path,
-              supported_includes: available_at_level.map(&:to_s)
-            )
-          end
-
-          # Move to next level for nested validation
-          if current_level.is_a?(Hash) && current_level[part.to_sym].is_a?(Hash)
-            current_level = current_level[part.to_sym]
-          elsif current_level.is_a?(Hash) && current_level[part].is_a?(Hash)
-            current_level = current_level[part]
-          end
+          validate_include_part(part, current_level, path_parts, index)
+          current_level = move_to_next_include_level(part, current_level)
         end
       end
 
+      def validate_include_part(part, current_level, path_parts, index)
+        return if include_part_supported?(part, current_level)
+
+        current_path = path_parts[0..index].join('.')
+        available_at_level = extract_available_includes(current_level)
+
+        raise JPie::Errors::UnsupportedIncludeError.new(
+          include_path: current_path,
+          supported_includes: available_at_level.map(&:to_s)
+        )
+      end
+
+      def include_part_supported?(part, current_level)
+        current_level.include?(part.to_sym) || current_level.include?(part)
+      end
+
+      def extract_available_includes(current_level)
+        current_level.is_a?(Hash) ? current_level.keys : current_level
+      end
+
+      def move_to_next_include_level(part, current_level)
+        return current_level unless current_level.is_a?(Hash)
+
+        current_level[part.to_sym] if current_level[part.to_sym].is_a?(Hash)
+        current_level[part] if current_level[part].is_a?(Hash)
+        current_level
+      end
+
       # Validate sort parameters against supported fields
       def validate_sort_params
         return if params[:sort].blank?
@@ -148,7 +169,8 @@ module JPie
         # Validate field name format
         unless field_name.match?(/\A[a-zA-Z][a-zA-Z0-9_]*\z/)
           raise JPie::Errors::InvalidSortParameterError.new(
-            detail: "Invalid sort field format: '#{sort_field}'. Field names must start with a letter and contain only letters, numbers, and underscores"
+            detail: "Invalid sort field format: '#{sort_field}'. " \
+                    'Field names must start with a letter and contain only letters, numbers, and underscores'
           )
         end
 

data/lib/jpie/controller/parameter_parsing.rb

@@ -11,6 +11,16 @@ module JPie
         params[:sort]&.split(',')&.map(&:strip) || []
       end
 
+      def parse_pagination_params
+        page_params = params[:page] || {}
+        per_page_param = params[:per_page]
+
+        {
+          page: extract_page_number(page_params, per_page_param),
+          per_page: extract_per_page_size(page_params, per_page_param)
+        }
+      end
+
       def deserialize_params
         deserializer.deserialize(request.body.read, context)
       rescue JSON::ParserError => e
@@ -30,6 +40,39 @@ module JPie
           action: action_name
         }
       end
+
+      def extract_page_number(page_params, per_page_param)
+        page_number = determine_page_number(page_params)
+        page_number = '1' if page_number.nil? && per_page_param.present?
+        return 1 if page_number.blank?
+
+        parsed_page = page_number.to_i
+        parsed_page.positive? ? parsed_page : 1
+      end
+
+      def extract_per_page_size(page_params, per_page_param)
+        per_page_size = determine_per_page_size(page_params, per_page_param)
+        return nil if per_page_size.blank?
+
+        parsed_size = per_page_size.to_i
+        parsed_size.positive? ? parsed_size : nil
+      end
+
+      def determine_page_number(page_params)
+        if page_params.is_a?(String) || page_params.is_a?(Integer)
+          page_params
+        else
+          page_params[:number] || page_params['number']
+        end
+      end
+
+      def determine_per_page_size(page_params, per_page_param)
+        if page_params.is_a?(String) || page_params.is_a?(Integer)
+          per_page_param
+        else
+          page_params[:size] || page_params['size'] || per_page_param
+        end
+      end
     end
   end
 end