spree_api 6.0.0.rc1 → 6.0.0.rc3

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

@@ -16,16 +16,84 @@ 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|
+            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| object.public_send(name) unless params[:hide_prices] }
+            attribute(name) { |object| Spree::Money::Rounding.format_decimal(object.public_send(name)) }
           end
         end
 
@@ -47,6 +115,39 @@ module Spree
           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
@@ -143,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,19 +4,18 @@ 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,
+        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,
-                 locale: [:string, nullable: true], total_quantity: :number, coupon_code: [: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: ['number | null'],
-                 order_minimum_shortfall: ['number | null'], below_order_minimum: ['boolean | null'],
+                 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}>',
-                 store_credit_total: [:string, nullable: true], display_store_credit_total: [:string, nullable: true],
-                 covered_by_store_credit: :boolean, shipping_eq_billing_address: :boolean,
+                 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 }
@@ -59,25 +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, &:covered_by_store_credit?
+        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
@@ -91,7 +74,11 @@ module Spree
         # it is dropped rather than redacted for a gated guest: a requirement
         # with its numbers stripped tells them nothing they can act on.
         attribute :requirements do |order|
-          requirements = Spree::Checkout::Requirements.new(order).call
+          # 5.6 storefronts matched the delivery requirement by its field, so
+          # it keeps the old name until 6.1; `code` already carries the new one.
+          requirements = Spree::Checkout::Requirements.new(order).call.map do |requirement|
+            requirement[:field] == 'delivery_method' ? requirement.merge(field: 'shipping_method') : requirement
+          end
           next requirements unless params[:hide_prices]
 
           requirements.reject { |requirement| requirement[:code] == 'order_minimum_not_met' }
@@ -106,11 +93,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|
@@ -136,7 +123,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/claim_line_item_serializer.rb

@@ -6,13 +6,6 @@ module Spree
       class ClaimLineItemSerializer < BaseSerializer
         typelize quantity: :number,
                  send_replacement: :boolean,
-                 refund_amount: :string,
-                 display_refund_amount: :string,
-                 paid_amount: :string,
-                 pre_tax_amount: :string,
-                 included_tax_total: :string,
-                 additional_tax_total: :string,
-                 tax_total: :string,
                  description: [:string, nullable: true],
                  variant_id: [:string, nullable: true],
                  replacement_variant_id: [:string, nullable: true],
@@ -20,12 +13,11 @@ module Spree
 
         attributes :quantity, :send_replacement, :description
 
-        attributes refund_amount: :string
-        # 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.
-        attributes paid_amount: :string, pre_tax_amount: :string, included_tax_total: :string,
-                   additional_tax_total: :string, tax_total: :string, display_refund_amount: :string
+        # 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') }

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],
@@ -21,7 +19,8 @@ module Spree
 
         prefixed_id_attributes :order, :reason
 
-        attributes refund_total: :string, display_refund_total: :string
+        money_attributes :refund_total, :display_refund_total
+
         attribute :approved_at do |claim|
           claim.approved_at&.iso8601
         end

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/customer_serializer.rb

@@ -7,7 +7,8 @@ module Spree
         typelize email: :string, first_name: [:string, nullable: true], last_name: [:string, nullable: true],
                  full_name: :string,
                  phone: [:string, nullable: true], accepts_email_marketing: :boolean,
-                 available_store_credit_total: :string, display_available_store_credit_total: :string,
+                 available_store_credit_total: :string,
+                 display_available_store_credit_total: display_money_type(:display_available_store_credit_total, nullable: false),
                  default_billing_address: { nullable: true }, default_shipping_address: { nullable: true },
                  newsletter_subscriber: { nullable: true },
                  email_marketing_consent_updated_at: [:string, nullable: true]
@@ -28,7 +29,7 @@ module Spree
         attribute :available_store_credit_total do |user, params|
           store = params&.dig(:store) || Spree::Current.store
           currency = params&.dig(:currency) || Spree::Current.currency || store&.default_currency
-          user.total_available_store_credit(currency, store).to_s
+          Spree::Money::Rounding.format(user.total_available_store_credit(currency, store), currency)
         end
 
         attribute :display_available_store_credit_total do |user, params|

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

@@ -3,11 +3,6 @@ module Spree
     module V3
       class DeliveryRateSerializer < BaseSerializer
         typelize name: :string, selected: :boolean, delivery_method_id: :string,
-                 cost: :string, display_cost: :string,
-                 total: :string, display_total: :string,
-                 additional_tax_total: :string, display_additional_tax_total: :string,
-                 included_tax_total: :string, display_included_tax_total: :string,
-                 tax_total: :string, display_tax_total: :string,
                  carrier: [:string, nullable: true],
                  service_level: [:string, nullable: true],
                  estimated_delivery_date: [:string, nullable: true],
@@ -19,11 +14,11 @@ module Spree
         # Carrier, service level and delivery date come from the rate provider
         # and are what the customer chooses between; nil on calculator-priced
         # methods. Provider metadata stays admin-only.
-        attributes :name, :selected,
-                   :cost, :total,
-                   :additional_tax_total, :included_tax_total,
-                   :tax_total,
-                   :carrier, :service_level, :estimated_delivery_date,
+        attributes :name, :selected
+
+        money_attributes :cost, :total, :additional_tax_total, :included_tax_total, :tax_total
+
+        attributes :carrier, :service_level, :estimated_delivery_date,
                    :unpriced
 
         # What the shipment looks like to a freight forwarder — cartons,
@@ -33,8 +28,9 @@ module Spree
         # froze it here when it quoted.
         one :freight_summary, resource: proc { Spree.api.freight_summary_serializer }
 
-        attributes display_cost: :string, display_total: :string, display_additional_tax_total: :string,
-                   display_included_tax_total: :string, display_tax_total: :string
+        money_attributes :display_cost, :display_total, :display_additional_tax_total,
+                         :display_included_tax_total, :display_tax_total
+
         one :delivery_method, resource: proc { Spree.api.delivery_method_serializer }
       end
     end

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

@@ -2,7 +2,7 @@ module Spree
   module Api
     module V3
       class DeliveryZoneMemberSerializer < BaseSerializer
-        typelize member_type: [:string, enum: Spree::DeliveryZoneMember::MEMBER_TYPES], country_code: [:string, nullable: true],
+        typelize member_type: [:string, enum: Spree::DeliveryZoneMember::MEMBER_TYPES], country_code: [:string, nullable: true, enum: Spree::IsoData.country_codes, enum_type_name: 'CountryCode'],
                  country_name: [:string, nullable: true],
                  state_code: [:string, nullable: true], state_name: [:string, nullable: true],
                  postal_code_prefix: [:string, nullable: true],

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

@@ -12,8 +12,11 @@ module Spree
 
         attributes :label, :kind, :code, :value_type
 
+        # A percent discount carries a rate; a flat one an amount.
         attribute :value do |record|
-          record.value&.to_s
+          next Spree::Money::Rounding.format_decimal(record.value) if record.value_type == 'percent'
+
+          Spree::Money::Rounding.format(record.value, record.currency) unless params[:hide_prices]
         end
 
         prefixed_id_attributes :promotion, :line_item, :fulfillment

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

@@ -7,11 +7,6 @@ module Spree
         typelize quantity: :number,
                  received_quantity: :number,
                  resellable: :boolean,
-                 original_price: :string,
-                 new_variant_price: :string,
-                 price_difference: :string,
-                 original_tax_total: :string,
-                 new_tax_total: :string,
                  original_variant_id: [:string, nullable: true],
                  new_variant_id: [:string, nullable: true],
                  line_item_id: [:string, nullable: true],
@@ -21,10 +16,9 @@ module Spree
 
         # What the customer paid for the units coming back, after discounts
         # and with their tax.
-        attributes original_price: :string
+        money_attributes :original_price
         # The replacement at the same discount, with its own tax.
-        attributes new_variant_price: :string, price_difference: :string, original_tax_total: :string,
-                   new_tax_total: :string
+        money_attributes :new_variant_price, :price_difference, :original_tax_total, :new_tax_total
         prefixed_id_attributes :original_variant, :new_variant, :line_item, :fulfillment_item
 
         one :original_variant, resource: proc { Spree.api.variant_serializer }, if: proc { expand?('original_variant') }

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

@@ -9,8 +9,6 @@ module Spree
                  status: [:string, enum: Spree::Exchange.statuses, enum_type_name: 'ExchangeStatus'],
                  order_id: [:string, nullable: true],
                  reason_id: [:string, nullable: true],
-                 price_difference: :string,
-                 display_price_difference: :string,
                  approved_at: [:string, nullable: true],
                  received_at: [:string, nullable: true],
                  fulfilled_at: [:string, nullable: true],
@@ -20,7 +18,8 @@ module Spree
 
         prefixed_id_attributes :order, :reason
 
-        attributes price_difference: :string, display_price_difference: :string
+        money_attributes :price_difference, :display_price_difference
+
         attribute :approved_at do |exchange|
           exchange.approved_at&.iso8601
         end

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

@@ -0,0 +1,28 @@
+module Spree
+  module Api
+    module V3
+      # A file accepted by an upload endpoint ({Spree::FileUpload}).
+      #
+      # `signed_id` is opaque: clients pass it back unchanged to the endpoint
+      # that uses the file and never parse it. It stops being attachable at
+      # `expires_at`. `upload` is where a presigned upload sends its bytes, and
+      # null once the file is already stored.
+      class FileUploadSerializer < BaseSerializer
+        # A value object, not a record — it has no id of its own.
+        _attributes.delete(:id)
+
+        typelize signed_id: :string,
+                 filename: :string,
+                 content_type: :string,
+                 byte_size: :number,
+                 visibility: [:string, enum: Spree::FileUpload::VISIBILITIES],
+                 expires_at: :string,
+                 upload: [:FileUploadTarget, nullable: true]
+
+        attributes :signed_id, :filename, :content_type, :byte_size, :visibility, expires_at: :iso8601
+
+        one :upload_target, key: :upload, resource: proc { Spree.api.file_upload_target_serializer }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Spree
+  module Api
+    module V3
+      # Where a presigned upload sends its bytes. Clients send them with
+      # `method` to `url` carrying exactly `headers`, and treat all three as
+      # opaque: the storage service decides them.
+      class FileUploadTargetSerializer < BaseSerializer
+        _attributes.delete(:id)
+
+        typelize method: :string, url: :string, headers: 'Record<string, string>'
+
+        attribute :method, &:http_method
+        attributes :url, :headers
+      end
+    end
+  end
+end

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

@@ -4,16 +4,14 @@ module Spree
   module Api
     module V3
       class GiftCardBatchSerializer < BaseSerializer
-        typelize codes_count: :number, amount: [:string, nullable: true], currency: [:string, nullable: true],
+        typelize codes_count: :number, currency: [:string, nullable: true, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                  prefix: [:string, nullable: true], expires_at: [:string, nullable: true],
                  created_by_id: [:string, nullable: true]
 
         attributes :codes_count, :currency, :prefix,
                    created_at: :iso8601, updated_at: :iso8601
 
-        attribute :amount do |batch|
-          batch.amount&.to_s
-        end
+        money_attributes :amount
 
         attribute :expires_at do |batch|
           batch.expires_at&.iso8601

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

@@ -4,8 +4,10 @@ module Spree
       class GiftCardSerializer < BaseSerializer
         typelize code: :string,
                  status: [:string, enum: Spree::GiftCard::DISPLAY_STATUSES, enum_type_name: 'GiftCardStatus'],
-                 display_amount: [:string, nullable: true], display_amount_used: [:string, nullable: true],
-                 display_amount_remaining: [:string, nullable: true], currency: :string,
+                 display_amount: display_money_type(:display_amount),
+                 display_amount_used: display_money_type(:display_amount_used),
+                 display_amount_remaining: display_money_type(:display_amount_remaining),
+                 currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                  expires_at: [:string, nullable: true], redeemed_at: [:string, nullable: true], expired: :boolean,
                  active: :boolean
 

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

@@ -6,7 +6,6 @@ module Spree
       class ImportSerializer < BaseSerializer
         typelize number: :string,
                  type: [:string, nullable: true, comment: 'Import type. Built-in: products, product_translations, customers, price_list_prices. Extensions may register more.'], status: [:string, enum: Spree::Import.statuses, enum_type_name: 'ImportStatus'],
-                 owner_type: [:string, nullable: true], owner_id: [:string, nullable: true],
                  store_id: [:string, nullable: true], seller_id: [:string, nullable: true],
                  user_id: [:string, nullable: true], rows_count: :number
 
@@ -26,17 +25,6 @@ module Spree
         # whose it is. A null `seller_id` means the operator's own.
         prefixed_id_attributes :store, :seller
 
-        # @deprecated Read `store_id` / `seller_id` — removed in 6.1. Emitted
-        #   from the pair above rather than the dropped columns, so a client
-        #   still reading them sees the same answer.
-        attribute :owner_type do |import|
-          Spree::Base.polymorphic_api_type(import.seller_id.present? ? 'Spree::Seller' : 'Spree::Store')
-        end
-
-        attribute :owner_id do |import|
-          (import.seller || import.store)&.prefixed_id
-        end
-
         prefixed_id_attributes :user
       end
     end

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

@@ -2,8 +2,8 @@ module Spree
   module Api
     module V3
       class LineItemSerializer < BaseSerializer
-        typelize variant_id: :string, quantity: :number, currency: :string, name: :string, slug: :string,
-                 options_text: :string, compare_at_amount: [:string, nullable: true],
+        typelize variant_id: :string, quantity: :number, currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'], name: :string, slug: :string,
+                 options_text: :string, compare_at_amount: [:string, nullable: true, comment: 'The compare-at price times quantity, or null when the variant has none.'],
                  thumbnail_url: [:string, nullable: true], preorder: :boolean,
                  preorder_ships_at: [:string, nullable: true], seller_id: [:string, nullable: true]
 
@@ -30,21 +30,31 @@ module Spree
 
         # Nulled for gated (prices_hidden) guests so the cart's line items can't
         # leak the prices that product/variant serializers already withhold.
-        money_attributes :price, :display_price, :total, :display_total,
+        money_attributes :price, :display_price, unit_price: true, descriptions: { price: 'The price of one unit.' }
+        money_attributes :total, :display_total,
                          :adjustment_total, :display_adjustment_total,
                          :additional_tax_total, :display_additional_tax_total,
                          :included_tax_total, :display_included_tax_total,
                          :discount_total, :display_discount_total,
                          :pre_tax_amount, :display_pre_tax_amount,
                          :discounted_amount, :display_discounted_amount,
-                         :display_compare_at_amount
+                         :display_compare_at_amount,
+                         descriptions: {
+                           total: 'What this line costs: price times quantity, with its discounts, fees and added tax.',
+                           adjustment_total: "This line's discounts, fees and added tax together.",
+                           additional_tax_total: 'Tax added on top of the price.',
+                           included_tax_total: 'Tax already included in the price.',
+                           discount_total: 'What promotions take off this line, as a negative amount.',
+                           pre_tax_amount: 'This line after discounts, without tax.',
+                           discounted_amount: 'Price times quantity, after discounts.'
+                         }
 
         # Return compare_at_amount as string, nil if zero
         attribute :compare_at_amount do |line_item|
           next nil if params[:hide_prices]
 
           amount = line_item.compare_at_amount
-          amount.present? && amount.positive? ? amount.to_s : nil
+          amount.present? && amount.positive? ? Spree::Money::Rounding.format(amount, line_item.currency, unit_price: true) : nil
         end
 
         # Thumbnail URL for line item (variant thumbnail or product thumbnail)

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

@@ -7,7 +7,9 @@ module Spree
         include Alba::Resource
         include Typelizer::DSL
 
-        typelize code: :string, name: :string, default: :boolean, rtl: :boolean
+        typelize code: [:string, enum: Spree::Locales::ALL, enum_type_name: 'LocaleCode'],
+                 name: [:string, deprecated: 'Name the locale from `code` with `Intl.DisplayNames`. Removed in 6.1.'],
+                 default: :boolean, rtl: :boolean
 
         attributes :code, :name
 

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

@@ -2,11 +2,11 @@ module Spree
   module Api
     module V3
       class MarketSerializer < BaseSerializer
-        typelize name: :string, currency: :string,
-                 default_locale: :string,
-                 supported_locales: [:string, multi: true],
-                 country_codes: [:string, multi: true],
-                 country_isos: [:string, multi: true],
+        typelize name: :string, currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
+                 default_locale: [:string, enum: Spree::Locales::ALL, enum_type_name: 'LocaleCode'],
+                 supported_locales: [:string, multi: true, enum: Spree::Locales::ALL, enum_type_name: 'LocaleCode'],
+                 country_codes: [:string, multi: true, enum: Spree::IsoData.country_codes, enum_type_name: 'CountryCode'],
+                 country_isos: [:string, multi: true, deprecated: 'Use `country_codes`. Removed in 6.1.'],
                  tax_inclusive: :boolean,
                  default: :boolean