has_helpers 5.0.2

data/spec/commands/cards/card_data_command_spec.rb

@@ -0,0 +1,1048 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+require "bigdecimal"
+require "active_support/time"
+
+describe HasHelpers::Cards::CardDataCommand, type: :model do
+  describe ".call" do
+    let(:role_id)       { 10 }
+    let(:resource_id)   { "resource-uuid" }
+    let(:identifier_id) { "identifier-uuid" }
+    let(:record_id)     { 42 }
+
+    let(:role) do
+      instance_double(
+        HasHelpers::Role,
+        id:              role_id,
+        organization_id: 99
+      )
+    end
+
+    let(:resource) do
+      instance_double(
+        HasHelpers::Resource,
+        id:    resource_id,
+        klass: dummy_model_class
+      )
+    end
+
+    let(:identifier) do
+      instance_double(
+        HasHelpers::Cards::CardIdentifier,
+        id:   identifier_id,
+        name: "Demographics"
+      )
+    end
+
+    let(:layout_type) do
+      instance_double(
+        HasHelpers::Cards::CardLayoutType,
+        name: "Summary"
+      )
+    end
+
+    let(:variant) do
+      instance_double(
+        HasHelpers::Cards::CardVariantType,
+        name: "Emails"
+      )
+    end
+
+    let(:card_definition) do
+      instance_double(
+        HasHelpers::Cards::CardDefinition,
+        id:           123,
+        name:         "Demographics",
+        identifier:   identifier,
+        layout_type:  layout_type,
+        variant:      variant,
+        description:  "Basic details",
+        position:     10,
+        default_visibility: true,
+        card_fields:  card_fields_relation,
+        new_record?:  false
+      )
+    end
+
+    # Plain RSpec double so we can safely stub `.find` on it.
+    let(:dummy_model_class) { double("DummyModelClass") }
+
+    let(:dummy_record) do
+      instance_double(
+        "DummyRecord",
+        id:                     record_id,
+        age:                    30,
+        ssn:                    "123-45-6789",
+        demographics_full_name: "John Full Name",
+        full_name:              "John Full Name",
+        status:                 "Active",
+        user_id:                linked_record_id,
+        user:                   linked_record
+      )
+    end
+
+    let(:json_weird_payload) do
+      ActionController::Parameters.new(
+        amount: BigDecimal("12.34"),
+        created_at: Time.zone.parse("2026-02-19 10:11:12"),
+        status: :active,
+        nested: { ok: true }
+      )
+    end
+
+    let(:linked_record_id) { 1234 }
+
+    let(:linked_record) do
+      instance_double(
+        "LinkedRecord",
+        id:   linked_record_id,
+        name: "Linked Record Name"
+      )
+    end
+
+    let(:field_meta) do
+      double(
+        "CardFieldMeta",
+        id:                  300,
+        card_definition:     card_definition,
+        field_resource:      nil,
+        virtual_ref:         "meta",
+        data_type:           field_json_data_type,
+        data_type_id:        field_json_data_type.id,
+        default_visibility:  true,
+        default_position:    99,
+        is_required:         false,
+        field_custom_name:   "Meta"
+      )
+    end
+
+    let(:field_age_resource) do
+      instance_double(
+        HasHelpers::Resource,
+        name:       "age",
+        alias_name: nil
+      )
+    end
+
+    let(:field_user_resource) do
+      instance_double(
+        HasHelpers::Resource,
+        name:       "user_id",
+        alias_name: nil,
+        field_class_name: "User"
+      )
+    end
+
+    let(:field_status_resource) do
+      instance_double(
+        HasHelpers::Resource,
+        name:       "status",
+        alias_name: nil
+      )
+    end
+
+    let(:field_age_data_type) do
+      instance_double(
+        HasHelpers::Cards::CardDataType,
+        id:   1,
+        name: "Numeric"
+      )
+    end
+
+    let(:field_link_data_type) do
+      instance_double(
+        HasHelpers::Cards::CardDataType,
+        id:   HasHelpers::Cards::CardDataType::LINK.id,
+        name: "Link"
+      )
+    end
+
+    let(:field_full_name_data_type) do
+      instance_double(
+        HasHelpers::Cards::CardDataType,
+        id:   2,
+        name: "String"
+      )
+    end
+
+    let(:field_json_data_type) do
+      instance_double(
+        HasHelpers::Cards::CardDataType,
+        id:   99,
+        name: "Json"
+      )
+    end
+
+    let(:field_badge_data_type) do
+      instance_double(
+        HasHelpers::Cards::CardDataType,
+        id:   HasHelpers::Cards::CardDataType::BADGE.id,
+        name: "Badge"
+      )
+    end
+
+    let(:field_hover_card_data_type) do
+      instance_double(
+        HasHelpers::Cards::CardDataType,
+        id:   HasHelpers::Cards::CardDataType::HOVER_CARD.id,
+        name: "HoverCard"
+      )
+    end
+
+    # Use plain doubles for CardField to avoid verifying dynamic AR attribute methods like `field_custom_name`
+    let(:field_age) do
+      double(
+        "CardFieldAge",
+        id:                  201,
+        card_definition:     card_definition,
+        field_resource:      field_age_resource,
+        data_type:           field_age_data_type,
+        data_type_id:        field_age_data_type.id,
+        default_visibility:  true,
+        default_position:    1,
+        is_required:         true,
+        field_custom_name:   nil # no custom label
+      )
+    end
+
+    let(:field_full_name) do
+      double(
+        "CardFieldFullName",
+        id:                  202,
+        card_definition:     card_definition,
+        field_resource:      nil,
+        field_custom_key:    nil,
+        data_type:           field_full_name_data_type,
+        data_type_id:        field_full_name_data_type.id,
+        default_visibility:  true,
+        default_position:    2,
+        is_required:         false,
+        field_custom_name:   "Full name"
+      )
+    end
+
+    let(:field_link) do
+      double(
+        "CardFieldLink",
+        id:                  203,
+        card_definition:     card_definition,
+        field_resource:      field_user_resource,
+        data_type:           field_link_data_type,
+        data_type_id:        field_link_data_type.id,
+        default_visibility:  true,
+        default_position:    3,
+        is_required:         false,
+        field_custom_name:   nil
+      )
+    end
+
+    let(:field_badge) do
+      double(
+        "CardFieldBadge",
+        id:                  204,
+        card_definition:     card_definition,
+        field_resource:      field_status_resource,
+        data_type:           field_badge_data_type,
+        data_type_id:        field_badge_data_type.id,
+        badge_color:         ->(_cfg, value) { value == "Active" ? Color::GREEN.name : Color::RED.name },
+        default_visibility:  true,
+        default_position:    3,
+        is_required:         false,
+        field_custom_name:   nil
+      )
+    end
+
+    let(:field_hover_card) do
+      double(
+        "CardFieldHoverCard",
+        id:                  205,
+        card_definition:     card_definition,
+        field_resource:      nil,
+        virtual_ref:         "advisor_link",
+        data_type:           field_hover_card_data_type,
+        data_type_id:        field_hover_card_data_type.id,
+        default_visibility:  true,
+        default_position:    4,
+        is_required:         false,
+        field_custom_name:   "Advisor"
+      )
+    end
+
+    let(:card_fields) { [field_age, field_full_name] }
+
+    let(:card_fields_relation) do
+      # Relation-like double so we can stub `.includes(...)`
+      double("CardFieldsRelation")
+    end
+
+    let(:role_resource_card) { nil }
+
+    let(:role_card_fields) { [] }
+
+    # Global registry without mapper (fallback behaviour)
+    let(:registry_cards) do
+      [
+        {
+          identifier:   identifier,
+          relationship: "demographic",
+          relationship_klass: "HasContactInfo::Demographic",
+          fields:       [
+            { kind: :resource, ref: "age" },
+              { kind: :custom, key:  "full_name" }
+          ]
+        }
+      ]
+    end
+
+    before do
+      # Role lookup
+      allow(HasHelpers::Role).to receive(:find_by)
+        .with(id: role_id)
+        .and_return(role)
+
+      # Resource lookup
+      allow(HasHelpers::Resource).to receive(:find)
+        .with(resource_id)
+        .and_return(resource)
+
+      # Identifier lookup
+      allow(HasHelpers::Cards::CardIdentifier).to receive(:find)
+        .with(identifier_id)
+        .and_return(identifier)
+
+      # CardDefinition lookup (joins/where/first!)
+      joins_relation = double("CardDefinitionJoinsRelation")
+      where_relation = double("CardDefinitionWhereRelation")
+
+      allow(HasHelpers::Cards::CardDefinition).to receive(:joins)
+        .with(:card_definition_resources)
+        .and_return(joins_relation)
+
+      allow(joins_relation).to receive(:where)
+        .with(
+          identifier_id:             identifier.id,
+          card_definition_resources: { resource_id: resource.id }
+        )
+        .and_return(where_relation)
+
+      allow(where_relation).to receive(:first!)
+        .and_return(card_definition)
+
+      # RoleResourceCard lookup
+      allow(HasHelpers::Cards::RoleResourceCard).to receive(:find_by)
+        .with(
+          role_id:            role&.id,
+          resource_id:        resource.id,
+          card_definition_id: card_definition.id,
+          organization_id:    role&.organization_id
+        )
+        .and_return(role_resource_card)
+
+      # Relation for card_definition.card_fields.includes(...)
+      allow(card_definition).to receive(:card_fields)
+        .and_return(card_fields_relation)
+
+      allow(card_fields_relation).to receive(:includes)
+        .with(:field_resource, :data_type)
+        .and_return(card_fields)
+
+      # Registry (HasHelpers::Cards::Registry.cards) → global version without mapper
+      allow(HasHelpers::Cards::Registry).to receive(:cards)
+        .and_return(registry_cards)
+
+      # Resource.klass.find(record_id) → dummy_record (used by .call)
+      allow(resource).to receive(:klass)
+        .and_return(dummy_model_class)
+
+      allow(dummy_model_class).to receive(:find)
+        .with(record_id)
+        .and_return(dummy_record)
+
+      # The registry relationship points to :demographic; stub it so we always
+      # get at least one target record.
+      allow(dummy_record).to receive(:demographic).and_return(dummy_record)
+    end
+
+    context "when the card is visible and there are no role overrides" do
+      it "returns card metadata, field configs, and entries using the record values" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        # Card metadata
+        expect(result.card).to include(
+          id:          card_definition.id,
+          name:        "Demographics",
+          identifier:  identifier.id,
+          layout:      :summary,
+          variant:     :emails,
+          description: "Basic details",
+          position:    10,
+          visible:     true
+        )
+
+        # Field configs (meta)
+        expect(result.fields.size).to eq(2)
+
+        age_field_cfg = result.fields.find { |f| f[:key] == :age }
+        full_name_cfg = result.fields.find { |f| f[:key] == :full_name }
+
+        expect(age_field_cfg).to include(
+          id:        field_age.id,
+          key:       :age,
+          label:     "Age",
+          data_type: :numeric,
+          required:  true,
+          position:  1
+        )
+
+        expect(full_name_cfg).to include(
+          id:        field_full_name.id,
+          key:       :full_name,
+          label:     "Full name",
+          data_type: :string,
+          required:  false,
+          position:  2
+        )
+
+        # Entries (data)
+        expect(result.entries.size).to eq(1)
+        entry = result.entries.first
+
+        expect(entry[:record_id]).to eq(record_id)
+
+        fields_hash = entry[:fields].index_by { |f| f[:id] }
+
+        expect(fields_hash[field_age.id]).to include(
+          label: "Age",
+          value: 30
+        )
+
+        # Here we expect the fallback (direct attribute), not the mapper
+        expect(fields_hash[field_full_name.id]).to include(
+          label: "Full name",
+          value: "John Full Name"
+        )
+      end
+    end
+
+    context "when a field uses the Link data type" do
+      let(:card_fields) { [field_age, field_full_name, field_link] }
+
+      let(:registry_cards) do
+        [
+          {
+            identifier:   identifier,
+            relationship: "demographic",
+            relationship_klass: "HasContactInfo::Demographic",
+            fields:       [
+              { kind: :resource, ref: "age" },
+              { kind: :custom, key: "full_name" },
+              { kind: :resource, ref: "user_id" }
+            ]
+          }
+        ]
+      end
+
+      it "adds the url for link fields while keeping the name as the value" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        entry = result.entries.first
+        fields_hash = entry[:fields].index_by { |f| f[:id] }
+        link_field_data = fields_hash[field_link.id]
+
+        expect(link_field_data[:label]).to eq("User")
+        expect(link_field_data[:value]).to eq("Linked Record Name")
+        expect(link_field_data[:url]).to eq("/users/#{linked_record_id}")
+      end
+    end
+
+    context "when a link field provides a custom url resolver" do
+      let(:card_fields) { [field_link] }
+
+      let(:registry_cards) do
+        [
+          {
+            identifier:   identifier,
+            relationship: "demographic",
+            relationship_klass: "HasContactInfo::Demographic",
+            fields:       [
+              {
+                kind: :resource,
+                ref:  "user_id",
+                url:  ->(_cfg, _field, raw_value, value) { "/custom/#{value}-#{raw_value.id}" }
+              }
+            ]
+          }
+        ]
+      end
+
+      it "uses the provided resolver to compute the url" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        entry = result.entries.first
+        fields_hash = entry[:fields].index_by { |f| f[:id] }
+        link_field_data = fields_hash[field_link.id]
+
+        expect(link_field_data[:url]).to eq("/custom/Linked Record Name-#{linked_record_id}")
+      end
+    end
+
+    context "when a field uses the Badge data type" do
+      let(:card_fields) { [field_age, field_full_name, field_badge] }
+
+      let(:registry_cards) do
+        [
+          {
+            identifier:   identifier,
+            relationship: "demographic",
+            relationship_klass: "HasContactInfo::Demographic",
+            fields:       [
+              { kind: :resource, ref: "age" },
+              { kind: :custom, key: "full_name" },
+              { kind: :resource, ref: "status" }
+            ]
+          }
+        ]
+      end
+
+      it "populates color for badge fields using proc or default" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        entry = result.entries.first
+        fields_hash = entry[:fields].index_by { |f| f[:id] }
+        badge_field_data = fields_hash[field_badge.id]
+
+        expect(badge_field_data[:label]).to eq("Status")
+        expect(badge_field_data[:value]).to eq("Active")
+        expect(badge_field_data[:badge_color]).to eq(Color::GREEN.name)
+      end
+    end
+
+    context "when a field uses the HoverCard data type" do
+      let(:card_fields) { [field_hover_card] }
+
+      let(:registry_cards) do
+        [
+          {
+            identifier:         identifier,
+            relationship:       "demographic",
+            relationship_klass: "HasContactInfo::Demographic",
+            data_sources: [
+              {
+                name: :hover,
+                resolver: ->(_record, _ctx) do
+                  {
+                    name: linked_record,
+                    target: {
+                      resource_name: "Advisor",
+                      record_id: linked_record_id
+                    }
+                  }
+                end
+              }
+            ],
+            fields: [
+              {
+                kind: :virtual,
+                ref: "advisor_link",
+                name: "Advisor",
+                data_type: :hover_card,
+                source: { from: :hover, key: :name },
+                hover_card: "AdvisorHover",
+                hover_record_source: { from: :hover, key: :target },
+                icon: "user"
+              }
+            ]
+          }
+        ]
+      end
+
+      it "serializes hover metadata and icon" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        entry = result.entries.first
+        hover_field_data = entry[:fields].find { |f| f[:id] == field_hover_card.id }
+
+        expect(hover_field_data).to include(
+          label: "Advisor",
+          value: "Linked Record Name",
+          hover_card_identifier: "AdvisorHover",
+          hover_target_resource: "Advisor",
+          hover_target_record_id: linked_record_id,
+          icon: "user"
+        )
+      end
+    end
+
+    context "when a HoverCard field source resolves to nil" do
+      let(:card_fields) { [field_hover_card] }
+
+      let(:registry_cards) do
+        [
+          {
+            identifier:         identifier,
+            relationship:       "demographic",
+            relationship_klass: "HasContactInfo::Demographic",
+            data_sources: [
+              {
+                name: :hover,
+                resolver: ->(_record, _ctx) do
+                  {
+                    name: "Advisor",
+                    target: nil
+                  }
+                end
+              }
+            ],
+            fields: [
+              {
+                kind: :virtual,
+                ref: "advisor_link",
+                name: "Advisor",
+                data_type: :hover_card,
+                source: { from: :hover, key: :name },
+                hover_card: "AdvisorHover",
+                hover_record_source: { from: :hover, key: :target }
+              }
+            ]
+          }
+        ]
+      end
+
+      it "keeps the value and emits null hover metadata" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        entry = result.entries.first
+        hover_field_data = entry[:fields].find { |f| f[:id] == field_hover_card.id }
+
+        expect(hover_field_data).to include(
+          value: "Advisor",
+          hover_card_identifier: nil,
+          hover_target_resource: nil,
+          hover_target_record_id: nil
+        )
+      end
+    end
+
+    context "when the card is hidden for the role (is_visible = false)" do
+      let(:role_resource_card) do
+        instance_double(
+          HasHelpers::Cards::RoleResourceCard,
+          is_visible:      false,
+          position:        5,
+          role_card_fields: []
+        )
+      end
+
+      it "returns only card metadata and leaves fields and entries empty" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        expect(result.card).to include(
+          id:       card_definition.id,
+          visible:  false,
+          position: 5
+        )
+
+        expect(result.fields).to eq([])
+        expect(result.entries).to eq([])
+      end
+    end
+
+    context "when a mapper is configured in the registry" do
+      before do
+        # Registry with mapper set only for this context
+        registry_with_mapper = [
+          {
+            identifier:   identifier,
+            relationship: "demographic",
+            relationship_klass: "HasContactInfo::Demographic",
+            fields:       [
+              { kind: :resource, ref: "age" },
+              { kind: :custom, key: "full_name", mapper: "HasHelpers::CardsFieldMapper::Demographics::FullName" }
+            ]
+          }
+        ]
+
+        allow(HasHelpers::Cards::Registry).to receive(:cards)
+          .and_return(registry_with_mapper)
+
+        # Define or override the mapper class to have a predictable behavior
+        module HasHelpers
+          module CardsFieldMapper
+            module Demographics
+              class FullName
+                def self.call(record)
+                  "MAPPED: #{record.full_name}"
+                end
+              end
+            end
+          end
+        end
+      end
+
+      it "uses the mapper to resolve the value instead of reading the attribute directly" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+        entry = result.entries.first
+        fields_hash = entry[:fields].index_by { |f| f[:id] }
+
+        mapped_field = fields_hash[field_full_name.id]
+
+        expect(mapped_field[:label]).to eq("Full name")
+        expect(mapped_field[:value]).to eq("MAPPED: John Full Name")
+      end
+    end
+
+    context "when invoked via .call_with_record with a preloaded record" do
+      it "does not hit the model .find and returns the same payload structure" do
+        # For this path we expect no extra DB lookup on the model class
+        expect(dummy_model_class).not_to receive(:find)
+
+        result = described_class.call_with_record(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record:        dummy_record
+        )
+
+        # Basic sanity checks: same shape as the regular .call case
+        expect(result.card).to include(
+          id:          card_definition.id,
+          name:        "Demographics",
+          identifier:  identifier.id,
+          layout:      :summary,
+          variant:     :emails,
+          description: "Basic details",
+          visible:     true
+        )
+
+        expect(result.fields.size).to eq(2)
+        expect(result.entries.size).to eq(1)
+        expect(result.entries.first[:record_id]).to eq(record_id)
+      end
+    end
+
+    # custom label tests
+    context "when a virtual field has custom label enabled" do
+      let(:field_virtual_note) do
+        double(
+          "CardFieldVirtualNote",
+          id:                 205,
+          card_definition:    card_definition,
+          field_resource:     nil,
+          virtual_ref:        "note",
+          data_type:          field_full_name_data_type,
+          data_type_id:       field_full_name_data_type.id,
+          default_visibility: true,
+          default_position:   4,
+          is_required:        false,
+          field_custom_name:  "Note"
+        )
+      end
+
+      let(:card_fields) { [field_age, field_full_name, field_virtual_note] }
+
+      let(:registry_cards) do
+        [
+          {
+            identifier:         identifier,
+            relationship:       "demographic",
+            relationship_klass: "HasContactInfo::Demographic",
+            data_sources: [
+              {
+                name: :data,
+                resolver: ->(_record, _ctx) do
+                  {
+                    note: "Test custom label",
+                    meta: { label: "Additional Notes" }
+                  }
+                end
+              }
+            ],
+            fields: [
+              { kind: :resource, ref: "age" },
+              { kind: :custom, key: "full_name" },
+              {
+                kind:             :virtual,
+                ref:              "note",
+                name:             "Note",
+                data_type:         :string,
+                source:           { from: :data, key: :note },
+                custom_label:     true,
+                custom_label_key: "data.meta.label"
+              }
+            ]
+          }
+        ]
+      end
+
+      it "adds custom_label using custom_label_key when enabled" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        # Field config should include the key
+        note_cfg = result.fields.find { |f| f[:key] == :note }
+        expect(note_cfg[:custom_label_key]).to eq("data.meta.label")
+
+        entry = result.entries.first
+        note_field = entry[:fields].find { |f| f[:id] == field_virtual_note.id }
+
+        expect(note_field[:label]).to eq("Note")
+        expect(note_field[:value]).to eq("Test custom label")
+        expect(note_field[:custom_label]).to eq("Additional Notes")
+      end
+    end
+
+    context "when a virtual field has custom_label_key but custom_label is disabled" do
+      let(:field_virtual_note) do
+        double(
+          "CardFieldVirtualNote",
+          id:                 206,
+          card_definition:    card_definition,
+          field_resource:     nil,
+          virtual_ref:        "note",
+          data_type:          field_full_name_data_type,
+          data_type_id:       field_full_name_data_type.id,
+          default_visibility: true,
+          default_position:   4,
+          is_required:        false,
+          field_custom_name:  "Note"
+        )
+      end
+
+      let(:card_fields) { [field_virtual_note] }
+
+      let(:registry_cards) do
+        [
+          {
+            identifier:         identifier,
+            relationship:       "demographic",
+            relationship_klass: "HasContactInfo::Demographic",
+            data_sources: [
+              {
+                name: :data,
+                resolver: ->(_record, _ctx) do
+                  {
+                    note: "Test custom label",
+                    meta: { label: "Additional Notes" }
+                  }
+                end
+              }
+            ],
+            fields: [
+              {
+                kind:             :virtual,
+                ref:              "note",
+                name:             "Note",
+                data_type:         :string,
+                source:           { from: :data, key: :note },
+                custom_label:     false,
+                custom_label_key: "meta.label"
+              }
+            ]
+          }
+        ]
+      end
+
+      it "does not include custom_label_key when custom_label is false" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        entry = result.entries.first
+        note_field = entry[:fields].find { |f| f[:id] == field_virtual_note.id }
+
+        expect(note_field[:value]).to eq("Test custom label")
+        expect(note_field.key?(:custom_label)).to eq(false)
+      end
+    end
+
+    context "when the resolved field value is not JSON-safe (BigDecimal/Time/Symbol/Parameters)" do
+      let(:card_fields) { [field_meta] }
+
+      let(:registry_cards) do
+        [
+          {
+            identifier:   identifier,
+            relationship: "demographic",
+            relationship_klass: "HasContactInfo::Demographic",
+            fields: [
+              {
+                kind:     :virtual,
+                ref:      "meta",
+                name:     "Meta",
+                data_type: :json,
+                source:   { from: :data, key: :meta }
+              }
+            ],
+            data_sources: [
+              {
+                name: :data,
+                resolver: ->(_record, _ctx) { { meta: json_weird_payload } }
+              }
+            ]
+          }
+        ]
+      end
+
+      let(:field_meta) do
+        double(
+          "CardFieldMeta",
+          id:                  300,
+          card_definition:     card_definition,
+          field_resource:      nil,
+          virtual_ref:         "meta",
+          data_type:           field_json_data_type,
+          data_type_id:        field_json_data_type.id,
+          default_visibility:  true,
+          default_position:    99,
+          is_required:         false,
+          field_custom_name:   "Meta"
+        )
+      end
+
+      it "serializes value into JSON-safe structures" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        entry = result.entries.first
+        meta_field = entry[:fields].find { |f| f[:id] == field_meta.id }
+
+        expect(meta_field[:label]).to eq("Meta")
+        expect(meta_field[:value]).to be_a(Hash)
+
+        # keys should be strings (safe default)
+        expect(meta_field[:value].keys).to include("amount", "created_at", "status", "nested")
+
+        # BigDecimal -> float 
+        expect(meta_field[:value]["amount"]).to eq(12.34)
+
+        # Time -> iso8601
+        expect(meta_field[:value]["created_at"]).to match(/2026-02-19T10:11:12/)
+
+        # Symbol -> string
+        expect(meta_field[:value]["status"]).to eq("active")
+
+        # nested stays JSON-safe
+
+        expect(meta_field[:value]["nested"]["ok"]).to be(true)
+      end
+    end
+
+    context "when the value is an object without a JSON representation" do
+      let(:card_fields) { [field_full_name] }
+
+      let(:registry_cards) do
+        [
+          {
+            identifier:   identifier,
+            relationship: "demographic",
+            relationship_klass: "HasContactInfo::Demographic",
+            fields: [
+              { kind: :custom, key: "full_name" }
+            ]
+          }
+        ]
+      end
+
+      let(:weird_object) { double("WeirdObject", id: 777) }
+
+      before do
+        allow(dummy_record).to receive(:full_name).and_return(weird_object)
+      end
+
+      it "returns a JSON-safe value (id or string fallback)" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        entry = result.entries.first
+        fields_hash = entry[:fields].index_by { |f| f[:id] }
+
+        # If jsonify uses id when it exists
+        expect(fields_hash[field_full_name.id][:value]).to eq(777)
+      end
+    end
+
+    context "when the value is a cyclic structure" do
+      let(:card_fields) { [field_full_name] }
+
+      let(:cyclic_hash) do
+        h = {}
+        h[:self] = h
+        h
+      end
+
+      before do
+        allow(dummy_record).to receive(:demographics_full_name).and_return(cyclic_hash)
+      end
+
+      it "does not blow up and degrades gracefully" do
+        result = described_class.call(
+          role_id:       role_id,
+          resource_id:   resource_id,
+          identifier_id: identifier_id,
+          record_id:     record_id
+        )
+
+        entry = result.entries.first
+        field = entry[:fields].find { |f| f[:id] == field_full_name.id }
+
+        expect(field[:value]).to be_a(String)
+      end
+    end
+  end
+end