@thorprovider/adapters 5.0.9 → 5.0.11

package/src/providers/medusa/live-smoke.test.ts

@@ -22,6 +22,7 @@
  */
 
 import { describe, expect, it, beforeAll } from 'vitest'
+import Medusa from '@medusajs/js-sdk'
 import { MedusaProvider } from './index'
 import { MedusaAdminClient } from './admin'
 
@@ -357,6 +358,7 @@ if (!runLive) {
   // --------------------------------------------------------------------------
   // Group E: Admin Standard Medusa Endpoints (via SDK with Basic auth)
   // --------------------------------------------------------------------------
+  // (See the separate change-B acceptance block below.)
   describe('Group E: Admin Standard Medusa Endpoints', () => {
     let provider: MedusaProvider;
 
@@ -410,3 +412,69 @@ if (!runLive) {
     })
   });
 }
+
+// --------------------------------------------------------------------------
+// Change B acceptance — native pagination-bound probes + directed product
+// lookup. Runs independently of MEDUSA_SMOKE_TEST; gated by
+// MEDUSA_B_ACCEPTANCE=1. Requires a running backend and the acceptance fixture
+// env (never printed): MEDUSA_BASE_URL, MEDUSA_PUBLISHABLE_KEY,
+// MEDUSA_REGION_ID, MEDUSA_SALES_CHANNEL_ID, B_ACCEPTANCE_PRODUCT_ID,
+// B_ACCEPTANCE_PRODUCT_HANDLE.
+// --------------------------------------------------------------------------
+const runBAcceptance = process.env.MEDUSA_B_ACCEPTANCE === '1'
+
+describe('Medusa change-B acceptance — pagination bound + directed lookup', () => {
+  it.skipIf(!runBAcceptance)(
+    'accepts native listing bounds 1/50/100/200/1000 (configured bound, not a claimed max)',
+    async () => {
+      const baseUrl = requiredEnv('MEDUSA_BASE_URL')
+      const publishableKey = requiredEnv('MEDUSA_PUBLISHABLE_KEY')
+      const regionId = requiredEnv('MEDUSA_REGION_ID')
+      const salesChannelId = requiredEnv('MEDUSA_SALES_CHANNEL_ID')
+
+      const sdk = new Medusa({ baseUrl, publishableKey })
+      for (const limit of [1, 50, 100, 200, 1000]) {
+        const { products, count } = await sdk.store.product.list({
+          limit,
+          region_id: regionId,
+          sales_channel_id: [salesChannelId],
+          fields: '+variants.calculated_price',
+        } as any)
+        expect(Array.isArray(products)).toBe(true)
+        expect(products.length).toBeLessThanOrEqual(limit)
+        expect(typeof count === 'number' || count === undefined).toBe(true)
+      }
+    },
+  )
+
+  it.skipIf(!runBAcceptance)(
+    'resolves the acceptance product by handle and by id with real variant prices',
+    async () => {
+      const baseUrl = requiredEnv('MEDUSA_BASE_URL')
+      const publishableKey = requiredEnv('MEDUSA_PUBLISHABLE_KEY')
+      const regionId = requiredEnv('MEDUSA_REGION_ID')
+      const productId = requiredEnv('B_ACCEPTANCE_PRODUCT_ID')
+      const handle = requiredEnv('B_ACCEPTANCE_PRODUCT_HANDLE')
+
+      const provider = new MedusaProvider({
+        baseUrl,
+        publishableKey,
+        regionId,
+        currencyCode: 'usd',
+      })
+
+      const byHandle = await provider.getProduct(handle)
+      expect(byHandle?.handle).toBe(handle)
+      expect(byHandle?.variants.length).toBeGreaterThanOrEqual(2)
+
+      const byId = await provider.getProductById(productId)
+      expect(byId?.id).toBe(productId)
+
+      const amounts = (byHandle?.variants ?? [])
+        .map((v) => v.price.amount)
+        .filter((amount) => amount !== '')
+      expect(amounts).toContain('11.11')
+      expect(amounts).toContain('22.22')
+    },
+  )
+})

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

@@ -0,0 +1,177 @@
+import { describe, expect, it } from 'vitest'
+import {
+  transformProduct,
+  transformProductPrice,
+  transformProductVariant,
+} from './transforms'
+
+const BASE_VARIANT = {
+  id: 'variant_s',
+  title: 'Small',
+  sku: 'B-ACC-S',
+  manage_inventory: false,
+  inventory_quantity: 5,
+  calculated_price: { calculated_amount: 11.11, currency_code: 'usd' },
+  options: [{ option: { title: 'Size' }, value: 'Small' }],
+  thumbnail: 'https://example.com/small.png',
+}
+
+describe('transformProductPrice (change B, decision 6)', () => {
+  it('preserves a valid zero in major units', () => {
+    expect(transformProductPrice(0, 'usd')).toEqual({
+      amount: '0.00',
+      currencyCode: 'USD',
+    })
+  })
+
+  it('carries an absent price as an empty amount, never a fabricated zero', () => {
+    expect(transformProductPrice(undefined, 'usd')).toEqual({
+      amount: '',
+      currencyCode: 'USD',
+    })
+    expect(transformProductPrice(null, 'usd').amount).toBe('')
+  })
+
+  it('rejects a non-finite amount before display', () => {
+    expect(transformProductPrice(Number.NaN, 'usd').amount).toBe('')
+    expect(transformProductPrice(Number.POSITIVE_INFINITY, 'usd').amount).toBe('')
+  })
+
+  it('never hardcodes USD: an unresolved currency stays empty', () => {
+    expect(transformProductPrice(11.11, undefined)).toEqual({
+      amount: '11.11',
+      currencyCode: '',
+    })
+  })
+})
+
+describe('transformProductVariant', () => {
+  it('maps real options, availability, SKU and the backend currency', () => {
+    const variant = transformProductVariant(BASE_VARIANT)
+    expect(variant.id).toBe('variant_s')
+    expect(variant.selectedOptions).toEqual([{ name: 'Size', value: 'Small' }])
+    expect(variant.availableForSale).toBe(true)
+    expect(variant.sku).toBe('B-ACC-S')
+    expect(variant.price).toEqual({ amount: '11.11', currencyCode: 'USD' })
+  })
+
+  it('keeps stock availability when the price is unresolved (price is separate)', () => {
+    const variant = transformProductVariant({
+      ...BASE_VARIANT,
+      calculated_price: undefined,
+      prices: [],
+    })
+    expect(variant.availableForSale).toBe(true)
+    expect(variant.price.amount).toBe('')
+  })
+
+  it('preserves a valid zero price', () => {
+    const variant = transformProductVariant({
+      ...BASE_VARIANT,
+      calculated_price: { calculated_amount: 0, currency_code: 'eur' },
+    })
+    expect(variant.price).toEqual({ amount: '0.00', currencyCode: 'EUR' })
+  })
+
+  it('omits SKU when the merchant does not supply one (optional descriptive)', () => {
+    const variant = transformProductVariant({ ...BASE_VARIANT, sku: undefined })
+    expect(variant.sku).toBeUndefined()
+    expect(variant.id).toBe('variant_s')
+  })
+})
+
+describe('transformProduct', () => {
+  it('builds the price range from resolvable variant prices', () => {
+    const product = transformProduct({
+      id: 'prod_1',
+      handle: 'b-acceptance-product',
+      title: 'B Acceptance Product',
+      description: '',
+      thumbnail: 'https://example.com/p.png',
+      images: [],
+      options: [],
+      variants: [
+        BASE_VARIANT,
+        {
+          ...BASE_VARIANT,
+          id: 'variant_l',
+          title: 'Large',
+          calculated_price: { calculated_amount: 22.22, currency_code: 'usd' },
+        },
+      ],
+    })
+    expect(product.priceRange.minVariantPrice).toEqual({
+      amount: '11.11',
+      currencyCode: 'USD',
+    })
+    expect(product.priceRange.maxVariantPrice).toEqual({
+      amount: '22.22',
+      currencyCode: 'USD',
+    })
+  })
+
+  it('maps a present thumbnail and images to featuredImage and images', () => {
+    const product = transformProduct({
+      id: 'prod_media',
+      handle: 'with-media',
+      title: 'With Media',
+      description: '',
+      thumbnail: 'https://example.com/cover.png',
+      images: [
+        { url: 'https://example.com/a.png' },
+        { url: 'https://example.com/b.png' },
+      ],
+      options: [],
+      variants: [],
+    })
+
+    expect(product.featuredImage).toEqual({
+      url: 'https://example.com/cover.png',
+      altText: 'With Media',
+      width: 800,
+      height: 800,
+    })
+    expect(product.images?.map((img) => img.url)).toEqual([
+      'https://example.com/a.png',
+      'https://example.com/b.png',
+    ])
+  })
+
+  it('omits featuredImage and images when the backend supplies neither (never an empty src)', () => {
+    const product = transformProduct({
+      id: 'prod_no_media',
+      handle: 'no-media',
+      title: 'No Media',
+      description: '',
+      thumbnail: undefined,
+      images: undefined,
+      options: [],
+      variants: [],
+    })
+
+    expect(product.featuredImage).toBeUndefined()
+    expect(product.images).toEqual([])
+    expect(product.images?.some((img) => img.url === '')).toBe(false)
+    expect(product.featuredImage?.url).toBeUndefined()
+  })
+
+  it('does not fabricate a zero range when no variant is priced', () => {
+    const product = transformProduct({
+      id: 'prod_1',
+      handle: 'sin-precio',
+      title: 'Sin precio',
+      description: '',
+      images: [],
+      options: [],
+      variants: [
+        {
+          ...BASE_VARIANT,
+          calculated_price: undefined,
+          prices: [],
+        },
+      ],
+    })
+    expect(product.priceRange.minVariantPrice.amount).toBe('')
+    expect(product.priceRange.maxVariantPrice.amount).toBe('')
+  })
+})

package/src/providers/medusa/transforms.ts

@@ -49,6 +49,44 @@ function transformMoney(amount: number | null | undefined, currencyCode: string
   };
 }
 
+/**
+ * Backend-authoritative money (change B, decision 9).
+ *
+ * A finite backend amount is carried through unchanged, including a legitimate
+ * zero; a missing or non-finite amount becomes an empty `amount` string instead
+ * of an invented zero, so the runtime boundary can surface the backend gap
+ * rather than fabricate a total. The currency comes from the backend and is
+ * never defaulted to a hardcoded `USD`.
+ */
+function transformAmount(
+  amount: number | null | undefined,
+  currencyCode?: string | null,
+): Money {
+  const currencyCodeUpper = (currencyCode ?? '').toUpperCase();
+  if (typeof amount !== 'number' || !Number.isFinite(amount)) {
+    return { amount: '', currencyCode: currencyCodeUpper };
+  }
+  return { amount: amount.toFixed(2), currencyCode: currencyCodeUpper };
+}
+
+/**
+ * Product price projection (change B, decision 6).
+ *
+ * Unlike cart/order money, a product variant price is NOT fabricated: an
+ * absent or non-finite backend amount is carried as an empty `amount` string
+ * so the runtime boundary (`parseMoney`) can reject it and mark the variant
+ * unavailable instead of showing a fake zero. A backend-resolved valid zero is
+ * preserved as `"0.00"`. The currency comes from the backend or the configured
+ * context — never a hardcoded `USD` (an unresolved currency stays empty and is
+ * likewise rejected downstream).
+ */
+export function transformProductPrice(
+  amount: number | null | undefined,
+  currencyCode?: string | null,
+): Money {
+  return transformAmount(amount, currencyCode);
+}
+
 /**
  * Transform Medusa image to unified Image
  */
@@ -126,43 +164,51 @@ export function transformProductOption(option: any): ProductOption {
  */
 export function transformProductVariant(
   variant: any,
-  currencyCode: string = 'USD'
+  currencyCode?: string
 ): ProductVariant {
   let priceAmount: number | null | undefined;
-  let priceCurrency: string = currencyCode;
-  
+  let priceCurrency: string | undefined = currencyCode;
+
   // Priority 1: Use calculated_price if available (from region-based pricing)
   if (variant.calculated_price) {
     priceAmount = variant.calculated_price.calculated_amount;
-    priceCurrency = variant.calculated_price.currency_code || currencyCode;
-  } 
-  // Priority 2: Fallback to prices array
+    priceCurrency = variant.calculated_price.currency_code ?? currencyCode;
+  }
+  // Priority 2: Fallback to prices array (match the context currency, else the first)
   else if (variant.prices && variant.prices.length > 0) {
-    const price = variant.prices.find((p: any) => p.currency_code === currencyCode.toLowerCase());
+    const target = currencyCode?.toLowerCase();
+    const price =
+      (target
+        ? variant.prices.find((p: any) => p.currency_code === target)
+        : undefined) ?? variant.prices[0];
     priceAmount = price?.amount;
-    priceCurrency = price?.currency_code || currencyCode;
+    priceCurrency = price?.currency_code ?? currencyCode;
   }
-  
+
   // Determine if variant is available for sale
   // Following Medusa docs: https://docs.medusajs.com/resources/storefront-development/products/inventory
   // A variant is in stock if:
   // 1. manage_inventory is false (inventory not tracked) - always in stock
   // 2. inventory_quantity > 0 (has stock)
   // 3. allow_backorder is true (can order even without stock)
+  // NOTE: this is stock availability only. Price availability is a separate
+  // concern resolved by the runtime boundary; an unpriced variant keeps its
+  // stock-derived availability and carries an empty amount.
   const isAvailable = variant.manage_inventory === false
     ? true
     : (variant.inventory_quantity ?? 0) > 0 || variant.allow_backorder === true;
-  
+
   return {
     id: variant.id!,
     title: variant.title ?? 'Default',
+    // SKU is optional descriptive data only — never API/purchase identity.
     sku: variant.sku ?? undefined,
     availableForSale: isAvailable,
     selectedOptions: variant.options?.map((opt: any) => ({
       name: (opt as any).option?.title ?? '',
       value: opt.value ?? '',
     })) ?? [],
-    price: transformMoney(priceAmount, priceCurrency),
+    price: transformProductPrice(priceAmount, priceCurrency),
     compareAtPrice: undefined,  // Medusa doesn't have compare-at pricing
     quantityAvailable: variant.manage_inventory ? variant.inventory_quantity : undefined,
     image: variant.thumbnail
@@ -176,14 +222,22 @@ export function transformProductVariant(
  */
 export function transformProduct(
   product: any,
-  currencyCode: string = 'USD'
+  currencyCode?: string
 ): Product {
   const variants = product.variants?.map((v: any) => transformProductVariant(v, currencyCode)) ?? [];
-  
-  // Calculate price range
-  const prices = variants.map((v: any) => parseFloat(v.price.amount));
-  const minPrice = Math.min(...prices);
-  const maxPrice = Math.max(...prices);
+
+  // Price range from resolvable variant prices only. An unresolved price is
+  // carried as an empty amount (never fabricated as zero); if no variant is
+  // priced, the range is unresolved too and the runtime marks it unavailable.
+  const validPrices = variants
+    .map((v: ProductVariant) => v.price)
+    .filter((money: Money) => money.amount !== '' && Number.isFinite(Number(money.amount)))
+    .map((money: Money) => Number(money.amount));
+  const rangeCurrency =
+    variants.find((v: ProductVariant) => v.price.currencyCode)?.price.currencyCode ??
+    (currencyCode ?? '').toUpperCase();
+  const minPrice = validPrices.length > 0 ? Math.min(...validPrices) : undefined;
+  const maxPrice = validPrices.length > 0 ? Math.max(...validPrices) : undefined;
   
   return {
     id: product.id!,
@@ -206,10 +260,16 @@ export function transformProduct(
     
     priceRange: {
       // Build Money directly from already-resolved major-unit prices.
-      // Do NOT pass through transformMoney (which would call toFixed on already-correct values)
-      // and do NOT multiply by 100 (that was a compensatory hack for the old /100 bug).
-      minVariantPrice: { amount: (Number.isFinite(minPrice) ? minPrice : 0).toFixed(2), currencyCode: currencyCode.toUpperCase() },
-      maxVariantPrice: { amount: (Number.isFinite(maxPrice) ? maxPrice : 0).toFixed(2), currencyCode: currencyCode.toUpperCase() },
+      // Do NOT multiply by 100 (that was a compensatory hack for the old /100
+      // bug) and do NOT fabricate a zero for an unresolved price.
+      minVariantPrice: {
+        amount: minPrice !== undefined ? minPrice.toFixed(2) : '',
+        currencyCode: rangeCurrency,
+      },
+      maxVariantPrice: {
+        amount: maxPrice !== undefined ? maxPrice.toFixed(2) : '',
+        currencyCode: rangeCurrency,
+      },
     },
     
     collections: product.collection ? [{
@@ -250,47 +310,30 @@ function resolveMedusaCartItemCurrencyCode(item: any, cartCurrencyCode?: string)
 }
 
 /**
- * Resolve the total amount for a Medusa cart item.
- * All amounts from Medusa v2 are in major units (dollars, euros).
+ * Resolve the authoritative line total a Medusa cart line reports.
+ *
+ * Only backend-supplied totals are used (`total` after discounts, then
+ * `item_total`, then `subtotal`); the adapter never multiplies a unit price by
+ * a quantity to invent a line total. A legitimate `0` is preserved and an
+ * absent total is returned as `undefined` so the money transform carries an
+ * empty amount instead of fabricating a value.
  */
-function resolveMedusaCartItemTotal(item: any): number {
-  const quantity = item?.quantity ?? 1;
-  const safeQuantity = typeof quantity === 'number' && quantity > 0 ? quantity : 1;
-
-  const totalCandidates = [
-    item?.total,
-    item?.item_total,
-    item?.original_total,
-    item?.subtotal,
-    item?.item_subtotal,
-    item?.original_subtotal,
-  ];
-
-  for (const candidate of totalCandidates) {
-    if (typeof candidate === 'number' && Number.isFinite(candidate) && candidate > 0) {
-      return candidate;
-    }
-  }
-
-  const unitCandidates = [
-    item?.unit_price,
-    item?.original_unit_price,
-  ];
+function resolveAuthoritativeLineTotal(item: any): number | undefined {
+  const candidates = [item?.total, item?.item_total, item?.subtotal];
 
-  for (const candidate of unitCandidates) {
-    if (typeof candidate === 'number' && Number.isFinite(candidate) && candidate > 0) {
-      return candidate * safeQuantity;
+  for (const candidate of candidates) {
+    if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+      return candidate;
     }
   }
 
-  return 0;
+  return undefined;
 }
 
 export function transformCartItem(item: any, cartCurrencyCode?: string): CartItem {
   const variant = item.variant;
   const product = variant?.product;
   const currencyCode = resolveMedusaCartItemCurrencyCode(item, cartCurrencyCode);
-  const totalCents = resolveMedusaCartItemTotal(item);
 
   // Medusa v2 store cart items return flat fields (product_title, variant_title,
   // product_handle, thumbnail) instead of a nested variant.product object.
@@ -305,7 +348,9 @@ export function transformCartItem(item: any, cartCurrencyCode?: string): CartIte
     id: item.id,
     quantity: item.quantity ?? 1,
     cost: {
-      totalAmount: transformMoney(totalCents, currencyCode),
+      totalAmount: transformAmount(resolveAuthoritativeLineTotal(item), currencyCode),
+      // Backend unit price, carried so the display never derives it locally.
+      unitPrice: transformAmount(item?.unit_price, currencyCode),
     },
     merchandise: {
       id: merchandiseId,
@@ -326,26 +371,53 @@ export function transformCartItem(item: any, cartCurrencyCode?: string): CartIte
 }
 
 /**
- * Transform Medusa Cart to unified Cart
+ * Transform Medusa Cart to unified Cart.
+ *
+ * Totals are backend-authoritative (change B, decision 9): subtotal, discount,
+ * tax, shipping and total are carried straight from the cart response, a
+ * legitimate zero is preserved, and no amount is derived locally.
+ *
+ * `subtotalAmount` prefers the backend's `item_subtotal` (the sum of the line
+ * items, excluding shipping and tax). Medusa's native `subtotal` also folds in
+ * `shipping_subtotal`; presenting that as the commercial subtotal would
+ * double-count shipping. When `item_subtotal` is absent the native `subtotal`
+ * is used unchanged, preserving backward compatibility.
+ *
+ * The cart's sales channel, region and currency are carried so the runtime can
+ * enforce the validated single-store context, and `completed_at` is carried so
+ * a completed cart can be reconciled.
  */
 export function transformCart(cart: any): Cart {
-  const currencyCode = cart.currency_code ?? 'usd';
-  
+  const currencyCode = cart.currency_code;
+
   return {
     id: cart.id,
     checkoutUrl: `/checkout/${cart.id}`, // Medusa doesn't have a direct checkout URL
     cost: {
-      subtotalAmount: transformMoney(cart.subtotal, currencyCode),
-      totalAmount: transformMoney(cart.total, currencyCode),
-      totalTaxAmount: transformMoney(cart.tax_total, currencyCode),
+      subtotalAmount: transformAmount(
+        typeof cart.item_subtotal === 'number' ? cart.item_subtotal : cart.subtotal,
+        currencyCode,
+      ),
+      discountAmount: transformAmount(cart.discount_total, currencyCode),
+      totalTaxAmount: transformAmount(cart.tax_total, currencyCode),
+      shippingAmount: transformAmount(cart.shipping_total, currencyCode),
+      totalAmount: transformAmount(cart.total, currencyCode),
     },
     lines: cart.items?.map((item: any) => transformCartItem(item, currencyCode)) ?? [],
     totalQuantity: cart.items?.reduce((sum: any, item: any) => sum + (item.quantity ?? 0), 0) ?? 0,
+    salesChannelId: cart.sales_channel_id ?? undefined,
+    regionId: cart.region_id ?? undefined,
+    currencyCode:
+      typeof currencyCode === 'string' ? currencyCode.toUpperCase() : undefined,
+    selectedShippingMethodId: cart.shipping_methods?.[0]?.id ?? undefined,
+    selectedShippingOptionId:
+      cart.shipping_methods?.[0]?.shipping_option_id ?? undefined,
     completedAt: cart.completed_at
       ? (typeof cart.completed_at === 'string'
         ? cart.completed_at
         : cart.completed_at?.toISOString())
       : undefined,
+    metadata: cart.metadata ?? undefined,
   };
 }
 
@@ -477,8 +549,8 @@ export function transformOrderItem(item: any, currencyCode: string): OrderItem {
     title: item.product_title ?? item.title ?? '',
     variantTitle: item.variant_title ?? variant?.title ?? undefined,
     quantity: item.quantity ?? 1,
-    price: transformMoney(item.unit_price, currencyCode),
-    total: transformMoney(item.total, currencyCode),
+    price: transformAmount(item.unit_price, currencyCode),
+    total: transformAmount(item.total, currencyCode),
     sku: variant?.sku ?? undefined,
     image: product?.thumbnail || item.thumbnail
       ? transformImage(product?.thumbnail || item.thumbnail, item.product_title ?? '')
@@ -556,12 +628,19 @@ export function transformOrder(order: any): Order {
       .filter((item: any) => item != null) // Filter out null/undefined items
       .map((item: any) => transformOrderItem(item, currencyCode)) ?? [],
     
-    // Pricing
-    subtotal: transformMoney(order.subtotal, currencyCode),
-    total: transformMoney(order.total, currencyCode),
-    tax: transformMoney(order.tax_total, currencyCode),
-    shipping: transformMoney(order.shipping_total, currencyCode),
-    discount: transformMoney(order.discount_total, currencyCode),
+    // Pricing — backend-authoritative; a legitimate zero is preserved and no
+    // amount is derived locally. `subtotal` prefers the backend's
+    // `item_subtotal` (lines only, excluding shipping/tax); Medusa's native
+    // `subtotal` folds in `shipping_subtotal`, so falling back to it is only
+    // for installs that do not supply `item_subtotal`.
+    subtotal: transformAmount(
+      typeof order.item_subtotal === 'number' ? order.item_subtotal : order.subtotal,
+      currencyCode,
+    ),
+    total: transformAmount(order.total, currencyCode),
+    tax: transformAmount(order.tax_total, currencyCode),
+    shipping: transformAmount(order.shipping_total, currencyCode),
+    discount: transformAmount(order.discount_total, currencyCode),
     
     // Addresses (transformed to camelCase)
     shippingAddress: order.shipping_address