jpie 0.4.1 → 0.4.3

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

data/lib/jpie/controller/related_actions.rb

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

data/lib/jpie/controller/relationship_actions.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require_relative 'relationship_validation'
+
+module JPie
+  module Controller
+    module RelationshipActions
+      extend ActiveSupport::Concern
+      include RelationshipValidation
+
+      # GET /resources/:id/relationships/:relationship_name
+      # Returns relationship linkage data
+      def relationship_show
+        validate_relationship_exists
+        resource = find_resource
+        relationship_data = get_relationship_data(resource)
+        render_relationship_data(relationship_data)
+      end
+
+      # PATCH /resources/:id/relationships/:relationship_name
+      # Updates relationship linkage (replaces all relationships)
+      def relationship_update
+        validate_relationship_exists
+        validate_relationship_update_request
+        resource = find_resource
+        relationship_data = parse_relationship_data
+        update_relationship_data(resource, relationship_data)
+        render_relationship_data(get_relationship_data(resource))
+      end
+
+      # POST /resources/:id/relationships/:relationship_name
+      # Adds to relationship linkage (for to-many relationships)
+      def relationship_create
+        validate_relationship_exists
+        validate_relationship_update_request
+        resource = find_resource
+
+        unless relationship_is_to_many?
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'POST is only supported for to-many relationships'
+          )
+        end
+
+        relationship_data = parse_relationship_data
+
+        unless relationship_data.is_a?(Array)
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'Adding to relationships requires an array of resource identifier objects'
+          )
+        end
+
+        add_to_relationship(resource, relationship_data)
+        render_relationship_data(get_relationship_data(resource))
+      end
+
+      # DELETE /resources/:id/relationships/:relationship_name
+      # Removes from relationship linkage (for to-many relationships)
+      def relationship_destroy
+        validate_relationship_exists
+        validate_relationship_update_request
+        resource = find_resource
+
+        unless relationship_is_to_many?
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'DELETE is only supported for to-many relationships'
+          )
+        end
+
+        relationship_data = parse_relationship_data
+
+        unless relationship_data.is_a?(Array)
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'Removing from relationships requires an array of resource identifier objects'
+          )
+        end
+
+        remove_from_relationship(resource, relationship_data)
+        render_relationship_data(get_relationship_data(resource))
+      end
+
+      private
+
+      def find_resource
+        resource_class.scope(context).find(params[:id])
+      end
+
+      def relationship_name
+        @relationship_name ||= params[:relationship_name].to_sym
+      end
+
+      def relationship_config
+        @relationship_config ||= resource_class._relationships[relationship_name]
+      end
+
+      def get_relationship_data(resource)
+        relationship_method = relationship_name
+        related_objects = resource.send(relationship_method)
+
+        if related_objects.respond_to?(:each)
+          # to-many relationship
+          related_objects.map { |obj| { type: infer_type(obj), id: obj.id.to_s } }
+        elsif related_objects
+          # to-one relationship
+          { type: infer_type(related_objects), id: related_objects.id.to_s }
+        end
+      end
+
+      def parse_relationship_data
+        body = request.body.read
+        request.body.rewind
+        parsed_body = JSON.parse(body)
+
+        unless parsed_body.key?('data')
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'Request must include a "data" member'
+          )
+        end
+
+        parsed_body['data']
+      end
+
+      def update_relationship_data(resource, relationship_data)
+        if relationship_data.nil?
+          # Set relationship to null (only valid for to-one relationships)
+          unless relationship_is_to_many?
+            clear_relationship(resource)
+          else
+            raise JPie::Errors::BadRequestError.new(
+              detail: 'Cannot set a to-many relationship to null'
+            )
+          end
+        elsif relationship_data.is_a?(Array)
+          # to-many relationship - replace all
+          if relationship_is_to_many?
+            replace_to_many_relationship(resource, relationship_data)
+          else
+            raise JPie::Errors::BadRequestError.new(
+              detail: 'Invalid data type for to-one relationship'
+            )
+          end
+        elsif relationship_data.is_a?(Hash)
+          # to-one relationship - replace
+          unless relationship_is_to_many?
+            replace_to_one_relationship(resource, relationship_data)
+          else
+            raise JPie::Errors::BadRequestError.new(
+              detail: 'Invalid data type for to-many relationship'
+            )
+          end
+        else
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'Relationship data must be null, an object, or an array of objects'
+          )
+        end
+      end
+
+      def add_to_relationship(resource, relationship_data)
+        begin
+          related_objects = find_related_objects(relationship_data)
+          association = association_for_resource(resource)
+
+          related_objects.each do |related_object|
+            association << related_object unless association.include?(related_object)
+          end
+
+          resource.save!
+        rescue ActiveRecord::AssociationTypeMismatch => e
+          raise JPie::Errors::NotFoundError.new(
+            detail: "Related resource not found: Invalid resource type for relationship"
+          )
+        rescue ActiveRecord::RecordInvalid => e
+          raise JPie::Errors::ValidationError.new(
+            detail: "Failed to add relationships: #{e.message}"
+          )
+        end
+      end
+
+      def remove_from_relationship(resource, relationship_data)
+        begin
+          related_objects = find_related_objects(relationship_data)
+          association = association_for_resource(resource)
+
+          related_objects.each do |related_object|
+            association.delete(related_object)
+          end
+
+          resource.save!
+        rescue ActiveRecord::AssociationTypeMismatch => e
+          raise JPie::Errors::NotFoundError.new(
+            detail: "Related resource not found: Invalid resource type for relationship"
+          )
+        rescue ActiveRecord::RecordInvalid => e
+          raise JPie::Errors::ValidationError.new(
+            detail: "Failed to remove relationships: #{e.message}"
+          )
+        end
+      end
+
+      def clear_relationship(resource)
+        association_name = association_name_for_relationship
+        resource.send("#{association_name}=", nil)
+        resource.save!
+      rescue ActiveRecord::RecordInvalid => e
+        raise JPie::Errors::ValidationError.new(
+          detail: "Failed to clear relationship: #{e.message}"
+        )
+      end
+
+      def replace_to_many_relationship(resource, relationship_data)
+        begin
+          related_objects = find_related_objects(relationship_data)
+          association_name = association_name_for_relationship
+          resource.send("#{association_name}=", related_objects)
+          resource.save!
+        rescue ActiveRecord::AssociationTypeMismatch => e
+          raise JPie::Errors::NotFoundError.new(
+            detail: "Related resource not found: Invalid resource type for relationship"
+          )
+        rescue ActiveRecord::RecordInvalid => e
+          raise JPie::Errors::ValidationError.new(
+            detail: "Failed to replace relationships: #{e.message}"
+          )
+        end
+      end
+
+      def replace_to_one_relationship(resource, relationship_data)
+        begin
+          related_object = find_related_object(relationship_data)
+          association_name = association_name_for_relationship
+          resource.send("#{association_name}=", related_object)
+          resource.save!
+        rescue ActiveRecord::AssociationTypeMismatch => e
+          raise JPie::Errors::NotFoundError.new(
+            detail: "Related resource not found: Invalid resource type for relationship"
+          )
+        rescue ActiveRecord::RecordInvalid => e
+          raise JPie::Errors::ValidationError.new(
+            detail: "Failed to replace relationship: #{e.message}"
+          )
+        end
+      end
+
+      def find_related_objects(relationship_data)
+        relationship_data.map { |data| find_related_object(data) }
+      end
+
+      def find_related_object(resource_identifier)
+        validate_resource_identifier(resource_identifier)
+
+        type = resource_identifier['type']
+        id = resource_identifier['id']
+
+        related_model_class = infer_model_class_from_type(type)
+        related_model_class.find(id)
+      rescue ActiveRecord::RecordNotFound
+        raise JPie::Errors::NotFoundError.new(
+          detail: "Related resource not found: #{type}##{id}"
+        )
+      end
+
+      def association_for_resource(resource)
+        association_name = association_name_for_relationship
+        resource.send(association_name)
+      end
+
+      def association_name_for_relationship
+        # For now, assume the relationship name matches the association name
+        # This could be made more sophisticated to handle custom association names
+        relationship_name
+      end
+
+      def infer_type(object)
+        # Convert model class name to JSON:API type
+        # e.g., "User" -> "users", "BlogPost" -> "blog-posts"
+        object.class.name.underscore.dasherize.pluralize
+      end
+
+      def infer_model_class_from_type(type)
+        # Convert JSON:API type back to model class
+        # e.g., "users" -> User, "blog-posts" -> BlogPost
+        class_name = type.singularize.underscore.camelize
+        class_name.constantize
+      end
+
+      def render_relationship_data(relationship_data)
+        response_data = { data: relationship_data }
+        render json: response_data, content_type: 'application/vnd.api+json'
+      end
+    end
+  end
+end

data/lib/jpie/controller/relationship_validation.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module JPie
+  module Controller
+    module RelationshipValidation
+      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 validate_relationship_update_request
+        validate_content_type
+        validate_request_body
+        validate_relationship_type
+      end
+
+      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
+
+      def validate_request_body
+        body = request.body.read
+        request.body.rewind
+
+        raise JPie::Errors::BadRequestError.new(detail: 'Request body cannot be empty') if body.blank?
+
+        JSON.parse(body)
+      rescue JSON::ParserError => e
+        raise JPie::Errors::BadRequestError.new(detail: "Invalid JSON: #{e.message}")
+      end
+
+      def validate_resource_identifier(resource_identifier)
+        unless resource_identifier.is_a?(Hash) &&
+               resource_identifier.key?('type') &&
+               resource_identifier.key?('id')
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'Resource identifier objects must have "type" and "id" members'
+          )
+        end
+
+        type = resource_identifier['type']
+        id = resource_identifier['id']
+
+        unless type.is_a?(String) && id.is_a?(String)
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'Resource identifier object members must be strings'
+          )
+        end
+
+        if type.empty? || id.empty?
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'Resource identifier object members cannot be empty strings'
+          )
+        end
+      end
+
+      def validate_relationship_type
+        validate_relationship_exists
+        data = parse_relationship_data
+
+        if relationship_is_to_many?
+          validate_to_many_relationship_data(data)
+        else
+          validate_to_one_relationship_data(data)
+        end
+      end
+
+      def validate_to_many_relationship_data(data)
+        if data.nil?
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'Cannot set a to-many relationship to null'
+          )
+        end
+
+        unless data.is_a?(Array)
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'The value of data must be an array for to-many relationships'
+          )
+        end
+
+        data.each { |identifier| validate_resource_identifier(identifier) }
+      end
+
+      def validate_to_one_relationship_data(data)
+        unless data.nil? || data.is_a?(Hash)
+          raise JPie::Errors::BadRequestError.new(
+            detail: 'The value of data must be a single resource identifier object or null for to-one relationships'
+          )
+        end
+
+        validate_resource_identifier(data) if data
+      end
+
+      def relationship_is_to_many?
+        return false unless relationship_config
+
+        relationship_config[:type] == :has_many
+      end
+    end
+  end
+end