jpie 1.3.1 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dea557b52cade83077a80c1371aef0a85dc756bbe871e24c345cf9c8caa67fdf
-  data.tar.gz: 2981d0c427c7b3e7b4ab7647614823ed324185812dc92c5daf9124c06c5c55b8
+  metadata.gz: be60282bbba362a7ac36dca3370a4733981bce7a949352513244879bc76546a7
+  data.tar.gz: 6c391beea011b7fd348f8a2439130ba174dd31fa7b8f9f4ea6eaef5c9fd916ee
 SHA512:
-  metadata.gz: c58a23284f8d71094e492a75ef5e7e814b796fe97955ca67f916fea1b27442f73f6d6879c899f6cf488738ecd4f701374b1de9a82a4727623ec80168c7cab511
-  data.tar.gz: 1922cb663461ba5e2c3e146489d8fbffb9a5449642cc4a6245ce643829cd108cb58fa85d11bb21fd6f84a76b4c5f102103f8ea27c6c11ed1916427b4658ff1fb
+  metadata.gz: 13f21d51760a269d54d1bcd46a9be3916506bae8c25af82eaabea8dc7a214d2f3d39b29437ca0703141a794444d13b7ab20ba26ac4f35f4fe3a8ca15207d1630
+  data.tar.gz: 35e11173e5942bc01059217acf3a5028f5980108b2c76e88b33fe03c9c2ae00a4a6a9c0051328e491a257d83700f02f6a206c7a34406cde968af1a6698ac63fd

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jpie (1.3.1)
+    jpie (1.5.1)
       actionpack (~> 8.0, >= 8.0.0)
       rails (~> 8.0, >= 8.0.0)
 

data/README.md

@@ -238,6 +238,8 @@ Nested includes use dot notation and support arbitrary depth. Related resources
 }
 ```
 
+Only relationships that appear in the `include` path are serialized (and thus loaded). For example, `include=messages` adds messages to `included` but does not serialize each message's `user`, `message_action`, or other relationships, so those associations are not queried. Use `include=messages,messages.user,messages.message_action` (etc.) to include and load nested relationships.
+
 ## Polymorphic Relationships
 
 Polymorphic relationships are accessed through the parent resource's relationship endpoints and includes. Route only the parent resource; the gem automatically handles polymorphic types through the relationship endpoints.
@@ -1392,7 +1394,7 @@ api.define(
   },
   {
     collectionPath: "users",
-  }
+  },
 );
 
 // Model with relationships
@@ -1412,7 +1414,7 @@ api.define(
   },
   {
     collectionPath: "posts",
-  }
+  },
 );
 ```
 
@@ -1622,7 +1624,7 @@ api.define(
   },
   {
     collectionPath: "workstreams",
-  }
+  },
 );
 
 // Create with polymorphic relationship

data/lib/json_api/routing.rb

@@ -65,7 +65,14 @@ module JSONAPI
     end
 
     def define_explicit_sti_routes(sti_resources, defaults)
-      sti_resources.each { |sub_resource_name| jsonapi_resources(sub_resource_name, defaults:) }
+      sti_resources.each do |entry|
+        case entry
+        in Hash
+          entry.each { |sub_resource_name, options| jsonapi_resources(sub_resource_name, defaults:, **options) }
+        else
+          jsonapi_resources(entry, defaults:)
+        end
+      end
     end
 
     def define_auto_sti_routes(resource, resource_name, defaults, namespace = nil)

data/lib/json_api/serialization/concerns/includes_serialization.rb

@@ -2,32 +2,62 @@
 
 module JSONAPI
   module Serialization
+    IncludeContext = Struct.new(:fields, :included_records, :processed, :all_includes, keyword_init: true)
+    PathContext = Struct.new(:path_parts, :path_to_related, :association_name, :current_record, keyword_init: true)
+    IncludeIteration = Struct.new(:related_record, :path_parts, :path_to_related, :association_name, :current_record,
+                                  keyword_init: true,)
+
     module IncludesSerialization
-      def serialize_included(includes, fields = {})
-        return [] if includes.empty?
+      include IncludePathHelpers
 
-        included_records = []
-        processed = Set.new
+      def serialize_included(includes, fields = {})
+        all_includes = normalize_include_paths(includes)
+        return [] if all_includes.empty?
 
-        includes.each do |include_path|
-          serialize_include_path(record, include_path, fields, included_records, processed)
-        end
+        ctx = build_include_context(fields, all_includes)
+        all_includes.each { |path| serialize_include_path(record, path, ctx, path_from_root: "") }
+        ctx.included_records
+      end
 
-        included_records
+      def build_include_context(fields, all_includes)
+        IncludeContext.new(
+          fields: fields,
+          included_records: [],
+          processed: Set.new,
+          all_includes: all_includes,
+        )
       end
 
       private
 
-      def serialize_include_path(current_record, include_path, fields, included_records, processed)
+      def serialize_include_path(current_record, include_path, ctx, path_from_root: "")
         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)
+        path_to_related = path_from_root.blank? ? path_parts.first : "#{path_from_root}.#{path_parts.first}"
+        path_ctx = PathContext.new(path_parts:, path_to_related:, association_name:, current_record: current_record)
+        process_related_records(get_related_records(current_record, association_name), path_ctx, ctx)
+      end
+
+      def process_related_records(related_array, path_ctx, ctx)
         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)
+          iter = IncludeIteration.new(related_record: related_record, **path_ctx.to_h)
+          serialize_related_record(iter, ctx)
+        end
+      end
+
+      def serialize_related_record(iter, ctx)
+        parent_context = parent_context_for(iter.association_name, iter.current_record)
+        serialize_and_process_record(iter.related_record, iter.path_to_related, ctx, **parent_context)
+        serialize_nested_path(iter.related_record, iter.path_parts, iter.path_to_related, ctx)
+      end
+
+      def parent_context_for(association_name, current_record)
+        if self.class.active_storage_attachment?(association_name, current_record.class)
+          { parent_record: current_record, association_name: }
+        else
+          {}
         end
       end
 
@@ -54,7 +84,16 @@ module JSONAPI
         related_klass = association.klass
         return [] if related_klass.blank?
 
-        build_scoped_relation(related_klass, association).to_a
+        scope = build_scoped_relation(related_klass, association)
+        association.loaded? ? scope_loaded_to_records_scope(association, scope) : scope.to_a
+      end
+
+      def scope_loaded_to_records_scope(association, scope)
+        loaded_array = association.target.respond_to?(:to_a) ? association.target.to_a : Array(association.target)
+        loaded_ids = loaded_array.filter_map(&:id)
+        return [] if loaded_ids.empty?
+
+        scope.where(id: loaded_ids).to_a
       end
 
       def build_scoped_relation(related_klass, association)
@@ -70,24 +109,24 @@ module JSONAPI
         [attachment.blob].compact
       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)
+      def serialize_and_process_record(related_record, path_to_record, ctx, parent_record: nil, association_name: nil)
+        return if ctx.processed.include?(build_record_key(related_record))
 
-        serializer = self.class.new(related_record)
-        included_records << serializer.serialize_record(fields)
-        processed.add(record_key)
+        requested = include_paths_to_relationship_names(ctx.all_includes, path_to_record)
+        serializer = self.class.new(related_record, parent_record:, association_name:)
+        ctx.included_records << serializer.serialize_record(ctx.fields, requested_relationships: requested)
+        ctx.processed.add(build_record_key(related_record))
       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)
+      def serialize_nested_path(related_record, path_parts, path_from_root, ctx)
         return unless path_parts.length > 1
 
         nested_path = path_parts[1..].join(".")
-        serialize_include_path(related_record, nested_path, fields, included_records, processed)
+        serialize_include_path(related_record, nested_path, ctx, path_from_root: path_from_root)
       end
     end
   end

data/lib/json_api/serialization/concerns/links_serialization.rb

@@ -16,11 +16,23 @@ module JSONAPI
       end
 
       def add_active_storage_download_link(links)
-        links[:download] = rails_blob_path || fallback_blob_path
+        links[:download] = variant_or_blob_path || fallback_blob_path
       rescue StandardError
         links[:download] = fallback_blob_path
       end
 
+      def variant_or_blob_path
+        return rails_blob_path unless parent_record && association_name && record.content_type&.start_with?("image/")
+
+        parent_definition = ResourceLoader.find_for_model(parent_record.class)
+        rel_def = RelationshipHelpers.find_relationship_definition(parent_definition, association_name)
+        variant_opts = rel_def&.dig(:options, :variant)
+        return rails_blob_path unless variant_opts.present?
+
+        representation = record.representation(**variant_opts.symbolize_keys)
+        Rails.application.routes.url_helpers.rails_representation_path(representation, only_path: true)
+      end
+
       def rails_blob_path
         Rails.application.routes.url_helpers.rails_blob_path(record, only_path: true)
       end

data/lib/json_api/serialization/concerns/relationships_serialization.rb

@@ -3,9 +3,13 @@
 module JSONAPI
   module Serialization
     module RelationshipsSerialization
-      def serialize_relationships
+      def serialize_relationships(requested_relationship_names = nil)
         relationships = {}
         relationship_definitions = definition.relationship_definitions
+        if requested_relationship_names
+          requested_set = requested_relationship_names.map(&:to_sym)
+          relationship_definitions = relationship_definitions.select { |r| requested_set.include?(r[:name]) }
+        end
 
         relationship_definitions.each do |rel_def|
           serialize_relationship(rel_def, relationships)

data/lib/json_api/serialization/include_path_helpers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Serialization
+    module IncludePathHelpers
+      def normalize_include_paths(include_param)
+        case include_param
+        when Array
+          include_param.flat_map { |s| s.to_s.split(",").map(&:strip) }.uniq
+        when String
+          include_param.split(",").map(&:strip)
+        else
+          []
+        end
+      end
+
+      def include_paths_to_relationship_names(include_paths, path_prefix)
+        return [] if include_paths.blank?
+
+        prefix = path_prefix.present? ? "#{path_prefix}." : ""
+        include_paths.filter_map do |p|
+          path = p.to_s
+          next unless path == path_prefix || path.start_with?(prefix)
+
+          segments = path.split(".")
+          prefix_segments = path_prefix.split(".")
+          next if segments.length <= prefix_segments.length
+
+          segments[prefix_segments.length].to_sym
+        end.uniq
+      end
+    end
+  end
+end

data/lib/json_api/serialization/serializer.rb

@@ -3,6 +3,7 @@
 require_relative "concerns/attributes_serialization"
 require_relative "concerns/relationships_serialization"
 require_relative "concerns/links_serialization"
+require_relative "include_path_helpers"
 require_relative "concerns/includes_serialization"
 require_relative "concerns/meta_serialization"
 
@@ -33,28 +34,32 @@ module JSONAPI
       @jsonapi_object = nil
     end
 
-    def initialize(record, definition: nil, base_definition: nil)
+    def initialize(record, definition: nil, base_definition: nil, parent_record: nil, association_name: nil)
       @record = record
       @definition = definition || ResourceLoader.find_for_model(record.class)
       @base_definition = base_definition
+      @parent_record = parent_record
+      @association_name = association_name
       @sti_subclass = nil
     end
 
     def to_hash(include: [], fields: {}, document_meta: nil)
+      include_paths = normalize_include_paths(include)
+      top_level_relationships = include_paths_to_relationship_names(include_paths, "")
       {
         jsonapi: jsonapi_object,
-        data: serialize_record(fields),
-        included: serialize_included(include, fields),
+        data: serialize_record(fields, requested_relationships: top_level_relationships),
+        included: serialize_included(include_paths, fields),
         meta: document_meta,
       }.compact
     end
 
-    def serialize_record(fields = {})
+    def serialize_record(fields = {}, requested_relationships: nil)
       {
         type: record_type,
         id: record_id,
         attributes: serialize_attributes(fields),
-        relationships: serialize_relationships,
+        relationships: serialize_relationships(requested_relationships),
         links: serialize_links,
         meta: record_meta,
       }.compact
@@ -62,7 +67,7 @@ module JSONAPI
 
     private
 
-    attr_reader :record, :definition
+    attr_reader :record, :definition, :parent_record, :association_name
 
     def base_definition
       @base_definition ||= definition

data/lib/json_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONAPI
-  VERSION = "1.3.1"
+  VERSION = "1.5.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jpie
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.5.1
 platform: ruby
 authors:
 - Emil Kampp
@@ -70,7 +70,6 @@ files:
 - bin/console
 - bin/setup
 - jpie.gemspec
-- kiln/app/resources/user_message_resource.rb
 - lib/jpie.rb
 - lib/json_api.rb
 - lib/json_api/active_storage/deserialization.rb
@@ -127,6 +126,7 @@ files:
 - lib/json_api/serialization/concerns/relationships_deserialization.rb
 - lib/json_api/serialization/concerns/relationships_serialization.rb
 - lib/json_api/serialization/deserializer.rb
+- lib/json_api/serialization/include_path_helpers.rb
 - lib/json_api/serialization/serializer.rb
 - lib/json_api/support/active_storage_support.rb
 - lib/json_api/support/collection_query.rb

data/kiln/app/resources/user_message_resource.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-class UserMessageResource < MessageResource
-end