spree_api 6.0.0.rc1 → 6.0.0.rc2

data/app/serializers/spree/api/v3/seller/payment_split_serializer.rb

@@ -13,19 +13,18 @@ module Spree
           AMOUNTS = %i[authorized_amount captured_amount refunded_amount claimed_amount
                        net_captured_amount refundable_amount].freeze
 
-          typelize currency: :string,
-                   authorized_amount: :string, display_authorized_amount: :string,
-                   captured_amount: :string, display_captured_amount: :string,
-                   refunded_amount: :string, display_refunded_amount: :string,
-                   claimed_amount: :string, display_claimed_amount: :string,
-                   net_captured_amount: :string, display_net_captured_amount: :string,
-                   refundable_amount: :string, display_refundable_amount: :string
+          typelize currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
+                   authorized_amount: :string,
+                   captured_amount: :string,
+                   refunded_amount: :string,
+                   claimed_amount: :string,
+                   net_captured_amount: :string,
+                   refundable_amount: :string
 
           attributes :currency, created_at: :iso8601
 
           AMOUNTS.each do |amount|
-            attribute(amount) { |split| split.public_send(amount).to_s }
-            attribute(:"display_#{amount}") { |split| split.public_send(:"display_#{amount}").to_s }
+            attribute(amount) { |split| Spree::Money::Rounding.format(split.public_send(amount), split.currency) }
           end
         end
       end

data/app/serializers/spree/api/v3/seller/payout_serializer.rb

@@ -5,10 +5,9 @@ module Spree
         # One settlement to this seller, as the seller reads it.
         class PayoutSerializer < V3::BaseSerializer
           typelize status: :string,
-                   currency: :string,
+                   currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                    provider: [:string, comment: 'Payout provider. Built-in: system. Provider gems register more (e.g. stripe).'],
                    amount: :string,
-                   display_amount: :string,
                    reference: 'string | null',
                    period_start: 'string | null',
                    period_end: 'string | null',
@@ -18,8 +17,7 @@ module Spree
                      period_start: :iso8601, period_end: :iso8601,
                      created_at: :iso8601, updated_at: :iso8601
 
-          attribute(:amount) { |payout| payout.amount&.to_s }
-          attribute(:display_amount) { |payout| payout.display_amount.to_s }
+          attribute(:amount) { |payout| Spree::Money::Rounding.format(payout.amount, payout.currency) }
 
           # How many earnings this settlement covers. Read from a count the
           # controller made for the whole page when there is one; a single

data/app/serializers/spree/api/v3/seller/price_history_serializer.rb

@@ -0,0 +1,11 @@
+module Spree
+  module Api
+    module V3
+      module Seller
+        class PriceHistorySerializer < V3::PriceHistorySerializer
+          without_formatted_money(:seller)
+        end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v3/seller/price_serializer.rb

@@ -0,0 +1,11 @@
+module Spree
+  module Api
+    module V3
+      module Seller
+        class PriceSerializer < V3::PriceSerializer
+          without_formatted_money(:seller)
+        end
+      end
+    end
+  end
+end

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

@@ -13,6 +13,8 @@ module Spree
         # both from the marketplace's list
         # (docs/plans/6.0-multi-vendor-marketplace.md, Decision 13).
         class ProductSerializer < V3::ProductSerializer
+          without_formatted_money(:seller)
+
           typelize status: [:string, enum: Spree::Product.statuses, enum_type_name: 'ProductStatus'], metadata: 'Record<string, unknown>',
                    product_type_id: [:string, nullable: true],
                    delivery_profile_id: [:string, nullable: true],

data/app/serializers/spree/api/v3/seller/profile_serializer.rb

@@ -15,11 +15,11 @@ module Spree
                    terms_accepted_at: [:string, nullable: true],
                    on_holiday: :boolean, sellable: :boolean,
                    products_count: :number,
-                   default_currency: :string,
-                   supported_currencies: [:string, multi: true],
-                   preferred_timezone: [:string, nullable: true]
+                   default_currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
+                   supported_currencies: [:string, multi: true, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
+                   timezone: [:string, nullable: true]
 
-          attributes :preferred_timezone,
+          attributes :timezone,
                      :status, :legal_name, :registration_number,
                      :contact_email, :billing_email,
                      :tax_remittance, :payouts_schedule_interval,
@@ -28,7 +28,7 @@ module Spree
                      created_at: :iso8601
 
           attribute :minimum_payout_amount do |seller|
-            seller.minimum_payout_amount&.to_s
+            Spree::Money::Rounding.format(seller.minimum_payout_amount, seller.store&.default_currency, unit_price: true)
           end
 
           # Rebound from the inherited store declaration to this branch's own
@@ -60,11 +60,11 @@ module Spree
           end
 
           one :billing_address,
-              resource: proc { Spree.api.address_serializer },
+              resource: proc { Spree.api.seller_address_serializer },
               if: proc { |seller| seller.billing_address.present? }
 
           one :returns_address,
-              resource: proc { Spree.api.address_serializer },
+              resource: proc { Spree.api.seller_address_serializer },
               if: proc { |seller| seller.returns_address.present? }
         end
       end

data/app/serializers/spree/api/v3/seller/return_line_item_serializer.rb

@@ -10,6 +10,14 @@ module Spree
         # its option values but no product name, so a card built from the
         # variant alone would show a bare id for anything unSKU'd.
         class ReturnLineItemSerializer < V3::ReturnLineItemSerializer
+          without_formatted_money(:seller)
+
+          # No guest price gating here, so the inherited money fields are always present.
+          typelize pre_tax_amount: [:string, nullable: false],
+                   included_tax_total: [:string, nullable: false], additional_tax_total: [:string, nullable: false],
+                   tax_total: [:string, nullable: false],
+                   refund_amount: [:string, nullable: false]
+
           typelize name: [:string, nullable: true]
 
           attribute :name do |line|

data/app/serializers/spree/api/v3/seller/return_serializer.rb

@@ -13,20 +13,23 @@ module Spree
         # What it adds over the shared one is the pair of figures a seller
         # needs to settle: what has already gone back, and what may still.
         class ReturnSerializer < V3::ReturnSerializer
+          without_formatted_money(:seller)
+
           typelize memo: [:string, nullable: true],
                    stock_location_id: [:string, nullable: true],
-                   refunded_total: :string,
-                   refundable_total: :string,
-                   display_refunded_total: :string
+                   refund_total: [:string, nullable: false],
+                   refund_tax_total: [:string, nullable: false]
 
           attributes :memo
 
           prefixed_id_attributes :stock_location
 
-          attributes refunded_total: :string
+          money_attributes :refunded_total
           # What the refund dialog opens on — never more than this may be
           # given back, whatever amount is typed.
-          attributes refundable_total: :string, display_refunded_total: :string
+          money_attributes :refundable_total
+          typelize refunded_total: [:string, nullable: false], refundable_total: [:string, nullable: false]
+
           many :return_line_items,
                resource: proc { Spree.api.seller_return_line_item_serializer },
                if: proc { expand?('return_line_items') }

data/app/serializers/spree/api/v3/seller/state_serializer.rb

@@ -0,0 +1,10 @@
+module Spree
+  module Api
+    module V3
+      module Seller
+        class StateSerializer < V3::StateSerializer
+        end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v3/seller/stock_location_serializer.rb

@@ -3,6 +3,9 @@ module Spree
     module V3
       module Seller
         class StockLocationSerializer < V3::StockLocationSerializer
+          # The Store API keeps these deprecated names until 6.1.
+          %i[country_iso state_abbr].each { |key| _attributes.delete(key) }
+
           typelize address2: [:string, nullable: true], state_name: [:string, nullable: true],
                    phone: [:string, nullable: true], company: [:string, nullable: true],
                    active: :boolean, default: :boolean, kind: [:string, enum: Spree::StockLocation::KINDS, enum_type_name: 'StockLocationKind'],

data/app/serializers/spree/api/v3/seller/transfer_serializer.rb

@@ -11,13 +11,12 @@ module Spree
         class TransferSerializer < V3::BaseSerializer
           typelize kind: :string,
                    status: :string,
-                   currency: :string,
+                   currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                    provider: [:string, comment: 'Payout provider. Built-in: system. Provider gems register more (e.g. stripe).'],
                    amount: :string,
                    settled_amount: 'string | null',
-                   settled_currency: 'string | null',
+                   settled_currency: [:string, nullable: true, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                    converted: :boolean,
-                   display_amount: :string,
                    reference: 'string | null',
                    order_id: 'string | null',
                    order_number: 'string | null',
@@ -27,13 +26,13 @@ module Spree
           attributes :kind, :status, :currency, :reference,
                      created_at: :iso8601, updated_at: :iso8601
 
-          # A string, so the figure a seller is paid round-trips exactly.
-          attribute(:amount) { |transfer| transfer.amount&.to_s }
-          attribute(:display_amount) { |transfer| transfer.display_amount.to_s }
+          attribute(:amount) { |transfer| Spree::Money::Rounding.format(transfer.amount, transfer.currency) }
 
           # What this seller's account received, when the provider converted
           # on the way in. Null when it settled in the currency of the sale.
-          attribute(:settled_amount) { |transfer| transfer.settled_amount&.to_s }
+          attribute(:settled_amount) do |transfer|
+            Spree::Money::Rounding.format(transfer.settled_amount, transfer.settled_currency || transfer.currency)
+          end
           attribute(:settled_currency) { |transfer| transfer.settled_currency }
           attribute(:converted) { |transfer| transfer.converted? }
 

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

@@ -10,9 +10,11 @@ module Spree
         # those are marketplace configuration and the seller cannot write them,
         # so showing them would invite an edit that silently does nothing.
         class VariantSerializer < V3::VariantSerializer
+          without_formatted_money(:seller)
+
           typelize position: :number,
                    cost_price: [:string, nullable: true],
-                   cost_currency: [:string, nullable: true],
+                   cost_currency: [:string, nullable: true, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                    barcode: [:string, nullable: true],
                    available_stock: [:number, nullable: true],
                    total_on_hand: [:number, nullable: true],
@@ -20,18 +22,20 @@ module Spree
                    preorder_ships_at: [:string, nullable: true],
                    backorder_limit: [:number, nullable: true],
                    hs_code: [:string, nullable: true],
-                   country_of_origin: [:string, nullable: true],
+                   country_of_origin: [:string, nullable: true, enum: Spree::IsoData.country_codes, enum_type_name: 'CountryCode'],
                    customs_description: [:string, nullable: true],
                    minimum_order_quantity: ['number | null'], order_multiple: ['number | null'],
                    purchase_unit: [:string, nullable: true, enum: Spree::Variant::PURCHASE_UNITS],
                    metadata: 'Record<string, unknown>'
 
-          attributes :metadata, :position, :cost_price, :cost_currency,
+          attributes :metadata, :position, :cost_currency,
                      :barcode, :backorder_limit,
                      :hs_code, :country_of_origin, :customs_description,
                      preorder_ships_at: :iso8601,
                      created_at: :iso8601, updated_at: :iso8601
 
+          money_attributes :cost_price, currency: :cost_currency, unit_price: true
+
           # The variant's own stored rules, not a buyer's resolved ones — a
           # seller edits the row.
           attribute :minimum_order_quantity, &:minimum_order_quantity
@@ -58,7 +62,7 @@ module Spree
                if: proc { expand?('media') }
 
           many :prices,
-               resource: proc { Spree.api.price_serializer },
+               resource: proc { Spree.api.seller_price_serializer },
                if: proc { expand?('prices') }
 
           many :stock_levels,

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

@@ -3,14 +3,21 @@ module Spree
     module V3
       class StockLocationSerializer < BaseSerializer
         typelize name: :string, address1: [:string, nullable: true], city: [:string, nullable: true],
-                 zipcode: [:string, nullable: true], country_code: [:string, nullable: true],
+                 zipcode: [:string, nullable: true], 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_text: [:string, nullable: true],
+                 country_iso: [:string, nullable: true, deprecated: 'Use `country_code`. Removed in 6.1.'],
+                 state_abbr: [:string, nullable: true, deprecated: 'Use `state_code`. Removed in 6.1.'],
                  pickup_ready_in_minutes: [:number, nullable: true],
                  pickup_instructions: [:string, nullable: true]
 
         attributes :name, :address1, :city, :zipcode, :country_code, :country_name, :state_code, :state_text
 
+        # @deprecated Storefronts shipped against these names; use +country_code+
+        #   and +state_code+. Removed in 6.1.
+        attribute :country_iso, &:country_code
+        attribute :state_abbr, &:state_code
+
         # Collection details the customer needs when choosing a counter: how
         # long until the order is ready, and where to go. This serializer
         # backs the pickup-locations endpoint, so without them the two

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

@@ -4,15 +4,13 @@ module Spree
       class StoreCreditEventSerializer < BaseSerializer
         typelize action: :string,
                  display_action: [:string, nullable: true],
-                 amount: :string,
-                 display_amount: :string,
                  authorization_code: [:string, nullable: true]
 
         attributes :action, :authorization_code
 
         attributes :display_action
 
-        attributes amount: :string, display_amount: :string
+        money_attributes :amount, :display_amount
         attributes created_at: :iso8601
       end
     end

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

@@ -2,12 +2,10 @@ module Spree
   module Api
     module V3
       class StoreCreditSerializer < BaseSerializer
-        typelize amount: :string, amount_used: :string, amount_remaining: :string,
-                 display_amount: :string, display_amount_used: :string, display_amount_remaining: :string,
-                 currency: :string
+        typelize currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode']
 
-        attributes amount: :string, amount_used: :string, amount_remaining: :string, display_amount: :string,
-                   display_amount_used: :string, display_amount_remaining: :string
+        money_attributes :amount, :amount_used, :amount_remaining, :display_amount,
+                         :display_amount_used, :display_amount_remaining
         attributes :currency
       end
     end

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

@@ -5,7 +5,7 @@ module Spree
       # or, after the sale, the tax a return, claim or exchange line gives
       # back (`credit`) or charges on an exchange's replacement.
       class TaxLineSerializer < BaseSerializer
-        typelize label: :string, rate: :string, included: :boolean, credit: :boolean,
+        typelize label: :string, included: :boolean, credit: :boolean,
                  tax_rate_id: [:string, nullable: true], line_item_id: [:string, nullable: true],
                  fulfillment_id: [:string, nullable: true], fee_id: [:string, nullable: true],
                  return_line_item_id: [:string, nullable: true], claim_line_item_id: [:string, nullable: true],
@@ -13,9 +13,7 @@ module Spree
 
         attributes :label, :included, :credit
 
-        attribute :rate do |record|
-          record.rate&.to_s
-        end
+        rate_attributes :rate
 
         prefixed_id_attributes :tax_rate, :line_item, :fulfillment, :fee, :return_line_item, :claim_line_item,
                                :exchange_line_item

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

@@ -88,7 +88,7 @@ module Spree
         # Price object - calculated price with price list resolution
         attribute :price do |variant|
           price = price_for(variant)
-          Spree.api.price_serializer.new(price, params: params).to_h if price.present?
+          price_serializer.new(price, params: params).to_h if price.present?
         end
 
         # Original price - base price without price list resolution (for showing strikethrough)
@@ -98,7 +98,7 @@ module Spree
           base = price_in(variant)
 
           if calculated.present? && base.present? && calculated.id != base.id
-            Spree.api.price_serializer.new(base, params: params).to_h
+            price_serializer.new(base, params: params).to_h
           end
         end
 
@@ -137,7 +137,7 @@ module Spree
         attribute :prior_price,
                   if: proc { expand?('prior_price') } do |variant|
           record = price_in(variant)&.prior_price
-          Spree.api.price_history_serializer.new(record, params: params).to_h if record
+          price_history_serializer.new(record, params: params).to_h if record
         end
       end
     end

data/app/services/spree/api/v3/filter_predicates.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Api
+    module V3
+      # The Ransack predicates the v3 API accepts, per kind of value. Ransack
+      # itself would take far more; this is the published contract, so a
+      # non-Ruby implementation needs to support exactly these.
+      module FilterPredicates
+        EQUALITY = %w[eq not_eq in not_in].freeze
+        NULLITY = %w[null not_null].freeze
+        RANGE = (EQUALITY + %w[lt lteq gt gteq] + NULLITY).freeze
+        IDENTITY = (EQUALITY + NULLITY).freeze
+
+        BY_KIND = {
+          'text' => (EQUALITY + %w[cont i_cont not_cont start end] + NULLITY + %w[present blank]).freeze,
+          'decimal' => RANGE,
+          'integer' => RANGE,
+          'date' => RANGE,
+          'datetime' => RANGE,
+          'enum' => IDENTITY,
+          'id' => IDENTITY,
+          'type' => IDENTITY,
+          'boolean' => (EQUALITY + %w[true false null]).freeze
+        }.freeze
+
+        KINDS = BY_KIND.keys.freeze
+      end
+    end
+  end
+end