jpie 0.4.5 → 1.0.1

data/lib/jpie/controller/relationship_actions.rb

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

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

data/lib/jpie/controller/rendering.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  module Controller
-    module Rendering
-      def resource_class
-        # Default implementation that infers from controller name
-        @resource_class ||= infer_resource_class
-      end
-
-      def serializer
-        @serializer ||= JPie::Serializer.new(resource_class)
-      end
-
-      def deserializer
-        @deserializer ||= JPie::Deserializer.new(resource_class)
-      end
-
-      protected
-
-      def model_class
-        resource_class.model
-      end
-
-      # More concise method names following Rails conventions
-      def render_jsonapi(resource_or_resources, status: :ok, meta: nil, pagination: nil, original_scope: nil)
-        includes = parse_include_params
-        json_data = serializer.serialize(resource_or_resources, context, includes: includes)
-
-        # Add pagination metadata and links if pagination is provided and valid
-        if pagination && pagination[:per_page]
-          add_pagination_metadata(json_data, resource_or_resources, pagination, original_scope)
-        end
-
-        json_data[:meta] = meta if meta
-
-        render json: json_data, status:, content_type: 'application/vnd.api+json'
-      end
-
-      # Keep original methods for backward compatibility
-      alias render_jsonapi_resource render_jsonapi
-      alias render_jsonapi_resources render_jsonapi
-
-      private
-
-      def add_pagination_metadata(json_data, resources, pagination, original_scope)
-        page = pagination[:page] || 1
-        per_page = pagination[:per_page]
-
-        # Get total count from the original scope before pagination
-        total_count = get_total_count(resources, original_scope)
-        total_pages = (total_count.to_f / per_page).ceil
-
-        # Add pagination metadata
-        json_data[:meta] ||= {}
-        json_data[:meta][:pagination] = {
-          page: page,
-          per_page: per_page,
-          total_pages: total_pages,
-          total_count: total_count
-        }
-
-        # Add pagination links
-        json_data[:links] = build_pagination_links(page, per_page, total_pages)
-      end
-
-      def get_total_count(resources, original_scope)
-        # Use original scope if provided, otherwise fall back to resources
-        scope_to_count = original_scope || resources
-
-        # If scope is an ActiveRecord relation, get the count
-        # Otherwise, if it's an array, get the length
-        if scope_to_count.respond_to?(:count) && !scope_to_count.loaded?
-          scope_to_count.count
-        elsif scope_to_count.respond_to?(:size)
-          scope_to_count.size
-        else
-          0
-        end
-      end
-
-      def build_pagination_links(page, per_page, total_pages)
-        url_components = extract_url_components
-        pagination_data = { page: page, per_page: per_page, total_pages: total_pages }
-
-        links = build_base_pagination_links(url_components, pagination_data)
-        add_conditional_pagination_links(links, url_components, pagination_data)
-
-        links
-      end
-
-      def extract_url_components
-        base_url = request.respond_to?(:base_url) ? request.base_url : 'http://example.com'
-        path = request.respond_to?(:path) ? request.path : '/resources'
-        query_params = request.respond_to?(:query_parameters) ? request.query_parameters.except('page') : {}
-
-        { base_url: base_url, path: path, query_params: query_params }
-      end
-
-      def build_base_pagination_links(url_components, pagination_data)
-        full_url = url_components[:base_url] + url_components[:path]
-        query_params = url_components[:query_params]
-        page = pagination_data[:page]
-        per_page = pagination_data[:per_page]
-        total_pages = pagination_data[:total_pages]
-
-        {
-          self: build_page_url(full_url, query_params, page, per_page),
-          first: build_page_url(full_url, query_params, 1, per_page),
-          last: build_page_url(full_url, query_params, total_pages, per_page)
-        }
-      end
-
-      def add_conditional_pagination_links(links, url_components, pagination_data)
-        full_url = url_components[:base_url] + url_components[:path]
-        query_params = url_components[:query_params]
-        page = pagination_data[:page]
-        per_page = pagination_data[:per_page]
-        total_pages = pagination_data[:total_pages]
-
-        links[:prev] = build_page_url(full_url, query_params, page - 1, per_page) if page > 1
-        links[:next] = build_page_url(full_url, query_params, page + 1, per_page) if page < total_pages
-      end
-
-      def build_page_url(base_url, query_params, page_num, per_page)
-        params = query_params.merge(
-          'page' => page_num.to_s,
-          'per_page' => per_page.to_s
-        )
-        query_string = params.respond_to?(:to_query) ? params.to_query : params.map { |k, v| "#{k}=#{v}" }.join('&')
-        "#{base_url}?#{query_string}"
-      end
-
-      def infer_resource_class
-        # Convert controller name to resource class name
-        # e.g., "UsersController" -> "UserResource"
-        # e.g., "Api::V1::UsersController" -> "UserResource"
-        controller_name = self.class.name
-        return nil unless controller_name&.end_with?('Controller')
-
-        # Remove "Controller" suffix and any namespace
-        base_name = controller_name.split('::').last.chomp('Controller')
-
-        # Convert plural controller name to singular resource name
-        # e.g., "Users" -> "User"
-        singular_name = base_name.singularize
-        resource_class_name = "#{singular_name}Resource"
-
-        # Try to constantize the resource class
-        resource_class_name.constantize
-      end
-    end
-  end
-end

data/lib/jpie/controller.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'controller/error_handling'
-require_relative 'controller/parameter_parsing'
-require_relative 'controller/rendering'
-require_relative 'controller/crud_actions'
-require_relative 'controller/json_api_validation'
-require_relative 'controller/relationship_actions'
-require_relative 'controller/related_actions'
-
-module JPie
-  module Controller
-    extend ActiveSupport::Concern
-
-    include ErrorHandling
-    include ParameterParsing
-    include Rendering
-    include CrudActions
-    include JsonApiValidation
-    include RelationshipActions
-    include RelatedActions
-
-    # Relationship route actions
-    def show_relationship
-      relationship_show
-    end
-
-    def update_relationship
-      relationship_update
-    end
-
-    def create_relationship
-      relationship_create
-    end
-
-    def destroy_relationship
-      relationship_destroy
-    end
-
-    def show_related
-      related_show
-    end
-  end
-end