@thorprovider/adapters 5.0.9 → 5.0.11

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

@@ -174,6 +174,140 @@ describe('MedusaProvider — Products', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// Catalog pagination bound + directed lookup (change B, group 4)
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Catalog pagination and directed lookup', () => {
+  function captureListUrl(): { urls: string[] } {
+    const urls: string[] = []
+    server.use(
+      http.get(`${BASE}/store/products`, ({ request }) => {
+        urls.push(request.url)
+        const url = new URL(request.url)
+        if (url.searchParams.get('handle') || url.searchParams.get('id')) {
+          return HttpResponse.json({
+            products: [MEDUSA_PRODUCT],
+            count: 1,
+            offset: 0,
+            limit: 1,
+          })
+        }
+        return HttpResponse.json({ products: [], count: 0, offset: 0, limit: 50 })
+      }),
+    )
+    return { urls }
+  }
+
+  it('getProducts uses the configured default bound (50), not an unbounded scan', async () => {
+    const { urls } = captureListUrl()
+    const provider = makeProvider()
+
+    await provider.getProducts()
+
+    expect(urls).toHaveLength(1)
+    expect(new URL(urls[0]).searchParams.get('limit')).toBe('50')
+  })
+
+  it('getProducts honors an explicit configured bound', async () => {
+    const { urls } = captureListUrl()
+    const provider = new MedusaProvider({
+      baseUrl: BASE,
+      publishableKey: PUB_KEY,
+      currencyCode: CURRENCY,
+      catalogPageSize: 25,
+      debug: false,
+    })
+
+    await provider.getProducts()
+
+    expect(new URL(urls[0]).searchParams.get('limit')).toBe('25')
+  })
+
+  it('getProducts paginates per request with first + after (count/offset)', async () => {
+    const { urls } = captureListUrl()
+    const provider = makeProvider()
+
+    await provider.getProducts({ first: 10, after: '20' })
+
+    const params = new URL(urls[0]).searchParams
+    expect(params.get('limit')).toBe('10')
+    expect(params.get('offset')).toBe('20')
+  })
+
+  it('getProduct resolves by handle with a single directed query (limit 1), never a scan', async () => {
+    const { urls } = captureListUrl()
+    const provider = makeProvider()
+
+    const product = await provider.getProduct('test-product')
+
+    expect(product?.handle).toBe('test-product')
+    expect(urls).toHaveLength(1)
+    const params = new URL(urls[0]).searchParams
+    expect(params.get('handle')).toBe('test-product')
+    expect(params.get('limit')).toBe('1')
+  })
+
+  it('getProductById resolves by id with a directed query, independent of the first page', async () => {
+    const { urls } = captureListUrl()
+    const provider = makeProvider()
+
+    const product = await provider.getProductById('prod_01')
+
+    expect(product?.id).toBe('prod_01')
+    expect(urls).toHaveLength(1)
+    const params = new URL(urls[0]).searchParams
+    expect(params.get('id')).toBe('prod_01')
+    expect(params.get('limit')).toBe('1')
+  })
+
+  it('a product beyond a >200 dataset resolves by handle without scanning the listing', async () => {
+    // 250-product regression dataset: the first bounded page never contains the
+    // target. A directed handle lookup still resolves it in one request.
+    const urls: string[] = []
+    const dataset = Array.from({ length: 250 }, (_, i) => ({
+      ...MEDUSA_PRODUCT,
+      id: `prod_${i}`,
+      handle: `prod-${i}`,
+    }))
+    const target = { ...MEDUSA_PRODUCT, id: 'prod_249', handle: 'prod-249' }
+    server.use(
+      http.get(`${BASE}/store/products`, ({ request }) => {
+        urls.push(request.url)
+        const url = new URL(request.url)
+        const handle = url.searchParams.get('handle')
+        if (handle) {
+          const hit = dataset.find((p) => p.handle === handle)
+          return HttpResponse.json({
+            products: hit ? [hit] : [],
+            count: hit ? 1 : 0,
+            offset: 0,
+            limit: 1,
+          })
+        }
+        const limit = Number(url.searchParams.get('limit') ?? 50)
+        return HttpResponse.json({
+          products: dataset.slice(0, limit),
+          count: dataset.length,
+          offset: 0,
+          limit,
+        })
+      }),
+    )
+
+    const provider = makeProvider()
+    const firstPage = await provider.getProducts()
+    expect(firstPage).toHaveLength(50)
+    expect(firstPage.some((p) => p.handle === target.handle)).toBe(false)
+
+    const resolved = await provider.getProduct('prod-249')
+    expect(resolved?.handle).toBe('prod-249')
+
+    const directed = urls.filter((u) => new URL(u).searchParams.get('handle'))
+    expect(directed).toHaveLength(1)
+    expect(new URL(directed[0]).searchParams.get('limit')).toBe('1')
+  })
+})
+
 // ---------------------------------------------------------------------------
 // Cart
 // ---------------------------------------------------------------------------
@@ -206,6 +340,42 @@ describe('MedusaProvider — Cart', () => {
     expect(cart.id).toBe('cart_01')
   })
 
+  it('createCart passes an explicit salesChannelId in the payload', async () => {
+    server.use(
+      http.post(`${BASE}/store/carts`, async ({ request }) => {
+        const body = await request.json() as any
+        expect(body.sales_channel_id).toBe('sc_explicit')
+        return HttpResponse.json({ cart: MEDUSA_CART })
+      }),
+    )
+
+    const provider = makeProvider()
+    await provider.createCart({ regionId: 'reg_01', salesChannelId: 'sc_explicit' })
+  })
+
+  it('createCart falls back to MEDUSA_SALES_CHANNEL_ID then the public var', async () => {
+    const originalServer = process.env.MEDUSA_SALES_CHANNEL_ID
+    const originalPublic = process.env.NEXT_PUBLIC_SALES_CHANNEL_ID
+    process.env.MEDUSA_SALES_CHANNEL_ID = 'sc_server'
+    process.env.NEXT_PUBLIC_SALES_CHANNEL_ID = 'sc_public'
+    try {
+      server.use(
+        http.post(`${BASE}/store/carts`, async ({ request }) => {
+          const body = await request.json() as any
+          expect(body.sales_channel_id).toBe('sc_server')
+          return HttpResponse.json({ cart: MEDUSA_CART })
+        }),
+      )
+      const provider = makeProvider()
+      await provider.createCart({ regionId: 'reg_01' })
+    } finally {
+      if (originalServer === undefined) delete process.env.MEDUSA_SALES_CHANNEL_ID
+      else process.env.MEDUSA_SALES_CHANNEL_ID = originalServer
+      if (originalPublic === undefined) delete process.env.NEXT_PUBLIC_SALES_CHANNEL_ID
+      else process.env.NEXT_PUBLIC_SALES_CHANNEL_ID = originalPublic
+    }
+  })
+
   it('getCart returns cart when found', async () => {
     server.use(
       http.get(`${BASE}/store/carts/cart_01`, () =>
@@ -235,6 +405,7 @@ describe('MedusaProvider — Cart', () => {
           thumbnail: 'https://img.example.com/cover.png',
           quantity: 2,
           unit_price: 60,
+          total: 120,
         },
       ],
       total: 120,
@@ -258,6 +429,93 @@ describe('MedusaProvider — Cart', () => {
     expect(line?.merchandise.product.title).toBe('Cover Samsung Note 10 Plus')
     expect(line?.merchandise.product.featuredImage.url).toBe('https://img.example.com/cover.png')
     expect(line?.cost.totalAmount.amount).toBe('120.00')
+    expect(line?.cost.unitPrice?.amount).toBe('60.00')
+  })
+
+  it('getCart does not invent a line total from unit_price × quantity', async () => {
+    const cartWithoutLineTotal = {
+      ...MEDUSA_CART,
+      items: [
+        {
+          id: 'cali_01',
+          variant_id: 'variant_01',
+          quantity: 2,
+          unit_price: 60,
+        },
+      ],
+      total: 0,
+      subtotal: 0,
+    }
+    server.use(
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({ cart: cartWithoutLineTotal }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const cart = await provider.getCart('cart_01')
+
+    // No backend line total → empty amount, never a locally multiplied `120`.
+    expect(cart?.lines?.[0]?.cost.totalAmount.amount).toBe('')
+  })
+
+  it('getCart carries the backend context, financial fields and item subtotal', async () => {
+    let retrieveUrl = ''
+    const cartWithTotals = {
+      ...MEDUSA_CART,
+      sales_channel_id: 'sc_01',
+      region_id: 'reg_01',
+      currency_code: 'usd',
+      item_subtotal: 22.22,
+      subtotal: 27.22,
+      discount_total: 10,
+      tax_total: 5,
+      shipping_total: 5,
+      total: 27.22,
+      items: [
+        {
+          id: 'cali_01',
+          variant_id: 'variant_01',
+          product_title: 'B Acceptance Product',
+          variant_title: 'Large',
+          quantity: 1,
+          unit_price: 22.22,
+          total: 22.22,
+        },
+      ],
+      shipping_methods: [{ id: 'sm_01', shipping_option_id: 'so_01' }],
+      completed_at: null,
+    }
+    server.use(
+      http.get(`${BASE}/store/carts/cart_01`, ({ request }) => {
+        retrieveUrl = request.url
+        return HttpResponse.json({ cart: cartWithTotals })
+      }),
+    )
+
+    const provider = makeProvider()
+    const cart = await provider.getCart('cart_01')
+
+    // The retrieve requests the explicit financial line fields.
+    const fields = new URL(retrieveUrl).searchParams.get('fields') ?? ''
+    expect(fields).toContain('+items.total')
+    expect(fields).toContain('+items.unit_price')
+
+    expect(cart?.salesChannelId).toBe('sc_01')
+    expect(cart?.regionId).toBe('reg_01')
+    expect(cart?.currencyCode).toBe('USD')
+    expect(cart?.selectedShippingMethodId).toBe('sm_01')
+    expect(cart?.selectedShippingOptionId).toBe('so_01')
+    expect(cart?.cost).toMatchObject({
+      // item_subtotal (lines only), not native subtotal (which includes shipping)
+      subtotalAmount: { amount: '22.22', currencyCode: 'USD' },
+      discountAmount: { amount: '10.00', currencyCode: 'USD' },
+      totalTaxAmount: { amount: '5.00', currencyCode: 'USD' },
+      shippingAmount: { amount: '5.00', currencyCode: 'USD' },
+      totalAmount: { amount: '27.22', currencyCode: 'USD' },
+    })
+    expect(cart?.lines[0]?.cost.unitPrice?.amount).toBe('22.22')
+    expect(cart?.lines[0]?.cost.totalAmount.amount).toBe('22.22')
   })
 
   it('getCart returns undefined when cart not found (404)', async () => {
@@ -430,3 +688,225 @@ describe('MedusaProvider — Error propagation', () => {
     await expect(provider.createCart()).rejects.toThrow()
   })
 })
+
+// ---------------------------------------------------------------------------
+// Completion — discriminated native result, never blindly retried
+// ---------------------------------------------------------------------------
+const MEDUSA_ORDER = {
+  id: 'order_01',
+  display_id: 1001,
+  email: 'buyer@example.com',
+  status: 'pending',
+  payment_status: 'awaiting',
+  fulfillment_status: 'not_fulfilled',
+  currency_code: 'usd',
+  item_subtotal: 22.22,
+  subtotal: 27.22,
+  items: [
+    {
+      id: 'ordli_01',
+      title: 'B Acceptance Product',
+      product_title: 'B Acceptance Product',
+      variant_title: 'Large',
+      variant_id: 'variant_01',
+      product_id: 'prod_01',
+      quantity: 1,
+      unit_price: 22.22,
+      total: 22.22,
+      thumbnail: 'https://example.com/p.png',
+    },
+  ],
+  total: 27.22,
+  tax_total: 0,
+  shipping_total: 5,
+  discount_total: 0,
+  created_at: '2026-01-01T00:00:00Z',
+  updated_at: '2026-01-01T00:00:00Z',
+}
+
+describe('MedusaProvider — Completion', () => {
+  it('completeCart requests explicit order item fields and maps populated items', async () => {
+    let completeUrl = ''
+    server.use(
+      http.post(`${BASE}/store/carts/cart_01/complete`, ({ request }) => {
+        completeUrl = request.url
+        return HttpResponse.json({ type: 'order', order: MEDUSA_ORDER })
+      }),
+    )
+
+    const provider = makeProvider()
+    const result = await provider.completeCart('cart_01')
+
+    expect(new URL(completeUrl).searchParams.get('fields')).toBe('*items')
+    expect(result.type).toBe('order')
+    if (result.type === 'order') {
+      expect(result.order.id).toBe('order_01')
+      expect(result.order.items).toHaveLength(1)
+      expect(result.order.items[0]).toMatchObject({
+        id: 'ordli_01',
+        title: 'B Acceptance Product',
+        variantTitle: 'Large',
+        quantity: 1,
+      })
+      expect(result.order.items[0].price.amount).toBe('22.22')
+      expect(result.order.items[0].total.amount).toBe('22.22')
+      // Subtotal prefers the backend item_subtotal (lines only), not the
+      // native subtotal that folds in shipping.
+      expect(result.order.subtotal.amount).toBe('22.22')
+      expect(result.order.shipping?.amount).toBe('5.00')
+      expect(result.order.total.amount).toBe('27.22')
+    }
+  })
+
+  it('completeCart preserves a cart-with-error discriminator', async () => {
+    server.use(
+      http.post(`${BASE}/store/carts/cart_01/complete`, () =>
+        HttpResponse.json({
+          type: 'cart',
+          cart: MEDUSA_CART,
+          error: {
+            message: 'Payment not authorized',
+            name: 'PaymentError',
+            type: 'invalid_data',
+          },
+        }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const result = await provider.completeCart('cart_01')
+
+    expect(result.type).toBe('cart')
+    if (result.type === 'cart') {
+      expect(result.error.message).toBe('Payment not authorized')
+      expect(result.cart.id).toBe('cart_01')
+    }
+  })
+
+  it('completeCart returns unresolved and does not retry a failed mutation', async () => {
+    let calls = 0
+    server.use(
+      http.post(`${BASE}/store/carts/cart_01/complete`, () => {
+        calls += 1
+        return HttpResponse.json({ message: 'Gateway Timeout' }, { status: 504 })
+      }),
+    )
+
+    const provider = makeProvider()
+    const result = await provider.completeCart('cart_01')
+
+    expect(result.type).toBe('unresolved')
+    expect(calls).toBe(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Payment session compatibility (reuse vs replace)
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Payment session compatibility', () => {
+  const BASE_CART_WITH_PAYMENT = {
+    ...MEDUSA_CART,
+    items: [{ id: 'li_01', quantity: 1 }],
+    email: 'buyer@example.com',
+    shipping_address: { country_code: 'gb' },
+    shipping_methods: [{ id: 'sm_01' }],
+    total: 103,
+  }
+
+  it('reuses a compatible session without creating a new one', async () => {
+    let posts = 0
+    server.use(
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({
+          cart: {
+            ...BASE_CART_WITH_PAYMENT,
+            payment_collection: {
+              id: 'paycol_01',
+              payment_sessions: [
+                { id: 'ps_01', provider_id: 'pp_system_default', amount: 103, status: 'pending' },
+              ],
+            },
+          },
+        }),
+      ),
+      http.post(`${BASE}/store/payment-collections/paycol_01/payment-sessions`, () => {
+        posts += 1
+        return HttpResponse.json({ payment_collection: {} })
+      }),
+    )
+
+    const provider = makeProvider()
+    await provider.initiatePaymentSession('cart_01', 'pp_system_default')
+
+    expect(posts).toBe(0)
+  })
+
+  it('replaces a session whose provider/amount is incompatible', async () => {
+    let posts = 0
+    server.use(
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({
+          cart: {
+            ...BASE_CART_WITH_PAYMENT,
+            payment_collection: {
+              id: 'paycol_01',
+              payment_sessions: [
+                { id: 'ps_old', provider_id: 'pp_stripe_stripe', amount: 50, status: 'pending' },
+              ],
+            },
+          },
+        }),
+      ),
+      http.post(`${BASE}/store/payment-collections/paycol_01/payment-sessions`, () => {
+        posts += 1
+        return HttpResponse.json({ payment_collection: {} })
+      }),
+    )
+
+    const provider = makeProvider()
+    await provider.initiatePaymentSession('cart_01', 'pp_system_default')
+
+    expect(posts).toBe(1)
+  })
+
+  it('rejects payment before a shipping method is selected', async () => {
+    server.use(
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({
+          cart: { ...BASE_CART_WITH_PAYMENT, shipping_methods: [] },
+        }),
+      ),
+    )
+
+    const provider = makeProvider()
+    await expect(
+      provider.initiatePaymentSession('cart_01', 'pp_system_default'),
+    ).rejects.toThrow(/Shipping method is required/)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Shipping truthfulness — no fabricated amount or placeholder ETA
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Shipping truthfulness', () => {
+  it('does not fabricate a zero amount or an "N/A" ETA', async () => {
+    server.use(
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({ cart: { ...MEDUSA_CART, region_id: 'reg_01' } }),
+      ),
+      http.get(`${BASE}/store/shipping-options`, () =>
+        HttpResponse.json({
+          shipping_options: [
+            { id: 'so_01', name: 'Standard Shipping', data: {} },
+          ],
+        }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const methods = await provider.getShippingMethods('cart_01')
+
+    expect(methods[0].price.amount).toBe('')
+    expect(methods[0].estimatedDays).toBeUndefined()
+  })
+})