spree_api 5.4.3 → 5.5.0.rc1

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

@@ -3,7 +3,10 @@ module Spree
     module V3
       module Admin
         class OptionTypeSerializer < V3::OptionTypeSerializer
-          attributes created_at: :iso8601, updated_at: :iso8601
+          typelize metadata: 'Record<string, unknown>', filterable: :boolean
+
+          attributes :metadata, :filterable,
+                     created_at: :iso8601, updated_at: :iso8601
 
           many :option_values,
                resource: Spree.api.admin_option_value_serializer,

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

@@ -3,7 +3,10 @@ module Spree
     module V3
       module Admin
         class OptionValueSerializer < V3::OptionValueSerializer
-          attributes created_at: :iso8601, updated_at: :iso8601
+          typelize metadata: 'Record<string, unknown>'
+
+          attributes :metadata,
+                     created_at: :iso8601, updated_at: :iso8601
 
           one :option_type,
               resource: Spree.api.admin_option_type_serializer,

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

@@ -6,25 +6,36 @@ module Spree
         # Full order data including admin-only fields
         class OrderSerializer < V3::OrderSerializer
 
-          typelize last_ip_address: [:string, nullable: true],
+          typelize status: :string,
+                   last_ip_address: [:string, nullable: true],
                    considered_risky: :boolean, confirmation_delivered: :boolean,
                    store_owner_notification_delivered: :boolean,
                    internal_note: [:string, nullable: true], approver_id: [:string, nullable: true],
                    canceler_id: [:string, nullable: true], created_by_id: [:string, nullable: true],
                    customer_id: [:string, nullable: true],
+                   preferred_stock_location_id: [:string, nullable: true],
                    canceled_at: [:string, nullable: true], approved_at: [:string, nullable: true],
                    payment_total: :string, display_payment_total: :string,
-                   metadata: 'Record<string, unknown> | null'
+                   tags: [:string, multi: true],
+                   metadata: 'Record<string, unknown>'
 
           # Admin-only attributes
-          attributes :last_ip_address, :considered_risky,
+          attributes :status, :last_ip_address, :considered_risky,
                      :confirmation_delivered, :store_owner_notification_delivered,
-                     :internal_note, :payment_total, :display_payment_total,
+                     :payment_total, :display_payment_total, :metadata,
                      canceled_at: :iso8601, approved_at: :iso8601,
                      created_at: :iso8601, updated_at: :iso8601
 
-          attribute :metadata do |order|
-            order.metadata.presence
+          attribute :preferred_stock_location_id do |order|
+            order.preferred_stock_location&.prefixed_id
+          end
+
+          attribute :tags do |order|
+            order.tag_list.to_a
+          end
+
+          attribute :internal_note do |order|
+            order.internal_note&.to_plain_text.presence
           end
 
           attribute :approver_id do |order|
@@ -53,6 +64,10 @@ module Spree
           one :shipping_address, resource: Spree.api.admin_address_serializer, if: proc { expand?('shipping_address') }
           one :gift_card, resource: Spree.api.admin_gift_card_serializer
           one :market, resource: Spree.api.admin_market_serializer
+          one :channel, resource: Spree.api.admin_channel_serializer, if: proc { expand?('channel') }
+          one :preferred_stock_location,
+              resource: Spree.api.admin_stock_location_serializer,
+              if: proc { expand?('preferred_stock_location') }
 
           many :payment_methods, resource: Spree.api.admin_payment_method_serializer, if: proc { expand?('payment_methods') }
 

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

@@ -3,10 +3,19 @@ module Spree
     module V3
       module Admin
         class PaymentMethodSerializer < V3::PaymentMethodSerializer
-          typelize active: :boolean, auto_capture: [:boolean, nullable: true]
+          typelize active: :boolean,
+                   auto_capture: [:boolean, nullable: true],
+                   storefront_visible: :boolean,
+                   position: :number,
+                   metadata: 'Record<string, unknown>',
+                   preferences: 'Record<string, unknown>',
+                   preference_schema: "Array<{ key: string; type: string; default: unknown }>"
 
-          attributes :active, :auto_capture,
+          attributes :metadata, :active, :auto_capture, :storefront_visible, :position,
                      created_at: :iso8601, updated_at: :iso8601
+
+          attribute :preferences, &:serialized_preferences
+          attribute :preference_schema, &:serialized_preference_schema
         end
       end
     end

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

@@ -3,20 +3,16 @@ module Spree
     module V3
       module Admin
         class PaymentSerializer < V3::PaymentSerializer
-          typelize metadata: 'Record<string, unknown> | null',
+          typelize metadata: 'Record<string, unknown>',
                    captured_amount: :string,
                    order_id: [:string, nullable: true],
                    avs_response: [:string, nullable: true],
                    cvv_response_code: [:string, nullable: true],
                    cvv_response_message: [:string, nullable: true]
 
-          attributes :avs_response, :cvv_response_code, :cvv_response_message,
+          attributes :metadata, :avs_response, :cvv_response_code, :cvv_response_message,
                      created_at: :iso8601, updated_at: :iso8601
 
-          attribute :metadata do |payment|
-            payment.metadata.presence
-          end
-
           attribute :captured_amount do |payment|
             payment.captured_amount.to_s
           end

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

@@ -3,7 +3,10 @@ module Spree
     module V3
       module Admin
         class PaymentSourceSerializer < V3::PaymentSourceSerializer
-          attributes created_at: :iso8601, updated_at: :iso8601
+          typelize metadata: 'Record<string, unknown>'
+
+          attributes :metadata,
+                     created_at: :iso8601, updated_at: :iso8601
         end
       end
     end

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

@@ -0,0 +1,51 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Serializes Spree::PriceList for the admin pricing surface.
+        # Price lists are admin-only — there's no Store API counterpart;
+        # storefront callers only ever see the *resolved* price (see
+        # PriceSerializer#price_list_id), never the list itself.
+        class PriceListSerializer < V3::BaseSerializer
+          typelize name: :string,
+                   description: 'string | null',
+                   status: :string,
+                   position: :number,
+                   starts_at: 'string | null',
+                   ends_at: 'string | null',
+                   deleted_at: 'string | null',
+                   match_policy: :string,
+                   currently_active: :boolean,
+                   products_count: :number,
+                   prices_count: :number,
+                   product_ids: [:string, multi: true]
+
+          attributes :name, :description, :status, :position, :match_policy,
+                     starts_at: :iso8601, ends_at: :iso8601, deleted_at: :iso8601,
+                     created_at: :iso8601, updated_at: :iso8601
+
+          attribute :currently_active, &:currently_active?
+
+          # Cheap counts so the index can render "12 products / 36 prices"
+          # without forcing each row to expand the children.
+          attribute :products_count do |pl|
+            pl.products.count
+          end
+
+          attribute :prices_count do |pl|
+            pl.prices.count
+          end
+
+          # Prefixed product ids in the list — drives the SPA's
+          # Products picker pre-fill, and is the same payload the
+          # client ships back on PATCH to reconcile membership.
+          attribute :product_ids, &:product_prefixed_ids
+
+          many :price_rules,
+               resource: Spree.api.admin_price_rule_serializer,
+               if: proc { expand?('price_rules') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Serializes Spree::PriceRule (STI subclasses live under Spree::PriceRules).
+        # Same shape as PromotionRuleSerializer so the SPA can drive both
+        # editors from one generic preference-form component.
+        class PriceRuleSerializer < V3::BaseSerializer
+          typelize type: :string,
+                   price_list_id: :string,
+                   preferences: 'Record<string, unknown>',
+                   preference_schema: 'Array<{ key: string; type: string; default: unknown }>',
+                   label: :string,
+                   description: 'string | null'
+
+          attributes created_at: :iso8601, updated_at: :iso8601
+
+          attribute :type do |rule|
+            rule.class.api_type
+          end
+
+          attribute :price_list_id do |rule|
+            rule.price_list&.prefixed_id
+          end
+
+          attribute :preferences, &:serialized_preferences
+          attribute :preference_schema, &:serialized_preference_schema
+
+          attribute :label do |rule|
+            rule.class.respond_to?(:human_name) ? rule.class.human_name : rule.class.to_s.demodulize
+          end
+
+          attribute :description do |rule|
+            rule.class.respond_to?(:description) ? rule.class.description : nil
+          end
+
+          # Embeds skip rules that don't carry the association (e.g.
+          # VolumeRule has no markets/customers — the keys are omitted).
+          many :markets,
+               resource: Spree.api.admin_market_serializer,
+               if: proc { |rule| rule.respond_to?(:markets) }
+
+          many :customer_groups,
+               resource: Spree.api.admin_customer_group_serializer,
+               if: proc { |rule| rule.respond_to?(:customer_groups) }
+
+          many :users,
+               key: :customers,
+               resource: Spree.api.admin_customer_serializer,
+               if: proc { |rule| rule.respond_to?(:users) }
+        end
+      end
+    end
+  end
+end

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

@@ -14,6 +14,10 @@ module Spree
           end
 
           attributes created_at: :iso8601, updated_at: :iso8601
+
+          one :variant,
+              resource: Spree.api.admin_variant_serializer,
+              if: proc { expand?('variant') }
         end
       end
     end

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

@@ -0,0 +1,11 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        class ProductPublicationSerializer < V3::ProductPublicationSerializer
+          attributes created_at: :iso8601, updated_at: :iso8601
+        end
+      end
+    end
+  end
+end

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

@@ -7,21 +7,33 @@ module Spree
         # Extends the store serializer with additional attributes
         class ProductSerializer < V3::ProductSerializer
 
-          # Additional type hints for admin-only computed attributes
-          typelize status: :string, make_active_at: [:string, nullable: true], discontinue_on: [:string, nullable: true],
-                   cost_price: [:string, nullable: true], cost_currency: [:string, nullable: true],
-                   deleted_at: [:string, nullable: true]
+          typelize status: :string,
+                   tax_category_id: [:string, nullable: true],
+                   price: ['Price', nullable: true],
+                   deleted_at: [:string, nullable: true],
+                   metadata: 'Record<string, unknown>'
 
-          # Admin-only attributes
-          attributes :status, :make_active_at, :discontinue_on, deleted_at: :iso8601,
+          attributes :status,
+                     :metadata, deleted_at: :iso8601,
                      created_at: :iso8601, updated_at: :iso8601
 
-          attribute :cost_price do |product|
-            product.master&.cost_price
+          attribute :tax_category_id do |product|
+            product.tax_category&.prefixed_id
           end
 
-          attribute :cost_currency do |product|
-            product.master&.cost_currency
+          attribute :price do |product|
+            price = price_for(product.default_variant)
+            Spree.api.admin_price_serializer.new(price, params: params).to_h if price&.persisted?
+          end
+
+          attribute :original_price do |product|
+            variant = product.default_variant
+            calculated = price_for(variant)
+            base = price_in(variant)
+
+            if calculated.present? && base.present? && calculated.id != base.id
+              Spree.api.admin_price_serializer.new(base, params: params).to_h
+            end
           end
 
           # Admin uses admin variant serializer
@@ -46,6 +58,10 @@ module Spree
                resource: Spree.api.admin_option_type_serializer,
                if: proc { expand?('option_types') }
 
+          many :option_values,
+               resource: Spree.api.admin_option_value_serializer,
+               if: proc { expand?('option_values') }
+
           many :taxons,
                proc { |taxons, params|
                  taxons.select { |t| t.taxonomy.store_id == params[:store].id }
@@ -58,6 +74,14 @@ module Spree
                key: :custom_fields,
                resource: Spree.api.admin_custom_field_serializer,
                if: proc { expand?('custom_fields') }
+
+          many :product_publications,
+               resource: Spree.api.admin_product_publication_serializer,
+               if: proc { expand?('product_publications') }
+
+          many :channels,
+               resource: Spree.api.admin_channel_serializer,
+               if: proc { expand?('channels') }
         end
       end
     end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Serializes Spree::PromotionAction (and its STI subclasses) for the
+        # admin promotion editor. The shape is intentionally generic so a
+        # single component can render any subclass — `preferences` is the
+        # current value hash, `preference_schema` describes its fields.
+        class PromotionActionSerializer < BaseSerializer
+          typelize type: :string,
+                   promotion_id: :string,
+                   preferences: 'Record<string, unknown>',
+                   preference_schema: "Array<{ key: string; type: string; default: unknown }>",
+                   label: :string,
+                   calculator: "{ type: string; label: string; preferences: Record<string, unknown>; preference_schema: Array<{ key: string; type: string; default: unknown }> } | null",
+                   line_items: 'Array<{ variant_id: string; quantity: number }> | null'
+
+          attributes created_at: :iso8601, updated_at: :iso8601
+
+          attribute :type do |action|
+            action.class.api_type
+          end
+
+          attribute :promotion_id do |action|
+            action.promotion&.prefixed_id
+          end
+
+          attribute :preferences, &:serialized_preferences
+          attribute :preference_schema, &:serialized_preference_schema
+
+          attribute :label do |action|
+            action.respond_to?(:human_name) ? action.human_name : action.type.to_s.demodulize
+          end
+
+          # Calculator is exposed as a nested object so the SPA can render
+          # the calculator picker + its own preference fields. Null for
+          # actions that don't include CalculatedAdjustments. The SPA
+          # formats the row summary itself off `label` + `preferences` —
+          # see the action-summary helper in the admin promotion editor.
+          attribute :calculator do |action|
+            next nil unless action.respond_to?(:calculator) && action.calculator
+
+            calc = action.calculator
+            {
+              type: calc.class.api_type,
+              label: calc.class.respond_to?(:description) ? calc.class.description : calc.class.to_s.demodulize.titleize,
+              preferences: calc.serialized_preferences,
+              preference_schema: calc.serialized_preference_schema
+            }
+          end
+
+          # Line items the action will add for CreateLineItems. variant_id
+          # is prefixed for consistency with the rest of the API. Null on
+          # actions that don't have the association.
+          attribute :line_items do |action|
+            next nil unless action.respond_to?(:promotion_action_line_items)
+
+            action.promotion_action_line_items.map do |item|
+              {
+                variant_id: item.variant&.prefixed_id,
+                quantity: item.quantity
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Serializes Spree::PromotionRule (and its STI subclasses) for the
+        # admin promotion editor. Same shape as PromotionAction so the
+        # frontend renders both with the same generic component.
+        class PromotionRuleSerializer < BaseSerializer
+          typelize type: :string,
+                   promotion_id: :string,
+                   preferences: 'Record<string, unknown>',
+                   preference_schema: "Array<{ key: string; type: string; default: unknown }>",
+                   label: :string,
+                   product_ids: 'Array<string> | null',
+                   category_ids: 'Array<string> | null',
+                   customer_ids: 'Array<string> | null'
+
+          attributes created_at: :iso8601, updated_at: :iso8601
+
+          attribute :type do |rule|
+            rule.class.api_type
+          end
+
+          attribute :promotion_id do |rule|
+            rule.promotion&.prefixed_id
+          end
+
+          attribute :preferences, &:serialized_preferences
+          attribute :preference_schema, &:serialized_preference_schema
+
+          attribute :label do |rule|
+            rule.respond_to?(:human_name) ? rule.human_name : rule.class.to_s.demodulize
+          end
+
+          # Association IDs for rules that wire products/taxons/users through
+          # join tables. Returned as prefixed IDs to match the rest of the
+          # API; null on rules that don't have the association. The matching
+          # `products`/`categories`/`customers` collections below embed the
+          # full records via their admin serializers so the SPA can render
+          # names + extra info without an extra round-trip.
+          attribute :product_ids do |rule|
+            rule.products.map(&:prefixed_id) if rule.respond_to?(:products)
+          end
+
+          attribute :category_ids do |rule|
+            rule.taxons.map(&:prefixed_id) if rule.respond_to?(:taxons)
+          end
+
+          attribute :customer_ids do |rule|
+            rule.users.map(&:prefixed_id) if rule.respond_to?(:users)
+          end
+
+          # Embed the related records so promotion-row summaries can render
+          # names + extra info without a separate fetch. Rules that don't
+          # carry a given collection (e.g. an ItemTotal rule has no
+          # products) skip via `if:` and the key is omitted from the
+          # payload.
+          many :products,
+               resource: Spree.api.admin_product_serializer,
+               if: proc { |rule| rule.respond_to?(:products) }
+
+          many :taxons,
+               key: :categories,
+               resource: Spree.api.admin_category_serializer,
+               if: proc { |rule| rule.respond_to?(:taxons) }
+
+          many :users,
+               key: :customers,
+               resource: Spree.api.admin_customer_serializer,
+               if: proc { |rule| rule.respond_to?(:users) }
+
+          many :customer_groups,
+               resource: Spree.api.admin_customer_group_serializer,
+               if: proc { |rule| rule.respond_to?(:customer_groups) }
+
+          many :countries,
+               resource: Spree.api.admin_country_serializer,
+               if: proc { |rule| rule.respond_to?(:countries) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Admin Promotion serializer — adds operational fields the Store API
+        # never exposes (multi-codes counts, usage stats, internal promotion
+        # category, store assignments, timestamps).
+        class PromotionSerializer < V3::PromotionSerializer
+          typelize starts_at: [:string, nullable: true],
+                   expires_at: [:string, nullable: true],
+                   usage_limit: [:number, nullable: true],
+                   match_policy: "'all' | 'any'",
+                   path: [:string, nullable: true],
+                   kind: "'coupon_code' | 'automatic'",
+                   multi_codes: :boolean,
+                   number_of_codes: [:number, nullable: true],
+                   code_prefix: [:string, nullable: true],
+                   promotion_category_id: [:string, nullable: true],
+                   metadata: 'Record<string, unknown>',
+                   action_ids: 'string[]',
+                   rule_ids: 'string[]'
+
+          attributes :starts_at, :expires_at, :usage_limit, :match_policy,
+                     :path, :kind, :multi_codes, :number_of_codes, :code_prefix,
+                     :promotion_category_id, :metadata,
+                     created_at: :iso8601, updated_at: :iso8601
+
+          attribute :action_ids do |promotion|
+            promotion.promotion_actions.map(&:prefixed_id)
+          end
+
+          attribute :rule_ids do |promotion|
+            promotion.promotion_rules.map(&:prefixed_id)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,9 +5,11 @@ module Spree
         class RefundSerializer < V3::RefundSerializer
           typelize payment_id: [:string, nullable: true],
                    refund_reason_id: [:string, nullable: true],
-                   reimbursement_id: [:string, nullable: true]
+                   reimbursement_id: [:string, nullable: true],
+                   metadata: 'Record<string, unknown>'
 
-          attributes created_at: :iso8601, updated_at: :iso8601
+          attributes :metadata,
+                     created_at: :iso8601, updated_at: :iso8601
 
           one :payment,
               resource: Spree.api.admin_payment_serializer,

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

@@ -0,0 +1,17 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Admin API serializer for {Spree::Role}. Read-only — used to populate
+        # the role picker on the staff invite/edit forms. Spree core ships
+        # with a single `admin` role today; richer role/permission management
+        # is on the roadmap.
+        class RoleSerializer < V3::BaseSerializer
+          typelize name: :string
+
+          attributes :name, created_at: :iso8601, updated_at: :iso8601
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,22 @@ module Spree
     module V3
       module Admin
         class StockItemSerializer < V3::StockItemSerializer
-          attributes created_at: :iso8601, updated_at: :iso8601
+          typelize metadata: 'Record<string, unknown>',
+                   allocated_count: :number, available_count: :number
+
+          attributes :metadata,
+                     created_at: :iso8601, updated_at: :iso8601
+
+          # Units already allocated to pending shipments. Always 0 in 5.5;
+          # 6.0 Typed Stock Movements wires it up.
+          attribute :allocated_count do |stock_item|
+            stock_item.allocated_count.to_i
+          end
+
+          # Physical stock minus allocated units (per stock_item).
+          attribute :available_count do |stock_item|
+            stock_item.available_count.to_i
+          end
 
           one :stock_location,
               resource: Spree.api.admin_stock_location_serializer,

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

@@ -4,9 +4,18 @@ module Spree
       module Admin
         class StockLocationSerializer < V3::StockLocationSerializer
           typelize active: :boolean, default: :boolean, backorderable_default: :boolean,
-                   propagate_all_variants: :boolean
+                   propagate_all_variants: :boolean, pickup_enabled: :boolean,
+                   admin_name: [:string, nullable: true],
+                   address2: [:string, nullable: true], state_name: [:string, nullable: true],
+                   phone: [:string, nullable: true], company: [:string, nullable: true],
+                   kind: :string, pickup_stock_policy: :string,
+                   pickup_ready_in_minutes: [:number, nullable: true],
+                   pickup_instructions: [:string, nullable: true]
 
-          attributes :active, :default, :backorderable_default, :propagate_all_variants,
+          attributes :admin_name, :address2, :state_name, :phone, :company,
+                     :active, :default, :backorderable_default, :propagate_all_variants,
+                     :kind, :pickup_enabled, :pickup_stock_policy,
+                     :pickup_ready_in_minutes, :pickup_instructions,
                      created_at: :iso8601, updated_at: :iso8601
         end
       end

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

@@ -0,0 +1,46 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        class StockReservationSerializer < V3::StockReservationSerializer
+          typelize stock_item_id: :string,
+                   line_item_id: :string,
+                   order_id: :string,
+                   variant_id: [:string, nullable: true],
+                   stock_location_id: [:string, nullable: true],
+                   quantity: :number,
+                   expires_at: :string,
+                   active: :boolean
+
+          attribute :stock_item_id do |reservation|
+            reservation.stock_item.prefixed_id
+          end
+
+          attribute :line_item_id do |reservation|
+            reservation.line_item.prefixed_id
+          end
+
+          attribute :order_id do |reservation|
+            reservation.order.prefixed_id
+          end
+
+          attribute :variant_id do |reservation|
+            reservation.stock_item&.variant&.prefixed_id
+          end
+
+          attribute :stock_location_id do |reservation|
+            reservation.stock_item&.stock_location&.prefixed_id
+          end
+
+          attributes :quantity, expires_at: :iso8601
+
+          attribute :active do |reservation|
+            reservation.active?
+          end
+
+          attributes created_at: :iso8601, updated_at: :iso8601
+        end
+      end
+    end
+  end
+end