@thorprovider/adapters 4.2.1 → 4.3.0

package/docs/profile-management.md

@@ -1,26 +1,32 @@
-# Profile Management
-
 ---
+title: Profile Management
+purpose: Guide for managing customer profiles using capability-aware patterns for cross-backend compatibility
 type: how-to
 tags: [profile, account, customer, metadata, avatar]
 related:
   - authentication.md
   - capabilities-system.md
   - services-overview.md
-updated: 2026-02-28
+updated: 2026-05-03
 ---
 
+# Profile Management
+
 Guide for managing customer profiles using capability-aware patterns for cross-backend compatibility.
 
 ## Prerequisites
 
 - [Authentication set up](authentication.md)
-- User logged in to access profile features
+- User logged in (`commerce.auth` available and `isAuthenticated()` returns `true`)
 
 ## Quick Example
 
 ```typescript
-import { commerce } from '@/lib/commerce';
+import { createProvider } from '@thorprovider/adapters';
+
+const commerce = createProvider({ provider: 'medusa', config: { ... } });
+
+if (!commerce.auth) throw new Error('Auth not available');
 
 // Simple profile update
 const updated = await commerce.auth.updateCustomer({
@@ -41,6 +47,10 @@ const { updateEmail, updateProfile, deleteAccount } = commerce.capabilities;
 if (updateEmail) {
   // Render email update field
 }
+
+if (updateProfile) {
+  // Render name/phone fields
+}
 ```
 
 ### Step 2: Retrieve Current Profile
@@ -48,6 +58,8 @@ if (updateEmail) {
 Fetch the customer object to populate your forms.
 
 ```typescript
+if (!commerce.auth) return;
+
 const customer = await commerce.auth.getCurrentCustomer();
 ```
 
@@ -56,18 +68,24 @@ const customer = await commerce.auth.getCurrentCustomer();
 Handle updates carefully, checking for specific field support.
 
 ```typescript
-async function handleUpdate(formData) {
-  const updateData = {};
-  
+async function handleUpdate(formData: {
+  firstName: string;
+  lastName: string;
+  email?: string;
+}) {
+  if (!commerce.auth) throw new Error('Auth not available');
+
+  const updateData: Record<string, unknown> = {};
+
   if (commerce.capabilities.updateProfile) {
     updateData.first_name = formData.firstName;
     updateData.last_name = formData.lastName;
   }
-  
-  if (commerce.capabilities.updateEmail) {
+
+  if (commerce.capabilities.updateEmail && formData.email) {
     updateData.email = formData.email;
   }
-  
+
   return await commerce.auth.updateCustomer(updateData);
 }
 ```
@@ -78,42 +96,54 @@ Handle password changes based on whether the backend supports direct or email-ba
 
 ```typescript
 if (commerce.capabilities.changePasswordDirect) {
+  // Direct password change (Shopify, Spree, Magento)
   await commerce.auth.updateCustomer({
-    current_password: 'old',
-    password: 'new',
+    password: 'NewPassword123!',
   });
+} else if (commerce.capabilities.changePasswordViaEmail) {
+  // Email-based reset (Medusa v2)
+  await commerce.auth.requestPasswordReset(customer.email);
 }
 ```
 
-## ✅ DO's
-
-1. **Check Capabilities First:** Avoid rendering buttons for features the backend doesn't support.
-2. **Use Metadata for Extensions:** Store extra info like `avatar_url` or `notifications` in `customer.metadata`.
-3. **Handle Errors explicitly:** Distinguish between `EMAIL_TAKEN` and generic update errors.
-4. **Validate on Client:** Use patterns/regex for phone and email before sending to the adapter.
-5. **Protect UI with Loading States:** Backend operations can take time; show a spinner.
-
-## ❌ DONT's
+### Step 5: Account Deletion
 
-1. **Don't assume all backends are equal:** Medusa v2 has different capabilities than Shopify or WooCommerce.
-2. **Don't hardcode profile fields:** Use the `Customer` interface from `@thorprovider/adapters`.
-3. **Don't ignore account deletion:** Provide a way for users to delete their account if `deleteAccount` is true.
-4. **Don't send sensitive data in metadata:** Metadata is often visible to the user and sometimes less secure.
-5. **Don't forget to re-fetch profile:** After a successful update, the local customer state should be refreshed.
+```typescript
+if (commerce.capabilities.deleteAccount && commerce.auth) {
+  await commerce.auth.deleteCustomerAccount();
+}
+```
 
-## Common Patterns
+## Avatar Management
 
-### Metadata-based Avatar Management
-Since many backends don't support native avatars, use an external service (S3/Cloudinary) and store the URL in metadata.
+Most backends don't support native avatar uploads. Use an external service (S3, Cloudinary) and store the URL in metadata.
 
 ```typescript
-await commerce.auth.updateCustomer({
-  metadata: { avatar_url: 'https://...' }
-});
+// Check capability first
+if (commerce.capabilities.avatarViaMetadata && commerce.auth) {
+  await commerce.auth.updateCustomer({
+    metadata: { avatar_url: 'https://cdn.example.com/avatars/user-123.jpg' },
+  });
+}
 ```
 
-### Adaptive Profile Form
-Render only the fields supported by the current provider.
+> ⚠️ **Backend Disparity:** `uploadAvatar` (native file upload) is `false` for all current providers. Use `avatarViaMetadata` instead.
+
+## ✅ DO's
+
+1. **Check `commerce.capabilities` first:** Avoid rendering buttons for features the backend doesn't support.
+2. **Use metadata for extensions:** Store extra info like `avatar_url` or notification preferences in `customer.metadata`.
+3. **Handle errors explicitly:** Distinguish between `EMAIL_TAKEN` and generic update errors.
+4. **Validate on client:** Use patterns/regex for phone and email before sending to the adapter.
+5. **Re-fetch after update:** After a successful update, refresh the local customer state.
+
+## ❌ DONT's
+
+1. **Don't assume all backends are equal:** Medusa v2 has different capabilities than Shopify or WooCommerce.
+2. **Don't hardcode profile fields:** Use the `UpdateCustomerData` type from `@thorprovider/adapters`.
+3. **Don't ignore account deletion:** Provide a way for users to delete their account if `deleteAccount` is `true`.
+4. **Don't send sensitive data in metadata:** Metadata is often visible to the user and may be less secure.
+5. **Don't call `commerce.auth.updateCustomer` without checking `commerce.auth`:** It may be undefined.
 
 ## Common Errors & Solutions
 
@@ -128,16 +158,16 @@ Render only the fields supported by the current provider.
 ## Common Pitfalls
 
 > ⚠️ **Pitfall 1: Metadata Overwrites**
-> Some backends overwrite the entire metadata object instead of merging. Always fetch the current ones first if you want to preserve existing fields.
+> Some backends overwrite the entire metadata object instead of merging. Always fetch the current metadata first if you want to preserve existing fields.
 
 > ⚠️ **Pitfall 2: Password Complexity**
-> Backends have different password requirements. Let the backend validate and handle the error message.
+> Backends have different password requirements. Let the backend validate and surface the error message.
 
 ## Troubleshooting
 
 | Issue | Solution |
 |-------|----------|
-| Profile data not saving | Check if the user session is still active |
+| Profile data not saving | Check if the user session is still active (`isAuthenticated()`) |
 | Metadata field missing | Ensure the key exists in the backend's allowed metadata list |
 | 403 Forbidden | User might not have permission to update their own profile |
 

package/docs/services-overview.md

@@ -1,6 +1,6 @@
-# Services Overview
-
 ---
+title: Services Overview
+purpose: Overview of adapter services and provider capabilities
 type: guide
 tags: [architecture, services, commerce, api, architecture]
 related:
@@ -10,6 +10,8 @@ related:
 updated: 2026-02-28
 ---
 
+# Services Overview
+
 Overview of the functional services provided by Thor adapters and how they interact to provide a unified e-commerce interface.
 
 ## Overview

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thorprovider/adapters",
-  "version": "4.2.1",
+  "version": "4.3.0",
   "description": "Framework-agnostic commerce adapters for Thor Commerce ecosystem - Multi-platform support with unified API",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/quick-reference.md

@@ -52,6 +52,39 @@ Framework-agnostic business logic SDK for e-commerce operations. Provides unifie
 - **Collections**: Product collections/categories
 - **Customer**: Authentication, profile management
 - **Orders**: Order history, details, tracking
+- **Auth — Multi-Tenant**: `linkCustomerToChannel()` — links authenticated customer to sales channel (Medusa only)
+
+### Admin Client (Medusa only)
+`provider.admin` — available when `adminConfig.apiKey` is set. Exposes 15 methods for the `/admin/thor/` endpoints:
+```typescript
+const commerce = createProvider({ provider: 'medusa', config: { ..., adminConfig: { apiKey: '...' } } })
+if (!commerce.admin) throw new Error('Admin not configured')
+
+// Sales Channel — Customers / API Keys / Categories
+await commerce.admin.getChannelCustomers(salesChannelId, { limit, offset })
+await commerce.admin.getChannelApiKeys(salesChannelId)
+await commerce.admin.getChannelCategories(salesChannelId, { limit, offset, include_descendants })
+
+// Category ↔ Sales Channel assignments
+await commerce.admin.getCategorySalesChannels(categoryId)
+await commerce.admin.assignCategoryToChannels(categoryId, { sales_channel_ids: [...] })
+await commerce.admin.unassignCategoryFromChannels(categoryId, { sales_channel_ids: [...] })
+
+// Collection ↔ Sales Channel assignments
+await commerce.admin.getCollectionSalesChannels(collectionId)
+await commerce.admin.assignCollectionToChannels(collectionId, { sales_channel_ids: [...] })
+await commerce.admin.unassignCollectionFromChannels(collectionId, { sales_channel_ids: [...] })
+
+// Storefront Config (visual theme, SEO defaults)
+await commerce.admin.getStorefrontConfig(salesChannelId)
+await commerce.admin.updateStorefrontConfig(salesChannelId, { theme_accent_color, logo_url, currency_code, seo_defaults })
+
+// Site Designer Config (page builder config with history)
+await commerce.admin.getSiteConfig(salesChannelId)
+await commerce.admin.updateSiteConfig(salesChannelId, { config: { ... } })
+await commerce.admin.getSiteConfigHistory(salesChannelId, { limit, offset })
+await commerce.admin.restoreSiteConfig(salesChannelId, version)
+```
 
 ### Provider Architecture
 ```

package/src/providers/medusa/admin.test.ts

@@ -0,0 +1,404 @@
+/**
+ * @fileoverview Tests for MedusaAdminClient
+ *
+ * Uses msw to intercept fetch calls and verify that each method:
+ * - Hits the correct URL and HTTP method
+ * - Sends `x-medusa-access-token`
+ * - Forwards query-string options correctly
+ * - Returns the parsed response body
+ * - Throws ProviderAPIError on non-2xx responses
+ */
+
+import { describe, expect, it } from 'vitest'
+import { http, HttpResponse } from 'msw'
+import { server } from '../stelorder/client.test-helpers'
+import { MedusaAdminClient } from './admin'
+
+const BASE = 'https://medusa.example.com'
+const API_KEY = 'test-admin-key'
+
+function client() {
+  return new MedusaAdminClient({ baseUrl: BASE, apiKey: API_KEY })
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function requireAdminKey(request: Request) {
+  expect(request.headers.get('x-medusa-access-token')).toBe(API_KEY)
+}
+
+// ---------------------------------------------------------------------------
+// Sales Channel — Customers
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getChannelCustomers', () => {
+  it('GET /admin/thor/sales-channels/:id/customers with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_01/customers`, ({ request }) => {
+        requireAdminKey(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('20')
+        expect(url.searchParams.get('offset')).toBe('0')
+        return HttpResponse.json({ customers: [{ id: 'cus_1', email: 'a@b.com', sales_channel_ids: ['sc_01'] }], count: 1 })
+      }),
+    )
+
+    const result = await client().getChannelCustomers('sc_01')
+    expect(result.customers).toHaveLength(1)
+    expect(result.count).toBe(1)
+  })
+
+  it('forwards custom limit/offset', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_01/customers`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('5')
+        expect(url.searchParams.get('offset')).toBe('10')
+        return HttpResponse.json({ customers: [], count: 0 })
+      }),
+    )
+
+    await client().getChannelCustomers('sc_01', { limit: 5, offset: 10 })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Sales Channel — API Keys
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getChannelApiKeys', () => {
+  it('GET /admin/thor/sales-channels/:id/api-keys', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_01/api-keys`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({ api_keys: [{ id: 'apk_1', token: 'pk_live_xxx', sales_channel_id: 'sc_01' }] })
+      }),
+    )
+
+    const result = await client().getChannelApiKeys('sc_01')
+    expect(result.api_keys).toHaveLength(1)
+    expect(result.api_keys[0].id).toBe('apk_1')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Sales Channel — Categories
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getChannelCategories', () => {
+  it('GET /admin/thor/sales-channels/:id/categories with include_descendants', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_01/categories`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('include_descendants')).toBe('true')
+        return HttpResponse.json({ categories: [], count: 0 })
+      }),
+    )
+
+    const result = await client().getChannelCategories('sc_01', { include_descendants: true })
+    expect(result.categories).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Category — Sales Channels
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getCategorySalesChannels', () => {
+  it('GET /admin/thor/categories/:id/sales-channels', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/categories/cat_01/sales-channels`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({ sales_channels: [{ id: 'sc_01', name: 'Main' }] })
+      }),
+    )
+
+    const result = await client().getCategorySalesChannels('cat_01')
+    expect(result.sales_channels).toHaveLength(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Category — Assign / Unassign
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.assignCategoryToChannels', () => {
+  it('POST /admin/thor/categories/:id/sales-channels', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/categories/cat_01/sales-channels`, async ({ request }) => {
+        requireAdminKey(request)
+        const body = await request.clone().json() as any
+        expect(body.sales_channel_ids).toEqual(['sc_01'])
+        return HttpResponse.json({ message: 'ok', linked: 1 })
+      }),
+    )
+
+    const result = await client().assignCategoryToChannels('cat_01', { sales_channel_ids: ['sc_01'] })
+    expect(result.linked).toBe(1)
+  })
+})
+
+describe('MedusaAdminClient.unassignCategoryFromChannels', () => {
+  it('DELETE /admin/thor/categories/:id/sales-channels with body', async () => {
+    server.use(
+      http.delete(`${BASE}/admin/thor/categories/cat_01/sales-channels`, async ({ request }) => {
+        requireAdminKey(request)
+        const body = await request.clone().json() as any
+        expect(body.sales_channel_ids).toEqual(['sc_01'])
+        return HttpResponse.json({ message: 'ok', dismissed: 1 })
+      }),
+    )
+
+    const result = await client().unassignCategoryFromChannels('cat_01', { sales_channel_ids: ['sc_01'] })
+    expect(result.dismissed).toBe(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Collection — Sales Channels
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getCollectionSalesChannels', () => {
+  it('GET /admin/thor/collections/:id/sales-channels', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/collections/col_01/sales-channels`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({ sales_channels: [{ id: 'sc_01', name: 'Main' }] })
+      }),
+    )
+
+    const result = await client().getCollectionSalesChannels('col_01')
+    expect(result.sales_channels).toHaveLength(1)
+  })
+})
+
+describe('MedusaAdminClient.assignCollectionToChannels', () => {
+  it('POST /admin/thor/collections/:id/sales-channels', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/collections/col_01/sales-channels`, async ({ request }) => {
+        const body = await request.clone().json() as any
+        expect(body.sales_channel_ids).toEqual(['sc_01'])
+        return HttpResponse.json({ message: 'ok', linked: 1 })
+      }),
+    )
+
+    const result = await client().assignCollectionToChannels('col_01', { sales_channel_ids: ['sc_01'] })
+    expect(result.linked).toBe(1)
+  })
+})
+
+describe('MedusaAdminClient.unassignCollectionFromChannels', () => {
+  it('DELETE /admin/thor/collections/:id/sales-channels', async () => {
+    server.use(
+      http.delete(`${BASE}/admin/thor/collections/col_01/sales-channels`, async ({ request }) => {
+        const body = await request.clone().json() as any
+        expect(body.sales_channel_ids).toEqual(['sc_01'])
+        return HttpResponse.json({ message: 'ok', dismissed: 1 })
+      }),
+    )
+
+    const result = await client().unassignCollectionFromChannels('col_01', { sales_channel_ids: ['sc_01'] })
+    expect(result.dismissed).toBe(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Storefront Config
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getStorefrontConfig', () => {
+  it('GET /admin/thor/storefront-config/:id', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/storefront-config/sc_01`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({
+          storefront_config: {
+            id: 'scfg_01',
+            sales_channel_id: 'sc_01',
+            theme_accent_color: '#000',
+            logo_url: '',
+            currency_code: 'USD',
+            seo_defaults: { title: 'Store', description: '' },
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-01T00:00:00Z',
+          },
+        })
+      }),
+    )
+
+    const result = await client().getStorefrontConfig('sc_01')
+    expect(result.storefront_config.id).toBe('scfg_01')
+  })
+})
+
+describe('MedusaAdminClient.updateStorefrontConfig', () => {
+  it('PUT /admin/thor/storefront-config/:id', async () => {
+    server.use(
+      http.put(`${BASE}/admin/thor/storefront-config/sc_01`, async ({ request }) => {
+        const body = await request.clone().json() as any
+        expect(body.theme_accent_color).toBe('#ff0000')
+        return HttpResponse.json({
+          storefront_config: {
+            id: 'scfg_01',
+            sales_channel_id: 'sc_01',
+            theme_accent_color: '#ff0000',
+            logo_url: '',
+            currency_code: 'USD',
+            seo_defaults: { title: 'Store', description: '' },
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-02T00:00:00Z',
+          },
+        })
+      }),
+    )
+
+    const result = await client().updateStorefrontConfig('sc_01', {
+      theme_accent_color: '#ff0000',
+      logo_url: '',
+      currency_code: 'USD',
+      seo_defaults: { title: 'Store', description: '' },
+    })
+    expect(result.storefront_config.theme_accent_color).toBe('#ff0000')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Site Config
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getSiteConfig', () => {
+  it('GET /admin/thor/site-config/:sales_channel_id', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/site-config/sc_01`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({
+          site_config: {
+            id: 'scfg_01',
+            sales_channel_id: 'sc_01',
+            version: 'v1',
+            config: { theme: 'dark' },
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-01T00:00:00Z',
+            history: [],
+          },
+        })
+      }),
+    )
+
+    const result = await client().getSiteConfig('sc_01')
+    expect(result.site_config.id).toBe('scfg_01')
+  })
+})
+
+describe('MedusaAdminClient.updateSiteConfig', () => {
+  it('PUT /admin/thor/site-config/:sales_channel_id', async () => {
+    server.use(
+      http.put(`${BASE}/admin/thor/site-config/sc_01`, async ({ request }) => {
+        const body = await request.json() as any
+        expect(body.config).toEqual({ theme: 'light' })
+        return HttpResponse.json({
+          site_config: {
+            id: 'scfg_02',
+            sales_channel_id: 'sc_01',
+            version: 'v2',
+            config: { theme: 'light' },
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-02T00:00:00Z',
+            history: [],
+          },
+        })
+      }),
+    )
+
+    const result = await client().updateSiteConfig('sc_01', { config: { theme: 'light' } })
+    expect(result.site_config.version).toBe('v2')
+  })
+})
+
+describe('MedusaAdminClient.getSiteConfigHistory', () => {
+  it('GET /admin/thor/site-config/:id/history with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/site-config/sc_01/history`, ({ request }) => {
+        requireAdminKey(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('20')
+        expect(url.searchParams.get('offset')).toBe('0')
+        return HttpResponse.json({ history: [], count: 0 })
+      }),
+    )
+
+    const result = await client().getSiteConfigHistory('sc_01')
+    expect(result.count).toBe(0)
+  })
+
+  it('forwards custom limit/offset', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/site-config/sc_01/history`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('5')
+        expect(url.searchParams.get('offset')).toBe('10')
+        return HttpResponse.json({ history: [], count: 0 })
+      }),
+    )
+
+    await client().getSiteConfigHistory('sc_01', { limit: 5, offset: 10 })
+  })
+})
+
+describe('MedusaAdminClient.restoreSiteConfig', () => {
+  it('POST /admin/thor/site-config/:id/restore/:version', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/site-config/sc_01/restore/v1`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({
+          site_config: {
+            id: 'scfg_03',
+            sales_channel_id: 'sc_01',
+            version: 'v3',
+            config: { theme: 'dark' },
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-03T00:00:00Z',
+            history: [],
+          },
+        })
+      }),
+    )
+
+    const result = await client().restoreSiteConfig('sc_01', 'v1')
+    expect(result.site_config.version).toBe('v3')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient error handling', () => {
+  it('throws ProviderAPIError on 404', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_missing/customers`, () =>
+        HttpResponse.json({ message: 'Sales channel not found' }, { status: 404 }),
+      ),
+    )
+
+    await expect(client().getChannelCustomers('sc_missing')).rejects.toMatchObject({
+      name: 'ProviderAPIError',
+      provider: 'ADMIN_API_404',
+    })
+  })
+
+  it('throws ProviderAPIError on 401', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_01/api-keys`, () =>
+        HttpResponse.json({ message: 'Unauthorized' }, { status: 401 }),
+      ),
+    )
+
+    await expect(client().getChannelApiKeys('sc_01')).rejects.toMatchObject({
+      name: 'ProviderAPIError',
+      provider: 'ADMIN_API_401',
+    })
+  })
+})