spree_api 6.0.0.beta4 → 6.0.0.rc2

data/app/serializers/spree/api/v3/admin/update_status_serializer.rb

@@ -0,0 +1,28 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # What the last update check found (Spree::UpdateStatus). A computed
+        # value rather than a record, so it carries no id.
+        class UpdateStatusSerializer < V3::BaseSerializer
+          typelize current_version: :string,
+                   enabled: :boolean,
+                   update_available: :boolean,
+                   latest_version: [:string, nullable: true],
+                   latest_release_url: [:string, nullable: true],
+                   latest_release_published_at: [:string, nullable: true],
+                   checked_at: [:string, nullable: true]
+
+          _attributes.delete(:id)
+
+          attributes :current_version, :enabled, checked_at: :iso8601
+
+          attribute(:update_available) { |status| status.update_available? }
+          attribute(:latest_version) { |status| status.latest_release&.dig(:version) }
+          attribute(:latest_release_url) { |status| status.latest_release&.dig(:url) }
+          attribute(:latest_release_published_at) { |status| status.latest_release&.dig(:published_at)&.iso8601(3) }
+        end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v3/admin/variant_serializer.rb

@@ -5,19 +5,21 @@ module Spree
         # Admin API Variant Serializer
         # Full variant data including admin-only fields
         class VariantSerializer < V3::VariantSerializer
+          without_formatted_money
+
           include Concerns::ExternalReferencesAttribute
 
 
           typelize product_name: :string,
                    position: :number, tax_category_id: [:string, nullable: true],
-                   cost_price: [:string, nullable: true], cost_currency: [:string, nullable: true],
+                   cost_price: [:string, nullable: true], cost_currency: [:string, nullable: true, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                    barcode: [:string, nullable: true],
                    available_stock: [:number, nullable: true],
                    reserved_quantity: :number, total_on_hand: [:number, nullable: true],
                    preorderable: :boolean, preorder_ships_at: [:string, nullable: true],
                    backorder_limit: [:number, nullable: true],
                    hs_code: [:string, nullable: true],
-                   country_of_origin: [:string, nullable: true],
+                   country_of_origin: [:string, nullable: true, enum: Spree::IsoData.country_codes, enum_type_name: 'CountryCode'],
                    customs_description: [:string, nullable: true],
                    deleted_at: [:string, nullable: true],
                    delivery_profile_id: [:string, nullable: true],
@@ -32,7 +34,7 @@ module Spree
           # The last three override the store serializer's buyer-resolved
           # values with the variant's OWN: a merchant edits what is stored on
           # the row, not what some catalog resolves to for a buyer they are not.
-          attributes :metadata, :position, :cost_price, :cost_currency,
+          attributes :metadata, :position, :cost_currency,
                      :barcode, :backorder_limit,
                      :hs_code, :country_of_origin, :customs_description,
                      :minimum_order_quantity, :order_multiple, :purchase_unit,
@@ -40,12 +42,15 @@ module Spree
                      preorder_ships_at: :iso8601, deleted_at: :iso8601,
                      created_at: :iso8601, updated_at: :iso8601
 
-          attribute :preorderable do |variant|
-            variant.preorderable?
-          end
+          money_attributes :cost_price, currency: :cost_currency, unit_price: true
 
+          attribute :preorderable, &:preorderable?
+
+          # Stored on the row only — nil means inherit from the product. The
+          # model's +tax_category+ reader resolves the effective category for
+          # tax; the admin form needs the raw column to tell override from inherit.
           attribute :tax_category_id do |variant|
-            variant.tax_category&.prefixed_id
+            Spree::TaxCategory.prefixed_id_for(variant[:tax_category_id])
           end
 
           # Encoded from the foreign key: loading the carton row just to
@@ -82,9 +87,7 @@ module Spree
           # seller's row ships; on an owned product the write is a no-op, since
           # every variant ships as the product does. The dashboard need not
           # know which.
-          attribute :delivery_profile_id do |variant|
-            variant.resolved_delivery_profile&.prefixed_id
-          end
+          prefixed_id_attributes delivery_profile_id: :resolved_delivery_profile
 
           one :seller,
               resource: proc { Spree.api.admin_seller_serializer },

data/app/serializers/spree/api/v3/admin/webhook_delivery_serializer.rb

@@ -38,9 +38,7 @@ module Spree
             Spree::WebhookPayloadRedaction.split(delivery.payload).first
           end
 
-          attribute :webhook_endpoint_id do |delivery|
-            delivery.webhook_endpoint&.prefixed_id
-          end
+          prefixed_id_attributes :webhook_endpoint
 
           # Delegated from the parent endpoint — saves callers from having to
           # join the endpoint payload to show "where did this delivery go?".

data/app/serializers/spree/api/v3/admin/webhook_event_serializer.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # One event catalog entry (Spree::Events::Catalog::Entry).
+        class WebhookEventSerializer
+          include Alba::Resource
+          include Typelizer::DSL
+
+          typelize name: :string, group: :string, credential: :boolean,
+                   credential_permission: [:string, nullable: true],
+                   deprecated: :boolean, replaced_by: [:string, nullable: true]
+
+          attributes :name, :group, :credential_permission
+
+          attribute(:credential, &:credential?)
+          attribute(:deprecated, &:deprecated?)
+          attribute(:replaced_by, &:deprecated_alias_of)
+        end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v3/applied_promotion_serializer.rb

@@ -6,11 +6,9 @@ module Spree
       # the typed Spree::Discount money rows.
       class AppliedPromotionSerializer < BaseSerializer
         typelize name: :string, description: [:string, nullable: true], code: [:string, nullable: true],
-                 amount: [:string, nullable: true], display_amount: [:string, nullable: true], promotion_id: :string
+                 promotion_id: :string
 
-        attribute :promotion_id do |record|
-          record.promotion&.prefixed_id
-        end
+        prefixed_id_attributes :promotion
 
         attributes :name, :description, :code
 

data/app/serializers/spree/api/v3/base_serializer.rb

@@ -16,17 +16,138 @@ module Spree
           object.prefixed_id
         end
 
-        # Declares money/display attributes that render +null+ for gated
-        # (prices_hidden) guests, keyed off the same +hide_prices+ flag the
-        # +price_for+/+price_in+ helpers use — so the whole price surface
-        # (product prices AND cart/order/line-item totals) is gated from one
-        # place instead of per-attribute opt-in.
-        def self.money_attributes(*names)
+        # Display strings that are labels, not formatted money.
+        FORMATTED_LABELS = %i[display_name display_description display_code display_action].freeze
+
+        # Back-office serializers leave formatting money to the client, which
+        # shows it in the admin's own language (docs/plans/6.0-money-correctness.md,
+        # PR E): inherited display_* attributes are dropped, and nested prices
+        # are written with the admin price serializers, which carry none.
+        #
+        # @param surface [Symbol] :admin or :seller, whose price serializers to use
+        def self.without_formatted_money(surface = :admin)
+          without_display_money
+          define_method(:price_serializer) { Spree.api.public_send(:"#{surface}_price_serializer") }
+          define_method(:price_history_serializer) { Spree.api.public_send(:"#{surface}_price_history_serializer") }
+        end
+
+        # Drops the inherited display_* money attributes, keeping labels.
+        # Emails use it alone: their templates format amounts with the `money`
+        # Liquid filter.
+        def self.without_display_money
+          _attributes.delete_if { |key, _| display_money?(key) }
+        end
+
+        # Declares money attributes, written as decimal strings with exactly
+        # the currency's decimal places ("10.00", "1.500", "100"), or up to
+        # four for unit prices ("0.0125"). +display_*+ names pass through as
+        # formatted. All render +null+ for gated (prices_hidden) guests, keyed
+        # off the same +hide_prices+ flag the +price_for+/+price_in+ helpers
+        # use, so the whole price surface is gated from one place.
+        #
+        # @param currency [Symbol, Proc] the record's reader for its currency,
+        #   or a block taking the record
+        # @param unit_price [Boolean]
+        # @param descriptions [Hash{Symbol => String}] what each amount is, for
+        #   the API reference and the SDK types
+        def self.money_attributes(*names, currency: :currency, unit_price: false, descriptions: {})
+          typelize(**names.index_with do |name|
+            next display_money_type(name) if display_money?(name)
+
+            descriptions[name] ? [:string, nullable: true, comment: descriptions[name]] : [:string, nullable: true]
+          end)
+
           names.each do |name|
-            attribute(name) { |object| object.public_send(name) unless params[:hide_prices] }
+            formatted = display_money?(name)
+            attribute(name) do |object|
+              next if params[:hide_prices]
+
+              value = object.public_send(name)
+              next value if formatted || value.nil?
+
+              code = currency.is_a?(Proc) ? currency.call(object) : object.public_send(currency)
+              Spree::Money::Rounding.format(value, code, unit_price: unit_price)
+            end
           end
         end
 
+        # A formatted money copy, as opposed to a label such as +display_name+.
+        def self.display_money?(name)
+          name.to_s.start_with?('display_') && !FORMATTED_LABELS.include?(name.to_sym)
+        end
+
+        # The type of a formatted money copy: deprecated in favour of the
+        # amount it formats, which clients format in the reader's language.
+        def self.display_money_type(name, nullable: true)
+          amount = name.to_s.delete_prefix('display_')
+          [:string, nullable: nullable,
+                    comment: "`#{amount}` formatted with its currency symbol in the request's language.",
+                    deprecated: "Format `#{amount}` with its currency instead. Removed in 6.1."]
+        end
+
+        # Declares rates and percentages, written as decimal strings without
+        # trailing zeros ("0.23", "7.25", "10"). A name ending +_percent+ or
+        # +_percentage+ holds 0-100; +rate+ or a name ending +_rate+ holds a
+        # fraction.
+        def self.rate_attributes(*names)
+          typelize(**names.index_with { [:string, nullable: true] })
+
+          names.each do |name|
+            attribute(name) { |object| Spree::Money::Rounding.format_decimal(object.public_send(name)) }
+          end
+        end
+
+        # Declares `<association>_id` attributes carrying the associated
+        # record's prefixed id, or nil when there is none. Pass
+        # `seller_id: :resolved_seller` when the attribute name and the
+        # association it reads differ.
+        def self.prefixed_id_attributes(*associations, **renamed)
+          associations.index_by { |association| :"#{association}_id" }.merge(renamed).each do |name, association|
+            attribute(name) { |object| object.public_send(association)&.prefixed_id }
+          end
+        end
+
+        # Declares attributes whose column stores a provider or strategy class
+        # name, sent as its shorthand (`manual`, `rules`) instead.
+        def self.api_type_attributes(*names)
+          names.each do |name|
+            attribute(name) { |object| Spree::ApiTyped.api_type_for(object.public_send(name)) }
+          end
+        end
+
+        # Declares a model's settings under their plain names (see
+        # `exposes_preferences`) — every exposed one unless named — typed from
+        # their declarations so the generated SDK types never drift from the
+        # model. Each reads the stored setting, never a reader the model
+        # overrides with a fallback.
+        #
+        #   preference_attributes Spree::Store, except: %i[payout_provider]
+        def self.preference_attributes(model, *names, except: [])
+          names = model.exposed_preference_names.to_a - except if names.empty?
+          definitions = model.preference_definitions
+          names.each do |name|
+            typelize name => preference_type_hint(Spree::PreferenceSchema::JsonSchema.property_schema(definitions.fetch(name)))
+            reader = :"preferred_#{name}"
+            attribute(name) do |object|
+              value = object.public_send(reader)
+              value.is_a?(BigDecimal) ? value.to_s('F') : value
+            end
+          end
+        end
+
+        TYPELIZER_TYPES = { 'string' => :string, 'integer' => :number, 'number' => :number, 'boolean' => :boolean }.freeze
+        private_constant :TYPELIZER_TYPES
+
+        def self.preference_type_hint(schema)
+          types = Array(schema['type'])
+          hint = TYPELIZER_TYPES.fetch((types - ['null']).first, :unknown)
+          options = {}
+          options[:nullable] = true if types.include?('null')
+          options[:enum] = schema['enum'].compact if schema['enum']
+          options.empty? ? hint : [hint, options]
+        end
+        private_class_method :preference_type_hint
+
         # Declares the wire form of an `acted_by` association: the actor's
         # prefixed id, the kind of actor it is, and the expansion. Both
         # halves read off the columns, so naming an actor costs no query and
@@ -123,6 +244,10 @@ module Spree
           product.featured_variant(currency: current_currency)
         end
 
+        def price_serializer = Spree.api.price_serializer
+
+        def price_history_serializer = Spree.api.price_history_serializer
+
         # Returns price for a variant using full Price List resolution
         # This may return a price from a price list if applicable
         # Memoized per variant to avoid duplicate queries

data/app/serializers/spree/api/v3/cart_serializer.rb

@@ -4,58 +4,35 @@ module Spree
       # Store API Cart Serializer
       # Pre-purchase cart data with checkout progression info
       class CartSerializer < BaseSerializer
-        typelize number: :string, current_step: :string, completed_steps: 'string[]', token: :string, email: [:string, nullable: true],
-                 customer_note: [:string, nullable: true], market_id: [:string, nullable: true], channel_id: [:string, nullable: true],
-                 currency: :string, locale: [:string, nullable: true], total_quantity: :number,
-                 coupon_code: [:string, nullable: true],
-                 preferred_stock_location_id: [:string, nullable: true],
-                 company_id: [:string, nullable: true], company_name: [:string, nullable: true],
-                 po_number: [:string, nullable: true], po_number_required: :boolean,
-                 po_document_filename: [:string, nullable: true],
-                 po_document_byte_size: ['number | null'],
-                 order_minimum: ['number | null'], order_minimum_shortfall: ['number | null'],
-                 below_order_minimum: ['boolean | null'],
+        typelize number: [:string, deprecated: 'Use `id`; a cart has no order number. Removed in 6.1.'], current_step: :string, completed_steps: 'string[]', token: :string,
+                 email: [:string, nullable: true], customer_note: [:string, nullable: true],
+                 market_id: [:string, nullable: true], channel_id: [:string, nullable: true], currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
+                 locale: [:string, nullable: true, enum: Spree::Locales::ALL, enum_type_name: 'LocaleCode'], total_quantity: :number, coupon_code: [:string, nullable: true],
+                 preferred_stock_location_id: [:string, nullable: true], company_id: [:string, nullable: true],
+                 company_name: [:string, nullable: true], po_number: [:string, nullable: true],
+                 po_number_required: :boolean, po_document_filename: [:string, nullable: true],
+                 po_document_byte_size: ['number | null'], order_minimum: [:string, nullable: true],
+                 order_minimum_shortfall: [:string, nullable: true], below_order_minimum: ['boolean | null'],
                  freight_summary: [:FreightSummary, nullable: true],
                  requirements: 'Array<{step: string, field: string, code: string, message: string}>',
-                 item_total: [:string, nullable: true], display_item_total: [:string, nullable: true],
-                 delivery_total: [:string, nullable: true], display_delivery_total: [:string, nullable: true],
-                 adjustment_total: [:string, nullable: true], display_adjustment_total: [:string, nullable: true],
-                 discount_total: [:string, nullable: true], display_discount_total: [:string, nullable: true],
-                 tax_total: [:string, nullable: true], display_tax_total: [:string, nullable: true],
-                 included_tax_total: [:string, nullable: true], display_included_tax_total: [:string, nullable: true],
-                 additional_tax_total: [:string, nullable: true], display_additional_tax_total: [:string, nullable: true],
-                 fee_total: [:string, nullable: true], display_fee_total: [:string, nullable: true],
-                 store_credit_total: [:string, nullable: true], display_store_credit_total: [:string, nullable: true],
-                 gift_card_total: [:string, nullable: true], display_gift_card_total: [:string, nullable: true],
-                 covered_by_store_credit: :boolean,
-                 total: [:string, nullable: true], display_total: [:string, nullable: true],
-                 amount_due: [:string, nullable: true], display_amount_due: [:string, nullable: true],
                  shipping_eq_billing_address: :boolean,
                  warnings: 'Array<{code: string, message: string, line_item_id?: string, variant_id?: string, item_index?: number}>',
                  billing_address: { nullable: true }, shipping_address: { nullable: true },
                  gift_card: { nullable: true }, market: { nullable: true }
 
-        attribute :market_id do |order|
-          order.market&.prefixed_id
-        end
+        prefixed_id_attributes :market
 
         # Which surface this cart belongs to — lets a multi-channel storefront
         # verify a cookie-persisted cart against its own channel before
         # adopting it (see the wholesale reference storefront's cart guard).
-        attribute :channel_id do |order|
-          order.channel&.prefixed_id
-        end
+        prefixed_id_attributes :channel
 
         # Pickup selection — mirrors the writable param on cart update.
-        attribute :preferred_stock_location_id do |cart|
-          cart.preferred_stock_location&.prefixed_id
-        end
+        prefixed_id_attributes :preferred_stock_location
 
         # Which company node the purchase is for — mirrors the writable
         # `company_id` param. Read from the column, never re-resolved.
-        attribute :company_id do |cart|
-          cart.company&.prefixed_id
-        end
+        prefixed_id_attributes :company
 
         attribute :company_name do |cart|
           cart.company&.name
@@ -64,9 +41,7 @@ module Spree
         # The buyer's own purchase-order reference, and whether their company
         # demands one — the storefront marks the field required from this
         # rather than fetching the company to ask.
-        attribute :po_number_required do |cart|
-          cart.po_number_required?
-        end
+        attribute :po_number_required, &:po_number_required?
 
         attribute :po_document_filename do |cart|
           cart.po_document.blob&.filename&.to_s if cart.po_document.attached?
@@ -83,27 +58,9 @@ module Spree
 
         # Nulled for gated (prices_hidden) guests so the cart can't leak the
         # prices that product/variant serializers already withhold.
-        money_attributes :item_total, :display_item_total,
-                         :adjustment_total, :display_adjustment_total,
-                         :discount_total, :display_discount_total,
-                         :tax_total, :display_tax_total, :included_tax_total, :display_included_tax_total,
-                         :additional_tax_total, :display_additional_tax_total, :total, :display_total,
-                         :gift_card_total, :display_gift_card_total,
-                         :amount_due, :display_amount_due,
-                         :delivery_total, :display_delivery_total,
-                         :fee_total, :display_fee_total
-
-        attribute :store_credit_total do |order|
-          order.total_applied_store_credit.to_s unless params[:hide_prices]
-        end
-
-        attribute :display_store_credit_total do |order|
-          order.display_total_applied_store_credit.to_s unless params[:hide_prices]
-        end
-
-        attribute :covered_by_store_credit do |order|
-          order.covered_by_store_credit?
-        end
+        include Spree::Api::V3::PurchaseSummary
+        money_attributes :adjustment_total, :display_adjustment_total,
+                         descriptions: { adjustment_total: 'Every discount, fee and added tax together, as one amount.' }
 
         attribute :current_step do |order|
           order.current_checkout_step
@@ -132,11 +89,11 @@ module Spree
         # shortfall are amounts, and a storefront that hides prices from
         # guests must not hand them "$180 short of $500" instead.
         attribute :order_minimum do |order|
-          order.order_minimum_amount&.to_f unless params[:hide_prices]
+          Spree::Money::Rounding.format(order.order_minimum_amount, order.currency) unless params[:hide_prices]
         end
 
         attribute :order_minimum_shortfall do |order|
-          order.order_minimum_shortfall&.to_f unless params[:hide_prices]
+          Spree::Money::Rounding.format(order.order_minimum_shortfall, order.currency) unless params[:hide_prices]
         end
 
         attribute :below_order_minimum do |order|
@@ -153,9 +110,7 @@ module Spree
         # withhold.
         one :freight_summary, resource: proc { Spree.api.freight_summary_serializer }
 
-        attribute :shipping_eq_billing_address do |order|
-          order.shipping_eq_billing_address?
-        end
+        attribute :shipping_eq_billing_address, &:shipping_eq_billing_address?
 
         many :order_promotions, key: :discounts, resource: proc { Spree.api.applied_promotion_serializer }
         # Itemized charges (duties, surcharges, COD, handling). Storefronts
@@ -164,7 +119,6 @@ module Spree
         many :fees, resource: proc { Spree.api.fee_serializer }
         many :line_items, key: :items, resource: proc { Spree.api.line_item_serializer }
         many :fulfillments, resource: proc { Spree.api.fulfillment_serializer }
-        many :payments, resource: proc { Spree.api.payment_serializer }
         one :billing_address, resource: proc { Spree.api.address_serializer }
         one :shipping_address, resource: proc { Spree.api.address_serializer }
 

data/app/serializers/spree/api/v3/category_serializer.rb

@@ -13,17 +13,13 @@ module Spree
                    :meta_title, :meta_description, :meta_keywords,
                    :children_count
 
-        attribute :parent_id do |category|
-          category.parent&.prefixed_id
-        end
+        prefixed_id_attributes :parent
 
         attribute :description do |category|
           Spree::RichTextHelper.to_plain_text(category.description)
         end
 
-        attribute :description_html do |category|
-          category.description_html
-        end
+        attributes :description_html
 
         attribute :image_url do |category|
           image_url_for(category.image)
@@ -33,17 +29,11 @@ module Spree
           image_url_for(category.square_image)
         end
 
-        attribute :is_root do |category|
-          category.root?
-        end
+        attribute :is_root, &:root?
 
-        attribute :is_child do |category|
-          category.child?
-        end
+        attribute :is_child, &:child?
 
-        attribute :is_leaf do |category|
-          category.leaf?
-        end
+        attribute :is_leaf, &:leaf?
 
         # Conditional associations
         # Note: We pass empty expand to nested categories to prevent infinite recursion

data/app/serializers/spree/api/v3/claim_line_item_serializer.rb

@@ -6,9 +6,6 @@ module Spree
       class ClaimLineItemSerializer < BaseSerializer
         typelize quantity: :number,
                  send_replacement: :boolean,
-                 refund_amount: :string,
-                 display_refund_amount: :string,
-                 paid_amount: :string,
                  description: [:string, nullable: true],
                  variant_id: [:string, nullable: true],
                  replacement_variant_id: [:string, nullable: true],
@@ -16,32 +13,12 @@ module Spree
 
         attributes :quantity, :send_replacement, :description
 
-        attribute :refund_amount do |line|
-          line.refund_amount.to_s
-        end
-
-        # What the customer actually paid for these units — the ceiling the
-        # resolve workflow enforces, and what the dashboard offers when the
-        # claim carries no explicit amount.
-        attribute :paid_amount do |line|
-          line.paid_amount.to_s
-        end
-
-        attribute :display_refund_amount do |line|
-          line.display_refund_amount.to_s
-        end
-
-        attribute :variant_id do |line|
-          line.variant&.prefixed_id
-        end
-
-        attribute :replacement_variant_id do |line|
-          line.replacement_variant&.prefixed_id
-        end
-
-        attribute :line_item_id do |line|
-          line.line_item&.prefixed_id
-        end
+        # paid_amount is what the customer actually paid for these units, tax
+        # included — the ceiling the resolve workflow enforces, and what the
+        # dashboard offers when the claim carries no explicit amount.
+        money_attributes :refund_amount, :paid_amount, :pre_tax_amount, :included_tax_total,
+                         :additional_tax_total, :tax_total, :display_refund_amount
+        prefixed_id_attributes :variant, :replacement_variant, :line_item
 
         one :variant, resource: proc { Spree.api.variant_serializer }, if: proc { expand?('variant') }
       end

data/app/serializers/spree/api/v3/claim_serializer.rb

@@ -10,8 +10,6 @@ module Spree
                  resolution: [:string, nullable: true],
                  order_id: [:string, nullable: true],
                  reason_id: [:string, nullable: true],
-                 refund_total: :string,
-                 display_refund_total: :string,
                  approved_at: [:string, nullable: true],
                  resolved_at: [:string, nullable: true],
                  denied_at: [:string, nullable: true],
@@ -19,21 +17,9 @@ module Spree
 
         attributes :number, :status, :resolution
 
-        attribute :order_id do |claim|
-          claim.order&.prefixed_id
-        end
-
-        attribute :reason_id do |claim|
-          claim.reason&.prefixed_id
-        end
+        prefixed_id_attributes :order, :reason
 
-        attribute :refund_total do |claim|
-          claim.refund_total.to_s
-        end
-
-        attribute :display_refund_total do |claim|
-          claim.display_refund_total.to_s
-        end
+        money_attributes :refund_total, :display_refund_total
 
         attribute :approved_at do |claim|
           claim.approved_at&.iso8601

data/app/serializers/spree/api/v3/collection_serializer.rb

@@ -19,9 +19,7 @@ module Spree
           Spree::RichTextHelper.to_plain_text(collection.description)
         end
 
-        attribute :description_html do |collection|
-          collection.description_html
-        end
+        attributes :description_html
 
         attribute :image_url do |collection|
           image_url_for(collection.image)

data/app/serializers/spree/api/v3/company_serializer.rb

@@ -15,9 +15,7 @@ module Spree
         # the PO field required from it.
         attributes :name, :kind, :po_number_required
 
-        attribute :parent_id do |company|
-          company.parent&.prefixed_id
-        end
+        prefixed_id_attributes :parent
 
         # The path above this node, root first — lets a client render
         # "Acme / EMEA / Berlin" without a request per level. Bounded by the

data/app/serializers/spree/api/v3/country_serializer.rb

@@ -5,7 +5,8 @@ module Spree
         include Alba::Resource
         include Typelizer::DSL
 
-        typelize iso: :string, iso3: :string, name: :string,
+        typelize iso: [:string, enum: Spree::IsoData.country_codes, enum_type_name: 'CountryCode'], iso3: :string,
+                 name: [:string, deprecated: 'Name the country from `iso` with `Intl.DisplayNames` (type `region`). Removed in 6.1.'],
                  states_required: :boolean, zipcode_required: :boolean,
                  market: [:Market, nullable: true]
 

data/app/serializers/spree/api/v3/currency_serializer.rb

@@ -5,9 +5,17 @@ module Spree
         include Alba::Resource
         include Typelizer::DSL
 
-        typelize iso_code: :string, name: :string, symbol: :string
+        typelize iso_code: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'], name: [:string, deprecated: 'Name the currency from `iso_code` with `Intl.DisplayNames` (type `currency`). Removed in 6.1.'],
+                 symbol: [:string, deprecated: 'Format amounts with `formatMoney` or `Intl.NumberFormat`, which place the symbol. Removed in 6.1.'],
+                 decimal_places: :number
 
         attributes :iso_code, :name, :symbol
+
+        # ISO 4217 minor units: the decimals every amount in this currency is
+        # written with (2 for USD, 0 for JPY, 3 for KWD).
+        attribute :decimal_places do |currency|
+          Spree::Money::Rounding.precision(currency)
+        end
       end
     end
   end

data/app/serializers/spree/api/v3/custom_field_serializer.rb

@@ -6,11 +6,10 @@ module Spree
       class CustomFieldSerializer < BaseSerializer
         typelize key: :string,
                  label: :string,
-                 type: [:string, deprecated: 'Use `field_type` instead. The legacy `type` field returns the Ruby STI class name (e.g. `Spree::CustomFields::ShortText`) and will be removed in a future minor.'],
                  field_type: Spree::CustomField::FIELD_TYPE_TOKENS,
                  value: :any
 
-        attributes :label, :type, :field_type
+        attributes :label, :field_type
 
         attribute :key, &:full_key
         attribute :value, &:serialize_value