spree_api 6.0.0.rc1 → 6.0.0.rc2

data/app/request_schemas/spree/api/v3/tax_identifier_request_schema.rb

@@ -0,0 +1,18 @@
+module Spree
+  module Api
+    module V3
+      # A tax registration. Each endpoint publishes it under its own name
+      # (`TaxIdentifierParams`, `SellerTaxIdentifierParams`). `kind` is
+      # registry-driven, so a plain string: any kind is stored, and one with a
+      # validator in Spree.tax_identifier_validators is checked by it.
+      class TaxIdentifierRequestSchema < Spree::Api::V3::RequestSchema
+        KIND_DESCRIPTION = 'The registration the number belongs to, such as `eu_vat` or `gb_vat`. ' \
+                           'Any kind is accepted; one with a registered validator is checked by it. ' \
+                           'Built-in: `eu_vat`. Extensions may register more.'.freeze
+
+        attribute :kind, :string, required: true, example: 'eu_vat', description: KIND_DESCRIPTION
+        attribute :value, :string, required: true, example: 'DE123456789'
+      end
+    end
+  end
+end

data/app/request_schemas/spree/api/v3/variant_option_request_schema.rb

@@ -0,0 +1,13 @@
+module Spree
+  module Api
+    module V3
+      # One option pair of a variant, such as size Small. Option types and values are created when missing.
+      class VariantOptionRequestSchema < Spree::Api::V3::RequestSchema
+        publishes 'VariantOptionParams'
+
+        attribute :name, :string, required: true, example: 'size'
+        attribute :value, :string, required: true, example: 'Small'
+      end
+    end
+  end
+end

data/app/request_schemas/spree/api/v3/variant_request_schema.rb

@@ -0,0 +1,52 @@
+module Spree
+  module Api
+    module V3
+      # A variant's own attributes, shared by the variant endpoints and the
+      # variants nested in a product payload. Not published on its own: each
+      # endpoint includes these fields into its own type.
+      class VariantRequestSchema < Spree::Api::V3::RequestSchema
+        attribute :sku, :string
+        attribute :barcode, :string
+        attribute :cost_price, :decimal, nullable: true
+        attribute :cost_currency, :currency
+        attribute :weight, :number, nullable: true
+        attribute :height, :number, nullable: true
+        attribute :width, :number, nullable: true
+        attribute :depth, :number, nullable: true
+        attribute :weight_unit, :string, choices: Spree::Variant::WEIGHT_UNITS
+        attribute :dimensions_unit, :string, choices: Spree::Variant::DIMENSION_UNITS
+        attribute :hs_code, :string
+        attribute :customs_description, :string
+        attribute :country_of_origin, :country
+        attribute :minimum_order_quantity, :integer, nullable: true
+        attribute :order_multiple, :integer, nullable: true
+        attribute :purchase_unit, :string
+        attribute :units_per_carton, :integer, nullable: true, description: 'How many units fill one carton.'
+        attribute :carton_package_type_id, :id,
+          nullable: true,
+          description: 'The carton this variant is packed into: a package type of kind `carton`. Its dimensions are shared by every product packed the same way, so a corrected carton size fixes all of them at once.'
+        attribute :carton_weight, :number,
+          nullable: true,
+          description: "What one packed carton weighs, in the variant's weight unit."
+        attribute :cartons_per_pallet, :integer, nullable: true, description: 'How many cartons stack on one pallet.'
+        attribute :seller_id, :id
+        attribute :delivery_profile_id, :id, nullable: true
+        attribute :track_inventory, :boolean
+        attribute :preorderable, :boolean,
+          description: "Sell this variant before it's in stock. Adds the pre-order label and ships-by promise; the cap comes from `backorder_limit`, an incoming stock count, or backorder."
+        attribute :preorder_ships_at, :datetime,
+          nullable: true,
+          description: 'The "ships by" date shown to customers while the variant is a pre-order. Once it passes, the variant is no longer a pre-order. Null clears it.'
+        attribute :backorder_limit, :integer,
+          nullable: true,
+          description: 'Maximum units sellable beyond available stock, capping backorders and pre-orders. Null is unlimited.'
+        attribute :tax_category_id, :id
+        attribute :position, :integer
+        attribute :prices, :array, of: Spree::Api::V3::PriceRequestSchema,
+          description: 'Per-currency prices. Upserted by currency.'
+        attribute :stock_levels, :array, of: Spree::Api::V3::StockLevelRequestSchema,
+          description: 'Stock per location. Upserted by location; omitted locations are removed.'
+      end
+    end
+  end
+end

data/app/serializers/concerns/spree/api/v3/purchase_summary.rb

@@ -0,0 +1,48 @@
+module Spree
+  module Api
+    module V3
+      # The money summary a cart, an order and a multi-seller purchase all
+      # carry, declared once so a storefront renders any of them with one
+      # component, and a fix to one is a fix to all three.
+      #
+      # Every amount is nulled for a guest the storefront hides prices from,
+      # the payments' own included.
+      module PurchaseSummary
+        extend ActiveSupport::Concern
+
+        included do
+          typelize covered_by_store_credit: :boolean
+
+          money_attributes :item_total, :display_item_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,
+                           :delivery_total, :display_delivery_total,
+                           :fee_total, :display_fee_total,
+                           :gift_card_total, :display_gift_card_total,
+                           :store_credit_total, :display_store_credit_total,
+                           :total, :display_total,
+                           :amount_due, :display_amount_due,
+                           descriptions: {
+                             item_total: 'The line items: each price times its quantity, before discounts, fees and delivery.',
+                             discount_total: 'What promotions take off, as a negative amount. Manual discounts are not included.',
+                             tax_total: 'All tax, both included in prices and added on top.',
+                             included_tax_total: 'Tax already included in the prices, as in a store whose prices are tax-inclusive.',
+                             additional_tax_total: 'Tax added on top of the prices.',
+                             delivery_total: 'What delivery costs, before delivery discounts.',
+                             fee_total: 'Every fee charged, such as handling or a customs duty.',
+                             gift_card_total: 'What a gift card pays.',
+                             store_credit_total: 'What store credit pays, apart from gift cards.',
+                             total: 'What the customer pays in all: items, delivery, fees and added tax, less discounts.',
+                             amount_due: 'What is left to pay after payments and store credit.'
+                           }
+
+          attribute :covered_by_store_credit, &:covered_by_store_credit?
+
+          many :payments, resource: proc { Spree.api.payment_serializer }
+        end
+      end
+    end
+  end
+end

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

@@ -6,8 +6,10 @@ module Spree
                  address1: [:string, nullable: true], address2: [:string, nullable: true],
                  city: [:string, nullable: true], postal_code: [:string, nullable: true], phone: [:string, nullable: true],
                  company: [:string, nullable: true], state_code: [:string, nullable: true],
-                 state_abbr: [:string, nullable: true], state_name: [:string, nullable: true],
-                 state_text: [:string, nullable: true], country_code: :string, country_iso: :string,
+                 state_abbr: [:string, nullable: true, deprecated: 'Use `state_code`. Removed in 6.1.'],
+                 state_name: [:string, nullable: true],
+                 state_text: [:string, nullable: true], country_code: [:string, enum: Spree::IsoData.country_codes, enum_type_name: 'CountryCode'],
+                 country_iso: [:string, deprecated: 'Use `country_code`. Removed in 6.1.'],
                  country_name: :string,
                  quick_checkout: :boolean, is_default_billing: :boolean, is_default_shipping: :boolean,
                  label: [:string, nullable: true]

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

@@ -3,6 +3,9 @@ module Spree
     module V3
       module Admin
         class AddressSerializer < V3::AddressSerializer
+          # The Store API keeps these deprecated names until 6.1.
+          %i[state_abbr country_iso].each { |key| _attributes.delete(key) }
+
           typelize customer_id: [:string, nullable: true],
                    owner_id: [:string, nullable: true],
                    owner_type: [:string, nullable: true],

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

@@ -3,9 +3,11 @@ module Spree
     module V3
       module Admin
         class AppliedPromotionSerializer < V3::AppliedPromotionSerializer
+          without_formatted_money
+
           # The Admin API has no guest gating — money fields inherited from the
           # store serializer are always present, so override their nullability.
-          typelize amount: [:string, nullable: false], display_amount: [:string, nullable: false]
+          typelize amount: [:string, nullable: false]
 
           attributes created_at: :iso8601, updated_at: :iso8601
         end

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

@@ -12,7 +12,9 @@ module Spree
         # are redeclared with admin counterparts — admin serializers never
         # reference store serializers.
         class CartSerializer < V3::CartSerializer
-          %i[fulfillments payments payment_methods gift_card discounts fees].each { |key| _attributes.delete(key) }
+          without_formatted_money
+
+          %i[fulfillments payments payment_methods gift_card discounts fees number].each { |key| _attributes.delete(key) }
 
           typelize completed_at: [:string, nullable: true]
 

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

@@ -5,11 +5,12 @@ module Spree
         # The least a whole order must come to under a catalog's agreement,
         # in one currency.
         class CatalogOrderMinimumSerializer < V3::BaseSerializer
-          typelize currency: :string, amount: :string, display_amount: :string
+          typelize currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode']
 
           attributes :currency, created_at: :iso8601, updated_at: :iso8601
 
-          attributes amount: :string, display_amount: :string
+          money_attributes :amount
+          typelize amount: [:string, nullable: false]
         end
       end
     end

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

@@ -17,8 +17,7 @@ module Spree
           _attributes.delete(:id)
 
           typelize id: 'string | null', label: 'string | null', sku: 'string | null',
-                   amount: :string, display_amount: :string,
-                   currency: :string, source: [:string, enum: Spree::CatalogPrice::SOURCES], break_count: :number
+                   currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'], source: [:string, enum: Spree::CatalogPrice::SOURCES], break_count: :number
 
           # The variant this prices, so a row can name what it is showing —
           # a product's variants can be priced differently, and one figure
@@ -33,9 +32,9 @@ module Spree
           # though it were the only one.
           attributes :currency, :source, :break_count
 
-          attribute :amount, &:display_value
+          money_attributes :amount, unit_price: true
+          typelize amount: [:string, nullable: false]
 
-          attributes :display_amount
 
           # The ladder itself, so the agreement page can show what a buyer
           # pays at each threshold without opening the price sheet

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

@@ -11,11 +11,12 @@ module Spree
         class CatalogPriceTierSerializer < V3::BaseSerializer
           _attributes.delete(:id)
 
-          typelize min_quantity: :number, amount: :string, display_amount: :string
+          typelize min_quantity: :number
 
-          attributes :min_quantity, :display_amount
+          attributes :min_quantity
 
-          attribute :amount, &:display_value
+          money_attributes :amount, unit_price: true
+          typelize amount: [:string, nullable: false]
         end
       end
     end

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

@@ -4,17 +4,15 @@ module Spree
       module Admin
         class ChannelSerializer < V3::ChannelSerializer
           typelize store_id: :string,
-                   preferred_order_routing_strategy: [:string, nullable: true, comment: 'Order routing strategy; null inherits the store setting. Built-in: rules. Extensions may register more.'],
-                   preferred_storefront_access: [:string, nullable: true],
-                   preferred_guest_checkout: [:boolean, nullable: true],
+                   order_routing_strategy: [:string, nullable: true, comment: 'Order routing strategy; null inherits the store setting. Built-in: rules. Extensions may register more.'],
                    stock_location_ids: [:string, multi: true],
                    default_catalog_id: [:string, nullable: true]
 
-          attributes :preferred_storefront_access,
-                     :preferred_guest_checkout,
-                     created_at: :iso8601, updated_at: :iso8601
+          attributes created_at: :iso8601, updated_at: :iso8601
 
-          api_type_attributes :preferred_order_routing_strategy
+          preference_attributes Spree::Channel, except: %i[order_routing_strategy]
+
+          api_type_attributes :order_routing_strategy
 
           # Fulfillment-origin allowlist; empty means every store location
           # serves this channel.

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

@@ -5,6 +5,13 @@ module Spree
     module V3
       module Admin
         class ClaimLineItemSerializer < V3::ClaimLineItemSerializer
+          without_formatted_money
+
+          # No guest price gating here, so the inherited money fields are always present.
+          typelize refund_amount: [:string, nullable: false], paid_amount: [:string, nullable: false],
+                   pre_tax_amount: [:string, nullable: false], included_tax_total: [:string, nullable: false],
+                   additional_tax_total: [:string, nullable: false], tax_total: [:string, nullable: false]
+
           attributes created_at: :iso8601, updated_at: :iso8601
 
           one :variant, resource: proc { Spree.api.admin_variant_serializer }, if: proc { expand?('variant') }

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

@@ -5,6 +5,11 @@ module Spree
     module V3
       module Admin
         class ClaimSerializer < V3::ClaimSerializer
+          without_formatted_money
+
+          # No guest price gating here, so the inherited money fields are always present.
+          typelize refund_total: [:string, nullable: false]
+
           typelize memo: [:string, nullable: true],
                    metadata: 'Record<string, unknown>',
                    created_by_id: [:string, nullable: true],

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

@@ -20,18 +20,10 @@ module Spree
                    fulfillment_id: 'string | null',
                    commission_rate_id: 'string | null',
                    kind: [:string, enum: Spree::CommissionRate::KINDS],
-                   rate: :string,
-                   tax_rate: :string,
                    taxability_reason: 'string | null',
-                   country_code: 'string | null',
+                   country_code: [:string, nullable: true, enum: Spree::IsoData.country_codes, enum_type_name: 'CountryCode'],
                    state_code: 'string | null',
-                   amount: :string,
-                   tax_amount: :string,
-                   total: :string,
-                   currency: :string,
-                   display_amount: :string,
-                   display_tax_amount: :string,
-                   display_total: :string
+                   currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode']
 
           # The treatment, in Spree::TaxLine's vocabulary — a seller's invoice
           # has to explain why its fee was taxed the way it was, and the
@@ -39,14 +31,11 @@ module Spree
           attributes :kind, :currency, :taxability_reason, :country_code, :state_code,
                      created_at: :iso8601, updated_at: :iso8601
 
-          # Strings, so the figures a seller is invoiced round-trip exactly.
-          %i[rate tax_rate amount tax_amount total].each do |decimal|
-            attribute(decimal) { |line| line.public_send(decimal)&.to_s }
-          end
-
-          %i[display_amount display_tax_amount display_total].each do |formatted|
-            attribute(formatted) { |line| line.public_send(formatted).to_s }
-          end
+          rate_attributes :rate, :tax_rate
+          money_attributes :amount, :tax_amount, :total
+          typelize rate: [:string, nullable: false], tax_rate: [:string, nullable: false],
+                   amount: [:string, nullable: false], tax_amount: [:string, nullable: false],
+                   total: [:string, nullable: false]
 
           %i[order seller line_item fulfillment commission_rate].each do |association|
             attribute(:"#{association}_id") { |line| line.public_send(association)&.prefixed_id }

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

@@ -10,21 +10,16 @@ module Spree
         # were actually charged (Spree::CommissionLine) on their own branch,
         # never the rules that produced it.
         class CommissionRateSerializer < V3::BaseSerializer
-          # Decimals serialize as strings, like every other money-ish field on
-          # the admin API: a rate has to round-trip exactly, and a float does
-          # not promise that.
           typelize name: :string,
                    code: 'string | null',
                    enabled: :boolean,
                    position: :number,
                    global: :boolean,
                    kind: [:string, enum: Spree::CommissionRate::KINDS],
-                   value: :string,
                    amounts: 'Record<string, string>',
                    bounds: 'Record<string, { min_amount: string | null; max_amount: string | null }>',
                    tax_inclusive: :boolean,
                    include_shipping: :boolean,
-                   commission_tax_rate: 'string | null',
                    metadata: 'Record<string, unknown> | null',
                    deleted_at: 'string | null'
 
@@ -32,22 +27,23 @@ module Spree
                      :tax_inclusive, :include_shipping, :metadata,
                      deleted_at: :iso8601, created_at: :iso8601, updated_at: :iso8601
 
-          %i[value commission_tax_rate].each do |decimal|
-            attribute(decimal) { |rate| rate.public_send(decimal)&.to_s }
-          end
+          # +value+ is the percentage a percentage rate charges; a flat fee's
+          # money lives in +amounts+, per currency.
+          rate_attributes :value, :commission_tax_rate
+          typelize value: [:string, nullable: false]
 
           # What a flat fee charges, per currency. Empty on a percentage rate,
           # which needs no amount of its own.
           attribute :amounts do |rate|
-            rate.amounts.transform_values(&:to_s)
+            rate.amounts.to_h { |currency, amount| [currency, Spree::Money::Rounding.format(amount, currency)] }
           end
 
           # The floor and cap a percentage charges within, per currency. Each
           # holds only in its own currency, so a rate may bound some and leave
           # others unbounded.
           attribute :bounds do |rate|
-            rate.bounds.transform_values do |bound|
-              bound.transform_values { |amount| amount&.to_s }
+            rate.bounds.to_h do |currency, bound|
+              [currency, bound.transform_values { |amount| Spree::Money::Rounding.format(amount, currency) }]
             end
           end
 

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

@@ -13,7 +13,6 @@ module Spree
           typelize type: [:string, comment: 'Rule type. Built-in: seller_rule, category_rule, product_rule, item_total_rule. Extensions may register more.'],
                    commission_rate_id: :string,
                    preferences: 'Record<string, unknown>',
-                   preference_schema: 'Array<{ key: string; type: string; default: unknown }>',
                    product_ids: 'Array<string> | null',
                    seller_ids: 'Array<string> | null',
                    category_ids: 'Array<string> | null'
@@ -27,7 +26,6 @@ module Spree
           prefixed_id_attributes :commission_rate
 
           attribute :preferences, &:serialized_preferences
-          attribute :preference_schema, &:serialized_preference_schema
 
           # Reference lists are returned as prefixed IDs to match the rest of
           # the API. Product ids are read through a join table; seller and

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

@@ -4,7 +4,11 @@ module Spree
       module Admin
         # No timestamps: countries are reference data supplied by the countries
         # gem rather than records, so they have no created_at/updated_at.
+        # The dashboard names countries with Intl.DisplayNames in the admin's
+        # own language, so the Admin API sends the ISO code alone.
         class CountrySerializer < V3::CountrySerializer
+          _attributes.delete(:name)
+
           many :states,
                resource: proc { Spree.api.admin_state_serializer },
                if: proc { params[:expand]&.include?('states') }

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

@@ -5,13 +5,14 @@ module Spree
         # Admin API Customer Serializer
         # Full customer data including admin-only fields
         class CustomerSerializer < V3::CustomerSerializer
+          without_formatted_money
+
           typelize failed_attempts: :number,
                    tags: [:string, multi: true],
                    internal_note: [:string, nullable: true], internal_note_html: [:string, nullable: true],
                    metadata: 'Record<string, unknown>',
                    orders_count: :number,
                    total_spent: :string,
-                   display_total_spent: :string,
                    last_order_completed_at: [:string, nullable: true],
                    default_billing_address_id: [:string, nullable: true],
                    default_shipping_address_id: [:string, nullable: true],
@@ -53,13 +54,8 @@ module Spree
           end
 
           attribute :total_spent do |user|
-            (user.attributes['total_spent'] || user.orders.complete.sum(:total)).to_s
-          end
-
-          attribute :display_total_spent do |user|
             amount = user.attributes['total_spent'] || user.orders.complete.sum(:total)
-            currency = Spree::Current.currency || Spree::Current.store&.default_currency
-            Spree::Money.new(amount, currency: currency).to_s
+            Spree::Money::Rounding.format(amount, (current_store || Spree::Current.store)&.default_currency)
           end
 
           attribute :last_order_completed_at do |user|

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

@@ -6,7 +6,6 @@ module Spree
           typelize type: [:string, comment: 'Rule type. Built-in: item_total_rule, weight_rule, excluded_products_rule, channel_rule, volume_rule, company_rule. Extensions may register more.'],
                    active: :boolean,
                    preferences: 'Record<string, unknown>',
-                   preference_schema: "Array<{ key: string; type: string; default: unknown; choices?: string[] }>",
                    product_ids: [:string, multi: true]
 
           attributes :active, created_at: :iso8601, updated_at: :iso8601
@@ -18,7 +17,6 @@ module Spree
           end
 
           attribute :preferences, &:serialized_preferences
-          attribute :preference_schema, &:serialized_preference_schema
 
           # Association-backed config (ExcludedProductsRule); empty for
           # preference-only rules. Same name read and written.

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

@@ -13,18 +13,25 @@ module Spree
                    delivery_origin_group_id: [:string, nullable: true],
                    delivery_zone_id: [:string, nullable: true],
                    stock_location_ids: [:string, multi: true],
-                   calculator_type: [:string, nullable: true],
-                   calculator_preferences: ['Record<string, unknown>', nullable: true],
+                   calculator: 'TypedDeliveryCalculator | null',
                    markup_flat: [:string, nullable: true],
                    markup_percent: [:string, nullable: true],
                    available_to_sellers: :boolean,
                    seller_id: [:string, nullable: true],
                    seller_name: [:string, nullable: true]
 
-          attributes :admin_name, :storefront_visible, :tracking_url,
-                     :markup_flat, :markup_percent, :available_to_sellers,
+          attributes :admin_name, :storefront_visible, :tracking_url, :available_to_sellers,
                      created_at: :iso8601, updated_at: :iso8601, deleted_at: :iso8601
 
+          # The flat markup is charged in whatever currency the rate is quoted
+          # in, so it is shown as stored rather than rounded to one currency:
+          # a rounded figure would be saved back.
+          attribute :markup_flat do |record|
+            Spree::Money::Rounding.format(record.markup_flat, (current_store || Spree::Current.store)&.default_currency, unit_price: true)
+          end
+
+          rate_attributes :markup_percent
+
           # Which seller runs this method, so the operator's list can say
           # whose it is. Null is the marketplace's own
           # (docs/plans/6.0-multi-vendor-marketplace.md, Decision 13).
@@ -48,12 +55,9 @@ module Spree
 
           api_type_attributes :fulfillment_provider, :pickup_point_provider, :rate_provider
 
-          attribute :calculator_type do |record|
-            record.calculator&.class&.api_type
-          end
-
-          attribute :calculator_preferences do |record|
-            record.calculator.respond_to?(:serialized_preferences) ? record.calculator.serialized_preferences : record.calculator&.preferences
+          attribute :calculator do |record|
+            calculator = record.calculator
+            { type: calculator.class.api_type, preferences: calculator.serialized_preferences } if calculator
           end
         end
       end

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

@@ -7,7 +7,15 @@ module Spree
                    markup_flat: [:string, nullable: true], markup_percent: [:string, nullable: true],
                    position: :number
 
-          attributes :carrier, :service, :label, :markup_flat, :markup_percent, :position
+          attributes :carrier, :service, :label
+
+          attribute :markup_flat do |record|
+            Spree::Money::Rounding.format(record.markup_flat, (current_store || Spree::Current.store)&.default_currency, unit_price: true)
+          end
+
+          rate_attributes :markup_percent
+
+          attributes :position
         end
       end
     end

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

@@ -3,6 +3,14 @@ module Spree
     module V3
       module Admin
         class DeliveryRateSerializer < V3::DeliveryRateSerializer
+          without_formatted_money
+
+          # No guest price gating here, so the inherited money fields are always present.
+          typelize cost: [:string, nullable: false],
+                   total: [:string, nullable: false],
+                   additional_tax_total: [:string, nullable: false],
+                   included_tax_total: [:string, nullable: false], tax_total: [:string, nullable: false]
+
           typelize metadata: ['Record<string, unknown>', nullable: true]
 
           # Raw carrier payload (quote ids, service codes) — operational

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

@@ -3,7 +3,9 @@ module Spree
     module V3
       module Admin
         class DiscountSerializer < V3::DiscountSerializer
-          typelize amount: [:string, nullable: false], display_amount: [:string, nullable: false],
+          without_formatted_money
+
+          typelize amount: [:string, nullable: false],
                    metadata: ['Record<string, unknown>', nullable: true]
 
           attributes :metadata, created_at: :iso8601, updated_at: :iso8601

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

@@ -5,6 +5,11 @@ module Spree
     module V3
       module Admin
         class ExchangeLineItemSerializer < V3::ExchangeLineItemSerializer
+          # No guest price gating here, so the inherited money fields are always present.
+          typelize original_price: [:string, nullable: false], new_variant_price: [:string, nullable: false],
+                   price_difference: [:string, nullable: false], original_tax_total: [:string, nullable: false],
+                   new_tax_total: [:string, nullable: false]
+
           attributes created_at: :iso8601, updated_at: :iso8601
 
           one :original_variant, resource: proc { Spree.api.admin_variant_serializer }, if: proc { expand?('original_variant') }

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

@@ -5,6 +5,11 @@ module Spree
     module V3
       module Admin
         class ExchangeSerializer < V3::ExchangeSerializer
+          without_formatted_money
+
+          # No guest price gating here, so the inherited money fields are always present.
+          typelize price_difference: [:string, nullable: false]
+
           typelize memo: [:string, nullable: true],
                    metadata: 'Record<string, unknown>',
                    stock_location_id: [:string, nullable: true],

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

@@ -3,7 +3,9 @@ module Spree
     module V3
       module Admin
         class FeeSerializer < V3::FeeSerializer
-          typelize amount: [:string, nullable: false], display_amount: [:string, nullable: false],
+          without_formatted_money
+
+          typelize amount: [:string, nullable: false],
                    metadata: ['Record<string, unknown>', nullable: true]
 
           attributes :metadata, created_at: :iso8601, updated_at: :iso8601

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

@@ -0,0 +1,11 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        class FileUploadSerializer < V3::FileUploadSerializer
+          one :upload_target, key: :upload, resource: proc { Spree.api.admin_file_upload_target_serializer }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        class FileUploadTargetSerializer < V3::FileUploadTargetSerializer
+        end
+      end
+    end
+  end
+end