spree_api 5.5.3 → 5.6.0.rc1

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

@@ -3,6 +3,15 @@ module Spree
     module V3
       module Admin
         class FulfillmentSerializer < V3::FulfillmentSerializer
+          # The Admin API has no guest gating — money fields inherited from the
+          # store serializer are always present, so override their nullability.
+          typelize cost: [:string, nullable: false], display_cost: [:string, nullable: false],
+                   total: [:string, nullable: false], display_total: [:string, nullable: false],
+                   discount_total: [:string, nullable: false], display_discount_total: [:string, nullable: false],
+                   additional_tax_total: [:string, nullable: false], display_additional_tax_total: [:string, nullable: false],
+                   included_tax_total: [:string, nullable: false], display_included_tax_total: [:string, nullable: false],
+                   tax_total: [:string, nullable: false], display_tax_total: [:string, nullable: false]
+
           typelize metadata: 'Record<string, unknown>',
                    order_id: [:string, nullable: true],
                    stock_location_id: [:string, nullable: true],

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

@@ -6,6 +6,13 @@ module Spree
         # context the admin UI needs: who the card was issued to (customer),
         # who issued it (admin), and the orders that consumed it.
         class GiftCardSerializer < V3::GiftCardSerializer
+          # 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], amount_used: [:string, nullable: false],
+                   amount_authorized: [:string, nullable: false], amount_remaining: [:string, nullable: false],
+                   display_amount: [:string, nullable: false], display_amount_used: [:string, nullable: false],
+                   display_amount_remaining: [:string, nullable: false]
+
           typelize customer_id: [:string, nullable: true],
                    created_by_id: [:string, nullable: true]
 

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

@@ -0,0 +1,20 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Admin API serializer for {Spree::ImportMapping}. The
+        # `complete_mapping` endpoint accepts exactly these attribute names
+        # back (read/write symmetry).
+        class ImportMappingSerializer < V3::BaseSerializer
+          typelize schema_field: :string,
+                   file_column: [:string, nullable: true],
+                   required: :boolean
+
+          attributes :schema_field, :file_column
+
+          attribute :required, &:required?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Admin API serializer for {Spree::ImportRow}. Adds the raw CSV row
+        # (`data`) so the failure report can show the offending values.
+        class ImportRowSerializer < V3::ImportRowSerializer
+          typelize data: 'Record<string, string | null>'
+
+          attribute :data do |row|
+            row.data_json
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Admin API serializer for {Spree::Import} — drives the SPA import
+        # wizard: mapping payload while `mapping`, poll counters afterwards.
+        class ImportSerializer < V3::ImportSerializer
+          typelize completed_rows_count: :number,
+                   failed_rows_count: :number,
+                   processing_errors: [:string, nullable: true],
+                   preferred_delimiter: :string,
+                   schema_fields: 'Array<{ name: string; label: string; required: boolean }>',
+                   csv_headers: [:string, multi: true],
+                   sample_row: 'Record<string, string | null>',
+                   original_filename: [:string, nullable: true],
+                   original_byte_size: [:number, nullable: true],
+                   original_file_url: [:string, nullable: true]
+
+          attributes :processing_errors, :preferred_delimiter
+
+          # The originally uploaded file — the audit trail. `original_file_url`
+          # is our own streaming endpoint (JWT-authenticated), not a signed
+          # ActiveStorage URL; see ExportSerializer#download_url.
+          attribute :original_filename do |import|
+            import.attachment.blob&.filename&.to_s if import.attachment.attached?
+          end
+
+          attribute :original_byte_size do |import|
+            import.attachment.blob&.byte_size if import.attachment.attached?
+          end
+
+          attribute :original_file_url do |import|
+            next nil unless import.attachment.attached?
+
+            Spree::Core::Engine.routes.url_helpers.download_api_v3_admin_import_path(
+              id: import.prefixed_id
+            )
+          end
+
+          attribute :completed_rows_count do |import|
+            import.rows_status_counts['completed'] || 0
+          end
+
+          attribute :failed_rows_count do |import|
+            import.rows_status_counts['failed'] || 0
+          end
+
+          attribute :schema_fields do |import|
+            import.schema_fields.map do |field|
+              { name: field[:name], label: field[:label], required: field[:required].present? }
+            end
+          end
+
+          # Mapping-state only: these read the attached blob, which the 2s
+          # processing poll must never do.
+          attribute :csv_headers do |import|
+            import.mapping? ? (import.csv_headers || []) : []
+          end
+
+          attribute :sample_row do |import|
+            import.mapping? ? import.sample_row : {}
+          end
+
+          many :mappings,
+               resource: proc { Spree.api.admin_import_mapping_serializer }
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,17 @@ module Spree
         # Admin API Line Item Serializer
         # Extends the store serializer with metadata visibility
         class LineItemSerializer < V3::LineItemSerializer
+          # The Admin API has no guest gating — money fields inherited from the
+          # store serializer are always present, so override their nullability.
+          typelize price: [:string, nullable: false], display_price: [:string, nullable: false],
+                   total: [:string, nullable: false], display_total: [:string, nullable: false],
+                   adjustment_total: [:string, nullable: false], display_adjustment_total: [:string, nullable: false],
+                   additional_tax_total: [:string, nullable: false], display_additional_tax_total: [:string, nullable: false],
+                   included_tax_total: [:string, nullable: false], display_included_tax_total: [:string, nullable: false],
+                   discount_total: [:string, nullable: false], display_discount_total: [:string, nullable: false],
+                   pre_tax_amount: [:string, nullable: false], display_pre_tax_amount: [:string, nullable: false],
+                   discounted_amount: [:string, nullable: false], display_discounted_amount: [:string, nullable: false]
+
           typelize metadata: 'Record<string, unknown>',
                    cost_price: [:string, nullable: true],
                    tax_category_id: [:string, nullable: true]

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

@@ -3,6 +3,8 @@ module Spree
     module V3
       module Admin
         class OptionTypeSerializer < V3::OptionTypeSerializer
+          include Spree::Api::V3::Admin::Translatable
+
           typelize metadata: 'Record<string, unknown>', filterable: :boolean
 
           attributes :metadata, :filterable,

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

@@ -6,6 +6,20 @@ module Spree
         # Full order data including admin-only fields
         class OrderSerializer < V3::OrderSerializer
 
+          # The Admin API has no guest gating — money fields inherited from the
+          # store serializer are always present, so override their nullability.
+          typelize item_total: [:string, nullable: false], display_item_total: [:string, nullable: false],
+                   delivery_total: [:string, nullable: false], display_delivery_total: [:string, nullable: false],
+                   adjustment_total: [:string, nullable: false], display_adjustment_total: [:string, nullable: false],
+                   discount_total: [:string, nullable: false], display_discount_total: [:string, nullable: false],
+                   tax_total: [:string, nullable: false], display_tax_total: [:string, nullable: false],
+                   included_tax_total: [:string, nullable: false], display_included_tax_total: [:string, nullable: false],
+                   additional_tax_total: [:string, nullable: false], display_additional_tax_total: [:string, nullable: false],
+                   store_credit_total: [:string, nullable: false], display_store_credit_total: [:string, nullable: false],
+                   gift_card_total: [:string, nullable: false], display_gift_card_total: [:string, nullable: false],
+                   total: [:string, nullable: false], display_total: [:string, nullable: false],
+                   amount_due: [:string, nullable: false], display_amount_due: [:string, nullable: false]
+
           typelize status: :string,
                    last_ip_address: [:string, nullable: true],
                    considered_risky: :boolean, confirmation_delivered: :boolean,
@@ -31,7 +45,7 @@ module Spree
           end
 
           attribute :tags do |order|
-            order.tag_list.to_a
+            order.tags.map(&:name) # not pluck as we preload tags
           end
 
           attribute :internal_note do |order|

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

@@ -3,6 +3,10 @@ module Spree
     module V3
       module Admin
         class PaymentSerializer < V3::PaymentSerializer
+          # 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 metadata: 'Record<string, unknown>',
                    captured_amount: :string,
                    order_id: [:string, nullable: true],

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

@@ -6,6 +6,7 @@ module Spree
         # Full product data including admin-only fields
         # Extends the store serializer with additional attributes
         class ProductSerializer < V3::ProductSerializer
+          include Spree::Api::V3::Admin::Translatable
 
           typelize status: :string,
                    tax_category_id: [:string, nullable: true],

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

@@ -78,6 +78,14 @@ module Spree
           many :countries,
                resource: proc { Spree.api.admin_country_serializer },
                if: proc { |rule| rule.respond_to?(:countries) }
+
+          many :channels,
+               resource: Spree.api.admin_channel_serializer,
+               if: proc { |rule| rule.respond_to?(:channels) }
+
+          many :markets,
+               resource: Spree.api.admin_market_serializer,
+               if: proc { |rule| rule.respond_to?(:markets) }
         end
       end
     end

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

@@ -0,0 +1,76 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Serializes a translatable record's translation payload — the locale ×
+        # field matrix, optionally with self-describing discovery +fields+, the
+        # locale envelope, and nested translatable +children+.
+        #
+        # Params select the shape:
+        # - +fields: true+ — include +fields+ (key/type/source) and nested
+        #   +children+ (e.g. an option type's option values). The read endpoint
+        #   (`GET …/:id/translations`) uses this so an editor fetches the whole
+        #   tree in one request.
+        # - +envelope: true+ — include +default_locale+/+supported_locales+ from
+        #   the record's own translatable store (so they can't contradict the
+        #   matrix). The top-level read node and each batch-write echo carry it;
+        #   nested children do not.
+        #
+        # The batch write echo passes +fields: false+ (matrix only); the read
+        # endpoint passes both true at the top level and re-renders children
+        # with +envelope: false+.
+        #
+        # Deliberately does NOT include Typelizer::DSL: the payload is computed
+        # (matrix/fields/children resolve to `unknown`), so the admin-sdk ships
+        # richer hand-written types in `src/types/translations.ts` instead.
+        # Without the DSL, Typelizer never enumerates this serializer.
+        class ResourceTranslationsSerializer
+          include Alba::Resource
+
+          attribute :resource_id, &:prefixed_id
+
+          attribute :resource_type do |record|
+            Spree::Translations.public_resource_type(record.class)
+          end
+
+          attribute :translations do |record|
+            Spree::Translations.matrix_for(record)
+          end
+
+          attribute :fields, if: proc { params[:fields] } do |record|
+            Spree::Translations.fields_for(record)
+          end
+
+          attribute :default_locale, if: proc { params[:envelope] } do |record|
+            locale_store(record).default_locale
+          end
+
+          attribute :supported_locales, if: proc { params[:envelope] } do |record|
+            locale_store(record).supported_locales_list
+          end
+
+          attribute :children, if: proc { |record| params[:fields] && children_for(record).any? } do |record|
+            # Children carry their own fields + matrix, but not the locale
+            # envelope (that's a property of the top-level request, not each row).
+            # Recurse with self.class so a swapped subclass renders children too.
+            child_params = params.merge(envelope: false)
+            children_for(record).map { |child| self.class.new(child, params: child_params).to_h }
+          end
+
+          private
+
+          # The store whose locales the payload reports — the record's own
+          # translatable store, falling back to the current store.
+          def locale_store(record)
+            record.translatable_store || params[:store]
+          end
+
+          def children_for(record)
+            assoc = record.class.try(:translatable_children)
+            assoc.present? ? Array(record.public_send(assoc)) : []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Serializes {Spree::SetupTask} — an evaluated onboarding checklist
+        # entry. A value object, so no id.
+        class SetupTaskSerializer
+          include Alba::Resource
+          include Typelizer::DSL
+
+          typelize name: :string, done: :boolean
+
+          attributes :name, :done
+        end
+      end
+    end
+  end
+end

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

@@ -3,10 +3,12 @@ module Spree
     module V3
       module Admin
         class StoreSerializer < V3::BaseSerializer
-          typelize name: :string, url: :string,
+          typelize name: :string, url: :string, code: :string, api_url: :string,
+                   preferred_storefront_url: [:string, nullable: true],
                    default_currency: :string, default_locale: :string,
                    supported_currencies: [:string, multi: true],
                    supported_locales: [:string, multi: true],
+                   available_locales: [:string, multi: true],
                    logo_url: [:string, nullable: true],
                    mailer_logo_url: [:string, nullable: true],
                    mail_from_address: [:string, nullable: true],
@@ -17,10 +19,14 @@ module Spree
                    preferred_timezone: :string,
                    preferred_weight_unit: :string,
                    preferred_unit_system: :string,
+                   preferred_storefront_access: :string,
+                   preferred_guest_checkout: :boolean,
                    metadata: 'Record<string, unknown>'
 
           attributes :metadata,
                      :name,
+                     :code,
+                     :preferred_storefront_url,
                      :default_currency,
                      :default_locale,
                      :mail_from_address,
@@ -31,16 +37,36 @@ module Spree
                      :preferred_timezone,
                      :preferred_weight_unit,
                      :preferred_unit_system,
+                     :preferred_storefront_access,
+                     :preferred_guest_checkout,
                      created_at: :iso8601, updated_at: :iso8601
 
           attribute :url, &:storefront_url
 
+          # The backend's own public URL — what a headless client sets as its
+          # Store API endpoint (distinct from `url`, the storefront's URL).
+          attribute :api_url, &:formatted_url
+
+          # The Getting Started checklist in display order. Task names map to
+          # frontend copy/components by convention.
+          many :setup_tasks,
+               resource: proc { Spree.api.admin_setup_task_serializer }
+
           attribute :supported_currencies do |store|
             store.supported_currencies_list.map(&:iso_code)
           end
 
           attribute :supported_locales, &:supported_locales_list
 
+          # Canonical set of locales a merchant may translate content into,
+          # independent of the store's currently-configured locales. Identical
+          # for every store, so the locale pickers can offer the full list
+          # rather than only locales already in use (avoids a chicken-and-egg
+          # where a new locale can never be added). See `Spree::Locales::ALL`.
+          attribute :available_locales do
+            Spree::Locales::ALL
+          end
+
           attribute :logo_url do |store|
             image_url_for(store.logo)
           end

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

@@ -13,13 +13,20 @@ module Spree
                    weight_unit: [:string, nullable: true], dimensions_unit: [: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],
                    deleted_at: [:string, nullable: true],
                    metadata: 'Record<string, unknown>'
 
           attributes :metadata, :position, :cost_price, :cost_currency,
-                     :barcode, :weight_unit, :dimensions_unit, deleted_at: :iso8601,
+                     :barcode, :weight_unit, :dimensions_unit, :backorder_limit,
+                     preorder_ships_at: :iso8601, deleted_at: :iso8601,
                      created_at: :iso8601, updated_at: :iso8601
 
+          attribute :preorderable do |variant|
+            variant.preorderable?
+          end
+
           attribute :tax_category_id do |variant|
             variant.tax_category&.prefixed_id
           end

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

@@ -16,6 +16,17 @@ 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)
+          names.each do |name|
+            attribute(name) { |object| object.public_send(name) unless params[:hide_prices] }
+          end
+        end
+
         # Context accessors
         def current_store
           params[:store]
@@ -77,6 +88,7 @@ module Spree
         # Memoized per variant to avoid duplicate queries
         def price_for(variant, quantity: nil)
           return nil unless variant.respond_to?(:price_for)
+          return nil if params[:hide_prices]
 
           @price_for_cache ||= {}
           cache_key = [variant.id, quantity]
@@ -95,6 +107,7 @@ module Spree
         # Memoized per variant to avoid duplicate queries
         def price_in(variant)
           return nil unless variant.respond_to?(:price_in)
+          return nil if params[:hide_prices]
 
           @price_in_cache ||= {}
           return @price_in_cache[variant.id] if @price_in_cache.key?(variant.id)

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

@@ -8,18 +8,18 @@ module Spree
                  customer_note: [:string, nullable: true], market_id: [:string, nullable: true],
                  currency: :string, locale: [:string, nullable: true], total_quantity: :number,
                  requirements: 'Array<{step: string, field: string, message: string}>',
-                 item_total: :string, display_item_total: :string,
-                 delivery_total: :string, display_delivery_total: :string,
-                 adjustment_total: :string, display_adjustment_total: :string,
-                 discount_total: :string, display_discount_total: :string,
-                 tax_total: :string, display_tax_total: :string,
-                 included_tax_total: :string, display_included_tax_total: :string,
-                 additional_tax_total: :string, display_additional_tax_total: :string,
-                 store_credit_total: :string, display_store_credit_total: :string,
-                 gift_card_total: :string, display_gift_card_total: :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],
+                 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, display_total: :string,
-                 amount_due: :string, display_amount_due: :string,
+                 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}>',
                  billing_address: { nullable: true }, shipping_address: { nullable: true },
@@ -35,22 +35,25 @@ module Spree
         end
 
         attributes :number, :token, :email, :customer_note,
-                   :currency, :locale, :total_quantity,
-                   :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, :warnings
+                   :currency, :locale, :total_quantity, :warnings
+
+        # 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
 
         attribute :store_credit_total do |order|
-          order.total_applied_store_credit.to_s
+          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
+          order.display_total_applied_store_credit.to_s unless params[:hide_prices]
         end
 
         attribute :covered_by_store_credit do |order|

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

@@ -5,13 +5,17 @@ module Spree
       # Replaces CartPromotionSerializer and OrderPromotionSerializer.
       class DiscountSerializer < BaseSerializer
         typelize name: :string, description: [:string, nullable: true], code: [:string, nullable: true],
-                 amount: :string, display_amount: :string, promotion_id: :string
+                 amount: [:string, nullable: true], display_amount: [:string, nullable: true], promotion_id: :string
 
         attribute :promotion_id do |record|
           record.promotion&.prefixed_id
         end
 
-        attributes :name, :description, :code, :amount, :display_amount
+        attributes :name, :description, :code
+
+        # Nulled for gated (prices_hidden) guests so an applied discount can't
+        # leak the amount the cart/order totals already withhold.
+        money_attributes :amount, :display_amount
       end
     end
   end

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

@@ -5,21 +5,24 @@ module Spree
         typelize number: :string, status: :string, fulfillment_type: :string,
                  tracking: [:string, nullable: true],
                  tracking_url: [:string, nullable: true], fulfilled_at: [:string, nullable: true],
-                 cost: :string, display_cost: :string,
-                 total: :string, display_total: :string,
-                 discount_total: :string, display_discount_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,
+                 cost: [:string, nullable: true], display_cost: [:string, nullable: true],
+                 total: [:string, nullable: true], display_total: [:string, nullable: true],
+                 discount_total: [:string, nullable: true], display_discount_total: [:string, nullable: true],
+                 additional_tax_total: [:string, nullable: true], display_additional_tax_total: [:string, nullable: true],
+                 included_tax_total: [:string, nullable: true], display_included_tax_total: [:string, nullable: true],
+                 tax_total: [:string, nullable: true], display_tax_total: [:string, nullable: true],
                  items: 'Array<{ item_id: string; variant_id: string; quantity: number }>'
 
-        attributes :number, :tracking, :tracking_url,
-                   :cost, :display_cost,
-                   :total, :display_total,
-                   :discount_total, :display_discount_total,
-                   :additional_tax_total, :display_additional_tax_total,
-                   :included_tax_total, :display_included_tax_total,
-                   :tax_total, :display_tax_total
+        attributes :number, :tracking, :tracking_url
+
+        # Nulled for gated (prices_hidden) guests so a fulfillment can't leak the
+        # shipping/tax amounts the cart/order totals already withhold.
+        money_attributes :cost, :display_cost,
+                         :total, :display_total,
+                         :discount_total, :display_discount_total,
+                         :additional_tax_total, :display_additional_tax_total,
+                         :included_tax_total, :display_included_tax_total,
+                         :tax_total, :display_tax_total
 
         attribute :status do |shipment|
           shipment.state

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

@@ -4,13 +4,13 @@ module Spree
       class GiftCardSerializer < BaseSerializer
         typelize code: :string,
                  status: :string,
-                 amount: :string,
-                 amount_used: :string,
-                 amount_authorized: :string,
-                 amount_remaining: :string,
-                 display_amount: :string,
-                 display_amount_used: :string,
-                 display_amount_remaining: :string,
+                 amount: [:string, nullable: true],
+                 amount_used: [:string, nullable: true],
+                 amount_authorized: [:string, nullable: true],
+                 amount_remaining: [:string, nullable: true],
+                 display_amount: [:string, nullable: true],
+                 display_amount_used: [:string, nullable: true],
+                 display_amount_remaining: [:string, nullable: true],
                  currency: :string,
                  expires_at: [:string, nullable: true],
                  redeemed_at: [:string, nullable: true],
@@ -25,18 +25,22 @@ module Spree
           gift_card.display_state
         end
 
-        attributes :currency, :amount, :amount_used, :amount_authorized, :amount_remaining
+        attributes :currency
+
+        # Nulled for gated (prices_hidden) guests so a gift card applied to a
+        # cart can't leak balances the cart/order totals already withhold.
+        money_attributes :amount, :amount_used, :amount_authorized, :amount_remaining
 
         attribute :display_amount do |gift_card|
-          gift_card.display_amount.to_s
+          gift_card.display_amount.to_s unless params[:hide_prices]
         end
 
         attribute :display_amount_used do |gift_card|
-          gift_card.display_amount_used.to_s
+          gift_card.display_amount_used.to_s unless params[:hide_prices]
         end
 
         attribute :display_amount_remaining do |gift_card|
-          gift_card.display_amount_remaining.to_s
+          gift_card.display_amount_remaining.to_s unless params[:hide_prices]
         end
 
         attribute :expires_at do |gift_card|

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

@@ -5,7 +5,7 @@ module Spree
     module V3
       class ImportRowSerializer < BaseSerializer
         typelize import_id: [:string, nullable: true], row_number: :number,
-                 status: :string, validation_errors: 'unknown',
+                 status: :string, validation_errors: [:string, nullable: true],
                  item_type: [:string, nullable: true], item_id: [:string, nullable: true]
 
         attributes :row_number, :status, :validation_errors, :item_type,