Skip to content

The complete open source platform to run your entire marketplace. Storefront, vendor panel, admin console, and integrations in one enterprise-grade platform you own.

feat(core): seller management improvements, read-only RBAC link, and suspend validation (#811)

Viktor Holikce780f410448
diff --git a/docs/roles-and-permissions.md b/docs/roles-and-permissions.md
new file mode 100644
index 000000000..bab7bb623
--- /dev/null
+++ b/docs/roles-and-permissions.md
@@ -0,0 +1,88 @@
+# Roles and Permissions
+
+Mercur uses a **role-based access control (RBAC)** system to govern what each [seller member](seller-members.md) can do within a seller account. This page describes the two-layer architecture, the default permission set, the built-in roles, and how role assignment works.
+
+## Two-Layer Architecture
+
+The RBAC system is built on two layers:
+
+1. **Permissions** — Fine-grained capabilities defined at the platform level (e.g. "can edit products", "can view orders"). Permissions are atomic and cannot be subdivided further.
+2. **Roles** — Named bundles of permissions that can be assigned to members. A role groups related permissions into a meaningful job function (e.g. "Inventory Management" bundles product and stock permissions together).
+
+Members are never assigned permissions directly. Instead, they receive one or more **roles**, and their effective permissions are the union of all permissions across their assigned roles.
+
+## Permissions
+
+The platform ships with the following permissions:
+
+
+| Permission | Description |
+| ------------------- | ---------------------------------------------------------- |
+| `seller_management` | Manage seller account settings, profile, and configuration |
+| `member_management` | Add, remove, and manage members and their role assignments |
+| `product_read` | View products, variants, and associated data |
+| `product_write` | Create, edit, and delete products and variants |
+| `inventory_read` | View stock levels and inventory locations |
+| `inventory_write` | Update stock levels and manage inventory |
+| `order_read` | View orders, line items, and order history |
+| `order_write` | Process orders — fulfill, cancel, issue refunds |
+| `payout_read` | View payout history and balance information |
+| `payout_write` | Request payouts and manage payout settings |
+| `customer_read` | View customer information related to the seller's orders |
+| `support` | Access and respond to customer inquiries and disputes |
+
+
+### Permissions Grow With Modules
+
+The permissions listed above represent the **base set** shipped with the core platform. As additional modules are installed (e.g. promotions, analytics, messaging), new permissions are registered automatically. The RBAC system is designed to accommodate this growth without requiring changes to existing roles.
+
+## Default Roles
+
+Mercur includes **five default roles** that cover common team structures:
+
+
+| Role | Permissions Included |
+| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Store Administration** | `seller_management`, `member_management`, `product_read`, `product_write`, `inventory_read`, `inventory_write`, `order_read`, `order_write`, `payout_read`, `payout_write`, `customer_read`, `support` |
+| **Inventory Management** | `product_read`, `product_write`, `inventory_read`, `inventory_write` |
+| **Order Management** | `order_read`, `order_write`, `customer_read`, `support` |
+| **Accounting** | `order_read`, `payout_read`, `payout_write` |
+| **Support** | `order_read`, `customer_read`, `support` |
+
+
+### Default Roles Are Immutable
+
+Default roles **cannot be edited or deleted**. They provide a consistent baseline across all seller accounts on the platform. This ensures that core job functions remain predictable regardless of customization elsewhere.
+
+If the default roles do not match a seller's team structure, custom roles (see below) will address this in a future release.
+
+## Role Assignment
+
+Roles are assigned **per seller account**. When a [member](seller-members.md) is added to a seller account, they receive one or more roles that define their permissions within that specific store.
+
+Key points:
+
+- A member can hold **multiple roles** on the same seller account. Their effective permissions are the combined set of all assigned roles.
+- The same user can have **different roles** on different seller accounts. For example, a user might be a Store Administrator on one store and limited to Order Management on another.
+- Role assignment is managed by members with the `member_management` permission or by platform operators.
+
+### Minimum Admin Requirement
+
+Every seller account must have at least one member assigned the **Store Administration** role (or a role containing `member_management`). This prevents a seller account from becoming unmanageable — there must always be someone who can manage team access.
+
+## Custom Roles (Phase 2)
+
+A future release will introduce **custom roles**, allowing seller admins to define their own permission bundles tailored to their team's needs. Custom roles will:
+
+- Be created and managed per seller account
+- Combine any subset of available permissions
+- Coexist alongside the immutable default roles
+
+Until custom roles are available, sellers should use the default roles and assign multiple roles to members who need a specific combination of permissions.
+
+## Relationship to Other Concepts
+
+- **Members** are assigned roles through their [seller–member association](seller-members.md)
+- **Seller accounts** define the scope in which roles apply (see [Seller](seller.md))
+- **Subscriptions** are independent of RBAC — billing access is controlled by the `payout_read` / `payout_write` permissions within the Accounting role (see [Subscriptions](subscriptions.md))
+
diff --git a/docs/seller-members.md b/docs/seller-members.md
new file mode 100644
index 000000000..9299aeda2
--- /dev/null
+++ b/docs/seller-members.md
@@ -0,0 +1,77 @@
+# Seller Members
+
+A **seller member** represents a user who has access to a seller account. Mercur supports **multi-user seller accounts** — multiple people can manage the same store — and **multi-seller users** — a single person can belong to more than one store. This page covers how members relate to sellers, how access is structured, and the rules governing team management.
+
+## Concept
+
+The relationship between users and sellers is **many-to-many**. A seller account can have several members (e.g. an owner, a warehouse manager, and a support agent), and a single user can be a member of multiple seller accounts (e.g. a consultant managing stores for different brands).
+
+Each membership is a distinct association that carries its own [role assignment](roles-and-permissions.md). This means the same user can have different permissions on different stores.
+
+## Member Data
+
+Each member record holds the following information:
+
+| Field | Description |
+|---|---|
+| `email` | The member's email address, used for login and notifications |
+| `locale` | Preferred language/locale for the vendor portal UI |
+| `status` | Whether the member is active or deactivated |
+
+The member's identity is tied to their **email address**. Email addresses must be unique across all members within a single seller account but the same email can appear on different seller accounts.
+
+## Member–Seller Association
+
+When a member is added to a seller account, the association includes:
+
+- A reference to the **seller account**
+- A reference to the **member**
+- One or more **roles** that define the member's permissions on that account
+
+This association is the core of the access model. Removing the association revokes the member's access to that seller account entirely.
+
+## Store Switcher
+
+For users who belong to multiple seller accounts, the vendor portal provides a **store switcher**. Each store context is fully isolated — when a member switches stores, they see only the data (products, orders, payouts) belonging to that seller account, and their permissions are governed by the roles assigned on that specific account.
+
+This isolation ensures that access to one store never leaks information from another, even when the same person manages both.
+
+## Adding Members
+
+Members can be added to a seller account by:
+
+- **Operators** — via the admin dashboard, an operator can add members to any seller account
+- **Seller admins** — members with the appropriate role (see [Roles and Permissions](roles-and-permissions.md)) can invite new members to their own seller account
+
+When a new member is added, they receive an invitation to set up their access. If the email already belongs to an existing user in the system, the new seller association is linked to their existing account.
+
+## Removing Members
+
+Removing a member **deletes the association** between the user and the seller account. The user's account continues to exist — they simply lose access to that particular store.
+
+Both **operators** and **seller admins** can remove members, subject to the constraint that a seller account must always retain at least one admin member.
+
+## Deactivation vs. Deletion
+
+Rather than removing a member entirely, a seller admin can **deactivate** a member. A deactivated member:
+
+- Cannot log in to the seller account
+- Retains their association and role assignments
+- Can be reactivated later without re-invitation
+
+This is useful for temporary access revocation — for example, when a seasonal worker is off-duty or when investigating a potential issue.
+
+## Member Notifications
+
+In the current implementation, **all members** of a seller account receive all notifications related to that account (order placed, payout settled, etc.). There is no per-member notification filtering — every member sees every event.
+
+Future iterations may introduce notification preferences tied to roles or individual member settings.
+
+## Business Rules
+
+- A seller account must have **at least one member** with an admin role at all times
+- **Email addresses** must be unique within a single seller account
+- A member's **roles** are scoped to a specific seller account — the same user can hold different roles on different stores
+- **Deactivation** preserves the member record; **removal** deletes the association entirely
+- Members are managed through the [seller account lifecycle](seller.md) — if a seller is terminated, all member associations are effectively void
+- Permissions are determined by the member's assigned roles (see [Roles and Permissions](roles-and-permissions.md))
diff --git a/docs/seller.md b/docs/seller.md
new file mode 100644
index 000000000..97503eab8
--- /dev/null
+++ b/docs/seller.md
@@ -0,0 +1,129 @@
+# Seller
+
+A **seller** is the central actor in a Mercur marketplace. Every product listing, order, payout, and storefront presence traces back to a seller account. This page covers the seller data model, lifecycle, and the business rules that govern how sellers operate on the platform.
+
+## Seller Profile
+
+Each seller account holds the following core fields:
+
+
+| Field | Description |
+| ----------------- | ----------------------------------------------------------------------------- |
+| `name` | Display name shown to customers on the storefront (unique) |
+| `handle` | URL-friendly identifier for the seller (unique) |
+| `email` | Primary contact email for the seller account (unique) |
+| `description` | Free-text seller description, typically shown on the seller's storefront page |
+| `logo` | Seller logo or avatar |
+| `banner` | Banner image for the seller's storefront page |
+| `website_url` | Seller's external website |
+| `currency_code` | The single currency in which this seller operates |
+| `is_premium` | Operator-designated premium seller flag (see below) |
+| `status_reason` | Optional explanation for the current status (e.g. reason for suspension) |
+| `external_id` | Identifier in an external system (unique, optional) |
+| `metadata` | Arbitrary JSON metadata |
+
+
+### Single Currency Per Account
+
+Every seller account is locked to **one currency**. Prices, payouts, and subscription billing all use this currency. This constraint keeps financial reporting simple and eliminates exchange-rate ambiguity in payouts.
+
+If a seller needs to trade in multiple currencies, the recommended pattern is to create **separate seller accounts** — one per currency. Each account operates independently with its own products, orders, and payouts.
+
+### Professional Sellers
+
+A seller is considered professional when it has associated **`professional_details`** — a separate record containing business information such as company name, registration number, and VAT ID. If this record is present, the seller is treated as a registered business; if absent, the seller is an individual.
+
+This distinction affects tax handling, invoice formatting, and may influence storefront presentation.
+
+## Address and Payment Information
+
+Sellers can store one or more **addresses** (warehouse, return, business) and **payment details** used for payout processing. These are managed as sub-resources of the seller account and are referenced by workflows such as fulfillment and payout settlement.
+
+## Seller Lifecycle
+
+A seller account moves through **four statuses** over its lifetime:
+
+```
+ ┌──────────────────┐
+ │ pending_approval │
+ └────────┬─────────┘
+ │ approve
+ ▼
+ ┌──────────┐ ┌────────┐
+ │ suspended │◄────►│ open │
+ └──────────┘ └───┬────┘
+ │ terminate
+ ▼
+ ┌────────────┐
+ │ terminated │
+ └────────────┘
+```
+
+### Status Definitions
+
+- `**pending_approval**` — The seller has registered but has not yet been reviewed by the platform operator.
+- `**open**` — The seller is active and may list products, receive orders, and collect payouts.
+- `**suspended**` — The seller's operations are temporarily frozen. Products remain in the catalog but cannot be purchased.
+- `**terminated**` — The seller account is permanently closed. This status is irreversible.
+
+### Status Transition Rules
+
+
+| From | To | Who | Conditions |
+| ------------------ | ------------ | ----------------- | --------------------------------------------------------- |
+| `pending_approval` | `open` | Operator | Operator reviews and approves the application |
+| `open` | `suspended` | Operator | Policy violation, compliance hold, or operator discretion |
+| `suspended` | `open` | Operator | Issue resolved, seller reinstated |
+| `open` | `terminated` | Operator / Seller | All prerequisites met (see below) |
+| `suspended` | `terminated` | Operator | All prerequisites met (see below) |
+
+
+Transitions not listed above are **not permitted**. A terminated seller cannot be reopened — a new account must be created instead.
+
+### Termination Prerequisites
+
+Before a seller account can be terminated:
+
+- All **open orders** must be fulfilled, cancelled, or otherwise resolved
+- All **pending payouts** must be settled or forfeited
+- Any **active subscription** must be cancelled and final billing completed
+
+## Scheduled Closures
+
+Sellers can schedule **temporary closures** without changing their account status. Two date fields control this:
+
+- `closed_from` — The date the closure begins
+- `closed_to` — The date the closure ends
+
+During a scheduled closure the seller's storefront shows as unavailable and new orders cannot be placed, but the account remains in `open` status. This is designed for holidays, seasonal breaks, or planned downtime. Once `closed_to` passes, the seller automatically resumes normal operation.
+
+Scheduled closures are **not a status** — they overlay on top of the current status and do not affect status transition rules.
+
+## Premium Sellers
+
+The `is_premium` flag is set **exclusively by the platform operator**. Sellers cannot designate themselves as premium. This flag is used for storefront features such as:
+
+- Featured placement in search results or category pages
+- Visual badges or highlights on the seller's profile
+- Priority in marketplace curation
+
+The specific storefront behavior tied to premium status is determined by the frontend implementation.
+
+## Registration Flows
+
+There are **three methods** for creating a seller account:
+
+1. **Operator-created** — The platform operator creates the seller account directly via the admin dashboard. The account can be set to `open` immediately, bypassing `pending_approval`.
+2. **Invite** — The operator sends an invitation to a prospective seller. The seller completes registration using the invite link. The resulting account may still require approval depending on platform configuration.
+3. **Self-registration** — The seller registers through the public-facing registration flow. The account enters `pending_approval` status and waits for operator review.
+
+## Business Rules Summary
+
+- A seller account operates in **exactly one currency**
+- The presence of `professional_details` determines whether the seller is a registered business
+- Only the **operator** can approve, suspend, or reinstate sellers
+- **Termination** is irreversible and requires all orders and payouts to be resolved
+- Scheduled closures are **date-driven** and do not change account status
+- **Premium** designation is operator-only and influences storefront presentation
+- Every seller account must have at least one [member](seller-members.md) with an admin role (see [Roles and Permissions](roles-and-permissions.md))
+
diff --git a/docs/subscriptions.md b/docs/subscriptions.md
new file mode 100644
index 000000000..3c4f8df02
--- /dev/null
+++ b/docs/subscriptions.md
@@ -0,0 +1,93 @@
+# Subscriptions
+
+**Subscriptions** allow the platform operator to charge sellers a recurring fee for marketplace access. This is an opt-in feature — when disabled, sellers operate without any platform billing. This page covers the subscription model, billing rules, and how overrides work.
+
+## Platform-Level Toggle
+
+Subscriptions are controlled by a **platform-wide toggle**:
+
+- **Disabled** (default) — No subscription billing occurs. Sellers are not charged any platform fees. The subscription UI is hidden from both the admin dashboard and the vendor portal.
+- **Enabled** — Sellers are billed according to their subscription plan. The operator must configure at least one default plan before enabling subscriptions.
+
+Toggling subscriptions off after they have been enabled **does not delete** existing subscription records. Billing simply stops, and sellers are not charged for subsequent periods. Re-enabling resumes billing from the next cycle.
+
+## Default Subscription Plan
+
+When subscriptions are enabled, the operator defines a **default plan** for each currency in which sellers operate. Each plan specifies:
+
+| Field | Description |
+|---|---|
+| `currency_code` | The currency this plan applies to (matches the seller's `currency_code`, unique per plan) |
+| `monthly_amount` | The recurring fee charged each billing cycle |
+| `free_months` | Number of initial months during which no charge is applied (default: 0) |
+| `requires_orders` | When enabled, billing only occurs for months in which the seller had at least one order |
+| `metadata` | Arbitrary JSON metadata |
+
+### How the Default Plan Works
+
+When a new [seller](seller.md) account is approved, the system automatically assigns the default plan matching the seller's currency. The seller begins their subscription immediately, starting with any configured free months.
+
+The `requires_orders` flag is designed for marketplaces that want to avoid charging inactive sellers. When this flag is set, a billing cycle with zero orders produces no invoice — the seller is effectively not charged for that month.
+
+## Per-Seller Overrides
+
+The operator can override subscription terms for **individual sellers**. An override is linked to a plan and identified by a `reference` / `reference_id` pair (e.g. referencing a specific seller). Each seller can have at most one override per plan. Override fields take precedence over the default plan when present:
+
+| Field | Description |
+|---|---|
+| `monthly_amount` | Custom recurring fee (nullable — when null, the plan's amount applies) |
+| `free_months` | Custom number of free initial months (nullable — when null, the plan's value applies) |
+| `free_from` | Start date of a temporary free period |
+| `free_to` | End date of a temporary free period |
+| `metadata` | Arbitrary JSON metadata |
+
+The `free_from` / `free_to` date range allows **time-bound fee waivers** independent of the initial free months. This is useful for granting temporary relief without permanently changing the seller's subscription terms.
+
+Overrides are managed through the admin dashboard and can be applied at any time during the seller's lifecycle. They are commonly used for:
+
+- **Promotional onboarding** — Offering an extended free trial to attract high-value sellers
+- **Negotiated rates** — Enterprise or high-volume sellers may negotiate custom pricing
+- **Temporary relief** — Waiving fees for a specific date range during platform incidents or market disruptions
+
+## Billing Rules
+
+### Billing Cycle
+
+Subscriptions are billed on a **monthly anniversary** basis. The cycle starts on the date the seller's account was approved, and each subsequent billing occurs on the same day of the month.
+
+If the start date falls on the 29th, 30th, or 31st, billing rolls to the last day of shorter months.
+
+### Billing Across Statuses
+
+Subscription billing continues regardless of the seller's [account status](seller.md), with one exception:
+
+| Status | Billed? | Notes |
+|---|---|---|
+| `open` | Yes | Normal billing |
+| `suspended` | Yes | Seller is still occupying platform resources |
+| `pending_approval` | No | Billing begins only after approval |
+| `terminated` | No | Final invoice issued at termination; no further billing |
+
+Suspended sellers **continue to be billed**. This is intentional — suspension is a temporary measure, and the seller retains their catalog, data, and platform presence. If the operator does not wish to charge a suspended seller, they can apply a per-seller override.
+
+### Negative Balance
+
+If a seller's subscription payment fails, the unpaid amount carries forward as a **negative balance**. The platform does not automatically retry payment. The outstanding amount is added to the next billing cycle's invoice.
+
+Persistent negative balances may be grounds for suspension or termination at the operator's discretion.
+
+## Taxes on Subscriptions
+
+In the current implementation, subscription fees support a **flat tax rate** or **zero tax**:
+
+- The operator configures a single tax rate that applies to all subscription invoices
+- Tax is calculated on the `monthly_amount` and included as a line item on the invoice
+- Per-region or per-category tax rules are not supported for subscriptions in this phase
+
+Future iterations may integrate with the platform's tax engine for more granular tax handling.
+
+## Relationship to Other Concepts
+
+- **Seller accounts** determine which default plan applies based on `currency_code` (see [Seller](seller.md))
+- **Billing access** in the vendor portal is controlled by the `payout_read` and `payout_write` permissions (see [Roles and Permissions](roles-and-permissions.md))
+- Subscription status is independent of [member management](seller-members.md) — adding or removing members does not affect billing
diff --git a/integration-tests/http/seller/admin/seller.spec.ts b/integration-tests/http/seller/admin/seller.spec.ts
new file mode 100644
index 000000000..e33c739cf
--- /dev/null
+++ b/integration-tests/http/seller/admin/seller.spec.ts
@@ -0,0 +1,1557 @@
+import { medusaIntegrationTestRunner } from "@medusajs/test-utils"
+import { MedusaContainer } from "@medusajs/framework/types"
+import {
+ adminHeaders,
+ createAdminUser,
+} from "../../../helpers/create-admin-user"
+import { createSellerUser } from "../../../helpers/create-seller-user"
+
+jest.setTimeout(50000)
+
+medusaIntegrationTestRunner({
+ testSuite: ({ getContainer, api, dbConnection }) => {
+ describe("Admin - Sellers", () => {
+ let appContainer: MedusaContainer
+ let sellerA: any
+ let sellerB: any
+ let sellerC: any
+ let memberA: any
+ let memberB: any
+ let memberC: any
+
+ beforeAll(async () => {
+ appContainer = getContainer()
+ })
+
+ beforeEach(async () => {
+ await createAdminUser(dbConnection, adminHeaders, appContainer)
+
+ const resultA = await createSellerUser(appContainer, {
+ email: "[email protected]",
+ name: "Alpha Store",
+ })
+ sellerA = resultA.seller
+ memberA = resultA.member
+
+ const resultB = await createSellerUser(appContainer, {
+ email: "[email protected]",
+ name: "Beta Premium",
+ })
+ sellerB = resultB.seller
+ memberB = resultB.member
+
+ const resultC = await createSellerUser(appContainer, {
+ email: "[email protected]",
+ name: "Gamma Shop",
+ })
+ sellerC = resultC.seller
+ memberC = resultC.member
+ })
+
+ describe("POST /admin/sellers", () => {
+ it("should create a seller with required fields", async () => {
+ const response = await api.post(
+ `/admin/sellers`,
+ {
+ name: "New Seller",
+ email: "[email protected]",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.seller).toEqual(
+ expect.objectContaining({
+ name: "New Seller",
+ email: "[email protected]",
+ currency_code: "usd",
+ })
+ )
+ })
+
+ it("should auto-generate handle from name", async () => {
+ const response = await api.post(
+ `/admin/sellers`,
+ {
+ name: "My Awesome Store",
+ email: "[email protected]",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.seller.handle).toEqual("my-awesome-store")
+ })
+
+ it("should default status to pending_approval", async () => {
+ const response = await api.post(
+ `/admin/sellers`,
+ {
+ name: "Pending Seller",
+ email: "[email protected]",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.seller.status).toEqual("pending_approval")
+ })
+
+ it("should create an associated member with the provided email", async () => {
+ const response = await api.post(
+ `/admin/sellers`,
+ {
+ name: "Member Test Seller",
+ email: "[email protected]",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+
+ const membersResponse = await api.get(
+ `/admin/sellers/${response.data.seller.id}/members`,
+ adminHeaders
+ )
+
+ expect(membersResponse.data.seller_members).toHaveLength(1)
+ })
+
+ it("should set the first member as owner", async () => {
+ const response = await api.post(
+ `/admin/sellers`,
+ {
+ name: "Owner Test Seller",
+ email: "[email protected]",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+
+ const membersResponse = await api.get(
+ `/admin/sellers/${response.data.seller.id}/members`,
+ adminHeaders
+ )
+
+ expect(membersResponse.data.seller_members[0].is_owner).toBe(true)
+ })
+
+ it("should create a seller with all optional fields", async () => {
+ const response = await api.post(
+ `/admin/sellers`,
+ {
+ name: "Full Seller",
+ handle: "custom-handle",
+ email: "[email protected]",
+ currency_code: "eur",
+ description: "A great seller",
+ website_url: "https://example.com",
+ external_id: "ext-123",
+ is_premium: true,
+ metadata: { key: "value" },
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.seller).toEqual(
+ expect.objectContaining({
+ name: "Full Seller",
+ handle: "custom-handle",
+ description: "A great seller",
+ website_url: "https://example.com",
+ external_id: "ext-123",
+ is_premium: true,
+ })
+ )
+ })
+
+ it("should use provided handle instead of auto-generating", async () => {
+ const response = await api.post(
+ `/admin/sellers`,
+ {
+ name: "Handle Override",
+ handle: "my-custom-handle",
+ email: "[email protected]",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.seller.handle).toEqual("my-custom-handle")
+ })
+
+ it("should create a seller with is_premium true", async () => {
+ const response = await api.post(
+ `/admin/sellers`,
+ {
+ name: "Premium Seller",
+ email: "[email protected]",
+ currency_code: "usd",
+ is_premium: true,
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.seller.is_premium).toBe(true)
+ })
+
+ it("should fail for missing name", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers`,
+ {
+ email: "[email protected]",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail for missing email", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers`,
+ {
+ name: "No Email Seller",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail for missing currency_code", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers`,
+ {
+ name: "No Currency",
+ email: "[email protected]",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail for missing member object", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers`,
+ {
+ name: "No Member",
+ email: "[email protected]",
+ currency_code: "usd",
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail for invalid email format", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers`,
+ {
+ name: "Bad Email",
+ email: "not-an-email",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail for invalid logo URL format", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers`,
+ {
+ name: "Bad Logo",
+ email: "[email protected]",
+ currency_code: "usd",
+ logo: "not-a-url",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail for invalid banner URL format", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers`,
+ {
+ name: "Bad Banner",
+ email: "[email protected]",
+ currency_code: "usd",
+ banner: "not-a-url",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail for duplicate seller email", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers`,
+ {
+ name: "Duplicate Email Seller",
+ email: "[email protected]",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+
+ it("should fail for duplicate seller name", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers`,
+ {
+ name: "Alpha Store",
+ email: "[email protected]",
+ currency_code: "usd",
+ member: { email: "[email protected]" },
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+ })
+
+ describe("GET /admin/sellers", () => {
+ it("should list all sellers", async () => {
+ const response = await api.get(`/admin/sellers`, adminHeaders)
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers).toBeDefined()
+ expect(response.data.sellers.length).toBeGreaterThanOrEqual(3)
+ })
+
+ it("should return count, offset, limit in response", async () => {
+ const response = await api.get(`/admin/sellers`, adminHeaders)
+
+ expect(response.status).toEqual(200)
+ expect(response.data.count).toBeDefined()
+ expect(response.data.offset).toBeDefined()
+ expect(response.data.limit).toBeDefined()
+ })
+
+ it("should filter by status pending_approval", async () => {
+ const response = await api.get(
+ `/admin/sellers?status=pending_approval`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ response.data.sellers.forEach((seller: any) => {
+ expect(seller.status).toEqual("pending_approval")
+ })
+ })
+
+ it("should filter by status open", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api.get(
+ `/admin/sellers?status=open`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers.length).toBeGreaterThanOrEqual(1)
+ response.data.sellers.forEach((seller: any) => {
+ expect(seller.status).toEqual("open")
+ })
+ })
+
+ it("should filter by is_premium true", async () => {
+ await api.post(
+ `/admin/sellers/${sellerB.id}`,
+ { is_premium: true },
+ adminHeaders
+ )
+
+ const response = await api.get(
+ `/admin/sellers?is_premium=true`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers.length).toBeGreaterThanOrEqual(1)
+ response.data.sellers.forEach((seller: any) => {
+ expect(seller.is_premium).toBe(true)
+ })
+ })
+
+ it("should filter by is_premium false", async () => {
+ await api.post(
+ `/admin/sellers/${sellerB.id}`,
+ { is_premium: true },
+ adminHeaders
+ )
+
+ const response = await api.get(
+ `/admin/sellers?is_premium=false`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ response.data.sellers.forEach((seller: any) => {
+ expect(seller.is_premium).toBe(false)
+ })
+ })
+
+ it("should filter by name", async () => {
+ const response = await api.get(
+ `/admin/sellers?name=Alpha+Store`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers).toHaveLength(1)
+ expect(response.data.sellers[0].name).toEqual("Alpha Store")
+ })
+
+ it("should filter by name array", async () => {
+ const response = await api.get(
+ `/admin/sellers?name[]=Alpha+Store&name[]=Beta+Premium`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers).toHaveLength(2)
+ })
+
+ it("should filter by id", async () => {
+ const response = await api.get(
+ `/admin/sellers?id=${sellerA.id}`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers).toHaveLength(1)
+ expect(response.data.sellers[0].id).toEqual(sellerA.id)
+ })
+
+ it("should filter by id array", async () => {
+ const response = await api.get(
+ `/admin/sellers?id[]=${sellerA.id}&id[]=${sellerC.id}`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers).toHaveLength(2)
+ })
+
+ it("should filter by email", async () => {
+ const response = await api.get(
+ `/admin/[email protected]`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers).toHaveLength(1)
+ expect(response.data.sellers[0].email).toEqual("[email protected]")
+ })
+
+ it("should filter by handle", async () => {
+ const response = await api.get(
+ `/admin/sellers?handle=alpha-store`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers).toHaveLength(1)
+ expect(response.data.sellers[0].handle).toEqual("alpha-store")
+ })
+
+ it("should search by q param", async () => {
+ const response = await api.get(
+ `/admin/sellers?q=Alpha`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers.length).toBeGreaterThanOrEqual(1)
+ expect(response.data.sellers[0].name).toContain("Alpha")
+ })
+
+ it("should return empty for non-matching search", async () => {
+ const response = await api.get(
+ `/admin/sellers?q=nonexistentseller`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers).toHaveLength(0)
+ })
+
+ it("should support limit pagination", async () => {
+ const response = await api.get(
+ `/admin/sellers?limit=1`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers).toHaveLength(1)
+ expect(response.data.limit).toEqual(1)
+ })
+
+ it("should support offset pagination", async () => {
+ const response = await api.get(
+ `/admin/sellers?offset=1&limit=1`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.sellers).toHaveLength(1)
+ expect(response.data.offset).toEqual(1)
+ })
+
+ it("should return correct total count with pagination", async () => {
+ const response = await api.get(
+ `/admin/sellers?limit=1`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.count).toBeGreaterThanOrEqual(3)
+ })
+ })
+
+ describe("GET /admin/sellers/:id", () => {
+ it("should retrieve a seller by id with all fields", async () => {
+ const response = await api.get(
+ `/admin/sellers/${sellerA.id}`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller).toEqual(
+ expect.objectContaining({
+ id: sellerA.id,
+ name: "Alpha Store",
+ email: "[email protected]",
+ currency_code: "usd",
+ status: "pending_approval",
+ })
+ )
+ })
+
+ it("should include nested members", async () => {
+ const response = await api.get(
+ `/admin/sellers/${sellerA.id}`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.members).toBeDefined()
+ expect(Array.isArray(response.data.seller.members)).toBe(true)
+ })
+
+ it("should return 404 for non-existent id", async () => {
+ const response = await api
+ .get(`/admin/sellers/sel_nonexistent`, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(404)
+ })
+ })
+
+ describe("POST /admin/sellers/:id", () => {
+ it("should update seller name", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}`,
+ { name: "Updated Alpha" },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.name).toEqual("Updated Alpha")
+ })
+
+ it("should update seller description", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}`,
+ { description: "Updated description" },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.description).toEqual(
+ "Updated description"
+ )
+ })
+
+ it("should update is_premium flag", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}`,
+ { is_premium: true },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.is_premium).toBe(true)
+ })
+
+ it("should update metadata", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}`,
+ { metadata: { tier: "gold" } },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.metadata).toEqual({ tier: "gold" })
+ })
+
+ it("should update website_url", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}`,
+ { website_url: "https://newsite.com" },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.website_url).toEqual(
+ "https://newsite.com"
+ )
+ })
+
+ it("should return 404 for non-existent id", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers/sel_nonexistent`,
+ { name: "Nope" },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+ })
+
+ describe("POST /admin/sellers/:id/approve", () => {
+ it("should approve a pending_approval seller", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.status).toEqual("open")
+ })
+
+ it("should fail when seller is already open", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/approve`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+
+ it("should fail when seller is suspended", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/approve`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+
+ it("should fail when seller is terminated", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/terminate`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/approve`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+ })
+
+ describe("POST /admin/sellers/:id/suspend", () => {
+ it("should suspend an open seller", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.status).toEqual("suspended")
+ })
+
+ it("should accept optional reason", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ { reason: "Policy violation" },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.status).toEqual("suspended")
+ expect(response.data.seller.status_reason).toEqual(
+ "Policy violation"
+ )
+ })
+
+ it("should fail when seller is pending_approval", async () => {
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/suspend`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+
+ it("should fail when seller is already suspended", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/suspend`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+
+ it("should fail when seller is terminated", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/terminate`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/suspend`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+ })
+
+ describe("POST /admin/sellers/:id/unsuspend", () => {
+ it("should unsuspend a suspended seller", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/unsuspend`,
+ {},
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.status).toEqual("open")
+ })
+
+ it("should fail when seller is open", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/unsuspend`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+
+ it("should fail when seller is pending_approval", async () => {
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/unsuspend`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+
+ it("should fail when seller is terminated", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/terminate`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/unsuspend`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+ })
+
+ describe("POST /admin/sellers/:id/terminate", () => {
+ it("should terminate a suspended seller", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/terminate`,
+ {},
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.status).toEqual("terminated")
+ })
+
+ it("should accept optional reason", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/terminate`,
+ { reason: "Terms of service violation" },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.status_reason).toEqual(
+ "Terms of service violation"
+ )
+ })
+
+ it("should terminate a pending_approval seller", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/terminate`,
+ {},
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.status).toEqual("terminated")
+ })
+
+ it("should fail when seller is open (must suspend first)", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/terminate`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+
+ it("should fail when seller is already terminated", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/terminate`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/terminate`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+ })
+
+ describe("POST /admin/sellers/:id/unterminate", () => {
+ it("should unterminate a terminated seller", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/terminate`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/unterminate`,
+ {},
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.status).toEqual("suspended")
+ })
+
+ it("should fail when seller is open", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/unterminate`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+
+ it("should fail when seller is pending_approval", async () => {
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/unterminate`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+
+ it("should fail when seller is suspended", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+
+ const response = await api
+ .post(`/admin/sellers/${sellerA.id}/unterminate`, {}, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+ })
+
+ describe("Full Status Lifecycle", () => {
+ it("should complete full cycle: pending_approval → open → suspended → terminated → suspended → open", async () => {
+ // pending_approval → open
+ let response = await api.post(
+ `/admin/sellers/${sellerA.id}/approve`,
+ {},
+ adminHeaders
+ )
+ expect(response.data.seller.status).toEqual("open")
+
+ // open → suspended
+ response = await api.post(
+ `/admin/sellers/${sellerA.id}/suspend`,
+ {},
+ adminHeaders
+ )
+ expect(response.data.seller.status).toEqual("suspended")
+
+ // suspended → terminated
+ response = await api.post(
+ `/admin/sellers/${sellerA.id}/terminate`,
+ {},
+ adminHeaders
+ )
+ expect(response.data.seller.status).toEqual("terminated")
+
+ // terminated → suspended
+ response = await api.post(
+ `/admin/sellers/${sellerA.id}/unterminate`,
+ {},
+ adminHeaders
+ )
+ expect(response.data.seller.status).toEqual("suspended")
+
+ // suspended → open
+ response = await api.post(
+ `/admin/sellers/${sellerA.id}/unsuspend`,
+ {},
+ adminHeaders
+ )
+ expect(response.data.seller.status).toEqual("open")
+ })
+ })
+
+ describe("POST /admin/sellers/:id/address", () => {
+ it("should create address for seller", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/address`,
+ {
+ company: "Alpha Corp",
+ first_name: "John",
+ last_name: "Doe",
+ address_1: "123 Main St",
+ address_2: "Suite 100",
+ city: "New York",
+ country_code: "us",
+ province: "NY",
+ postal_code: "10001",
+ phone: "+1234567890",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.address).toEqual(
+ expect.objectContaining({
+ company: "Alpha Corp",
+ first_name: "John",
+ last_name: "Doe",
+ address_1: "123 Main St",
+ city: "New York",
+ country_code: "us",
+ })
+ )
+ })
+
+ it("should update existing address fields", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/address`,
+ {
+ company: "Alpha Corp",
+ city: "New York",
+ },
+ adminHeaders
+ )
+
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/address`,
+ {
+ city: "Los Angeles",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.address.city).toEqual("Los Angeles")
+ })
+
+ it("should return seller with nested address in response", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/address`,
+ { city: "Chicago" },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller).toBeDefined()
+ expect(response.data.seller.address).toBeDefined()
+ })
+ })
+
+ describe("POST /admin/sellers/:id/payment-details", () => {
+ it("should create payment details with IBAN", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/payment-details`,
+ {
+ holder_name: "John Doe",
+ bank_name: "First National",
+ iban: "DE89370400440532013000",
+ bic: "COBADEFFXXX",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.payment_details).toEqual(
+ expect.objectContaining({
+ holder_name: "John Doe",
+ bank_name: "First National",
+ iban: "DE89370400440532013000",
+ bic: "COBADEFFXXX",
+ })
+ )
+ })
+
+ it("should create payment details with routing/account number", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/payment-details`,
+ {
+ holder_name: "Jane Doe",
+ routing_number: "021000021",
+ account_number: "123456789",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.payment_details).toEqual(
+ expect.objectContaining({
+ holder_name: "Jane Doe",
+ routing_number: "021000021",
+ account_number: "123456789",
+ })
+ )
+ })
+
+ it("should update existing payment details", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/payment-details`,
+ { holder_name: "John Doe" },
+ adminHeaders
+ )
+
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/payment-details`,
+ { holder_name: "Jane Doe" },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.payment_details.holder_name).toEqual(
+ "Jane Doe"
+ )
+ })
+
+ it("should return seller with nested payment_details in response", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/payment-details`,
+ { holder_name: "Test" },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller).toBeDefined()
+ expect(response.data.seller.payment_details).toBeDefined()
+ })
+ })
+
+ describe("POST /admin/sellers/:id/professional-details", () => {
+ it("should create professional details", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/professional-details`,
+ {
+ corporate_name: "Alpha Corp LLC",
+ registration_number: "REG-12345",
+ tax_id: "TAX-67890",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller.professional_details).toEqual(
+ expect.objectContaining({
+ corporate_name: "Alpha Corp LLC",
+ registration_number: "REG-12345",
+ tax_id: "TAX-67890",
+ })
+ )
+ })
+
+ it("should update existing professional details", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/professional-details`,
+ { corporate_name: "Alpha Corp LLC" },
+ adminHeaders
+ )
+
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/professional-details`,
+ { corporate_name: "Alpha Corp Inc" },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(
+ response.data.seller.professional_details.corporate_name
+ ).toEqual("Alpha Corp Inc")
+ })
+
+ it("should return seller with nested professional_details in response", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/professional-details`,
+ { corporate_name: "Test Corp" },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller).toBeDefined()
+ expect(response.data.seller.professional_details).toBeDefined()
+ })
+ })
+
+ describe("DELETE /admin/sellers/:id/professional-details", () => {
+ it("should remove professional details from seller", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/professional-details`,
+ { corporate_name: "Alpha Corp LLC" },
+ adminHeaders
+ )
+
+ const response = await api.delete(
+ `/admin/sellers/${sellerA.id}/professional-details`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ })
+
+ it("should return seller with null professional_details after removal", async () => {
+ await api.post(
+ `/admin/sellers/${sellerA.id}/professional-details`,
+ { corporate_name: "Alpha Corp LLC" },
+ adminHeaders
+ )
+
+ await api.delete(
+ `/admin/sellers/${sellerA.id}/professional-details`,
+ adminHeaders
+ )
+
+ const getResponse = await api.get(
+ `/admin/sellers/${sellerA.id}`,
+ adminHeaders
+ )
+
+ expect(getResponse.data.seller.professional_details).toBeFalsy()
+ })
+
+ it("should succeed even if no professional details exist (idempotent)", async () => {
+ const response = await api.delete(
+ `/admin/sellers/${sellerA.id}/professional-details`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ })
+ })
+
+ describe("GET /admin/sellers/:id/members", () => {
+ it("should list members for a seller", async () => {
+ const response = await api.get(
+ `/admin/sellers/${sellerA.id}/members`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller_members).toBeDefined()
+ expect(Array.isArray(response.data.seller_members)).toBe(true)
+ })
+
+ it("should return the owner member created during seller creation", async () => {
+ const response = await api.get(
+ `/admin/sellers/${sellerA.id}/members`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.seller_members.length).toBeGreaterThanOrEqual(1)
+ const ownerMember = response.data.seller_members.find(
+ (sm: any) => sm.is_owner === true
+ )
+ expect(ownerMember).toBeDefined()
+ })
+
+ it("should return count, offset, limit", async () => {
+ const response = await api.get(
+ `/admin/sellers/${sellerA.id}/members`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.count).toBeDefined()
+ expect(response.data.offset).toBeDefined()
+ expect(response.data.limit).toBeDefined()
+ })
+ })
+
+ describe("POST /admin/sellers/:id/members", () => {
+ it("should add an existing member to a seller with a role_id", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/members`,
+ {
+ member_id: memberB.id,
+ role_id: "role_test",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.seller_member).toBeDefined()
+ })
+
+ it("should return the created seller_member", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/members`,
+ {
+ member_id: memberC.id,
+ role_id: "role_test",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.seller_member).toEqual(
+ expect.objectContaining({
+ role_id: "role_test",
+ })
+ )
+ })
+ })
+
+ describe("DELETE /admin/sellers/:id/members/:member_id", () => {
+ it("should remove a non-owner member from seller", async () => {
+ // Add memberB to sellerA first
+ const addResponse = await api.post(
+ `/admin/sellers/${sellerA.id}/members`,
+ {
+ member_id: memberB.id,
+ role_id: "role_test",
+ },
+ adminHeaders
+ )
+
+ const sellerMemberId = addResponse.data.seller_member.id
+
+ const response = await api.delete(
+ `/admin/sellers/${sellerA.id}/members/${sellerMemberId}`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data).toEqual(
+ expect.objectContaining({
+ id: sellerMemberId,
+ object: "seller_member",
+ deleted: true,
+ })
+ )
+ })
+
+ it("should fail when trying to remove the owner member", async () => {
+ // Get the owner seller_member id
+ const membersResponse = await api.get(
+ `/admin/sellers/${sellerA.id}/members`,
+ adminHeaders
+ )
+
+ const ownerSellerMember = membersResponse.data.seller_members.find(
+ (sm: any) => sm.is_owner === true
+ )
+
+ const response = await api
+ .delete(
+ `/admin/sellers/${sellerA.id}/members/${ownerSellerMember.id}`,
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ })
+ })
+
+ describe("POST /admin/sellers/:id/members/invite", () => {
+ it("should create an invitation for a new email", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/members/invite`,
+ {
+ email: "[email protected]",
+ role_id: "role_test",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.member_invite).toBeDefined()
+ })
+
+ it("should create invitation with email and role_id", async () => {
+ const response = await api.post(
+ `/admin/sellers/${sellerA.id}/members/invite`,
+ {
+ email: "[email protected]",
+ role_id: "role_admin",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.member_invite).toEqual(
+ expect.objectContaining({
+ email: "[email protected]",
+ role_id: "role_admin",
+ })
+ )
+ })
+
+ it("should fail for invalid email format", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers/${sellerA.id}/members/invite`,
+ {
+ email: "not-an-email",
+ role_id: "role_test",
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail for missing role_id", async () => {
+ const response = await api
+ .post(
+ `/admin/sellers/${sellerA.id}/members/invite`,
+ {
+ email: "[email protected]",
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+ })
+ })
+ },
+})
diff --git a/integration-tests/http/subscription-plans/admin/subscription-plans.spec.ts b/integration-tests/http/subscription-plans/admin/subscription-plans.spec.ts
new file mode 100644
index 000000000..065d0a832
--- /dev/null
+++ b/integration-tests/http/subscription-plans/admin/subscription-plans.spec.ts
@@ -0,0 +1,753 @@
+import { medusaIntegrationTestRunner } from "@medusajs/test-utils"
+import { MedusaContainer } from "@medusajs/framework/types"
+import {
+ adminHeaders,
+ createAdminUser,
+} from "../../../helpers/create-admin-user"
+
+jest.setTimeout(50000)
+
+medusaIntegrationTestRunner({
+ testSuite: ({ getContainer, api, dbConnection }) => {
+ describe("Admin - Subscription Plans", () => {
+ let appContainer: MedusaContainer
+
+ beforeAll(async () => {
+ appContainer = getContainer()
+ })
+
+ beforeEach(async () => {
+ await createAdminUser(dbConnection, adminHeaders, appContainer)
+ })
+
+ describe("POST /admin/subscription-plans", () => {
+ it("should create a plan with required fields", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.subscription_plan).toEqual(
+ expect.objectContaining({
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ })
+ )
+ })
+
+ it("should create a plan with all optional fields", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "eur",
+ monthly_amount: 49.99,
+ free_months: 3,
+ requires_orders: true,
+ metadata: { tier: "premium" },
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.subscription_plan).toEqual(
+ expect.objectContaining({
+ currency_code: "eur",
+ monthly_amount: 49.99,
+ free_months: 3,
+ requires_orders: true,
+ })
+ )
+ })
+
+ it("should default free_months when not provided", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "gbp",
+ monthly_amount: 19.99,
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.subscription_plan.free_months).toEqual(0)
+ })
+
+ it("should fail with 400 for missing currency_code", async () => {
+ const response = await api
+ .post(
+ `/admin/subscription-plans`,
+ { monthly_amount: 29.99 },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail with 400 for missing monthly_amount", async () => {
+ const response = await api
+ .post(
+ `/admin/subscription-plans`,
+ { currency_code: "usd" },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail with 400 for free_months > 120", async () => {
+ const response = await api
+ .post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ free_months: 121,
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail with 400 for free_months < 0", async () => {
+ const response = await api
+ .post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ free_months: -1,
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+
+ it("should fail with 400 for non-integer free_months", async () => {
+ const response = await api
+ .post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ free_months: 2.5,
+ },
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(400)
+ })
+ })
+
+ describe("GET /admin/subscription-plans", () => {
+ let planA: any
+ let planB: any
+
+ beforeEach(async () => {
+ const responseA = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ },
+ adminHeaders
+ )
+ planA = responseA.data.subscription_plan
+
+ const responseB = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "eur",
+ monthly_amount: 49.99,
+ },
+ adminHeaders
+ )
+ planB = responseB.data.subscription_plan
+ })
+
+ it("should list all subscription plans", async () => {
+ const response = await api.get(
+ `/admin/subscription-plans`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plans).toBeDefined()
+ expect(response.data.subscription_plans.length).toBeGreaterThanOrEqual(
+ 2
+ )
+ })
+
+ it("should return count, offset, limit", async () => {
+ const response = await api.get(
+ `/admin/subscription-plans`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.count).toBeDefined()
+ expect(response.data.offset).toBeDefined()
+ expect(response.data.limit).toBeDefined()
+ })
+
+ it("should filter by currency_code", async () => {
+ const response = await api.get(
+ `/admin/subscription-plans?currency_code=usd`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plans.length).toBeGreaterThanOrEqual(
+ 1
+ )
+ response.data.subscription_plans.forEach((plan: any) => {
+ expect(plan.currency_code).toEqual("usd")
+ })
+ })
+
+ it("should return empty for non-matching currency_code", async () => {
+ const response = await api.get(
+ `/admin/subscription-plans?currency_code=jpy`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plans).toHaveLength(0)
+ })
+
+ it("should support limit pagination", async () => {
+ const response = await api.get(
+ `/admin/subscription-plans?limit=1`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plans).toHaveLength(1)
+ expect(response.data.limit).toEqual(1)
+ })
+
+ it("should support offset pagination", async () => {
+ const response = await api.get(
+ `/admin/subscription-plans?offset=1&limit=1`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plans).toHaveLength(1)
+ expect(response.data.offset).toEqual(1)
+ })
+ })
+
+ describe("GET /admin/subscription-plans/:id", () => {
+ let plan: any
+
+ beforeEach(async () => {
+ const response = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ free_months: 1,
+ },
+ adminHeaders
+ )
+ plan = response.data.subscription_plan
+ })
+
+ it("should retrieve a subscription plan by id", async () => {
+ const response = await api.get(
+ `/admin/subscription-plans/${plan.id}`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plan).toEqual(
+ expect.objectContaining({
+ id: plan.id,
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ free_months: 1,
+ })
+ )
+ })
+
+ it("should return plan with overrides array", async () => {
+ const response = await api.get(
+ `/admin/subscription-plans/${plan.id}`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plan.overrides).toBeDefined()
+ expect(
+ Array.isArray(response.data.subscription_plan.overrides)
+ ).toBe(true)
+ })
+
+ it("should return 404 for non-existent id", async () => {
+ const response = await api
+ .get(
+ `/admin/subscription-plans/subplan_nonexistent`,
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(404)
+ })
+ })
+
+ describe("POST /admin/subscription-plans/:id", () => {
+ let plan: any
+
+ beforeEach(async () => {
+ const response = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ free_months: 1,
+ },
+ adminHeaders
+ )
+ plan = response.data.subscription_plan
+ })
+
+ it("should update monthly_amount", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}`,
+ { monthly_amount: 39.99 },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plan.monthly_amount).toEqual(39.99)
+ })
+
+ it("should update free_months", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}`,
+ { free_months: 6 },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plan.free_months).toEqual(6)
+ })
+
+ it("should update requires_orders", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}`,
+ { requires_orders: true },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plan.requires_orders).toBe(true)
+ })
+
+ it("should update metadata", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}`,
+ { metadata: { promo: "summer2024" } },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_plan.metadata).toEqual({
+ promo: "summer2024",
+ })
+ })
+ })
+
+ describe("DELETE /admin/subscription-plans/:id", () => {
+ let plan: any
+
+ beforeEach(async () => {
+ const response = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ },
+ adminHeaders
+ )
+ plan = response.data.subscription_plan
+ })
+
+ it("should delete a subscription plan", async () => {
+ const response = await api.delete(
+ `/admin/subscription-plans/${plan.id}`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data).toEqual(
+ expect.objectContaining({
+ id: plan.id,
+ object: "subscription_plan",
+ deleted: true,
+ })
+ )
+ })
+
+ it("should return 404 when retrieving deleted plan", async () => {
+ await api.delete(
+ `/admin/subscription-plans/${plan.id}`,
+ adminHeaders
+ )
+
+ const response = await api
+ .get(`/admin/subscription-plans/${plan.id}`, adminHeaders)
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(404)
+ })
+ })
+
+ describe("POST /admin/subscription-plans/:id/overrides", () => {
+ let plan: any
+
+ beforeEach(async () => {
+ const response = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ },
+ adminHeaders
+ )
+ plan = response.data.subscription_plan
+ })
+
+ it("should create an override with all fields", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides`,
+ {
+ reference: "seller",
+ reference_id: "sel_123",
+ monthly_amount: 19.99,
+ free_months: 2,
+ free_from: "2024-01-01T00:00:00.000Z",
+ free_to: "2024-06-01T00:00:00.000Z",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.subscription_plan).toBeDefined()
+ expect(
+ response.data.subscription_plan.overrides.length
+ ).toBeGreaterThanOrEqual(1)
+
+ const override = response.data.subscription_plan.overrides.find(
+ (o: any) => o.reference_id === "sel_123"
+ )
+ expect(override).toEqual(
+ expect.objectContaining({
+ reference: "seller",
+ reference_id: "sel_123",
+ monthly_amount: 19.99,
+ free_months: 2,
+ })
+ )
+ })
+
+ it("should return updated plan with overrides included", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides`,
+ {
+ reference: "seller",
+ reference_id: "sel_456",
+ monthly_amount: 9.99,
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ expect(response.data.subscription_plan.id).toEqual(plan.id)
+ expect(response.data.subscription_plan.overrides).toBeDefined()
+ })
+
+ it("should create override with just reference and reference_id (minimal)", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides`,
+ {
+ reference: "region",
+ reference_id: "reg_789",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(201)
+ const override = response.data.subscription_plan.overrides.find(
+ (o: any) => o.reference_id === "reg_789"
+ )
+ expect(override).toBeDefined()
+ expect(override.reference).toEqual("region")
+ })
+ })
+
+ describe("GET /admin/subscription-plans/:id/overrides/:override_id", () => {
+ let plan: any
+ let override: any
+
+ beforeEach(async () => {
+ const planResponse = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ },
+ adminHeaders
+ )
+ plan = planResponse.data.subscription_plan
+
+ const overrideResponse = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides`,
+ {
+ reference: "seller",
+ reference_id: "sel_test",
+ monthly_amount: 14.99,
+ },
+ adminHeaders
+ )
+ override = overrideResponse.data.subscription_plan.overrides.find(
+ (o: any) => o.reference_id === "sel_test"
+ )
+ })
+
+ it("should retrieve an override by id", async () => {
+ const response = await api.get(
+ `/admin/subscription-plans/${plan.id}/overrides/${override.id}`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_override).toEqual(
+ expect.objectContaining({
+ id: override.id,
+ reference: "seller",
+ reference_id: "sel_test",
+ monthly_amount: 14.99,
+ })
+ )
+ })
+
+ it("should return 404 for non-existent override", async () => {
+ const response = await api
+ .get(
+ `/admin/subscription-plans/${plan.id}/overrides/subovr_nonexistent`,
+ adminHeaders
+ )
+ .catch((e) => e.response)
+
+ expect(response.status).toEqual(404)
+ })
+ })
+
+ describe("POST /admin/subscription-plans/:id/overrides/:override_id", () => {
+ let plan: any
+ let override: any
+
+ beforeEach(async () => {
+ const planResponse = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ },
+ adminHeaders
+ )
+ plan = planResponse.data.subscription_plan
+
+ const overrideResponse = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides`,
+ {
+ reference: "seller",
+ reference_id: "sel_update",
+ monthly_amount: 14.99,
+ free_months: 1,
+ },
+ adminHeaders
+ )
+ override = overrideResponse.data.subscription_plan.overrides.find(
+ (o: any) => o.reference_id === "sel_update"
+ )
+ })
+
+ it("should update override monthly_amount", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides/${override.id}`,
+ { monthly_amount: 24.99 },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_override.monthly_amount).toEqual(
+ 24.99
+ )
+ })
+
+ it("should update override free_from/free_to dates", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides/${override.id}`,
+ {
+ free_from: "2024-01-01T00:00:00.000Z",
+ free_to: "2024-12-31T00:00:00.000Z",
+ },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(
+ response.data.subscription_override.free_from
+ ).toBeDefined()
+ expect(response.data.subscription_override.free_to).toBeDefined()
+ })
+
+ it("should update override free_months", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides/${override.id}`,
+ { free_months: 6 },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_override.free_months).toEqual(6)
+ })
+
+ it("should update override metadata", async () => {
+ const response = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides/${override.id}`,
+ { metadata: { note: "special discount" } },
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data.subscription_override.metadata).toEqual({
+ note: "special discount",
+ })
+ })
+ })
+
+ describe("DELETE /admin/subscription-plans/:id/overrides/:override_id", () => {
+ let plan: any
+ let override: any
+
+ beforeEach(async () => {
+ const planResponse = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ },
+ adminHeaders
+ )
+ plan = planResponse.data.subscription_plan
+
+ const overrideResponse = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides`,
+ {
+ reference: "seller",
+ reference_id: "sel_delete",
+ monthly_amount: 14.99,
+ },
+ adminHeaders
+ )
+ override = overrideResponse.data.subscription_plan.overrides.find(
+ (o: any) => o.reference_id === "sel_delete"
+ )
+ })
+
+ it("should delete an override", async () => {
+ const response = await api.delete(
+ `/admin/subscription-plans/${plan.id}/overrides/${override.id}`,
+ adminHeaders
+ )
+
+ expect(response.status).toEqual(200)
+ expect(response.data).toEqual(
+ expect.objectContaining({
+ id: override.id,
+ object: "subscription_override",
+ deleted: true,
+ })
+ )
+ })
+ })
+
+ describe("Override Lifecycle", () => {
+ it("should create plan → add override → update override → delete override → plan still exists without override", async () => {
+ // Create plan
+ const planResponse = await api.post(
+ `/admin/subscription-plans`,
+ {
+ currency_code: "usd",
+ monthly_amount: 29.99,
+ },
+ adminHeaders
+ )
+ const plan = planResponse.data.subscription_plan
+ expect(plan).toBeDefined()
+
+ // Add override
+ const overrideResponse = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides`,
+ {
+ reference: "seller",
+ reference_id: "sel_lifecycle",
+ monthly_amount: 9.99,
+ },
+ adminHeaders
+ )
+ expect(overrideResponse.status).toEqual(201)
+ const override =
+ overrideResponse.data.subscription_plan.overrides.find(
+ (o: any) => o.reference_id === "sel_lifecycle"
+ )
+ expect(override).toBeDefined()
+
+ // Update override
+ const updateResponse = await api.post(
+ `/admin/subscription-plans/${plan.id}/overrides/${override.id}`,
+ { monthly_amount: 14.99 },
+ adminHeaders
+ )
+ expect(updateResponse.status).toEqual(200)
+ expect(
+ updateResponse.data.subscription_override.monthly_amount
+ ).toEqual(14.99)
+
+ // Delete override
+ const deleteResponse = await api.delete(
+ `/admin/subscription-plans/${plan.id}/overrides/${override.id}`,
+ adminHeaders
+ )
+ expect(deleteResponse.status).toEqual(200)
+ expect(deleteResponse.data.deleted).toBe(true)
+
+ // Plan still exists without override
+ const getResponse = await api.get(
+ `/admin/subscription-plans/${plan.id}`,
+ adminHeaders
+ )
+ expect(getResponse.status).toEqual(200)
+ expect(getResponse.data.subscription_plan.id).toEqual(plan.id)
+ expect(getResponse.data.subscription_plan.overrides).toHaveLength(0)
+ })
+ })
+ })
+ },
+})
diff --git a/integration-tests/medusa-config.ts b/integration-tests/medusa-config.ts
index 8a86e1a7f..b09162890 100644
--- a/integration-tests/medusa-config.ts
+++ b/integration-tests/medusa-config.ts
@@ -1,4 +1,4 @@
-import { loadEnv, defineConfig } from '@medusajs/framework/utils'
+import { loadEnv, defineConfig, Modules } from '@medusajs/framework/utils'
loadEnv(process.env.NODE_ENV || 'development', process.cwd())
@@ -17,6 +17,9 @@ module.exports = defineConfig({
rbac: true,
},
modules: [
+ {
+ resolve: "@medusajs/medusa/rbac",
+ },
{
resolve: '@mercurjs/core-plugin/modules/admin-ui',
options: {
diff --git a/packages/core-plugin/src/api/admin/sellers/query-config.ts b/packages/core-plugin/src/api/admin/sellers/query-config.ts
index 1c62b4a4c..52c6b71e6 100644
--- a/packages/core-plugin/src/api/admin/sellers/query-config.ts
+++ b/packages/core-plugin/src/api/admin/sellers/query-config.ts
@@ -10,6 +10,7 @@ export const adminSellerFields = [
"external_id",
"currency_code",
"status",
+ "status_reason",
"is_premium",
"closed_from",
"closed_to",
@@ -48,8 +49,9 @@ export const adminMembersQueryConfig = {
list: {
defaults: [
"id",
+ "is_owner",
"member.*",
- "role.*",
+ "rbac_role.*",
],
defaultLimit: 50,
isList: true,
diff --git a/packages/core-plugin/src/jobs/capture-check.ts b/packages/core-plugin/src/jobs/capture-check.ts
deleted file mode 100644
index bc036265a..000000000
--- a/packages/core-plugin/src/jobs/capture-check.ts
+++ /dev/null
@@ -1,220 +0,0 @@
-import { getOrdersListWorkflow } from "@medusajs/core-flows"
-import type { MedusaContainer } from "@medusajs/framework/types"
-import { ContainerRegistrationKeys, Modules } from "@medusajs/framework/utils"
-import type { FulfillmentStatus, IOrderModuleService } from "@medusajs/types"
-import {
- MercurModules,
- PaymentCollectionDTO,
- PayoutAccountStatus,
- PayoutEvents,
-} from "@mercurjs/types"
-
-import PayoutModuleService from "../modules/payout/services/payout-module-service"
-
-const FULFILLMENT_STATUS_ORDER: FulfillmentStatus[] = [
- "not_fulfilled",
- "partially_fulfilled",
- "fulfilled",
- "partially_shipped",
- "shipped",
- "partially_delivered",
- "delivered",
-]
-
-function meetsRequiredFulfillmentStatus(
- status: FulfillmentStatus,
- required: FulfillmentStatus
-): boolean {
- const statusIndex = FULFILLMENT_STATUS_ORDER.indexOf(status)
- const requiredIndex = FULFILLMENT_STATUS_ORDER.indexOf(required)
-
- return statusIndex !== -1 && statusIndex >= requiredIndex
-}
-
-const CAPTURE_CHECK_FIELDS = [
- "id",
- "display_id",
- "status",
- "email",
- "currency_code",
- "region_id",
- "customer_id",
- "sales_channel_id",
- "created_at",
- "updated_at",
- "canceled_at",
- "metadata",
- "items.*",
- "items.variant.*",
- "items.variant.product.*",
- "shipping_address.*",
- "billing_address.*",
- "shipping_methods.*",
- "payment_collections.*",
- "fulfillments.*",
- "summary.*",
- "payouts.id",
- "seller.payout_account.id",
- "seller.payout_account.status",
-]
-
-export default async function captureCheckJob(container: MedusaContainer) {
- const logger = container.resolve(ContainerRegistrationKeys.LOGGER)
- const eventBus = container.resolve(Modules.EVENT_BUS)
- const orderModule = container.resolve<IOrderModuleService>(Modules.ORDER)
- const service = container.resolve<PayoutModuleService>(MercurModules.PAYOUT)
-
- const options = service.getOptions()
-
- if (options.disabled) {
- logger.warn("Capture check job skipped - payouts disabled")
- return
- }
-
- const batchSize = 100
- const authWindowMs = options.authorizationWindowMs
- const safetyBufferMs = options.captureSafetyBufferMs
- const requiredFulfillmentStatus = options.requiredFulfillmentStatus
-
- logger.info("Capture check job started")
- logger.debug(
- `Capture check config - authWindowMs: ${authWindowMs}, safetyBufferMs: ${safetyBufferMs}, requiredFulfillmentStatus: ${requiredFulfillmentStatus}`
- )
-
- let offset = 0
- let emittedCount = 0
-
- const createdAfter = new Date(Date.now() - authWindowMs)
-
- const workflow = getOrdersListWorkflow(container)
-
- while (true) {
- const { result } = await workflow.run({
- input: {
- fields: CAPTURE_CHECK_FIELDS,
- variables: {
- filters: {
- is_draft_order: false,
- canceled_at: null,
- created_at: { $gte: createdAfter },
- },
- take: batchSize,
- skip: offset,
- order: {
- created_at: "ASC",
- },
- },
- },
- })
-
- const { rows: orders } = result as {
- rows: any[];
- };
-
- if (!orders.length) break
-
- logger.debug(`Capture check - fetched ${orders.length} orders at offset ${offset}`)
-
- const events: { name: string; data: Record<string, unknown> }[] = []
- const orderIdsToUpdate: string[] = []
-
- for (const order of orders) {
- if (order.metadata?.capture_requested) {
- logger.debug(`Order ${order.id} - skipped, capture already requested`)
- continue
- }
-
- if (order.payouts?.length) {
- logger.debug(`Order ${order.id} - skipped, has payouts`)
- continue
- }
-
- if (order.seller?.payout_account?.status !== PayoutAccountStatus.ACTIVE) {
- logger.debug(`Order ${order.id} - skipped, payout account not active`)
- continue
- }
-
- if (!meetsRequiredFulfillmentStatus(order.fulfillment_status, requiredFulfillmentStatus)) {
- logger.debug(`Order ${order.id} - skipped, fulfillment status ${order.fulfillment_status} below required ${requiredFulfillmentStatus}`)
- continue
- }
-
- if (order.payment_status !== "authorized") {
- logger.debug(`Order ${order.id} - skipped, payment status ${order.payment_status}`)
- continue
- }
-
- const pc = (order.payment_collections ?? []).find(
- (c: PaymentCollectionDTO) => c.status === "authorized"
- )
-
- if (!pc) {
- logger.debug(`Order ${order.id} - skipped, no authorized payment collection`)
- continue
- }
-
- const authorizedAt = new Date(pc.created_at).getTime()
- const expiresAt = authorizedAt + authWindowMs
- const captureDeadline = expiresAt - safetyBufferMs
-
- const now = Date.now()
-
- if (now >= expiresAt) {
- logger.warn(`Order ${order.id} - authorization expired at ${new Date(expiresAt).toISOString()}`)
-
- events.push({
- name: PayoutEvents.OrderAuthorizationExpired,
- data: {
- order_id: order.id,
- authorized_at: new Date(authorizedAt),
- expires_at: new Date(expiresAt),
- },
- })
-
- orderIdsToUpdate.push(order.id)
- continue
- }
-
- if (now < captureDeadline) {
- logger.debug(`Order ${order.id} - skipped, capture deadline not reached`)
- continue
- }
-
- logger.info(`Emitting capture requested - order ${order.id}`)
-
- events.push({
- name: PayoutEvents.OrderCaptureRequested,
- data: {
- order_id: order.id,
- authorized_at: new Date(authorizedAt),
- expires_at: new Date(expiresAt),
- },
- })
-
- orderIdsToUpdate.push(order.id)
- }
-
- if (events.length) {
- await eventBus.emit(events, { attempts: 3 })
-
- await orderModule.updateOrders(
- orderIdsToUpdate.map((id) => ({
- id,
- metadata: { capture_requested: true },
- }))
- )
-
- emittedCount += events.length
- }
-
- if (orders.length < batchSize) break
- offset += batchSize
- }
-
- logger.info(`Capture check job completed - ${emittedCount} capture(s) requested`)
-}
-
-export const config = {
- name: "capture-check",
- schedule: "*/15 * * * *",
-}
diff --git a/packages/core-plugin/src/jobs/daily-payouts.ts b/packages/core-plugin/src/jobs/daily-payouts.ts
deleted file mode 100644
index d444c41e7..000000000
--- a/packages/core-plugin/src/jobs/daily-payouts.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import { getOrdersListWorkflow } from "@medusajs/core-flows"
-import type { MedusaContainer } from "@medusajs/framework/types"
-import {
- ContainerRegistrationKeys,
- Modules,
-} from "@medusajs/framework/utils"
-import { MercurModules, PayoutAccountStatus, PayoutEvents } from "@mercurjs/types"
-
-import PayoutModuleService from "../modules/payout/services/payout-module-service"
-
-const BATCH_SIZE = 100
-
-const DAILY_PAYOUTS_FIELDS = [
- "id",
- "metadata",
- "currency_code",
- "payment_collections.*",
- "fulfillments.*",
- "summary.*",
- "payouts.id",
- "seller.payout_account.id",
- "seller.payout_account.status",
-]
-
-export default async function dailyPayoutsJob(container: MedusaContainer) {
- const logger = container.resolve(ContainerRegistrationKeys.LOGGER)
- const eventBus = container.resolve(Modules.EVENT_BUS)
- const service = container.resolve<PayoutModuleService>(MercurModules.PAYOUT)
-
- const options = service.getOptions()
-
- if (options.disabled) {
- logger.warn("Daily payouts job skipped - payouts disabled")
- return
- }
-
- logger.info("Daily payouts job started")
-
- let offset = 0
- let emitted = 0
-
- const createdAfter = new Date(Date.now() - options.authorizationWindowMs)
-
- const listWorkflow = getOrdersListWorkflow(container)
-
- while (true) {
- const { result } = await listWorkflow.run({
- input: {
- fields: DAILY_PAYOUTS_FIELDS,
- variables: {
- filters: {
- is_draft_order: false,
- canceled_at: null,
- created_at: { $gte: createdAfter },
- },
- take: BATCH_SIZE,
- skip: offset,
- order: {
- created_at: "ASC",
- },
- },
- },
- })
-
- const { rows: orders } = result as {
- rows: any[];
- }
-
- if (!orders.length) break
-
- logger.debug(`Daily payouts - fetched ${orders.length} orders at offset ${offset}`)
-
- const events: { name: string; data: Record<string, unknown> }[] = []
-
- for (const order of orders) {
- if (!order.metadata?.captured) {
- logger.debug(`Order ${order.id} - skipped, not captured`)
- continue
- }
-
- if (order.metadata?.payout_transferred) {
- logger.debug(`Order ${order.id} - skipped, payout already transferred`)
- continue
- }
-
- if (order.metadata?.payout_failed) {
- logger.debug(`Order ${order.id} - skipped, payout previously failed`)
- continue
- }
-
- if (order.payouts?.length) {
- logger.debug(`Order ${order.id} - skipped, already has payouts`)
- continue
- }
-
- if (order.seller?.payout_account?.status !== PayoutAccountStatus.ACTIVE) {
- logger.debug(`Order ${order.id} - skipped, payout account not active (status: ${order.seller?.payout_account?.status})`)
- continue
- }
-
- logger.info(`Emitting payout transfer requested - order ${order.id}`)
-
- events.push({
- name: PayoutEvents.PayoutRequested,
- data: {
- order_id: order.id,
- },
- })
- }
-
- if (events.length) {
- await eventBus.emit(events, { attempts: 3 })
- emitted += events.length
- }
-
- if (orders.length < BATCH_SIZE) break
- offset += BATCH_SIZE
- }
-
- logger.info(`Daily payouts job completed - ${emitted} transfer(s) requested`)
-}
-
-export const config = {
- name: "daily-payouts",
- schedule: "0 1 * * *",
-}
diff --git a/packages/core-plugin/src/links/seller-member-rbac-role.ts b/packages/core-plugin/src/links/seller-member-rbac-role.ts
index ee30e1522..1517e8965 100644
--- a/packages/core-plugin/src/links/seller-member-rbac-role.ts
+++ b/packages/core-plugin/src/links/seller-member-rbac-role.ts
@@ -3,11 +3,10 @@ import RbacModule from "@medusajs/medusa/rbac"
import SellerModule from "../modules/seller"
export default defineLink(
- {
- linkable: SellerModule.linkable.sellerMember,
- field: "role_id",
- alias: 'role'
- },
- RbacModule.linkable.rbacRole,
- { readOnly: true }
+ {
+ linkable: SellerModule.linkable.sellerMember,
+ field: "role_id",
+ },
+ RbacModule.linkable.rbacRole,
+ { readOnly: true }
)
diff --git a/packages/core-plugin/src/modules/seller/index.ts b/packages/core-plugin/src/modules/seller/index.ts
index 14740f176..bdd90059c 100644
--- a/packages/core-plugin/src/modules/seller/index.ts
+++ b/packages/core-plugin/src/modules/seller/index.ts
@@ -2,9 +2,7 @@ import { Module } from "@medusajs/framework/utils"
import { MercurModules } from "@mercurjs/types"
import SellerModuleService from "./service"
-import sellerMemberRbacRoleLoader from "./loaders"
export default Module(MercurModules.SELLER, {
service: SellerModuleService,
- loaders: [sellerMemberRbacRoleLoader],
})
diff --git a/packages/core-plugin/src/modules/seller/loaders.ts b/packages/core-plugin/src/modules/seller/loaders.ts
deleted file mode 100644
index db5d9dd87..000000000
--- a/packages/core-plugin/src/modules/seller/loaders.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { LoaderOptions } from "@medusajs/framework/types"
-import { MedusaModule } from "@medusajs/framework/modules-sdk"
-import { Modules } from "@medusajs/framework/utils"
-import { MercurModules } from "@mercurjs/types"
-
-export default async function sellerMemberRbacRoleLoader({}: LoaderOptions) {
- MedusaModule.setCustomLink(() => {
- return {
- isLink: true,
- isReadOnlyLink: true,
- extends: [
- {
- serviceName: MercurModules.SELLER,
- entity: "SellerMember",
- relationship: {
- serviceName: Modules.RBAC,
- entity: "RbacRole",
- primaryKey: "id",
- foreignKey: "role_id",
- alias: "rbac_role",
- isList: false,
- },
- },
- ],
- }
- })
-}
diff --git a/packages/core-plugin/src/modules/subscription/migrations/Migration20260323170925.ts b/packages/core-plugin/src/modules/subscription/migrations/Migration20260324135903.ts
similarity index 97%
rename from packages/core-plugin/src/modules/subscription/migrations/Migration20260323170925.ts
rename to packages/core-plugin/src/modules/subscription/migrations/Migration20260324135903.ts
index 473391f4f..2f30738b6 100644
--- a/packages/core-plugin/src/modules/subscription/migrations/Migration20260323170925.ts
+++ b/packages/core-plugin/src/modules/subscription/migrations/Migration20260324135903.ts
@@ -1,6 +1,6 @@
import { Migration } from "@medusajs/framework/mikro-orm/migrations";
-export class Migration20260323170925 extends Migration {
+export class Migration20260324135903 extends Migration {
override async up(): Promise<void> {
this.addSql(`create table if not exists "subscription_plan" ("id" text not null, "currency_code" text not null, "monthly_amount" numeric not null, "free_months" integer not null default 0, "requires_orders" boolean not null default false, "metadata" jsonb null, "raw_monthly_amount" jsonb not null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "subscription_plan_pkey" primary key ("id"));`);
diff --git a/packages/core-plugin/src/workflows/seller/steps/validate-suspend-seller.ts b/packages/core-plugin/src/workflows/seller/steps/validate-suspend-seller.ts
index 96d1dc2c8..8e0eed49f 100644
--- a/packages/core-plugin/src/workflows/seller/steps/validate-suspend-seller.ts
+++ b/packages/core-plugin/src/workflows/seller/steps/validate-suspend-seller.ts
@@ -17,5 +17,11 @@ export const validateSuspendSellerStep = createStep(
"Seller is already suspended"
)
}
+ if (seller.status === SellerStatus.PENDING_APPROVAL) {
+ throw new MedusaError(
+ MedusaError.Types.NOT_ALLOWED,
+ "Cannot suspend a seller that is pending approval"
+ )
+ }
}
)