@sails-pay/bachs 0.0.1 → 0.0.3

package/adapter.js

@@ -4,6 +4,9 @@ module.exports = {
   identity: 'sails-bachs',
   config: {},
   checkout: methods.checkout,
+  customer: {
+    portal: methods.customer.portal
+  },
   verify: methods.verify,
   webhooks: {
     verify: methods.webhooks.verify

package/helpers/payloads.js

@@ -44,13 +44,22 @@ function buildProductCart(items) {
     return undefined
   }
 
-  return items.map((item) =>
-    withoutUndefined({
+  return items.map((item) => {
+    const pricing =
+      item.amount !== undefined
+        ? normalizePricing({
+            type: 'fixed',
+            amount: item.amount
+          })
+        : normalizePricing(item.pricing)
+
+    return withoutUndefined({
       product_id: item.product || item.productId,
       quantity: item.quantity,
-      amount: item.amount
+      pricing,
+      amount: item.chosenAmount
     })
-  )
+  })
 }
 
 function buildCheckoutSessionPayload(inputs, adapterConfig = {}) {
@@ -76,25 +85,44 @@ function buildCheckoutSessionPayload(inputs, adapterConfig = {}) {
   })
 }
 
-function buildPricingPayload(inputs) {
-  let pricing
+function normalizePricing(pricing, fallbackCurrencyOptions) {
+  if (!pricing || typeof pricing !== 'object' || Array.isArray(pricing)) {
+    return undefined
+  }
 
-  if (inputs.pricing) {
-    const { currencyOptions, ...pricingInput } = inputs.pricing
+  const {
+    type,
+    presetAmount,
+    minimumAmount,
+    maximumAmount,
+    currencyOptions,
+    ...pricingInput
+  } = pricing
+  const normalizedPricing = withoutUndefined({
+    ...pricingInput,
+    price_type: type,
+    preset_amount: presetAmount,
+    minimum_amount: minimumAmount,
+    maximum_amount: maximumAmount,
+    currency_options:
+      currencyOptions === undefined ? fallbackCurrencyOptions : currencyOptions
+  })
 
-    pricing = withoutUndefined({
-      ...pricingInput,
-      currency_options: currencyOptions || inputs.currencyOptions
-    })
-  } else {
-    pricing = withoutUndefined({
-      currency: inputs.currency,
-      amount: inputs.amount,
-      currency_options: inputs.currencyOptions
-    })
+  return Object.keys(normalizedPricing).length > 0
+    ? normalizedPricing
+    : undefined
+}
+
+function buildPricingPayload(inputs) {
+  if (inputs.pricing) {
+    return normalizePricing(inputs.pricing, inputs.currencyOptions)
   }
 
-  return Object.keys(pricing).length > 0 ? pricing : undefined
+  return normalizePricing({
+    currency: inputs.currency,
+    amount: inputs.amount,
+    currencyOptions: inputs.currencyOptions
+  })
 }
 
 function buildPureCheckoutPayload(inputs, adapterConfig = {}) {
@@ -142,5 +170,6 @@ module.exports = {
   buildRefundPayload,
   buildProductCart,
   buildCustomerPayload,
+  normalizePricing,
   withoutUndefined
 }

package/helpers/validate-checkout-items.js

@@ -0,0 +1,177 @@
+const pricingTypes = new Set(['fixed', 'custom', 'free'])
+const pricingMoneyFields = [
+  'amount',
+  'presetAmount',
+  'minimumAmount',
+  'maximumAmount'
+]
+const customPricingFields = ['presetAmount', 'minimumAmount', 'maximumAmount']
+const decimalStringPattern = /^\d+(?:\.\d+)?$/
+
+function fieldWasProvided(object, field) {
+  return object[field] !== undefined
+}
+
+function invalid(field, message) {
+  return {
+    field,
+    message: `${field} ${message}`
+  }
+}
+
+function validateMoney(value, field) {
+  if (typeof value !== 'string' || !decimalStringPattern.test(value)) {
+    return invalid(field, 'must be a non-negative decimal string.')
+  }
+}
+
+function validatePricingMoney(pricing, itemPath) {
+  for (const field of pricingMoneyFields) {
+    if (fieldWasProvided(pricing, field)) {
+      const error = validateMoney(
+        pricing[field],
+        `${itemPath}.pricing.${field}`
+      )
+
+      if (error) {
+        return error
+      }
+    }
+  }
+}
+
+function validateItem(item, index) {
+  const itemPath = `items[${index}]`
+
+  if (!item || typeof item !== 'object' || Array.isArray(item)) {
+    return invalid(itemPath, 'must be an object.')
+  }
+
+  if (
+    fieldWasProvided(item, 'quantity') &&
+    (!Number.isInteger(item.quantity) || item.quantity < 1)
+  ) {
+    return invalid(`${itemPath}.quantity`, 'must be an integer of at least 1.')
+  }
+
+  const hasAmount = fieldWasProvided(item, 'amount')
+  const hasPricing = fieldWasProvided(item, 'pricing')
+  const hasChosenAmount = fieldWasProvided(item, 'chosenAmount')
+
+  if (hasAmount && hasPricing) {
+    return invalid(
+      itemPath,
+      'must not provide both amount and pricing; amount is the fixed-price shorthand.'
+    )
+  }
+
+  if (hasAmount) {
+    const error = validateMoney(item.amount, `${itemPath}.amount`)
+
+    if (error) {
+      return error
+    }
+
+    if (hasChosenAmount) {
+      return invalid(
+        `${itemPath}.chosenAmount`,
+        'can only be used with catalog custom pricing or ad-hoc custom pricing.'
+      )
+    }
+  }
+
+  if (hasChosenAmount) {
+    const error = validateMoney(item.chosenAmount, `${itemPath}.chosenAmount`)
+
+    if (error) {
+      return error
+    }
+  }
+
+  if (!hasPricing) {
+    return
+  }
+
+  if (
+    !item.pricing ||
+    typeof item.pricing !== 'object' ||
+    Array.isArray(item.pricing)
+  ) {
+    return invalid(`${itemPath}.pricing`, 'must be an object.')
+  }
+
+  const pricing = item.pricing
+
+  if (!pricingTypes.has(pricing.type)) {
+    return invalid(
+      `${itemPath}.pricing.type`,
+      'must be fixed, custom, or free.'
+    )
+  }
+
+  if (pricing.type === 'fixed') {
+    if (!fieldWasProvided(pricing, 'amount')) {
+      return invalid(
+        `${itemPath}.pricing.amount`,
+        'is required for fixed pricing.'
+      )
+    }
+
+    const customField = customPricingFields.find((field) =>
+      fieldWasProvided(pricing, field)
+    )
+
+    if (customField) {
+      return invalid(
+        `${itemPath}.pricing.${customField}`,
+        'is not allowed with fixed pricing.'
+      )
+    }
+
+    if (hasChosenAmount) {
+      return invalid(
+        `${itemPath}.chosenAmount`,
+        'can only be used with catalog custom pricing or ad-hoc custom pricing.'
+      )
+    }
+  }
+
+  if (pricing.type === 'custom' && fieldWasProvided(pricing, 'amount')) {
+    return invalid(
+      `${itemPath}.pricing.amount`,
+      'is not allowed with custom pricing.'
+    )
+  }
+
+  if (pricing.type === 'free') {
+    const monetaryField = pricingMoneyFields.find((field) =>
+      fieldWasProvided(pricing, field)
+    )
+
+    if (monetaryField) {
+      return invalid(
+        `${itemPath}.pricing.${monetaryField}`,
+        'is not allowed with free pricing.'
+      )
+    }
+
+    if (hasChosenAmount) {
+      return invalid(
+        `${itemPath}.chosenAmount`,
+        'is not allowed with free pricing.'
+      )
+    }
+  }
+
+  return validatePricingMoney(pricing, itemPath)
+}
+
+module.exports = function validateCheckoutItems(items) {
+  for (let index = 0; index < items.length; index++) {
+    const error = validateItem(items[index], index)
+
+    if (error) {
+      return error
+    }
+  }
+}

package/machines/checkout.js

@@ -3,6 +3,7 @@ const {
   buildCheckoutSessionPayload,
   buildPureCheckoutPayload
 } = require('../helpers/payloads')
+const validateCheckoutItems = require('../helpers/validate-checkout-items')
 const parameters = require('../helpers/parameters')
 
 module.exports = require('machine').build({
@@ -16,7 +17,7 @@ module.exports = require('machine').build({
     items: {
       type: 'ref',
       description:
-        'Product items for Bachs Checkout Sessions. Each item should use product or productId plus optional quantity and amount.'
+        'Product items for Bachs Checkout Sessions. Supports catalog pricing, fixed amount shorthand, advanced pricing, and chosenAmount.'
     },
     productCollectionId: {
       type: 'string',
@@ -141,10 +142,6 @@ module.exports = require('machine').build({
       inputs.productCollectionId || inputs.productCollection
     )
     const shouldUseCheckoutSession = hasItems || hasProductCollection
-    const path = shouldUseCheckoutSession ? '/checkout-sessions' : '/checkouts'
-    const payload = shouldUseCheckoutSession
-      ? buildCheckoutSessionPayload(inputs, adapterConfig)
-      : buildPureCheckoutPayload(inputs, adapterConfig)
 
     if (shouldUseCheckoutSession && hasItems === hasProductCollection) {
       return exits.invalidRequest({
@@ -153,6 +150,19 @@ module.exports = require('machine').build({
       })
     }
 
+    if (hasItems) {
+      const validationError = validateCheckoutItems(inputs.items)
+
+      if (validationError) {
+        return exits.invalidRequest(validationError)
+      }
+    }
+
+    const path = shouldUseCheckoutSession ? '/checkout-sessions' : '/checkouts'
+    const payload = shouldUseCheckoutSession
+      ? buildCheckoutSessionPayload(inputs, adapterConfig)
+      : buildPureCheckoutPayload(inputs, adapterConfig)
+
     if (!shouldUseCheckoutSession && !payload.pricing) {
       return exits.invalidRequest({
         message:

package/machines/customer/portal.js

@@ -0,0 +1,57 @@
+const fetch = require('../../helpers/fetch')
+const parameters = require('../../helpers/parameters')
+
+module.exports = require('machine').build({
+  friendlyName: 'Create customer portal session',
+  description:
+    'Creates a fresh Bachs customer portal session and returns its hosted URL.',
+  moreInfoUrl:
+    'https://docs.bachs.io/guides/customer-portal/create-portal-session',
+  inputs: {
+    apiKey: parameters.BACHS_API_KEY,
+    baseUrl: parameters.BACHS_BASE_URL,
+    customerId: {
+      type: 'string',
+      required: true,
+      description: 'The Bachs customer ID.'
+    }
+  },
+  exits: {
+    success: {
+      description: 'The fresh customer portal URL.',
+      outputVariableName: 'portalUrl',
+      outputType: 'string'
+    },
+    couldNotCreatePortalUrl: {
+      description: 'Customer portal URL could not be created.',
+      outputVariableName: 'errors',
+      outputType: 'ref'
+    }
+  },
+  fn: async function ({ apiKey, baseUrl, customerId }, exits) {
+    const adapterConfig = require('../../adapter').config
+
+    try {
+      const portalSession = await fetch(
+        `/customers/${encodeURIComponent(customerId)}/portal-sessions`,
+        {
+          method: 'POST',
+          apiKey: apiKey || adapterConfig.apiKey,
+          baseUrl: baseUrl || adapterConfig.baseUrl
+        }
+      )
+
+      if (
+        !portalSession ||
+        typeof portalSession.url !== 'string' ||
+        portalSession.url.length === 0
+      ) {
+        return exits.couldNotCreatePortalUrl(portalSession)
+      }
+
+      return exits.success(portalSession.url)
+    } catch (error) {
+      return exits.couldNotCreatePortalUrl(error.bachs || error)
+    }
+  }
+})

package/machines/index.js

@@ -4,6 +4,9 @@ checkout.get = require('./checkout/get')
 
 module.exports = {
   checkout,
+  customer: {
+    portal: require('./customer/portal')
+  },
   verify: require('./verify'),
   webhooks: {
     verify: require('./webhooks/verify')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sails-pay/bachs",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Bachs adapter for Sails Pay",
   "main": "adapter.js",
   "scripts": {

package/test/checkout.test.js

@@ -4,6 +4,11 @@ const adapter = require('../adapter')
 const checkout = require('../machines/checkout')
 const fetch = require('../helpers/fetch')
 
+test.afterEach(() => {
+  fetch.resetFetchImplementation()
+  adapter.config = {}
+})
+
 test('checkout creates a Bachs checkout session from camelCase inputs', async () => {
   const calls = []
 
@@ -24,7 +29,7 @@ test('checkout creates a Bachs checkout session from camelCase inputs', async ()
 
   const checkoutUrl = await checkout({
     apiKey: 'sk_sandbox_123',
-    items: [{ product: 'prod_abc123', quantity: 1 }],
+    items: [{ product: 'prod_abc123' }],
     customer: {
       email: 'customer@example.com',
       name: 'Jane Doe'
@@ -47,18 +52,280 @@ test('checkout creates a Bachs checkout session from camelCase inputs', async ()
     },
     product_cart: [
       {
-        product_id: 'prod_abc123',
-        quantity: 1
+        product_id: 'prod_abc123'
       }
     ],
     return_url: 'https://example.com/return',
     cancel_url: 'https://example.com/cancel',
     reference: 'order_123'
   })
+})
 
-  fetch.resetFetchImplementation()
+test('checkout sends custom pricing and the buyer-selected amount', async () => {
+  const calls = []
+
+  fetch.setFetchImplementation(async (url, options) => {
+    calls.push({ url, options })
+
+    return {
+      ok: true,
+      status: 201,
+      statusText: 'Created',
+      text: async () =>
+        JSON.stringify({
+          checkout_url: 'https://pay.bachs.io/c/custom'
+        })
+    }
+  })
+
+  const checkoutUrl = await checkout({
+    apiKey: 'sk_sandbox_123',
+    items: [
+      {
+        product: 'prod_custom',
+        pricing: {
+          type: 'custom',
+          presetAmount: '10.00',
+          minimumAmount: '5.00',
+          maximumAmount: '100.00'
+        },
+        chosenAmount: '12.00'
+      }
+    ]
+  })
+
+  assert.equal(checkoutUrl, 'https://pay.bachs.io/c/custom')
+  assert.deepEqual(JSON.parse(calls[0].options.body), {
+    customer: {},
+    product_cart: [
+      {
+        product_id: 'prod_custom',
+        pricing: {
+          price_type: 'custom',
+          preset_amount: '10.00',
+          minimum_amount: '5.00',
+          maximum_amount: '100.00'
+        },
+        amount: '12.00'
+      }
+    ]
+  })
+})
+
+test('checkout preserves pure checkout behavior', async () => {
+  const calls = []
+
+  fetch.setFetchImplementation(async (url, options) => {
+    calls.push({ url, options })
+
+    return {
+      ok: true,
+      status: 201,
+      statusText: 'Created',
+      text: async () =>
+        JSON.stringify({
+          checkout_url: 'https://pay.bachs.io/c/pure'
+        })
+    }
+  })
+
+  const checkoutUrl = await checkout({
+    apiKey: 'sk_sandbox_123',
+    amount: '42.00',
+    currency: 'USD',
+    reference: 'pure_123'
+  })
+
+  assert.equal(checkoutUrl, 'https://pay.bachs.io/c/pure')
+  assert.equal(calls[0].url, 'https://sandbox-api.bachs.io/v1/checkouts')
+  assert.equal(calls[0].options.headers['Idempotency-Key'], 'pure_123')
+  assert.deepEqual(JSON.parse(calls[0].options.body), {
+    pricing: {
+      currency: 'USD',
+      amount: '42.00'
+    },
+    reference: 'pure_123'
+  })
 })
 
+const invalidItemCases = [
+  {
+    name: 'amount with explicit pricing',
+    item: {
+      product: 'prod_123',
+      amount: '19.00',
+      pricing: { type: 'fixed', amount: '19.00' }
+    },
+    field: 'items[0]',
+    message: /both amount and pricing/
+  },
+  {
+    name: 'an unsupported pricing type',
+    item: {
+      product: 'prod_123',
+      pricing: { type: 'metered' }
+    },
+    field: 'items[0].pricing.type',
+    message: /fixed, custom, or free/
+  },
+  {
+    name: 'fixed pricing without an amount',
+    item: {
+      product: 'prod_123',
+      pricing: { type: 'fixed' }
+    },
+    field: 'items[0].pricing.amount',
+    message: /required for fixed pricing/
+  },
+  ...['presetAmount', 'minimumAmount', 'maximumAmount'].map((field) => ({
+    name: `fixed pricing with ${field}`,
+    item: {
+      product: 'prod_123',
+      pricing: {
+        type: 'fixed',
+        amount: '19.00',
+        [field]: '10.00'
+      }
+    },
+    field: `items[0].pricing.${field}`,
+    message: /not allowed with fixed pricing/
+  })),
+  {
+    name: 'custom pricing with a fixed amount',
+    item: {
+      product: 'prod_123',
+      pricing: {
+        type: 'custom',
+        amount: '19.00'
+      }
+    },
+    field: 'items[0].pricing.amount',
+    message: /not allowed with custom pricing/
+  },
+  ...['amount', 'presetAmount', 'minimumAmount', 'maximumAmount'].map(
+    (field) => ({
+      name: `free pricing with ${field}`,
+      item: {
+        product: 'prod_123',
+        pricing: {
+          type: 'free',
+          [field]: '10.00'
+        }
+      },
+      field: `items[0].pricing.${field}`,
+      message: /not allowed with free pricing/
+    })
+  ),
+  {
+    name: 'free pricing with chosenAmount',
+    item: {
+      product: 'prod_123',
+      pricing: { type: 'free' },
+      chosenAmount: '10.00'
+    },
+    field: 'items[0].chosenAmount',
+    message: /not allowed with free pricing/
+  },
+  {
+    name: 'fixed amount shorthand with chosenAmount',
+    item: {
+      product: 'prod_123',
+      amount: '19.00',
+      chosenAmount: '10.00'
+    },
+    field: 'items[0].chosenAmount',
+    message: /catalog custom pricing or ad-hoc custom pricing/
+  },
+  {
+    name: 'explicit fixed pricing with chosenAmount',
+    item: {
+      product: 'prod_123',
+      pricing: { type: 'fixed', amount: '19.00' },
+      chosenAmount: '10.00'
+    },
+    field: 'items[0].chosenAmount',
+    message: /catalog custom pricing or ad-hoc custom pricing/
+  },
+  {
+    name: 'a numeric amount shorthand',
+    item: {
+      product: 'prod_123',
+      amount: 1900
+    },
+    field: 'items[0].amount',
+    message: /decimal string/
+  },
+  {
+    name: 'a numeric chosenAmount',
+    item: {
+      product: 'prod_123',
+      chosenAmount: 1200
+    },
+    field: 'items[0].chosenAmount',
+    message: /decimal string/
+  },
+  {
+    name: 'a numeric fixed pricing amount',
+    item: {
+      product: 'prod_123',
+      pricing: { type: 'fixed', amount: 1900 }
+    },
+    field: 'items[0].pricing.amount',
+    message: /decimal string/
+  },
+  ...['presetAmount', 'minimumAmount', 'maximumAmount'].map((field) => ({
+    name: `a numeric custom pricing ${field}`,
+    item: {
+      product: 'prod_123',
+      pricing: {
+        type: 'custom',
+        [field]: 1000
+      }
+    },
+    field: `items[0].pricing.${field}`,
+    message: /decimal string/
+  })),
+  ...[
+    ['zero', 0],
+    ['a fraction', 1.5],
+    ['a string', '2']
+  ].map(([description, quantity]) => ({
+    name: `${description} quantity`,
+    item: {
+      product: 'prod_123',
+      quantity
+    },
+    field: 'items[0].quantity',
+    message: /integer of at least 1/
+  }))
+]
+
+for (const invalidCase of invalidItemCases) {
+  test(`checkout rejects ${invalidCase.name} before calling Bachs`, async () => {
+    let fetchCalls = 0
+
+    fetch.setFetchImplementation(async () => {
+      fetchCalls += 1
+    })
+
+    await assert.rejects(
+      () =>
+        checkout({
+          apiKey: 'sk_sandbox_123',
+          items: [invalidCase.item]
+        }),
+      (error) => {
+        assert.equal(error.exit, 'invalidRequest')
+        assert.equal(error.raw.field, invalidCase.field)
+        assert.match(error.raw.message, invalidCase.message)
+        return true
+      }
+    )
+
+    assert.equal(fetchCalls, 0)
+  })
+}
+
 test('adapter exposes checkout.get as the uniform checkout lookup API', async () => {
   const calls = []
 
@@ -95,6 +362,4 @@ test('adapter exposes checkout.get as the uniform checkout lookup API', async ()
     'https://sandbox-api.bachs.io/v1/checkouts/chk_123'
   )
   assert.equal(calls[0].options.method, 'GET')
-
-  fetch.resetFetchImplementation()
 })

package/test/customer.test.js

@@ -0,0 +1,183 @@
+const { test, afterEach } = require('node:test')
+const assert = require('node:assert/strict')
+const adapter = require('../adapter')
+const fetch = require('../helpers/fetch')
+
+afterEach(() => {
+  adapter.config = {}
+  fetch.resetFetchImplementation()
+})
+
+test('customer.portal creates a fresh sandbox portal session without a body', async () => {
+  const calls = []
+
+  fetch.setFetchImplementation(async (url, options) => {
+    calls.push({ url, options })
+
+    return {
+      ok: true,
+      status: 201,
+      statusText: 'Created',
+      text: async () =>
+        JSON.stringify({
+          id: `psn_${calls.length}`,
+          url: `https://portal.bachs.io/s/${calls.length}`
+        })
+    }
+  })
+
+  const firstPortalUrl = await adapter.customer.portal({
+    apiKey: 'sk_sandbox_123',
+    customerId: 'cust_123'
+  })
+  const secondPortalUrl = await adapter.customer.portal({
+    apiKey: 'sk_sandbox_123',
+    customerId: 'cust_123'
+  })
+
+  assert.equal(typeof adapter.customer.portal, 'function')
+  assert.equal(firstPortalUrl, 'https://portal.bachs.io/s/1')
+  assert.equal(secondPortalUrl, 'https://portal.bachs.io/s/2')
+  assert.equal(calls.length, 2)
+
+  for (const call of calls) {
+    assert.equal(
+      call.url,
+      'https://sandbox-api.bachs.io/v1/customers/cust_123/portal-sessions'
+    )
+    assert.equal(call.options.method, 'POST')
+    assert.equal(call.options.headers.Authorization, 'Bearer sk_sandbox_123')
+    assert.equal(Object.hasOwn(call.options, 'body'), false)
+  }
+})
+
+test('customer.portal falls back to adapter configuration', async () => {
+  const calls = []
+  adapter.config = {
+    apiKey: 'sk_live_configured',
+    baseUrl: 'https://configured.example'
+  }
+
+  fetch.setFetchImplementation(async (url, options) => {
+    calls.push({ url, options })
+
+    return {
+      ok: true,
+      status: 201,
+      statusText: 'Created',
+      text: async () =>
+        JSON.stringify({
+          id: 'psn_configured',
+          url: 'https://portal.bachs.io/s/configured'
+        })
+    }
+  })
+
+  const portalUrl = await adapter.customer.portal({
+    customerId: 'cust_configured'
+  })
+
+  assert.equal(portalUrl, 'https://portal.bachs.io/s/configured')
+  assert.equal(
+    calls[0].url,
+    'https://configured.example/v1/customers/cust_configured/portal-sessions'
+  )
+  assert.equal(
+    calls[0].options.headers.Authorization,
+    'Bearer sk_live_configured'
+  )
+})
+
+test('customer.portal input credentials override adapter configuration', async () => {
+  const calls = []
+  adapter.config = {
+    apiKey: 'sk_live_configured',
+    baseUrl: 'https://configured.example'
+  }
+
+  fetch.setFetchImplementation(async (url, options) => {
+    calls.push({ url, options })
+
+    return {
+      ok: true,
+      status: 201,
+      statusText: 'Created',
+      text: async () =>
+        JSON.stringify({
+          id: 'psn_override',
+          url: 'https://portal.bachs.io/s/override'
+        })
+    }
+  })
+
+  await adapter.customer.portal({
+    apiKey: 'sk_sandbox_override',
+    baseUrl: 'https://override.example/api',
+    customerId: 'cust/override'
+  })
+
+  assert.equal(
+    calls[0].url,
+    'https://override.example/v1/customers/cust%2Foverride/portal-sessions'
+  )
+  assert.equal(
+    calls[0].options.headers.Authorization,
+    'Bearer sk_sandbox_override'
+  )
+})
+
+test('customer.portal rejects a malformed success response', async () => {
+  fetch.setFetchImplementation(async () => ({
+    ok: true,
+    status: 201,
+    statusText: 'Created',
+    text: async () => JSON.stringify({ id: 'psn_without_url' })
+  }))
+
+  await assert.rejects(
+    () =>
+      adapter.customer.portal({
+        apiKey: 'sk_sandbox_123',
+        customerId: 'cust_123'
+      }),
+    (error) => {
+      assert.equal(error.exit, 'couldNotCreatePortalUrl')
+      assert.deepEqual(error.raw, { id: 'psn_without_url' })
+      return true
+    }
+  )
+})
+
+for (const statusCode of [401, 403, 404, 429, 500, 503]) {
+  test(`customer.portal normalizes Bachs ${statusCode} responses`, async () => {
+    fetch.setFetchImplementation(async () => ({
+      ok: false,
+      status: statusCode,
+      statusText: 'Request failed',
+      text: async () =>
+        JSON.stringify({
+          detail: `Portal request failed with ${statusCode}`,
+          error_code: `STATUS_${statusCode}`
+        })
+    }))
+
+    await assert.rejects(
+      () =>
+        adapter.customer.portal({
+          apiKey: 'sk_sandbox_123',
+          customerId: 'cust_123'
+        }),
+      (error) => {
+        assert.equal(error.exit, 'couldNotCreatePortalUrl')
+        assert.equal(error.raw.statusCode, statusCode)
+        assert.equal(error.raw.statusText, 'Request failed')
+        assert.equal(error.raw.code, `STATUS_${statusCode}`)
+        assert.equal(
+          error.raw.message,
+          `Portal request failed with ${statusCode}`
+        )
+        return true
+      }
+    )
+  })
+}

package/test/payloads.test.js

@@ -3,9 +3,147 @@ const assert = require('node:assert/strict')
 const {
   buildCheckoutSessionPayload,
   buildPureCheckoutPayload,
-  buildRefundPayload
+  buildRefundPayload,
+  buildProductCart,
+  normalizePricing
 } = require('../helpers/payloads')
 
+test('buildProductCart preserves catalog pricing and optional quantity', () => {
+  assert.deepEqual(buildProductCart([{ product: 'prod_catalog' }]), [
+    {
+      product_id: 'prod_catalog'
+    }
+  ])
+
+  assert.deepEqual(
+    buildProductCart([{ product: 'prod_quantity', quantity: 2 }]),
+    [
+      {
+        product_id: 'prod_quantity',
+        quantity: 2
+      }
+    ]
+  )
+})
+
+test('buildProductCart normalizes fixed pricing shorthand and explicit pricing', () => {
+  const fixedPricing = {
+    product_id: 'prod_fixed',
+    pricing: {
+      price_type: 'fixed',
+      amount: '19.00'
+    }
+  }
+
+  assert.deepEqual(
+    buildProductCart([{ product: 'prod_fixed', amount: '19.00' }]),
+    [fixedPricing]
+  )
+
+  assert.deepEqual(
+    buildProductCart([
+      {
+        product: 'prod_fixed',
+        pricing: {
+          type: 'fixed',
+          amount: '19.00'
+        }
+      }
+    ]),
+    [fixedPricing]
+  )
+})
+
+test('buildProductCart normalizes custom pricing and chosenAmount', () => {
+  assert.deepEqual(
+    buildProductCart([
+      {
+        product: 'prod_custom',
+        pricing: {
+          type: 'custom',
+          presetAmount: '10.00',
+          minimumAmount: '5.00',
+          maximumAmount: '100.00'
+        },
+        chosenAmount: '12.00'
+      }
+    ]),
+    [
+      {
+        product_id: 'prod_custom',
+        pricing: {
+          price_type: 'custom',
+          preset_amount: '10.00',
+          minimum_amount: '5.00',
+          maximum_amount: '100.00'
+        },
+        amount: '12.00'
+      }
+    ]
+  )
+})
+
+test('buildProductCart normalizes free pricing', () => {
+  assert.deepEqual(
+    buildProductCart([
+      {
+        product: 'prod_free',
+        pricing: {
+          type: 'free'
+        }
+      }
+    ]),
+    [
+      {
+        product_id: 'prod_free',
+        pricing: {
+          price_type: 'free'
+        }
+      }
+    ]
+  )
+})
+
+test('buildProductCart maps catalog chosenAmount to the flat Bachs amount', () => {
+  assert.deepEqual(
+    buildProductCart([
+      {
+        product: 'prod_catalog_custom',
+        chosenAmount: '12.00'
+      }
+    ]),
+    [
+      {
+        product_id: 'prod_catalog_custom',
+        amount: '12.00'
+      }
+    ]
+  )
+})
+
+test('normalizePricing maps reusable pricing fields to Bachs snake case', () => {
+  assert.deepEqual(
+    normalizePricing({
+      type: 'custom',
+      presetAmount: '10.00',
+      minimumAmount: '5.00',
+      maximumAmount: '100.00',
+      currencyOptions: {
+        NGN: '15000.00'
+      }
+    }),
+    {
+      price_type: 'custom',
+      preset_amount: '10.00',
+      minimum_amount: '5.00',
+      maximum_amount: '100.00',
+      currency_options: {
+        NGN: '15000.00'
+      }
+    }
+  )
+})
+
 test('buildCheckoutSessionPayload maps product checkout inputs to Bachs snake case', () => {
   const payload = buildCheckoutSessionPayload(
     {
@@ -37,7 +175,10 @@ test('buildCheckoutSessionPayload maps product checkout inputs to Bachs snake ca
       {
         product_id: 'prod_abc123',
         quantity: 2,
-        amount: '50.00'
+        pricing: {
+          price_type: 'fixed',
+          amount: '50.00'
+        }
       }
     ],
     billing_currency: 'NGN',
@@ -118,6 +259,34 @@ test('buildPureCheckoutPayload maps amount checkout inputs to Bachs snake case',
   })
 })
 
+test('buildPureCheckoutPayload reuses advanced pricing normalization', () => {
+  const payload = buildPureCheckoutPayload({
+    pricing: {
+      type: 'custom',
+      currency: 'USD',
+      presetAmount: '10.00',
+      minimumAmount: '5.00',
+      maximumAmount: '100.00'
+    },
+    currencyOptions: {
+      NGN: '15000.00'
+    }
+  })
+
+  assert.deepEqual(payload, {
+    pricing: {
+      currency: 'USD',
+      price_type: 'custom',
+      preset_amount: '10.00',
+      minimum_amount: '5.00',
+      maximum_amount: '100.00',
+      currency_options: {
+        NGN: '15000.00'
+      }
+    }
+  })
+})
+
 test('buildRefundPayload maps refund inputs to Bachs snake case', () => {
   const payload = buildRefundPayload({
     chargeId: 'chr_123',