jpie 0.4.5 → 1.0.0

data/lib/json_api/serialization/serializer.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  class Serializer
+    include ActiveStorageSupport
+
+    # Class method for generating the JSON:API object
+    def self.jsonapi_object
+      obj = { version: JSONAPI.configuration.jsonapi_version }
+      obj[:meta] = JSONAPI.configuration.jsonapi_meta if JSONAPI.configuration.jsonapi_meta
+      obj
+    end
+
+    def initialize(record, definition: nil, base_definition: nil)
+      @record = record
+      @definition = definition || ResourceLoader.find_for_model(record.class)
+      @base_definition = base_definition
+      @sti_subclass = nil # Cache for sti_subclass? check
+    end
+
+    def to_hash(include: [], fields: {}, document_meta: nil)
+      {
+        jsonapi: jsonapi_object,
+        data: serialize_record(fields),
+        included: serialize_included(include, fields),
+        meta: document_meta
+      }.compact
+    end
+
+    def serialize_record(fields = {})
+      {
+        type: record_type,
+        id: record_id,
+        attributes: serialize_attributes(fields),
+        relationships: serialize_relationships,
+        links: serialize_links,
+        meta: record_meta
+      }.compact
+    end
+
+    private
+
+    attr_reader :record, :definition
+
+    def base_definition
+      @base_definition ||= definition
+    end
+
+    def record_type
+      if definition.name.end_with?("Resource")
+        RelationshipHelpers.resource_type_name(definition)
+      else
+        record.class.name.underscore.pluralize
+      end
+    end
+
+    def record_id
+      record.id.to_s
+    end
+
+    def serialize_attributes(fields = {})
+      type_fields = extract_type_fields(fields)
+      return {} if type_fields.empty? && fields.any?
+
+      attributes = build_attributes_hash
+      return attributes if type_fields.empty?
+
+      attributes.slice(*type_fields.map(&:to_sym))
+    end
+
+    def extract_type_fields(fields)
+      fields[record_type.to_sym] || []
+    end
+
+    def build_attributes_hash
+      permitted_attrs = definition.permitted_attributes.map(&:to_sym)
+      attributes = {}
+      definition_instance = definition.new(record, {})
+
+      permitted_attrs.each do |attr_sym|
+        attributes[attr_sym] = get_attribute_value(definition_instance, attr_sym)
+      end
+
+      attributes.compact
+    end
+
+    def get_attribute_value(definition_instance, attr_sym)
+      return definition_instance.public_send(attr_sym) if definition_instance.respond_to?(attr_sym, false)
+
+      attr_name = attr_sym.to_s
+      return record.attributes[attr_name] if model_has_attribute?(attr_name)
+
+      nil
+    end
+
+    def model_has_attribute?(attr_name)
+      record.respond_to?(:attributes) &&
+        record.attributes.is_a?(Hash) &&
+        record.attributes.key?(attr_name)
+    end
+
+    def serialize_relationships
+      relationships = {}
+      relationship_definitions = definition.relationship_definitions
+
+      relationship_definitions.each do |rel_def|
+        serialize_relationship(rel_def, relationships)
+      end
+
+      relationships
+    end
+
+    def serialize_relationship(rel_def, relationships)
+      association_name = rel_def[:name]
+
+      if active_storage_attachment?(association_name, record.class)
+        return serialize_active_storage_relationship_wrapper(rel_def, relationships, association_name)
+      end
+
+      serialize_regular_relationship(rel_def, relationships, association_name)
+    end
+
+    def serialize_active_storage_relationship_wrapper(rel_def, relationships, association_name)
+      relationships[association_name] = {
+        data: serialize_active_storage_relationship(association_name, record),
+        meta: rel_def[:meta]
+      }.compact
+    end
+
+    def serialize_regular_relationship(rel_def, relationships, association_name)
+      association = record.class.reflect_on_association(association_name)
+      return unless association
+
+      relationships[association_name] = {
+        data: serialize_relationship_data(association),
+        meta: rel_def[:meta]
+      }.compact
+    end
+
+    def serialize_relationship_data(association)
+      related = record.public_send(association.name)
+
+      if association.collection?
+        serialize_collection_relationship(related, association)
+      elsif related
+        serialize_single_relationship(related, association)
+      end
+    end
+
+    def serialize_collection_relationship(related, association)
+      return [] if related.nil?
+
+      related.map { |r| serialize_identifier_for_related(r, association) }
+    end
+
+    def serialize_single_relationship(related, association)
+      serialize_identifier_for_related(related, association)
+    end
+
+    def serialize_identifier_for_related(related_record, association)
+      base_def_for_related, use_instance_class = determine_sti_definition(related_record)
+
+      RelationshipHelpers.serialize_resource_identifier(
+        related_record,
+        association:,
+        resource_class: definition,
+        use_instance_class:,
+        base_resource_class: base_def_for_related
+      )
+    end
+
+    def determine_sti_definition(_related_record)
+      [nil, true]
+    end
+
+    def serialize_links
+      links = { self: "/#{record_type}/#{record_id}" }
+      add_active_storage_download_link(links) if active_storage_blob?
+      links
+    end
+
+    def active_storage_blob?
+      defined?(::ActiveStorage) && record.is_a?(::ActiveStorage::Blob)
+    end
+
+    def add_active_storage_download_link(links)
+      links[:download] = rails_blob_path || fallback_blob_path
+    rescue StandardError
+      links[:download] = fallback_blob_path
+    end
+
+    def rails_blob_path
+      Rails.application.routes.url_helpers.rails_blob_path(record, only_path: true)
+    end
+
+    def fallback_blob_path
+      "/rails/active_storage/blobs/#{record.signed_id}/#{record.filename}"
+    end
+
+    def serialize_included(includes, fields = {})
+      return [] if includes.empty?
+
+      included_records = []
+      processed = Set.new
+
+      includes.each do |include_path|
+        serialize_include_path(record, include_path, fields, included_records, processed)
+      end
+
+      included_records
+    end
+
+    def serialize_include_path(current_record, include_path, fields, included_records, processed)
+      path_parts = include_path.split(".")
+      association_name = path_parts.first.to_sym
+
+      return unless valid_include_association?(current_record, association_name)
+
+      related_array = get_related_records(current_record, association_name)
+      related_array.each do |related_record|
+        serialize_and_process_record(related_record, fields, included_records, processed)
+        serialize_nested_path(related_record, path_parts, fields, included_records, processed)
+      end
+    end
+
+    def valid_include_association?(current_record, association_name)
+      current_definition = ResourceLoader.find_for_model(current_record.class)
+      relationship_def = RelationshipHelpers.find_relationship_definition(current_definition, association_name)
+      return false unless relationship_def
+
+      # Check for ActiveStorage attachments
+      return true if self.class.active_storage_attachment?(association_name, current_record.class)
+
+      association = current_record.class.reflect_on_association(association_name)
+      association.present?
+    end
+
+    def get_related_records(current_record, association_name)
+      # Handle ActiveStorage attachments specially
+      if self.class.active_storage_attachment?(association_name, current_record.class)
+        attachment = current_record.public_send(association_name)
+        return [] unless attachment.respond_to?(:attached?) && attachment.attached?
+        return attachment.blobs.to_a if attachment.is_a?(::ActiveStorage::Attached::Many)
+
+        return [attachment.blob].compact
+
+      end
+
+      related = current_record.public_send(association_name)
+      Array(related)
+    end
+
+    def serialize_and_process_record(related_record, fields, included_records, processed)
+      record_key = build_record_key(related_record)
+      return if processed.include?(record_key)
+
+      serializer = self.class.new(related_record)
+      included_records << serializer.serialize_record(fields)
+      processed.add(record_key)
+    end
+
+    def build_record_key(related_record)
+      "#{related_record.class.name}-#{related_record.id}"
+    end
+
+    def serialize_nested_path(related_record, path_parts, fields, included_records, processed)
+      return unless path_parts.length > 1
+
+      nested_path = path_parts[1..].join(".")
+      serialize_include_path(related_record, nested_path, fields, included_records, processed)
+    end
+
+    def jsonapi_object
+      self.class.jsonapi_object
+    end
+
+    def record_meta
+      custom_meta = custom_meta_from_definition
+      default_meta = build_default_meta
+
+      # Merge defaults with custom meta (custom meta can override defaults)
+      return unless default_meta.any? || custom_meta.any?
+
+      default_meta.merge(custom_meta)
+    end
+
+    def custom_meta_from_definition
+      meta = nil
+
+      # Try instance method on Resource class first (dynamic, has access to model via resource)
+      if definition.method_defined?(:meta)
+        # Directly instantiate the resource class - all resources inherit from ApplicationResource
+        # which has initialize(resource = nil, context = {}) and attr_reader :resource
+        instance = definition.new(@record, {})
+        meta = instance.meta
+      # Fall back to class method (static)
+      elsif (class_meta = definition.resource_meta)
+        meta = class_meta.is_a?(Proc) ? class_meta.call(record) : class_meta
+      end
+
+      # Convert meta to hash if it's not nil
+      meta = meta.to_h if meta.respond_to?(:to_h) && !meta.is_a?(Hash)
+      meta || {}
+    end
+
+    def build_default_meta
+      default_timestamp_meta
+    end
+
+    def default_timestamp_meta
+      meta = {}
+
+      meta[:created_at] = record.created_at.iso8601 if record.respond_to?(:created_at) && record.created_at.present?
+
+      meta[:updated_at] = record.updated_at.iso8601 if record.respond_to?(:updated_at) && record.updated_at.present?
+
+      meta
+    end
+  end
+end

data/lib/json_api/support/active_storage_support.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module JSONAPI
+  module ActiveStorageSupport
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def active_storage_attachment?(association_name, model_class)
+        ActiveStorage::Detection.attachment?(association_name, model_class)
+      end
+
+      def active_storage_blob_type?(type)
+        ActiveStorage::Detection.blob_type?(type)
+      end
+    end
+
+    def active_storage_attachment?(association_name, model_class = nil)
+      return self.class.active_storage_attachment?(association_name, model_class) if model_class
+
+      resolved_model_class = if respond_to?(:model_class, true)
+                               send(:model_class)
+                             elsif respond_to?(:resource_model_class, true)
+                               send(:resource_model_class)
+                             elsif respond_to?(:resource, true) && (res = send(:resource)) && res.respond_to?(:class)
+                               res.class
+                             else
+                               raise NotImplementedError,
+                                     "Must implement resource_model_class or provide model_class parameter"
+                             end
+      self.class.active_storage_attachment?(association_name, resolved_model_class)
+    end
+
+    def extract_active_storage_params_from_hash(params_hash, model_class)
+      ActiveStorage::Deserialization.extract_params_from_hash(params_hash, model_class)
+    end
+
+    def attach_active_storage_files(record, attachment_params, resource_class: nil)
+      ActiveStorage::Deserialization.attach_files(record, attachment_params, definition: resource_class)
+    end
+
+    def purge_on_nil_enabled?(attachment_name, resource_class)
+      ActiveStorage::Deserialization.purge_on_nil_enabled?(attachment_name, resource_class)
+    end
+
+    def append_only_enabled?(attachment_name, resource_class)
+      ActiveStorage::Deserialization.append_only_enabled?(attachment_name, resource_class)
+    end
+
+    def find_relationship_definition(attachment_name, resource_class)
+      ActiveStorage::Deserialization.find_relationship_definition(attachment_name, resource_class)
+    end
+
+    def filter_active_storage_from_includes(includes_hash, current_model_class)
+      ActiveStorage::Detection.filter_from_includes(includes_hash, current_model_class)
+    end
+
+    def filter_polymorphic_from_includes(includes_hash, current_model_class)
+      ActiveStorage::Detection.filter_polymorphic_from_includes(includes_hash, current_model_class)
+    end
+
+    def serialize_active_storage_relationship(attachment_name, record)
+      ActiveStorage::Serialization.serialize_relationship(attachment_name, record)
+    end
+
+    def serialize_blob_identifier(blob)
+      ActiveStorage::Serialization.serialize_blob_identifier(blob)
+    end
+
+    def process_active_storage_attachment(attrs, association_name, id_or_ids, singular:)
+      ActiveStorage::Deserialization.process_attachment(attrs, association_name, id_or_ids, singular:)
+    end
+
+    def find_blob_by_signed_id(signed_id)
+      ActiveStorage::Deserialization.find_blob_by_signed_id(signed_id)
+    end
+
+    private
+
+    def resource_model_class
+      raise NotImplementedError, "Must implement resource_model_class or override active_storage_attachment?"
+    end
+  end
+end