Add PORO support in find_fragments for 0.9.x compatibility

In 0.10+, find_fragments uses ActiveRecord-specific methods (records.pluck)
which fails for PORO (Plain Old Ruby Object) models. This change adds
automatic detection of non-ActiveRecord models and falls back to a
find_by_key-based implementation.

Detection: _model_class.respond_to?(:all)
Fallback: find_fragments_for_non_active_record uses find_by_key

This eliminates the need for PORO resources to override find_fragments,
maintaining 0.9.x compatibility where create/find_by_key worked without
the subsequent re-fetch via find_fragments.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: takaokouji

lib/jsonapi/active_relation_resource.rb

@@ -96,6 +96,12 @@ def find_to_populate_by_keys(keys, options = {})
       #    the ResourceInstances matching the filters, sorting, and pagination rules along with any request
       #    additional_field values
       def find_fragments(filters, options = {})
+        # PORO compatibility: if _model_class doesn't respond to :all, it's not ActiveRecord
+        # Fall back to find_by_key-based implementation for 0.9.x compatibility
+        unless _model_class.respond_to?(:all)
+          return find_fragments_for_non_active_record(filters, options)
+        end
+
         include_directives = options.fetch(:include_directives, {})
         resource_klass = self
 
@@ -368,6 +374,22 @@ def join_relationship(records:, relationship:, resource_type: nil, join_type: :i
         records.merge(relationship_records)
       end
 
+      # Fallback implementation of find_fragments for non-ActiveRecord models (PORO)
+      # This provides 0.9.x compatibility by using find_by_key instead of records.pluck
+      def find_fragments_for_non_active_record(filters, options)
+        context = options[:context]
+        primary_keys = options.fetch(:primary_keys, nil) || filters[_primary_key]
+        return {} if primary_keys.blank?
+
+        fragments = {}
+        Array(primary_keys).each do |key|
+          resource = find_by_key(key, context: context)
+          identity = JSONAPI::ResourceIdentity.new(self, key)
+          fragments[identity] = JSONAPI::ResourceFragment.new(identity, resource: resource)
+        end
+        fragments
+      end
+
       protected
 
       def to_one_relationships_for_linkage(include_related)

test/unit/resource/poro_resource_test.rb

@@ -0,0 +1,101 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+# PORO (Plain Old Ruby Object) for testing
+class PoroModel
+  attr_accessor :id, :name, :created_at
+
+  def initialize(id, name)
+    @id = id
+    @name = name
+    @created_at = Time.now
+  end
+
+  # Note: No .all method - this is a PORO, not ActiveRecord
+end
+
+# Resource for PORO model
+class PoroModelResource < JSONAPI::Resource
+  model_name 'PoroModel'
+  attributes :name
+
+  class << self
+    def find_by_key(key, options = {})
+      context = options[:context]
+      model = PoroModel.new(key, "PORO Item #{key}")
+      new(model, context)
+    end
+
+    def create(context)
+      model = PoroModel.new(SecureRandom.uuid, "New PORO")
+      new(model, context)
+    end
+  end
+end
+
+class PoroResourceTest < ActiveSupport::TestCase
+  def test_poro_model_does_not_respond_to_all
+    # Verify our test PORO doesn't have .all method
+    refute PoroModel.respond_to?(:all),
+      "PORO model should not respond to :all"
+  end
+
+  def test_find_fragments_works_with_poro
+    # find_fragments should work with PORO by falling back to find_by_key
+    filters = {}
+    options = {
+      context: {},
+      primary_keys: ['key1', 'key2']
+    }
+
+    fragments = PoroModelResource.find_fragments(filters, options)
+
+    assert_equal 2, fragments.length, "Should return 2 fragments"
+
+    # Verify fragments have correct structure
+    fragments.each do |identity, fragment|
+      assert_kind_of JSONAPI::ResourceIdentity, identity
+      assert_kind_of JSONAPI::ResourceFragment, fragment
+      assert_not_nil fragment.resource, "Fragment should have resource for PORO"
+    end
+  end
+
+  def test_find_fragments_returns_empty_for_poro_without_keys
+    filters = {}
+    options = {
+      context: {},
+      primary_keys: nil
+    }
+
+    fragments = PoroModelResource.find_fragments(filters, options)
+
+    assert_equal({}, fragments, "Should return empty hash when no keys")
+  end
+
+  def test_find_fragments_with_single_key_for_poro
+    filters = {}
+    options = {
+      context: {},
+      primary_keys: 'single_key'
+    }
+
+    fragments = PoroModelResource.find_fragments(filters, options)
+
+    assert_equal 1, fragments.length, "Should return 1 fragment"
+  end
+
+  def test_active_record_resource_still_uses_original_find_fragments
+    # Ensure ActiveRecord resources still use the optimized pluck-based implementation
+    # This test verifies we didn't break existing behavior
+    filters = { PostResource._primary_key => [1, 2] }
+    options = { context: {} }
+
+    # PostResource uses ActiveRecord, should work normally
+    fragments = PostResource.find_fragments(filters, options)
+
+    assert_equal 2, fragments.length
+    fragments.each do |identity, fragment|
+      assert_kind_of JSONAPI::ResourceIdentity, identity
+      assert_kind_of JSONAPI::ResourceFragment, fragment
+    end
+  end
+end