jpie 0.4.5 → 1.0.0

data/lib/jpie/deserializer.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  class Deserializer
-    attr_reader :resource_class, :options
-
-    def initialize(resource_class, options = {})
-      @resource_class = resource_class
-      @options = options
-    end
-
-    def deserialize(json_data, context = {})
-      data = json_data.is_a?(String) ? JSON.parse(json_data) : json_data
-
-      validate_json_api_structure!(data)
-
-      if data['data'].is_a?(Array)
-        deserialize_collection(data['data'], context)
-      else
-        deserialize_single(data['data'], context)
-      end
-    rescue JSON::ParserError => e
-      raise Errors::BadRequestError.new(detail: "Invalid JSON: #{e.message}")
-    end
-
-    private
-
-    def deserialize_single(resource_data, context)
-      validate_resource_data!(resource_data)
-      extract_attributes(resource_data, context)
-    end
-
-    def deserialize_collection(resources_data, context)
-      resources_data.map { deserialize_single(it, context) }
-    end
-
-    def extract_attributes(resource_data, _context)
-      attributes = resource_data['attributes'] || {}
-      type = resource_data['type']
-      id = resource_data['id']
-
-      validate_type!(type) if type
-
-      model_attributes = transform_attribute_keys(attributes)
-      filtered_attributes = filter_allowed_attributes(model_attributes)
-      result = deserialize_attribute_values(filtered_attributes)
-
-      add_id_if_present(result, id)
-    end
-
-    def transform_attribute_keys(attributes)
-      attributes.transform_keys { it.to_s.underscore }
-    end
-
-    def filter_allowed_attributes(model_attributes)
-      allowed_attributes = resource_class._attributes.map(&:to_s)
-      model_attributes.slice(*allowed_attributes)
-    end
-
-    def deserialize_attribute_values(attributes)
-      attributes.transform_values { deserialize_value(it) }
-    end
-
-    def add_id_if_present(result, id)
-      result['id'] = id if id
-      result.with_indifferent_access
-    end
-
-    def deserialize_value(value)
-      case value
-      when String
-        # Only try to parse as datetime if it looks like an ISO8601 string
-        if value.match?(/\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
-          begin
-            Time.parse(value)
-          rescue ArgumentError, TypeError
-            value
-          end
-        else
-          value
-        end
-      else
-        value
-      end
-    end
-
-    def validate_json_api_structure!(data)
-      return if data.is_a?(Hash) && data.key?('data')
-
-      raise Errors::BadRequestError.new(detail: 'Invalid JSON:API structure. Missing "data" key.')
-    end
-
-    def validate_resource_data!(resource_data)
-      raise Errors::BadRequestError.new(detail: 'Invalid resource data structure.') unless resource_data.is_a?(Hash)
-
-      return if resource_data.key?('type')
-
-      raise Errors::BadRequestError.new(detail: 'Resource data must include "type".')
-    end
-
-    def validate_type!(type)
-      expected_type = resource_class.type
-      return if type == expected_type
-
-      raise Errors::BadRequestError.new(
-        detail: "Expected type '#{expected_type}', got '#{type}'"
-      )
-    end
-  end
-end

data/lib/jpie/errors.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  module Errors
-    class Error < StandardError
-      attr_reader :status, :code, :title, :detail, :source
-
-      def initialize(status:, code: nil, title: nil, detail: nil, source: nil)
-        @status = status
-        @code = code
-        @title = title
-        @detail = detail
-        @source = source
-        super(detail || title || 'An error occurred')
-      end
-
-      def to_hash
-        {
-          status: status.to_s,
-          code:,
-          title:,
-          detail:,
-          source:
-        }.compact
-      end
-    end
-
-    class ValidationError < Error
-      def initialize(detail:, source: nil)
-        super(status: 422, title: 'Validation Error', detail:, source:)
-      end
-    end
-
-    class NotFoundError < Error
-      def initialize(detail: 'Resource not found')
-        super(status: 404, title: 'Not Found', detail:)
-      end
-    end
-
-    class BadRequestError < Error
-      def initialize(detail: 'Bad Request')
-        super(status: 400, title: 'Bad Request', detail:)
-      end
-    end
-
-    class UnauthorizedError < Error
-      def initialize(detail: 'Unauthorized')
-        super(status: 401, title: 'Unauthorized', detail:)
-      end
-    end
-
-    class ForbiddenError < Error
-      def initialize(detail: 'Forbidden')
-        super(status: 403, title: 'Forbidden', detail:)
-      end
-    end
-
-    class UnsupportedMediaTypeError < Error
-      def initialize(detail: 'Unsupported Media Type')
-        super(status: 415, title: 'Unsupported Media Type', detail:)
-      end
-    end
-
-    class InternalServerError < Error
-      def initialize(detail: 'Internal Server Error')
-        super(status: 500, title: 'Internal Server Error', detail:)
-      end
-    end
-
-    class ResourceError < Error
-      def initialize(detail:)
-        super(status: 500, title: 'Resource Error', detail:)
-      end
-    end
-
-    # JSON:API Compliance Errors
-    class InvalidJsonApiRequestError < BadRequestError
-      def initialize(detail: 'Request is not JSON:API compliant')
-        super
-      end
-    end
-
-    class UnsupportedIncludeError < BadRequestError
-      def initialize(include_path:, supported_includes: [])
-        detail = if supported_includes.any?
-                   "Unsupported include '#{include_path}'. Supported includes: #{supported_includes.join(', ')}"
-                 else
-                   "Unsupported include '#{include_path}'. No includes are supported for this resource"
-                 end
-        super(detail: detail)
-      end
-    end
-
-    class UnsupportedSortFieldError < BadRequestError
-      def initialize(sort_field:, supported_fields: [])
-        detail = if supported_fields.any?
-                   "Unsupported sort field '#{sort_field}'. Supported fields: #{supported_fields.join(', ')}"
-                 else
-                   "Unsupported sort field '#{sort_field}'. No sorting is supported for this resource"
-                 end
-        super(detail: detail)
-      end
-    end
-
-    class InvalidSortParameterError < BadRequestError
-      def initialize(detail: 'Invalid sort parameter format')
-        super
-      end
-    end
-
-    class InvalidIncludeParameterError < BadRequestError
-      def initialize(detail: 'Invalid include parameter format')
-        super
-      end
-    end
-  end
-end

data/lib/jpie/generators/resource_generator.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails/generators/base'
-
-module JPie
-  module Generators
-    class ResourceGenerator < Rails::Generators::NamedBase
-      source_root File.expand_path('templates', __dir__)
-
-      desc 'Generate a JPie resource class with semantic field definitions'
-
-      argument :field_definitions, type: :array, default: [],
-                                   banner: 'attribute:field meta:field relationship:type:field'
-
-      class_option :model, type: :string,
-                           desc: 'Model class to associate with this resource (defaults to inferred model)'
-      class_option :skip_model, type: :boolean, default: false,
-                                desc: 'Skip explicit model declaration (use automatic inference)'
-
-      def create_resource_file
-        template 'resource.rb.erb', File.join('app/resources', "#{file_name}_resource.rb")
-      end
-
-      private
-
-      def model_class_name
-        options[:model] || class_name
-      end
-
-      def needs_explicit_model?
-        # Only need explicit model declaration if:
-        # 1. User explicitly provided a different model name, OR
-        # 2. User didn't use --skip-model flag AND the model name differs from the inferred name
-        return false if options[:skip_model]
-        return true if options[:model] && options[:model] != class_name
-
-        # For standard naming (UserResource -> User), we can skip the explicit declaration
-        false
-      end
-
-      def resource_attributes
-        parse_field_definitions.fetch(:attributes, [])
-      end
-
-      def meta_attributes_list
-        parse_field_definitions.fetch(:meta_attributes, [])
-      end
-
-      def relationships_list
-        parse_field_definitions.fetch(:relationships, [])
-      end
-
-      def parse_relationships
-        relationships_list.map do |rel|
-          # rel is already a hash with :type and :name from parse_field_definitions
-          rel
-        end
-      end
-
-      def parse_field_definitions
-        return @parsed_definitions if @parsed_definitions
-
-        @parsed_definitions = { attributes: [], meta_attributes: [], relationships: [] }
-
-        field_definitions.each do |definition|
-          process_field_definition(definition)
-        end
-
-        @parsed_definitions
-      end
-
-      def process_field_definition(definition)
-        case definition
-        when /^attribute:(.+)$/
-          @parsed_definitions[:attributes] << ::Regexp.last_match(1)
-        when /^meta:(.+)$/
-          @parsed_definitions[:meta_attributes] << ::Regexp.last_match(1)
-        when /^relationship:(.+):(.+)$/, /^(has_many|has_one|belongs_to):(.+)$/
-          add_relationship(::Regexp.last_match(1), ::Regexp.last_match(2))
-        when /^(.+):(.+)$/
-          process_legacy_field(::Regexp.last_match(1))
-        else
-          process_plain_field(definition)
-        end
-      end
-
-      def add_relationship(type, name)
-        @parsed_definitions[:relationships] << { type: type, name: name }
-      end
-
-      def process_legacy_field(field_name)
-        # Legacy support: field:type format - treat as attribute and ignore type
-        if meta_attribute_name?(field_name)
-          @parsed_definitions[:meta_attributes] << field_name
-        else
-          @parsed_definitions[:attributes] << field_name
-        end
-      end
-
-      def process_plain_field(field_name)
-        # Plain field name - treat as attribute
-        if meta_attribute_name?(field_name)
-          @parsed_definitions[:meta_attributes] << field_name
-        else
-          @parsed_definitions[:attributes] << field_name
-        end
-      end
-
-      def meta_attribute_name?(name)
-        # Check if field name suggests it's a meta attribute
-        meta_names = %w[created_at updated_at deleted_at published_at archived_at]
-        meta_names.include?(name)
-      end
-    end
-  end
-end

data/lib/jpie/generators/templates/resource.rb.erb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class <%= class_name %>Resource < JPie::Resource
-<% if needs_explicit_model? -%>
-  model <%= model_class_name %>
-<% end -%>
-
-<% if resource_attributes.any? -%>
-  attributes <%= resource_attributes.map { |attr| ":#{attr}" }.join(', ') %>
-<% else -%>
-  # Define your attributes here:
-  # attributes :name, :email, :title
-<% end -%>
-
-<% if meta_attributes_list.any? -%>
-  meta_attributes <%= meta_attributes_list.map { |attr| ":#{attr}" }.join(', ') %>
-<% else -%>
-  # Define your meta attributes here:
-  # meta_attributes :created_at, :updated_at
-<% end -%>
-
-<% if parse_relationships.any? -%>
-<% parse_relationships.each do |rel| -%>
-  <%= rel[:type] %> :<%= rel[:name] %>
-<% end -%>
-<% else -%>
-  # Define your relationships here:
-  # has_many :posts
-  # has_one :user
-<% end -%>
-end 

data/lib/jpie/railtie.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails/railtie'
-
-module JPie
-  class Railtie < Rails::Railtie
-    railtie_name :jpie
-
-    config.jpie = ActiveSupport::OrderedOptions.new
-
-    # Configure Rails inflections to preserve JPie casing
-    initializer 'jpie.inflections' do
-      ActiveSupport::Inflector.inflections(:en) do |inflect|
-        inflect.acronym 'JPie'
-      end
-    end
-
-    initializer 'jpie.configure' do |app|
-      JPie.configure do |config|
-        app.config.jpie.each do |key, value|
-          config.public_send("#{key}=", value) if config.respond_to?("#{key}=")
-        end
-      end
-    end
-
-    initializer 'jpie.action_controller' do
-      ActiveSupport.on_load(:action_controller) do
-        extend JPie::Controller::ClassMethods if defined?(JPie::Controller::ClassMethods)
-      end
-    end
-
-    initializer 'jpie.routing' do
-      ActiveSupport.on_load(:action_dispatch) do
-        ActionDispatch::Routing::Mapper.include JPie::Routing
-      end
-    end
-
-    generators do
-      require 'jpie/generators/resource_generator'
-    end
-  end
-end

data/lib/jpie/resource/attributable.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  class Resource
-    module Attributable
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :_attributes, :_relationships, :_meta_attributes
-        self._attributes = []
-        self._relationships = {}
-        self._meta_attributes = []
-      end
-
-      class_methods do
-        def attribute(name, options = {}, &)
-          name = name.to_sym
-          _attributes << name unless _attributes.include?(name)
-          define_attribute_method(name, options, &)
-        end
-
-        def attributes(*names)
-          names.each { attribute(it) }
-        end
-
-        def meta_attribute(name, options = {}, &)
-          name = name.to_sym
-          _meta_attributes << name unless _meta_attributes.include?(name)
-          define_attribute_method(name, options, &)
-        end
-
-        def meta_attributes(*names)
-          names.each { meta_attribute(it) }
-        end
-
-        # More concise aliases for modern Rails style
-        alias_method :meta, :meta_attribute
-        alias_method :metas, :meta_attributes
-
-        def relationship(name, options = {})
-          name = name.to_sym
-          _relationships[name] = options
-
-          # Check if method is already defined (public or private) to allow custom implementations
-          return if method_defined?(name) || private_method_defined?(name)
-
-          define_method(name) do
-            # Handle through associations
-            if options[:through]
-              handle_through_association(name, options)
-            else
-              # Standard association handling
-              attr_name = options[:attr] || name
-              @object.public_send(attr_name)
-            end
-          end
-        end
-
-        def has_many(name, options = {})
-          name = name.to_sym
-          resource_class_name = options[:resource] || infer_resource_class_name(name)
-          relationship(name, { type: :has_many, resource: resource_class_name }.merge(options))
-        end
-
-        def has_one(name, options = {})
-          name = name.to_sym
-          resource_class_name = options[:resource] || infer_resource_class_name(name)
-          relationship(name, { type: :has_one, resource: resource_class_name }.merge(options))
-        end
-
-        private
-
-        def define_attribute_method(name, options, &)
-          # If a block is provided, use it (existing behavior)
-          if block_given?
-            define_method(name) do
-              instance_exec(&)
-            end
-          # If options[:block] is provided, use it (existing behavior)
-          elsif options[:block]
-            define_method(name) do
-              instance_exec(&options[:block])
-            end
-          # If method is not already defined on the resource (public or private), define the default implementation
-          elsif !method_defined?(name) && !private_method_defined?(name)
-            define_method(name) do
-              attr_name = options[:attr] || name
-              @object.public_send(attr_name)
-            end
-          end
-          # If method is already defined, don't override it - let the custom method handle it
-        end
-
-        def infer_resource_class_name(relationship_name)
-          # Convert relationship name to resource class name
-          # :posts -> "PostResource"
-          # :user -> "UserResource"
-          singularized_name = relationship_name.to_s.singularize
-          "#{singularized_name.camelize}Resource"
-        end
-      end
-
-      private
-
-      # Handle through associations by calling the appropriate association method
-      def handle_through_association(name, options)
-        attr_name = options[:attr] || name
-        @object.public_send(attr_name)
-      end
-    end
-  end
-end

data/lib/jpie/resource/inferrable.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  class Resource
-    module Inferrable
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :_type, :_model_class
-      end
-
-      class_methods do
-        def model(model_class = nil)
-          if model_class
-            self._model_class = model_class
-          else
-            _model_class || infer_model_class
-          end
-        end
-
-        def type(type_name = nil)
-          if type_name
-            self._type = type_name.to_s
-          else
-            _type || infer_type_name
-          end
-        end
-
-        private
-
-        def infer_model_class
-          name.chomp('Resource').constantize
-        rescue NameError
-          nil
-        end
-
-        def infer_type_name
-          model&.model_name&.plural || name.chomp('Resource').underscore.pluralize
-        end
-      end
-    end
-  end
-end

data/lib/jpie/resource/sortable.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  class Resource
-    module Sortable
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :_sortable_fields
-        self._sortable_fields = {}
-      end
-
-      class_methods do
-        # Define a sortable field with optional custom sorting logic
-        # Example:
-        #   sortable_by :name
-        #   sortable_by :created_at, :created_at_desc
-        #   sortable_by :popularity do |direction|
-        #     if direction == :asc
-        #       model.order(:likes_count)
-        #     else
-        #       model.order(likes_count: :desc)
-        #     end
-        #   end
-        def sortable_by(field, column = nil, &block)
-          field = field.to_sym
-          _sortable_fields[field] = block || column || field
-        end
-
-        # More concise alias for modern Rails style
-        alias_method :sortable, :sortable_by
-
-        # Apply sorting to a query based on sort parameters
-        # sort_fields: array of sort field strings (e.g., ['name', '-created_at'])
-        def sort(query, sort_fields)
-          return query if sort_fields.blank?
-
-          sort_fields.each do |sort_field|
-            # Parse direction (- prefix means descending)
-            if sort_field.start_with?('-')
-              field = sort_field[1..].to_sym
-              direction = :desc
-            else
-              field = sort_field.to_sym
-              direction = :asc
-            end
-
-            # Check if field is sortable
-            unless sortable_field?(field)
-              raise JPie::Errors::BadRequestError.new(
-                detail: "Invalid sort field: #{field}. Sortable fields are: #{sortable_fields.join(', ')}"
-              )
-            end
-
-            # Apply sorting
-            query = apply_sort(query, field, direction)
-          end
-
-          query
-        end
-
-        # Get list of all sortable fields (attributes + explicitly defined sortable fields)
-        def sortable_fields
-          (_attributes + _sortable_fields.keys).uniq.map(&:to_s)
-        end
-
-        # Check if a field is sortable
-        def sortable_field?(field)
-          field = field.to_sym
-          _attributes.include?(field) || _sortable_fields.key?(field)
-        end
-
-        private
-
-        # Apply a single sort to the query
-        def apply_sort(query, field, direction)
-          sortable_config = _sortable_fields[field]
-
-          if sortable_config.is_a?(Proc)
-            # Custom sorting block
-            instance_exec(query, direction, &sortable_config)
-          elsif sortable_config.is_a?(Symbol)
-            # Custom column name
-            query.order(sortable_config => direction)
-          else
-            # Default sorting by attribute name
-            query.order(field => direction)
-          end
-        end
-      end
-    end
-  end
-end