@thorprovider/adapters 5.0.0 → 5.0.1

package/src/providers/medusa/auth.ts

@@ -19,7 +19,6 @@ import type {
   CreateAddressData,
   PasswordResetRequest,
   PasswordResetConfirm,
-  LinkCustomerToChannelResponse,
 } from '@thorprovider/types';
 import { createLogger } from '../../core/logger';
 import { ProviderAPIError } from '../../core/errors';
@@ -121,18 +120,12 @@ export class MedusaAuthProvider implements AuthProvider {
   private logger: ReturnType<typeof createLogger>;
   private authConfig: AuthConfig;
   private storageManager: AuthStorageManager;
-  /** Medusa backend base URL — needed for raw fetch calls */
-  private baseUrl: string;
-  /** Publishable API key — sent as x-publishable-api-key on store calls */
-  private publishableKey: string;
   
-  constructor(sdk: Medusa, authConfig: AuthConfig, debug = false, baseUrl = '', publishableKey = '') {
+  constructor(sdk: Medusa, authConfig: AuthConfig, debug = false) {
     this.sdk = sdk;
     this.authConfig = authConfig;
     this.logger = createLogger('MedusaAuthProvider', debug);
     this.storageManager = new AuthStorageManager(authConfig);
-    this.baseUrl = baseUrl;
-    this.publishableKey = publishableKey;
     
     this.logger.info('Medusa Auth Provider initialized', {
       method: authConfig.method,
@@ -146,35 +139,51 @@ export class MedusaAuthProvider implements AuthProvider {
   
   async login(credentials: LoginCredentials): Promise<AuthResponse> {
     this.logger.debug('login', { email: credentials.email });
-    
+
     try {
       // Step 1: Authenticate with Medusa
-      const token = await this.sdk.auth.login('customer', 'emailpass', {
+      const loginResult = await this.sdk.auth.login('customer', 'emailpass', {
         email: credentials.email,
         password: credentials.password,
       });
-      
-      // Check if token requires additional actions (OAuth flow)
-      if (typeof token !== 'string') {
-        this.logger.warn('Authentication requires additional actions', token);
-        return {
-          requiresAction: true,
-          redirectUrl: token.location,
-        };
+
+      // Check if login requires additional actions (OAuth or email verification)
+      if (typeof loginResult !== 'string') {
+        // v2.16.0: email verification required
+        if ('verification_required' in loginResult && loginResult.verification_required) {
+          this.logger.warn('Authentication requires email verification', loginResult);
+          return {
+            requiresAction: true,
+            token: loginResult.token,
+          };
+        }
+
+        // OAuth redirect flow
+        if ('location' in loginResult) {
+          this.logger.warn('Authentication requires additional actions', loginResult);
+          return {
+            requiresAction: true,
+            redirectUrl: loginResult.location,
+          };
+        }
+
+        throw new Error('Unexpected login result type');
       }
-      
+
+      const token = loginResult;
+
       // Step 2: Store token based on auth method
       if (this.authConfig.method === 'jwt') {
         await this.storageManager.setToken(token);
       }
       // Note: For session-based auth, the SDK automatically handles cookies
       // when auth.login() is called with auth.type='session' in SDK config
-      
+
       // Step 3: Fetch customer data
       const customer = await this.getCurrentCustomer();
-      
+
       this.logger.info('Login successful', { customerId: customer?.id });
-      
+
       return {
         token: this.authConfig.method === 'jwt' ? token : undefined,
         customer: customer ?? undefined,
@@ -191,36 +200,64 @@ export class MedusaAuthProvider implements AuthProvider {
   
   async register(data: RegisterData): Promise<AuthResponse> {
     this.logger.debug('register', { email: data.email });
-    
+
     try {
       // Step 1: Register auth identity with Medusa
-      const token = await this.sdk.auth.register('customer', 'emailpass', {
+      // v2.16.0: register no longer accepts returnVerification option.
+      // The SDK auto-stores the registration JWT token for subsequent requests.
+      await this.sdk.auth.register('customer', 'emailpass', {
         email: data.email,
         password: data.password,
       });
-      
-      if (typeof token !== 'string') {
-        throw new Error('Registration returned non-string token');
-      }
-      
+
       // Step 2: Create customer profile
-      // Note: The SDK automatically includes the token in the header after auth.register()
+      // The registration token is automatically included in the header by the SDK.
       const { customer } = await this.sdk.store.customer.create({
         email: data.email,
         first_name: data.first_name,
         last_name: data.last_name,
         phone: data.phone,
       });
-      
-      // Step 3: Store token based on auth method
+
+      // Step 3: Login to obtain the actual session/token
+      // v2.16.0: verification status is now returned by login, not register.
+      const loginResult = await this.sdk.auth.login('customer', 'emailpass', {
+        email: data.email,
+        password: data.password,
+      });
+
+      if (typeof loginResult !== 'string') {
+        // v2.16.0: email verification required before full login
+        if ('verification_required' in loginResult && loginResult.verification_required) {
+          this.logger.warn('Registration requires email verification', loginResult);
+          return {
+            requiresAction: true,
+            token: loginResult.token,
+          };
+        }
+
+        // OAuth redirect flow
+        if ('location' in loginResult) {
+          this.logger.warn('Registration requires additional actions', loginResult);
+          return {
+            requiresAction: true,
+            redirectUrl: loginResult.location,
+          };
+        }
+
+        throw new Error('Unexpected login result after registration');
+      }
+
+      const token = loginResult;
+
+      // Step 4: Store actual auth token based on auth method
       if (this.authConfig.method === 'jwt') {
         await this.storageManager.setToken(token);
       }
       // Note: For session-based auth, the SDK automatically handles cookies
-      // when auth.register() is called with auth.type='session' in SDK config
-      
+
       this.logger.info('Registration successful', { customerId: customer.id });
-      
+
       return {
         token: this.authConfig.method === 'jwt' ? token : undefined,
         customer: transformCustomer(customer, customer.email),
@@ -500,92 +537,4 @@ export class MedusaAuthProvider implements AuthProvider {
       undefined
     );
   }
-
-  // ========================================
-  // Multi-Tenant — Channel Link
-  // ========================================
-
-  /**
-   * Link the currently authenticated customer to the storefront's sales channel.
-   *
-   * Must be called immediately after a successful `login()` so the customer
-   * appears in the admin panel of the correct storefront channel.
-   *
-   * Implements `POST /store/thor/customers/me/channels`.
-   * Idempotent — returns `{ linked: false, reason: 'already_linked' }` when
-   * the link already exists.
-   *
-   * @throws {ProviderAPIError} When not authenticated (401) or channel cannot
-   *   be resolved from the publishable key (400).
-   */
-  async linkCustomerToChannel(): Promise<LinkCustomerToChannelResponse> {
-    this.logger.debug('linkCustomerToChannel');
-
-    if (!this.baseUrl || !this.publishableKey) {
-      throw new ProviderAPIError(
-        'linkCustomerToChannel requires baseUrl and publishableKey to be set on the auth provider.',
-        'CONFIGURATION_ERROR',
-        undefined
-      );
-    }
-
-    // Retrieve the JWT token for the Authorization header.
-    // Falls back to the SDK-managed token (session or JWT storage).
-    const token = await this.storageManager.getToken();
-
-    const headers: Record<string, string> = {
-      'x-publishable-api-key': this.publishableKey,
-      'Content-Type': 'application/json',
-    };
-
-    if (token) {
-      headers['Authorization'] = `Bearer ${token}`;
-    }
-
-    try {
-      const url = `${this.baseUrl}/store/thor/customers/me/channels`;
-      const response = await fetch(url, {
-        method: 'POST',
-        headers,
-      });
-
-      if (response.status === 401) {
-        throw new ProviderAPIError(
-          'linkCustomerToChannel: not authenticated. Call login() first.',
-          'NOT_AUTHENTICATED',
-          401
-        );
-      }
-
-      if (response.status === 400) {
-        const body = await response.json().catch(() => ({}));
-        throw new ProviderAPIError(
-          `linkCustomerToChannel: could not resolve sales channel from publishable key. ${body?.message ?? ''}`.trim(),
-          'CHANNEL_RESOLUTION_FAILED',
-          400
-        );
-      }
-
-      if (!response.ok) {
-        const body = await response.json().catch(() => ({}));
-        throw new ProviderAPIError(
-          `linkCustomerToChannel failed with status ${response.status}: ${body?.message ?? 'Unknown error'}`,
-          'LINK_CHANNEL_FAILED',
-          response.status
-        );
-      }
-
-      const data = await response.json() as LinkCustomerToChannelResponse;
-      this.logger.info('Customer linked to channel', { linked: data.linked, reason: data.reason });
-      return data;
-    } catch (error: any) {
-      if (error instanceof ProviderAPIError) throw error;
-      this.logger.error('linkCustomerToChannel failed', error);
-      throw new ProviderAPIError(
-        `linkCustomerToChannel failed: ${error.message}`,
-        'LINK_CHANNEL_FAILED',
-        error
-      );
-    }
-  }
 }

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

@@ -0,0 +1,392 @@
+/**
+ * Integration tests for MedusaProvider (main storefront provider).
+ *
+ * Uses msw to intercept HTTP requests — no real backend required.
+ * Follows the same pattern as auth.test.ts and admin.test.ts.
+ *
+ * Coverage:
+ *  - Products: getProduct, getProducts (success + 404 + 503)
+ *  - Cart: createCart, getCart (success + 404), addToCart
+ *  - Shipping: getShippingMethods
+ *  - Regions: getRegions
+ *  - Checkout: getPaymentMethods, completeCheckout
+ */
+import { describe, expect, it } from 'vitest'
+import { http, HttpResponse } from 'msw'
+import { server } from '../stelorder/client.test-helpers'
+import { MedusaProvider } from './index'
+
+// ---------------------------------------------------------------------------
+// Test constants
+// ---------------------------------------------------------------------------
+const BASE = 'https://medusa.example.com'
+const PUB_KEY = 'pk_test_abc123'
+const CURRENCY = 'usd'
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+function makeProvider() {
+  return new MedusaProvider({
+    baseUrl: BASE,
+    publishableKey: PUB_KEY,
+    currencyCode: CURRENCY,
+    debug: false,
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Minimal Medusa response fixtures
+// ---------------------------------------------------------------------------
+const MEDUSA_PRODUCT = {
+  id: 'prod_01',
+  handle: 'test-product',
+  title: 'Test Product',
+  subtitle: null,
+  description: 'A test product',
+  status: 'published',
+  thumbnail: 'https://example.com/thumb.jpg',
+  images: [{ id: 'img_01', url: 'https://example.com/img.jpg', metadata: null }],
+  tags: [],
+  collection: null,
+  categories: [],
+  options: [{ id: 'opt_01', title: 'Size', product_id: 'prod_01', values: [{ id: 'optval_01', value: 'One Size', option_id: 'opt_01' }] }],
+  variants: [
+    {
+      id: 'variant_01',
+      title: 'Default',
+      product_id: 'prod_01',
+      sku: 'SKU-001',
+      inventory_quantity: 10,
+      prices: [{ id: 'price_01', amount: 2500, currency_code: 'usd' }],
+      calculated_price: { calculated_amount: 2500, currency_code: 'usd' },
+      options: [{ id: 'optval_01', value: 'One Size' }],
+    },
+  ],
+  metadata: null,
+  created_at: '2026-01-01T00:00:00Z',
+  updated_at: '2026-01-01T00:00:00Z',
+}
+
+const MEDUSA_CART = {
+  id: 'cart_01',
+  currency_code: 'usd',
+  region_id: 'reg_01',
+  region: { id: 'reg_01', currency_code: 'usd' },
+  items: [],
+  total: 0,
+  subtotal: 0,
+  tax_total: 0,
+  shipping_total: 0,
+  discount_total: 0,
+  shipping_address: null,
+  billing_address: null,
+  shipping_methods: [],
+  payment_collection: null,
+  metadata: null,
+  created_at: '2026-01-01T00:00:00Z',
+  updated_at: '2026-01-01T00:00:00Z',
+}
+
+const MEDUSA_REGION = {
+  id: 'reg_01',
+  name: 'North America',
+  currency_code: 'usd',
+  countries: [{ iso_2: 'us', display_name: 'United States', name: 'UNITED STATES', iso_3: 'usa', num_code: '840', region_id: 'reg_01', metadata: null, created_at: '2026-01-01T00:00:00Z', updated_at: '2026-01-01T00:00:00Z', deleted_at: null }],
+  created_at: '2026-01-01T00:00:00Z',
+  updated_at: '2026-01-01T00:00:00Z',
+  deleted_at: null,
+  metadata: null,
+}
+
+// ---------------------------------------------------------------------------
+// Products
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Products', () => {
+  it('getProduct returns transformed product when found', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ products: [MEDUSA_PRODUCT], count: 1, offset: 0, limit: 1 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const product = await provider.getProduct('test-product')
+
+    expect(product).not.toBeUndefined()
+    expect(product!.id).toBe('prod_01')
+    expect(product!.handle).toBe('test-product')
+    expect(product!.title).toBe('Test Product')
+    expect(product!.variants).toHaveLength(1)
+  })
+
+  it('getProduct returns undefined when not found', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ products: [], count: 0, offset: 0, limit: 1 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const product = await provider.getProduct('does-not-exist')
+
+    expect(product).toBeUndefined()
+  })
+
+  it('getProduct throws ProviderAPIError on 503', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ message: 'Service unavailable' }, { status: 503 }),
+      ),
+    )
+
+    const provider = makeProvider()
+
+    await expect(provider.getProduct('any-handle')).rejects.toThrow()
+  })
+
+  it('getProducts returns array of transformed products', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ products: [MEDUSA_PRODUCT], count: 1, offset: 0, limit: 100 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const products = await provider.getProducts({ first: 10 })
+
+    expect(Array.isArray(products)).toBe(true)
+    expect(products).toHaveLength(1)
+    expect(products[0].handle).toBe('test-product')
+  })
+
+  it('getProducts returns empty array when backend returns none', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ products: [], count: 0, offset: 0, limit: 100 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const products = await provider.getProducts()
+
+    expect(products).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Cart
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Cart', () => {
+  it('createCart returns a cart with an id', async () => {
+    server.use(
+      http.post(`${BASE}/store/carts`, () =>
+        HttpResponse.json({ cart: MEDUSA_CART }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const cart = await provider.createCart()
+
+    expect(cart.id).toBe('cart_01')
+  })
+
+  it('createCart with regionId passes region_id in payload', async () => {
+    server.use(
+      http.post(`${BASE}/store/carts`, async ({ request }) => {
+        const body = await request.json() as any
+        expect(body.region_id).toBe('reg_test')
+        return HttpResponse.json({ cart: { ...MEDUSA_CART, region_id: 'reg_test' } })
+      }),
+    )
+
+    const provider = makeProvider()
+    const cart = await provider.createCart({ regionId: 'reg_test' })
+
+    expect(cart.id).toBe('cart_01')
+  })
+
+  it('getCart returns cart when found', async () => {
+    server.use(
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({ cart: MEDUSA_CART }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const cart = await provider.getCart('cart_01')
+
+    expect(cart).not.toBeUndefined()
+    expect(cart!.id).toBe('cart_01')
+  })
+
+  it('getCart returns undefined when cart not found (404)', async () => {
+    server.use(
+      http.get(`${BASE}/store/carts/cart_missing`, () =>
+        HttpResponse.json({ message: 'Not found' }, { status: 404 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const cart = await provider.getCart('cart_missing')
+
+    expect(cart).toBeUndefined()
+  })
+
+  it('createCart throws ProviderAPIError on server error', async () => {
+    server.use(
+      http.post(`${BASE}/store/carts`, () =>
+        HttpResponse.json({ message: 'Internal Server Error' }, { status: 500 }),
+      ),
+    )
+
+    const provider = makeProvider()
+
+    await expect(provider.createCart()).rejects.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Regions
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Regions', () => {
+  it('getRegions returns array of regions', async () => {
+    server.use(
+      http.get(`${BASE}/store/regions`, () =>
+        HttpResponse.json({ regions: [MEDUSA_REGION], count: 1, offset: 0, limit: 100 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const regions = await provider.getRegions()
+
+    expect(Array.isArray(regions)).toBe(true)
+    expect(regions).toHaveLength(1)
+    expect(regions[0].id).toBe('reg_01')
+    expect(regions[0].name).toBe('North America')
+  })
+
+  it('getRegions returns empty array when no regions', async () => {
+    server.use(
+      http.get(`${BASE}/store/regions`, () =>
+        HttpResponse.json({ regions: [], count: 0, offset: 0, limit: 100 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const regions = await provider.getRegions()
+
+    expect(regions).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Shipping
+// getShippingMethods first retrieves the cart (to get region_id), then fetches
+// shipping options for that cart via GET /store/shipping-options?cart_id=...
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Shipping', () => {
+  const CART_WITH_REGION = { ...MEDUSA_CART, region_id: 'reg_01' }
+
+  const MEDUSA_SHIPPING_OPTION = {
+    id: 'so_01',
+    name: 'Standard Shipping',
+    amount: 499,
+    price_type: 'flat',
+    provider_id: 'manual',
+    service_zone: { id: 'sz_01', name: 'Default' },
+  }
+
+  it('getShippingMethods returns available methods', async () => {
+    server.use(
+      // Step 1: cart retrieve
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({ cart: CART_WITH_REGION }),
+      ),
+      // Step 2: shipping options
+      http.get(`${BASE}/store/shipping-options`, () =>
+        HttpResponse.json({ shipping_options: [MEDUSA_SHIPPING_OPTION] }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const methods = await provider.getShippingMethods('cart_01')
+
+    expect(Array.isArray(methods)).toBe(true)
+    expect(methods).toHaveLength(1)
+    expect(methods[0].id).toBe('so_01')
+    expect(methods[0].name).toBe('Standard Shipping')
+  })
+
+  it('getShippingMethods returns empty array when none available', async () => {
+    server.use(
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({ cart: CART_WITH_REGION }),
+      ),
+      http.get(`${BASE}/store/shipping-options`, () =>
+        HttpResponse.json({ shipping_options: [] }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const methods = await provider.getShippingMethods('cart_01')
+
+    expect(methods).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Payment methods
+// getPaymentMethods fetches the cart first (to get region_id), then calls
+// GET /store/payment-providers?region_id=...
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Payment', () => {
+  it('getPaymentMethods returns payment providers', async () => {
+    server.use(
+      // Step 1: cart retrieve to get region_id
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({ cart: { ...MEDUSA_CART, region_id: 'reg_01' } }),
+      ),
+      // Step 2: payment providers
+      http.get(`${BASE}/store/payment-providers`, () =>
+        HttpResponse.json({
+          payment_providers: [{ id: 'pp_manual', name: 'Manual', is_enabled: true }],
+        }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const methods = await provider.getPaymentMethods({ cartId: 'cart_01' })
+
+    expect(Array.isArray(methods)).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Error propagation
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Error propagation', () => {
+  it('getProducts throws when backend returns 503', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ message: 'Service Unavailable' }, { status: 503 }),
+      ),
+    )
+
+    const provider = makeProvider()
+
+    await expect(provider.getProducts()).rejects.toThrow()
+  })
+
+  it('createCart throws when backend returns 500', async () => {
+    server.use(
+      http.post(`${BASE}/store/carts`, () =>
+        HttpResponse.json({ message: 'Internal Server Error' }, { status: 500 }),
+      ),
+    )
+
+    const provider = makeProvider()
+
+    await expect(provider.createCart()).rejects.toThrow()
+  })
+})