jpie 0.4.5 → 1.0.0

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

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

@@ -1,109 +0,0 @@
-# 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,23 +0,0 @@
-# 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
-
-        # Set up default handlers unless explicitly disabled
-        setup_jpie_error_handlers if jpie_error_handlers_enabled
-      end
-    end
-  end
-end

data/lib/jpie/controller/json_api_validation.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  module Controller
-    module JsonApiValidation
-      extend ActiveSupport::Concern
-
-      private
-
-      # Validate that the request is JSON:API compliant
-      def validate_json_api_request
-        validate_content_type if request.post? || request.patch? || request.put?
-        validate_json_api_structure if request.post? || request.patch? || request.put?
-      end
-
-      # Validate Content-Type header for write operations
-      def validate_content_type
-        # Only validate content type for write operations
-        return unless request.post? || request.patch? || request.put?
-
-        content_type = request.content_type
-        return if content_type&.include?('application/vnd.api+json')
-
-        raise JPie::Errors::InvalidJsonApiRequestError.new(
-          detail: 'Content-Type must be application/vnd.api+json for JSON:API requests'
-        )
-      end
-
-      # 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
-
-      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
-
-      def validate_top_level_structure(parsed_body)
-        return if 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
-
-      # Validate the structure of the data member
-      def validate_data_structure(data)
-        if data.is_a?(Array)
-          data.each { |item| validate_resource_object(item) }
-        elsif data.is_a?(Hash)
-          validate_resource_object(data)
-        elsif !data.nil?
-          raise JPie::Errors::InvalidJsonApiRequestError.new(
-            detail: 'Data member must be an object, array, or null'
-          )
-        end
-      end
-
-      # Validate individual resource object structure
-      def validate_resource_object(resource)
-        unless resource.is_a?(Hash)
-          raise JPie::Errors::InvalidJsonApiRequestError.new(
-            detail: 'Resource objects must be JSON objects'
-          )
-        end
-
-        unless resource.key?('type')
-          raise JPie::Errors::InvalidJsonApiRequestError.new(
-            detail: 'Resource objects must have a "type" member'
-          )
-        end
-
-        # ID is required for updates but not for creates
-        return unless request.patch? || request.put?
-        return if resource.key?('id')
-
-        raise JPie::Errors::InvalidJsonApiRequestError.new(
-          detail: 'Resource objects must have an "id" member for updates'
-        )
-      end
-
-      # Validate include parameters against supported includes
-      def validate_include_params
-        return if params[:include].blank?
-
-        include_paths = params[:include].to_s.split(',').map(&:strip)
-        supported_includes = resource_class.supported_includes
-
-        include_paths.each do |include_path|
-          next if include_path.blank?
-
-          validate_include_path(include_path, supported_includes)
-        end
-      end
-
-      # Validate a single include path
-      def validate_include_path(include_path, supported_includes)
-        path_parts = include_path.split('.')
-        current_level = supported_includes
-
-        path_parts.each_with_index do |part, index|
-          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?
-
-        sort_fields = params[:sort].to_s.split(',').map(&:strip)
-        supported_fields = resource_class.supported_sort_fields
-
-        sort_fields.each do |sort_field|
-          next if sort_field.blank?
-
-          validate_sort_field(sort_field, supported_fields)
-        end
-      end
-
-      # Validate a single sort field
-      def validate_sort_field(sort_field, supported_fields)
-        # Remove leading minus for descending sort
-        field_name = sort_field.start_with?('-') ? sort_field[1..] : sort_field
-
-        # 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'
-          )
-        end
-
-        return if supported_fields.include?(field_name.to_sym) || supported_fields.include?(field_name)
-
-        raise JPie::Errors::UnsupportedSortFieldError.new(
-          sort_field: field_name,
-          supported_fields: supported_fields.map(&:to_s)
-        )
-      end
-
-      # Validate all JSON:API request aspects
-      def validate_json_api_compliance
-        validate_json_api_request
-        validate_include_params
-        validate_sort_params
-      end
-    end
-  end
-end

data/lib/jpie/controller/parameter_parsing.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  module Controller
-    module ParameterParsing
-      def parse_include_params
-        params[:include]&.split(',')&.map(&:strip) || []
-      end
-
-      def parse_sort_params
-        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
-        raise JPie::Errors::BadRequestError.new(detail: "Invalid JSON: #{e.message}")
-      end
-
-      def context
-        @context ||= build_context
-      end
-
-      private
-
-      def build_context
-        {
-          current_user: try(:current_user),
-          controller: self,
-          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

data/lib/jpie/controller/related_actions.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  module Controller
-    module RelatedActions
-      extend ActiveSupport::Concern
-
-      # GET /resources/:id/:relationship_name
-      # Returns the related resources themselves (not just linkage)
-      def related_show
-        validate_relationship_exists
-        validate_include_params
-        resource = find_resource
-        related_resources = get_related_resources(resource)
-        render_jsonapi(related_resources)
-      end
-
-      private
-
-      def validate_relationship_exists
-        relationship_name = params[:relationship_name]
-        return unless relationship_name # Skip validation if no relationship_name param
-
-        return if resource_class._relationships.key?(relationship_name.to_sym)
-
-        raise JPie::Errors::NotFoundError.new(
-          detail: "Relationship '#{relationship_name}' does not exist for #{resource_class.name}"
-        )
-      end
-
-      def find_resource
-        resource_class.scope(context).find(params[:id])
-      end
-
-      def relationship_name
-        @relationship_name ||= params[:relationship_name].to_sym
-      end
-
-      def get_related_resources(resource)
-        relationship_method = relationship_name
-        resource.send(relationship_method)
-      end
-    end
-  end
-end