jpie 0.4.4 → 1.0.0

data/examples/resource_meta_configuration.md

@@ -1,244 +0,0 @@
-# Meta Field Configuration Example
-
-This example demonstrates all the different ways to define and configure meta fields in JPie, focusing on the various configuration patterns and syntax options available.
-
-## Setup
-
-### 1. Article model
-```ruby
-class Article < ActiveRecord::Base
-  validates :title, presence: true
-  validates :content, presence: true
-  validates :status, inclusion: { in: %w[draft published archived] }
-  
-  belongs_to :author, class_name: 'User'
-  
-  def word_count
-    content.split.length
-  end
-  
-  def reading_time_minutes
-    (word_count / 200.0).ceil
-  end
-end
-```
-
-### 2. Resource with All Meta Field Configuration Types 
-```ruby
-class ArticleResource < JPie::Resource
-  # 1. Basic meta attributes - direct model access and custom methods
-  meta_attributes :created_at, :updated_at
-  meta_attribute :reading_time
-  
-  # 2. Meta attribute with attr mapping (maps to different model attribute)
-  meta_attribute :author_name, attr: :author_email
-  
-  # 3. Meta attribute with block (legacy style)
-  meta_attribute :word_count do
-    object.word_count
-  end
-  
-  # 4. Meta attribute with proc block (alternative legacy style)
-  meta_attribute :character_count, block: proc { object.content.length }
-  
-  # 5. Short alias syntax (modern style)
-  meta :api_version
-  metas :request_id, :cache_key
-  
-  # 6. Custom meta method for dynamic metadata
-  def meta
-    # Start with declared meta attributes
-    base_meta = super
-    
-    # Add dynamic metadata
-    dynamic_meta = {
-      timestamp: Time.current.iso8601,
-      resource_version: '2.1'
-    }
-    
-    # Conditional metadata based on context
-    if context[:include_debug]
-      dynamic_meta[:debug_info] = {
-        object_class: object.class.name,
-        context_keys: context.keys
-      }
-    end
-    
-    # Merge and return
-    base_meta.merge(dynamic_meta)
-  end
-  
-  private
-  
-  # Custom method for reading_time meta attribute
-  def reading_time
-    {
-      minutes: object.reading_time_minutes,
-      formatted: "#{object.reading_time_minutes} min read"
-    }
-  end
-  
-  # Meta attribute accessing context
-  def user_role
-    context[:current_user]&.role || 'anonymous'
-  end
-  
-  # Meta attribute with conditional logic
-  def edit_permissions
-    current_user = context[:current_user]
-    return false unless current_user
-    
-    current_user.admin? || current_user == object.author
-  end
-  
-  # Meta attributes using short alias syntax
-  def api_version
-    '1.0'
-  end
-  
-  def request_id
-    context[:request_id] || SecureRandom.uuid
-  end
-  
-  def cache_key
-    "article:#{object.id}:#{object.updated_at.to_i}"
-  end
-end
-```
-
-## HTTP Examples
-
-### Create Article
-```http
-POST /articles
-Content-Type: application/vnd.api+json
-Authorization: Bearer user_token
-
-{
-  "data": {
-    "type": "articles",
-    "attributes": {
-      "title": "Meta Field Configuration Guide",
-      "content": "This guide demonstrates all the different ways to configure meta fields in JPie...",
-      "status": "draft"
-    }
-  }
-}
-
-HTTP/1.1 201 Created
-Content-Type: application/vnd.api+json
-
-{
-  "data": {
-    "id": "1",
-    "type": "articles",
-    "attributes": {
-      "title": "Meta Field Configuration Guide",
-      "content": "This guide demonstrates all the different ways to configure meta fields in JPie...",
-      "status": "draft"
-    },
-    "meta": {
-      "created_at": "2024-01-15T10:30:00Z",
-      "updated_at": "2024-01-15T10:30:00Z",
-      "reading_time": {
-        "minutes": 3,
-        "formatted": "3 min read"
-      },
-      "author_name": "john@example.com",
-      "word_count": 450,
-      "character_count": 2700,
-      "api_version": "1.0",
-      "request_id": "req_abc123def456",
-      "cache_key": "article:1:1705492800",
-      "timestamp": "2024-03-15T16:45:30Z",
-      "resource_version": "2.1"
-    }
-  }
-}
-```
-
-### Update Article
-```http
-PATCH /articles/1
-Content-Type: application/vnd.api+json
-Authorization: Bearer user_token
-
-{
-  "data": {
-    "id": "1",
-    "type": "articles",
-    "attributes": {
-      "status": "published"
-    }
-  }
-}
-
-HTTP/1.1 200 OK
-Content-Type: application/vnd.api+json
-
-{
-  "data": {
-    "id": "1",
-    "type": "articles",
-    "attributes": {
-      "title": "Meta Field Configuration Guide",
-      "content": "This guide demonstrates all the different ways to configure meta fields in JPie...",
-      "status": "published"
-    },
-    "meta": {
-      "created_at": "2024-01-15T10:30:00Z",
-      "updated_at": "2024-01-16T14:20:00Z",
-      "reading_time": {
-        "minutes": 3,
-        "formatted": "3 min read"
-      },
-      "author_name": "john@example.com",
-      "word_count": 450,
-      "character_count": 2700,
-      "api_version": "1.0",
-      "request_id": "req_xyz789ghi012",
-      "cache_key": "article:1:1705492800",
-      "timestamp": "2024-03-16T14:20:00Z",
-      "resource_version": "2.1"
-    }
-  }
-}
-```
-
-### Get Article with All Meta Field Configurations
-```http
-GET /articles/1
-Accept: application/vnd.api+json
-Authorization: Bearer user_token
-
-HTTP/1.1 200 OK
-Content-Type: application/vnd.api+json
-
-{
-  "data": {
-    "id": "1",
-    "type": "articles",
-    "attributes": {
-      "title": "Meta Field Configuration Guide",
-      "content": "This guide demonstrates all the different ways to configure meta fields in JPie...",
-      "status": "published"
-    },
-    "meta": {
-      "created_at": "2024-01-15T10:30:00Z",
-      "updated_at": "2024-01-16T14:20:00Z",
-      "reading_time": {
-        "minutes": 3,
-        "formatted": "3 min read"
-      },
-      "author_name": "john@example.com",
-      "word_count": 450,
-      "character_count": 2700,
-      "api_version": "1.0",
-      "request_id": "req_abc123def456",
-      "cache_key": "article:1:1705492800",
-      "timestamp": "2024-03-16T14:20:00Z",
-      "resource_version": "2.1"
-    }
-  }
-}
-```

data/examples/single_table_inheritance.md

@@ -1,160 +0,0 @@
-# Single Table Inheritance (STI) Example
-
-This example demonstrates the minimal setup required to implement Single Table Inheritance with JPie resources and controllers.
-
-## Setup
-
-### 1. Base Model (`app/models/vehicle.rb`)
-```ruby
-class Vehicle < ApplicationRecord
-  validates :name, presence: true
-  validates :brand, presence: true
-  validates :year, presence: true
-end
-```
-
-### 2. STI Models (`app/models/car.rb`, `app/models/truck.rb`)
-```ruby
-class Car < Vehicle
-  validates :engine_size, presence: true
-end
-
-class Truck < Vehicle
-  validates :cargo_capacity, presence: true
-end
-```
-
-### 3. Base Resource (`app/resources/vehicle_resource.rb`)
-```ruby
-class VehicleResource < JPie::Resource
-  attributes :name, :brand, :year
-end
-```
-
-### 4. STI Resources (`app/resources/car_resource.rb`, `app/resources/truck_resource.rb`)
-```ruby
-class CarResource < VehicleResource
-  attributes :engine_size
-end
-
-class TruckResource < VehicleResource
-  attributes :cargo_capacity
-end
-```
-
-### 5. Controller (`app/controllers/vehicles_controller.rb`)
-```ruby
-class VehiclesController < ApplicationController
-  include JPie::Controller
-end
-```
-
-### 6. Routes (`config/routes.rb`)
-```ruby
-Rails.application.routes.draw do
-  resources :vehicles
-end
-```
-
-## HTTP Examples
-
-### Create Car
-```http
-POST /vehicles
-Content-Type: application/vnd.api+json
-
-{
-  "data": {
-    "type": "cars",
-    "attributes": {
-      "name": "Civic",
-      "brand": "Honda",
-      "year": 2024,
-      "engine_size": 1500
-    }
-  }
-}
-
-HTTP/1.1 201 Created
-Content-Type: application/vnd.api+json
-
-{
-  "data": {
-    "id": "1",
-    "type": "cars",
-    "attributes": {
-      "name": "Civic",
-      "brand": "Honda",
-      "year": 2024,
-      "engine_size": 1500
-    }
-  }
-}
-```
-
-### Update Car
-```http
-PATCH /vehicles/1
-Content-Type: application/vnd.api+json
-
-{
-  "data": {
-    "id": "1",
-    "type": "cars",
-    "attributes": {
-      "name": "Civic Hybrid",
-      "engine_size": 1800
-    }
-  }
-}
-
-HTTP/1.1 200 OK
-Content-Type: application/vnd.api+json
-
-{
-  "data": {
-    "id": "1",
-    "type": "cars",
-    "attributes": {
-      "name": "Civic Hybrid",
-      "brand": "Honda",
-      "year": 2024,
-      "engine_size": 1800
-    }
-  }
-}
-```
-
-### Get Mixed Vehicles
-```http
-GET /vehicles
-Accept: application/vnd.api+json
-
-HTTP/1.1 200 OK
-Content-Type: application/vnd.api+json
-
-{
-  "data": [
-    {
-      "id": "1",
-      "type": "cars",
-      "attributes": {
-        "name": "Civic",
-        "brand": "Honda",
-        "year": 2024,
-        "engine_size": 1500
-      }
-    },
-    {
-      "id": "2",
-      "type": "trucks",
-      "attributes": {
-        "name": "F-150",
-        "brand": "Ford",
-        "year": 2024,
-        "cargo_capacity": 1000
-      }
-    }
-  ]
-}
-``` 

data/lib/jpie/configuration.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  class Configuration
-    attr_accessor :default_page_size, :maximum_page_size
-
-    def initialize
-      @default_page_size = 20
-      @maximum_page_size = 100
-    end
-  end
-end

data/lib/jpie/controller/crud_actions.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  module Controller
-    module CrudActions
-      extend ActiveSupport::Concern
-
-      class_methods do
-        def jsonapi_resource(resource_class)
-          setup_jsonapi_resource(resource_class)
-        end
-
-        # More concise alias for modern Rails style
-        alias_method :resource, :jsonapi_resource
-
-        private
-
-        def setup_jsonapi_resource(resource_class)
-          define_method :resource_class do
-            resource_class
-          end
-
-          # Define automatic CRUD methods
-          define_automatic_crud_methods(resource_class)
-        end
-
-        def define_automatic_crud_methods(resource_class)
-          define_index_method(resource_class)
-          define_show_method(resource_class)
-          define_create_method(resource_class)
-          define_update_method(resource_class)
-          define_destroy_method(resource_class)
-        end
-
-        def define_index_method(resource_class)
-          define_method :index do
-            validate_include_params
-            validate_sort_params
-            resources = resource_class.scope(context)
-            sort_fields = parse_sort_params
-            resources = resource_class.sort(resources, sort_fields) if sort_fields.any?
-
-            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
-
-        def define_show_method(resource_class)
-          define_method :show do
-            validate_include_params
-            resource = resource_class.scope(context).find(params[:id])
-            render_jsonapi(resource)
-          end
-        end
-
-        def define_create_method(resource_class)
-          define_method :create do
-            validate_json_api_request
-            attributes = deserialize_params
-            resource = resource_class.model.create!(attributes)
-            render_jsonapi(resource, status: :created)
-          end
-        end
-
-        def define_update_method(resource_class)
-          define_method :update do
-            validate_json_api_request
-            resource = resource_class.scope(context).find(params[:id])
-            attributes = deserialize_params
-            resource.update!(attributes)
-            render_jsonapi(resource)
-          end
-        end
-
-        def define_destroy_method(resource_class)
-          define_method :destroy do
-            resource = resource_class.scope(context).find(params[:id])
-            resource.destroy!
-            head :no_content
-          end
-        end
-      end
-
-      # These methods can still be called manually or used to override defaults
-      def index
-        validate_include_params
-        validate_sort_params
-        resources = resource_class.scope(context)
-        sort_fields = parse_sort_params
-        resources = resource_class.sort(resources, sort_fields) if sort_fields.any?
-
-        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
-        validate_include_params
-        resource = resource_class.scope(context).find(params[:id])
-        render_jsonapi(resource)
-      end
-
-      def create
-        validate_json_api_request
-        attributes = deserialize_params
-        resource = model_class.create!(attributes)
-        render_jsonapi(resource, status: :created)
-      end
-
-      def update
-        validate_json_api_request
-        resource = resource_class.scope(context).find(params[:id])
-        attributes = deserialize_params
-        resource.update!(attributes)
-        render_jsonapi(resource)
-      end
-
-      def destroy
-        resource = resource_class.scope(context).find(params[:id])
-        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

@@ -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