spree_api 5.6.1 → 6.0.0.beta1

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Spree
+  module Api
+    module V3
+      module Admin
+        class ReturnSerializer < V3::ReturnSerializer
+          typelize memo: [:string, nullable: true],
+                   metadata: 'Record<string, unknown>',
+                   documents: "Array<{ kind: string; url: string }>",
+                   stock_location_id: [:string, nullable: true],
+                   created_by_id: [:string, nullable: true],
+                   refunded_total: :string,
+                   refundable_total: :string
+
+          attributes :memo, :metadata, created_at: :iso8601, updated_at: :iso8601
+
+          attribute :stock_location_id do |return_record|
+            return_record.stock_location&.prefixed_id
+          end
+
+          attribute :created_by_id do |return_record|
+            return_record.created_by&.prefixed_id
+          end
+
+          attribute :refunded_total do |return_record|
+            return_record.refunded_total.to_s
+          end
+
+          attribute :refundable_total do |return_record|
+            return_record.refundable_total.to_s
+          end
+
+          many :return_line_items,
+               resource: proc { Spree.api.admin_return_line_item_serializer },
+               if: proc { expand?('return_line_items') }
+
+          one :reason, resource: proc { Spree.api.admin_return_reason_serializer }, if: proc { expand?('reason') }
+          one :order, resource: proc { Spree.api.admin_order_serializer }, if: proc { expand?('order') }
+          one :stock_location, resource: proc { Spree.api.admin_stock_location_serializer }, if: proc { expand?('stock_location') }
+          many :refunds, resource: proc { Spree.api.admin_refund_serializer }, if: proc { expand?('refunds') }
+
+          # Paperwork the provider produced beside the label: a cross-border
+          # return is declared like any other export.
+          attribute :documents do |return_record|
+            return_record.provider.documents(return_record).map(&:as_json)
+          end
+
+          # The prepaid label for the parcel coming back, refunded ones
+          # included — the postage history of the return.
+          many :shipping_labels, key: :labels, resource: proc { Spree.api.admin_shipping_label_serializer }
+
+          # Where the inbound parcel is, as the carrier last reported it.
+          many :deliveries, resource: proc { Spree.api.admin_delivery_serializer }
+        end
+      end
+    end
+  end
+end

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

@@ -2,14 +2,32 @@ 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.
+        # Admin API serializer for {Spree::Role}. A role belongs to the store
+        # it governs; permissions are flat catalog keys (see the
+        # `/admin/permissions` discovery endpoint). `mutable: false` marks the
+        # protected admin role and host-locked rows — the dashboard renders
+        # those read-only.
         class RoleSerializer < V3::BaseSerializer
-          typelize name: :string
+          typelize name: :string, description: 'string | null', mutable: :boolean,
+                   users_count: :number
+          typelize permissions: [:string, multi: true]
 
-          attributes :name, created_at: :iso8601, updated_at: :iso8601
+          attributes :name, :description, created_at: :iso8601, updated_at: :iso8601
+
+          # The admin role ignores its stored list and grants everything — so
+          # it reports every key its own audience may hold, which is what the
+          # role grid renders and what a duplicate of it copies.
+          attribute(:permissions) do |role|
+            role.name == Spree::Role::ADMIN_ROLE ? Spree.permissions.grantable_keys(role.audience) : role.permissions
+          end
+
+          attribute(:mutable, &:mutable?)
+
+          # Staff assignments. The role belongs to one store already, so every
+          # assignment it has is on that store.
+          attribute :users_count do |role|
+            role.role_users.size
+          end
         end
       end
     end

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

@@ -0,0 +1,33 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Admin API serializer for {Spree::SavedReport}: the reporting contract
+        # query and its attribution.
+        class SavedReportSerializer < V3::BaseSerializer
+          typelize name: :string,
+                   description: [:string, nullable: true],
+                   query: 'Record<string, unknown>',
+                   seeded: :boolean,
+                   user_id: [:string, nullable: true],
+                   author_name: [:string, nullable: true],
+                   created_at: :string,
+                   updated_at: :string
+
+          attributes :name, :description, :query, :seeded, :created_at, :updated_at
+
+          attribute :user_id do |report|
+            report.user&.prefixed_id
+          end
+
+          attribute :author_name do |report|
+            user = report.user
+            next nil unless user
+
+            user.full_name.presence || user.email
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # A seller's position in one currency (Spree::SellerBalance), for the
+        # operator. A computed value rather than a record, so it carries no id.
+        class SellerBalanceSerializer < V3::BaseSerializer
+          typelize seller_id: :string,
+                   currency: :string,
+                   settlement_currency: :string,
+                   converted: :boolean,
+                   earned: :string, display_earned: :string,
+                   payable: :string, display_payable: :string,
+                   paid: :string, display_paid: :string,
+                   balance: :string, display_balance: :string,
+                   pending: :string, display_pending: :string
+
+          _attributes.delete(:id)
+
+          # Two sides when the account settles in another currency: what the
+          # sales were worth, and what the account received once the provider
+          # converted. Never added together.
+          attributes :currency, :settlement_currency
+
+          attribute(:converted) { |balance| balance.converted? }
+
+          attribute(:seller_id) { |balance| balance.seller&.prefixed_id }
+
+          %i[earned payable paid balance pending].each do |figure|
+            attribute(figure) { |balance| balance.public_send(figure).to_s }
+            attribute(:"display_#{figure}") { |balance| balance.public_send(:"display_#{figure}").to_s }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Serializes Spree::SellerPayout — one settlement to one seller.
+        #
+        # Created by the sweep rather than by a caller, so the API offers no
+        # create or update. The one thing an operator does to a payout is say
+        # it landed, which is its own member action.
+        class SellerPayoutSerializer < V3::BaseSerializer
+          typelize seller_id: :string,
+                   seller_name: 'string | null',
+                   status: [:string, enum: Spree::SellerPayout.statuses, enum_type_name: 'SellerPayoutStatus'],
+                   provider: [:string, comment: 'Payout provider class name. Built-in: Spree::PayoutProvider::System. Provider gems register more.'],
+                   amount: :string,
+                   currency: :string,
+                   reference: 'string | null',
+                   period_start: 'string | null',
+                   period_end: 'string | null',
+                   transfers_count: :number,
+                   display_amount: :string
+
+          attributes :status, :currency, :provider, :reference, :metadata,
+                     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(:seller_id) { |payout| payout.seller&.prefixed_id }
+          attribute(:seller_name) { |payout| payout.seller&.name }
+
+          # How many earnings this settlement covers, so a list answers "what
+          # is in this deposit" without loading every transfer.
+          #
+          # Read from a count the controller made for the whole page when there
+          # is one; a single payout read falls back to asking for its own.
+          attribute(:transfers_count) do |payout, params|
+            counts = params && params[:transfer_counts]
+
+            counts ? counts.fetch(payout.id, 0) : payout.transfers.count
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # A configured requirement, as the operator manages it. Admin-only:
+        # what a marketplace asks of its sellers is between the operator and
+        # the seller, and never appears on the store surface.
+        class SellerRequirementSerializer < BaseSerializer
+          typelize kind: [:string, comment: 'Requirement kind. Built-in: accept_terms, complete_profile, billing_address, returns_address, delivery_method, package_type, minimum_products, payout_account, required_custom_fields, policy, attestation, operator_review, document. Extensions may register more.'], name: :string, description: [:string, nullable: true],
+                   position: :number, active: :boolean, required: :boolean,
+                   allow_multiple: :boolean, accepts_submissions: :boolean,
+                   reviewed_by_operator: :boolean,
+                   preferences: 'Record<string, unknown>',
+                   custom_field_definition_ids: [:string, multi: true],
+                   metadata: 'Record<string, unknown> | null'
+
+          attributes :position, :active, :required, :metadata,
+                     created_at: :iso8601,
+                     updated_at: :iso8601
+
+          # The kind, so a dashboard can key presentation off it without
+          # parsing the Ruby class name.
+          attribute :kind do |requirement|
+            requirement.class.api_type
+          end
+
+          # What the seller sees — the operator's wording, or the kind's own.
+          attribute :name do |requirement|
+            requirement.display_name
+          end
+
+          attribute :description do |requirement|
+            requirement.display_description
+          end
+
+          attribute :preferences do |requirement|
+            requirement.serialized_preferences
+          end
+
+          # The definitions a requirement asks for, when its kind takes any.
+          # Read through the association, so one the operator deleted is gone
+          # rather than echoed back as an id nothing can address.
+          attribute :custom_field_definition_ids do |requirement|
+            if requirement.respond_to?(:custom_field_definition_prefixed_ids)
+              requirement.custom_field_definition_prefixed_ids
+            else
+              []
+            end
+          end
+
+          # Capabilities of the kind, so the operator's form knows whether to
+          # offer a second row of it and whether sellers can submit anything.
+          attribute :allow_multiple do |requirement|
+            requirement.class.allow_multiple?
+          end
+
+          attribute :accepts_submissions do |requirement|
+            requirement.class.accepts_submissions?
+          end
+
+          attribute :reviewed_by_operator do |requirement|
+            requirement.class.reviewed_by_operator?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # One line of a seller's onboarding checklist — a requirement
+        # evaluated against them. A value object, so no id of its own: the
+        # `id` here is the requirement it came from, which is what a caller
+        # acts on.
+        class SellerRequirementStatusSerializer
+          include Alba::Resource
+          include Typelizer::DSL
+
+          typelize id: :string, kind: [:string, comment: 'Requirement kind. Built-in: accept_terms, complete_profile, billing_address, returns_address, delivery_method, package_type, minimum_products, payout_account, required_custom_fields, policy, attestation, operator_review, document. Extensions may register more.'], name: :string,
+                   description: [:string, nullable: true],
+                   required: :boolean, position: :number, status: [:string, enum: Spree::SellerRequirementStatus::STATUSES],
+                   blocking: :boolean, action_url: [:string, nullable: true],
+                   blocker: ['{ state: string; message: string | null } | null'],
+                   required_policy_name: [:string, nullable: true]
+
+          attributes :id, :kind, :name, :description, :required, :position, :status, :action_url, :blocker
+
+          # Whether this stands between the seller and approval. Serialized
+          # rather than left to each client to derive, so the dashboard's
+          # override warning and the approval gate cannot disagree.
+          attribute :blocking do |status|
+            status.blocking?
+          end
+
+          # The document this line asks for, and what the seller published
+          # against it. Embedded rather than left to a second request: the
+          # operator is deciding whether to approve, and a line that says
+          # "Done" without showing the text is not something to approve on.
+          attribute :required_policy_name do |status|
+            status.required_policy_name
+          end
+
+          one :submission,
+              resource: proc { Spree.api.admin_seller_requirement_submission_serializer },
+              if: proc { |status| status.submission.present? }
+
+          one :published_policy,
+              resource: proc { Spree.api.admin_policy_serializer },
+              if: proc { |status| status.published_policy.present? }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # What a seller submitted about one requirement, and what was made of
+        # it. The file is exposed as a URL rather than a blob id — it is what
+        # the reviewer opens.
+        class SellerRequirementSubmissionSerializer < BaseSerializer
+          typelize status: [:string, enum: Spree::SellerRequirementSubmission.statuses, enum_type_name: 'SellerRequirementSubmissionStatus'], note: [:string, nullable: true],
+                   review_note: [:string, nullable: true],
+                   reference: [:string, nullable: true],
+                   reviewed_at: [:string, nullable: true],
+                   file_url: [:string, nullable: true],
+                   file_name: [:string, nullable: true],
+                   seller_id: :string, requirement_id: :string,
+                   requirement_name: :string,
+                   metadata: 'Record<string, unknown> | null'
+
+          attributes :status, :note, :review_note, :reference, :metadata,
+                     reviewed_at: :iso8601,
+                     created_at: :iso8601,
+                     updated_at: :iso8601
+
+          attribute :seller_id do |submission|
+            submission.seller&.prefixed_id
+          end
+
+          attribute :requirement_id do |submission|
+            submission.requirement&.prefixed_id
+          end
+
+          # The reviewer is looking at a queue of these and needs to know what
+          # each one answers without fetching the requirement.
+          attribute :requirement_name do |submission|
+            submission.requirement&.display_name
+          end
+
+          # A path to this API's own download action rather than a storage
+          # URL: these are identity documents, and the download is authorized
+          # per request instead of being readable by anyone holding a link.
+          attribute :file_url do |submission|
+            next nil unless submission.file.attached?
+
+            Spree::Core::Engine.routes.url_helpers.download_api_v3_admin_seller_requirement_submission_path(
+              seller_id: submission.seller.prefixed_id,
+              id: submission.prefixed_id
+            )
+          end
+
+          attribute :file_name do |submission|
+            submission.file.attached? ? submission.file.filename.to_s : nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # A seller as the marketplace operator sees it: the public profile the
+        # shopper also gets, plus the operational state and the settlement and
+        # tax configuration only the operator sets.
+        class SellerSerializer < V3::SellerSerializer
+          typelize status: [:string, enum: Spree::Seller.statuses, enum_type_name: 'SellerStatus'],
+                   legal_name: [:string, nullable: true],
+                   registration_number: [:string, nullable: true],
+                   contact_email: [:string, nullable: true], billing_email: [:string, nullable: true],
+                   tax_remittance: :string,
+                   payouts_schedule_interval: [:string, nullable: true],
+                   minimum_payout_amount: [:string, nullable: true],
+                   holiday_mode_until: [:string, nullable: true],
+                   terms_accepted_at: [:string, nullable: true],
+                   deleted_at: [:string, nullable: true],
+                   on_holiday: :boolean, sellable: :boolean,
+                   products_count: :number, users_count: :number,
+                   onboarding_progress: '{ done: number; total: number }',
+                   onboarding_complete: :boolean,
+                   metadata: 'Record<string, unknown> | null'
+
+          attributes :status, :contact_email, :billing_email,
+                     :tax_remittance, :payouts_schedule_interval, :metadata,
+                     holiday_mode_until: :iso8601,
+                     terms_accepted_at: :iso8601,
+                     created_at: :iso8601,
+                     updated_at: :iso8601,
+                     deleted_at: :iso8601
+
+          # A seller's policies are the seller's own, managed on the seller
+          # branch — the operator neither edits nor lists them in 6.0. The
+          # inherited declaration is dropped rather than shadowed, since
+          # keeping it would render a store serializer inside an admin
+          # response.
+          _attributes.delete(:policies)
+
+          attribute :minimum_payout_amount do |seller|
+            seller.minimum_payout_amount&.to_s
+          end
+
+          # Approved but away still cannot sell, and the list has to say so
+          # without the dashboard re-deriving the rule.
+          attribute :on_holiday do |seller|
+            seller.on_holiday?
+          end
+
+          attribute :sellable do |seller|
+            seller.sellable?
+          end
+
+          # Saves the dashboard a request per row for the two counts its list
+          # and header show. Read off the seller, which memoizes the SQL count
+          # so the minimum-products requirement asks the same question free.
+          attribute :products_count do |seller|
+            seller.products_count
+          end
+
+          attribute :users_count do |seller|
+            seller.users.size
+          end
+
+          # How far through the marketplace's checklist this seller is — what
+          # the list's progress column and the profile's badge render. The
+          # requirements themselves, with their submissions, stay on the
+          # heavier `onboarding` action; a list of sellers needs the number,
+          # not the rows behind it.
+          attribute :onboarding_progress do |seller|
+            seller.onboarding_progress
+          end
+
+          attribute :onboarding_complete do |seller|
+            seller.onboarding_complete?
+          end
+
+          attribute :legal_name, &:legal_name
+          attribute :registration_number, &:registration_number
+
+          one :billing_address,
+              resource: proc { Spree.api.admin_address_serializer },
+              if: proc { |seller| seller.billing_address.present? }
+
+          one :returns_address,
+              resource: proc { Spree.api.admin_address_serializer },
+              if: proc { |seller| seller.returns_address.present? }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # A person who runs one of the marketplace's sellers.
+        #
+        # Deliberately not `AdminUserSerializer`: its `roles` attribute keeps
+        # only the roles held on the current *store*, and a seller's team hold
+        # theirs on the seller — so every member would read as having none. The
+        # role is not worth reporting anyway, since a seller's team all hold
+        # the one seeded role that carries the whole seller vocabulary.
+        class SellerTeamMemberSerializer < V3::BaseSerializer
+          typelize email: :string,
+                   first_name: [:string, nullable: true],
+                   last_name: [:string, nullable: true],
+                   full_name: [:string, nullable: true],
+                   avatar_url: [:string, nullable: true]
+
+          attributes :email, :first_name, :last_name, :full_name,
+                     created_at: :iso8601, updated_at: :iso8601
+
+          attribute :avatar_url do |user|
+            image_url_for(user.avatar)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Serializes Spree::SellerTransfer — what one order earned one seller.
+        #
+        # Read-only: a transfer records money that moved, or is moving. What
+        # corrects it is a reversal, which is another row rather than an edit.
+        class SellerTransferSerializer < V3::BaseSerializer
+          typelize seller_id: :string,
+                   order_id: 'string | null',
+                   payout_id: 'string | null',
+                   reversed_from_id: 'string | null',
+                   refund_id: 'string | null',
+                   seller_name: 'string | null',
+                   order_number: 'string | null',
+                   kind: [:string, enum: Spree::SellerTransfer::KINDS],
+                   status: [:string, enum: Spree::SellerTransfer.statuses, enum_type_name: 'SellerTransferStatus'],
+                   provider: [:string, comment: 'Payout provider class name. Built-in: Spree::PayoutProvider::System. Provider gems register more.'],
+                   amount: :string,
+                   currency: :string,
+                   settled_amount: 'string | null',
+                   settled_currency: 'string | null',
+                   converted: :boolean,
+                   reference: 'string | null',
+                   display_amount: :string
+
+          attributes :kind, :status, :currency, :provider, :reference, :metadata,
+                     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 }
+
+          # What the 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_currency) { |transfer| transfer.settled_currency }
+          attribute(:converted) { |transfer| transfer.converted? }
+
+          %i[seller order payout reversed_from refund].each do |association|
+            attribute(:"#{association}_id") { |transfer| transfer.public_send(association)&.prefixed_id }
+          end
+
+          # Both readable without expanding, since a ledger table is read row
+          # by row and these are what identify a row to an operator.
+          attribute(:seller_name) { |transfer| transfer.seller&.name }
+          attribute(:order_number) { |transfer| transfer.order&.number }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # A bought or uploaded carrier label. Admin-only by design: the cost is
+        # what the merchant paid the carrier, and the ids are the provider's.
+        # The file is streamed through +download_url+, never linked to storage.
+        class ShippingLabelSerializer < V3::BaseSerializer
+          typelize owner_id: :string,
+                   owner_type: [:string, enum: Spree::ShippingLabel::OWNER_TYPES],
+                   source: [:string, enum: Spree::ShippingLabel::SOURCES],
+                   status: [:string, enum: Spree::ShippingLabel.statuses, enum_type_name: 'ShippingLabelStatus'],
+                   carrier: [:string, nullable: true],
+                   carrier_name: [:string, nullable: true],
+                   service: [:string, nullable: true],
+                   tracking_number: [:string, nullable: true],
+                   cost: :string,
+                   currency: [:string, nullable: true],
+                   display_cost: :string,
+                   format: [:string, nullable: true],
+                   external_id: [:string, nullable: true],
+                   integration_id: [:string, nullable: true],
+                   download_url: [:string, nullable: true],
+                   file_pending: :boolean,
+                   refunded_at: [:string, nullable: true],
+                   metadata: 'Record<string, unknown>'
+
+          attributes :source, :status, :carrier, :carrier_name, :service, :tracking_number, :currency, :format,
+                     :external_id, :metadata, refunded_at: :iso8601, created_at: :iso8601, updated_at: :iso8601
+
+          attribute :owner_id do |shipping_label|
+            shipping_label.owner&.prefixed_id
+          end
+
+          attribute :owner_type do |shipping_label|
+            shipping_label.owner_type == 'Spree::Return' ? 'return' : 'fulfillment'
+          end
+
+          attribute :cost do |shipping_label|
+            shipping_label.cost.to_s
+          end
+
+          attribute :display_cost do |shipping_label|
+            shipping_label.display_cost.to_s
+          end
+
+          attribute :integration_id do |shipping_label|
+            shipping_label.integration&.prefixed_id
+          end
+
+          # Whether the file is still being fetched from the carrier; the
+          # download proxies the provider's copy meanwhile.
+          attribute :file_pending do |shipping_label|
+            shipping_label.file_pending?
+          end
+
+          # Our own endpoint rather than a storage URL: the controller streams
+          # the bytes, so admin auth runs on every print.
+          attribute :download_url do |shipping_label|
+            next nil unless shipping_label.file.attached? || shipping_label.file_pending?
+
+            helpers = Spree::Core::Engine.routes.url_helpers
+            owner = shipping_label.owner
+            # Both paths are nested under an order; a fulfillment still on a
+            # cart has none, so there is nowhere to download it from yet.
+            next nil if owner.order.nil?
+
+            if owner.is_a?(Spree::Return)
+              helpers.download_api_v3_admin_order_return_label_path(
+                order_id: owner.order.prefixed_id, return_id: owner.prefixed_id, id: shipping_label.prefixed_id
+              )
+            else
+              helpers.download_api_v3_admin_order_fulfillment_label_path(
+                order_id: owner.order.prefixed_id, fulfillment_id: owner.prefixed_id, id: shipping_label.prefixed_id
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,8 +2,8 @@ module Spree
   module Api
     module V3
       module Admin
+        # No timestamps — see Admin::CountrySerializer.
         class StateSerializer < V3::StateSerializer
-          attributes created_at: :iso8601, updated_at: :iso8601
         end
       end
     end