jpie 0.4.1 → 0.4.3

data/examples/relationships.md

@@ -0,0 +1,114 @@
+# JSON:API Relationship Management
+
+This example demonstrates how to manage relationships using JPie's JSON:API compliant relationship endpoints.
+
+## Setup
+
+Define your resources with relationships:
+
+```ruby
+# app/resources/user_resource.rb
+class UserResource < JPie::Resource
+  model User
+  attributes :name, :email
+  has_many :posts
+end
+
+# app/resources/post_resource.rb  
+class PostResource < JPie::Resource
+  model Post
+  attributes :title, :content
+  has_one :author, resource: 'UserResource'
+end
+
+# app/controllers/users_controller.rb
+class UsersController < ApplicationController
+  include JPie::Controller
+end
+```
+
+Configure routes:
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  jpie_resources :users
+  jpie_resources :posts
+end
+```
+
+## Relationship Operations
+
+### Get Relationship Linkage
+
+```http
+GET /users/1/relationships/posts
+
+Response:
+{
+  "data": [
+    { "type": "posts", "id": "1" },
+    { "type": "posts", "id": "3" }
+  ]
+}
+```
+
+### Replace Relationship
+
+```http
+PATCH /users/1/relationships/posts
+Content-Type: application/vnd.api+json
+
+{
+  "data": [
+    { "type": "posts", "id": "2" },
+    { "type": "posts", "id": "4" }
+  ]
+}
+```
+
+### Add to Relationship
+
+```http
+POST /users/1/relationships/posts
+Content-Type: application/vnd.api+json
+
+{
+  "data": [
+    { "type": "posts", "id": "5" }
+  ]
+}
+```
+
+### Remove from Relationship
+
+```http
+DELETE /users/1/relationships/posts
+Content-Type: application/vnd.api+json
+
+{
+  "data": [
+    { "type": "posts", "id": "2" }
+  ]
+}
+```
+
+### Get Related Resources
+
+```http
+GET /users/1/posts
+
+Response:
+{
+  "data": [
+    {
+      "type": "posts",
+      "id": "1",
+      "attributes": {
+        "title": "First Post",
+        "content": "Hello world!"
+      }
+    }
+  ]
+}
+```

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