@sails-pay/bachs 0.0.4 → 0.0.6

package/helpers/payloads.js

@@ -65,6 +65,7 @@ function buildProductCart(items) {
 function buildCheckoutSessionPayload(inputs, adapterConfig = {}) {
   const productCollectionId =
     inputs.productCollectionId || inputs.productCollection
+  const productCart = buildProductCart(inputs.items)
   const checkoutData = inputs.checkoutData || {}
   const returnUrl =
     inputs.returnUrl ||
@@ -74,14 +75,23 @@ function buildCheckoutSessionPayload(inputs, adapterConfig = {}) {
 
   return withoutUndefined({
     customer: buildCustomerPayload(inputs),
-    product_cart: buildProductCart(inputs.items),
+    product_cart: productCart,
     product_collection_id: productCollectionId,
+    // A session prices itself with products or with a raw amount, never both.
+    pricing:
+      productCart || productCollectionId
+        ? undefined
+        : buildPricingPayload(inputs),
     billing_currency: inputs.billingCurrency,
     allowed_payment_method_types: inputs.allowedPaymentMethodTypes,
     return_url: returnUrl,
     cancel_url: inputs.cancelUrl || adapterConfig.cancelUrl,
     reference: inputs.reference,
-    metadata: inputs.metadata || checkoutData.custom
+    metadata: inputs.metadata || checkoutData.custom,
+    transfer_data: inputs.connect && {
+      destination: inputs.connect.destination
+    },
+    platform_fee: inputs.connect && inputs.connect.platformFee
   })
 }
 

package/helpers/validate-checkout-connect.js

@@ -0,0 +1,54 @@
+const allowedFields = new Set(['destination', 'platformFee'])
+const decimalStringPattern = /^\d+(?:\.\d+)?$/
+
+function invalid(field, message) {
+  return {
+    field,
+    message: `${field} ${message}`
+  }
+}
+
+/**
+ * Validates the `connect` checkout input that splits a checkout between a
+ * connected account and the platform. Returns an error object, or null.
+ */
+function validateCheckoutConnect(connect, { isCheckoutSession }) {
+  if (!connect || typeof connect !== 'object' || Array.isArray(connect)) {
+    return invalid('connect', 'must be an object.')
+  }
+
+  if (!isCheckoutSession) {
+    return invalid(
+      'connect',
+      'is only supported on checkout sessions (items, productCollectionId, or pricing).'
+    )
+  }
+
+  for (const field of Object.keys(connect)) {
+    if (!allowedFields.has(field)) {
+      return invalid(
+        `connect.${field}`,
+        'is not supported. Use connect.destination and connect.platformFee.'
+      )
+    }
+  }
+
+  if (typeof connect.destination !== 'string' || !connect.destination) {
+    return invalid('connect.destination', 'must be a connected account ID.')
+  }
+
+  if (
+    typeof connect.platformFee !== 'string' ||
+    !decimalStringPattern.test(connect.platformFee) ||
+    Number(connect.platformFee) <= 0
+  ) {
+    return invalid(
+      'connect.platformFee',
+      'must be a positive decimal string, e.g. "500.00".'
+    )
+  }
+
+  return null
+}
+
+module.exports = validateCheckoutConnect

package/machines/checkout.js

@@ -4,6 +4,7 @@ const {
   buildPureCheckoutPayload
 } = require('../helpers/payloads')
 const validateCheckoutItems = require('../helpers/validate-checkout-items')
+const validateCheckoutConnect = require('../helpers/validate-checkout-connect')
 const parameters = require('../helpers/parameters')
 
 module.exports = require('machine').build({
@@ -116,6 +117,11 @@ module.exports = require('machine').build({
     simulatedOutcome: {
       type: 'string',
       description: 'Sandbox-only forced outcome.'
+    },
+    connect: {
+      type: 'ref',
+      description:
+        'Splits a checkout session with a connected account: { destination, platformFee }. The account receives the rest of the sale when it settles.'
     }
   },
   exits: {
@@ -141,9 +147,18 @@ module.exports = require('machine').build({
     const hasProductCollection = Boolean(
       inputs.productCollectionId || inputs.productCollection
     )
-    const shouldUseCheckoutSession = hasItems || hasProductCollection
+    const hasPricing = Boolean(
+      inputs.pricing || inputs.amount !== undefined || inputs.currency
+    )
+    // A split belongs to the platform, and Bachs only splits checkout
+    // sessions. A session takes products or a raw price, so a checkout that
+    // states its own amount and currency can be split too.
+    const shouldUseCheckoutSession =
+      hasItems ||
+      hasProductCollection ||
+      (hasPricing && inputs.connect !== undefined)
 
-    if (shouldUseCheckoutSession && hasItems === hasProductCollection) {
+    if (hasItems && hasProductCollection) {
       return exits.invalidRequest({
         message:
           'Provide exactly one of items or productCollectionId for a Bachs checkout session.'
@@ -158,12 +173,26 @@ module.exports = require('machine').build({
       }
     }
 
+    if (inputs.connect !== undefined) {
+      const connectError = validateCheckoutConnect(inputs.connect, {
+        isCheckoutSession: shouldUseCheckoutSession
+      })
+
+      if (connectError) {
+        return exits.invalidRequest(connectError)
+      }
+    }
+
     const path = shouldUseCheckoutSession ? '/checkout-sessions' : '/checkouts'
     const payload = shouldUseCheckoutSession
       ? buildCheckoutSessionPayload(inputs, adapterConfig)
       : buildPureCheckoutPayload(inputs, adapterConfig)
 
-    if (!shouldUseCheckoutSession && !payload.pricing) {
+    if (
+      !payload.product_cart &&
+      !payload.product_collection_id &&
+      !payload.pricing
+    ) {
       return exits.invalidRequest({
         message:
           'Provide product items/productCollectionId or pure checkout pricing.'

package/package.json

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

package/test/checkout.test.js

@@ -363,3 +363,213 @@ test('adapter exposes checkout.get as the uniform checkout lookup API', async ()
   )
   assert.equal(calls[0].options.method, 'GET')
 })
+
+test('checkout splits a checkout session with a connected account', async () => {
+  const calls = []
+
+  fetch.setFetchImplementation(async (url, options) => {
+    calls.push({ url, options })
+
+    return {
+      ok: true,
+      status: 201,
+      statusText: 'Created',
+      text: async () =>
+        JSON.stringify({
+          checkout_id: 'chk_split',
+          checkout_url: 'https://pay.bachs.io/c/split'
+        })
+    }
+  })
+
+  const checkoutUrl = await checkout({
+    apiKey: 'sk_sandbox_123',
+    items: [{ product: 'prod_abc123', amount: '10500.00' }],
+    reference: 'sponsorship_1',
+    connect: {
+      destination: 'acct_123',
+      platformFee: '500.00'
+    }
+  })
+
+  assert.equal(checkoutUrl, 'https://pay.bachs.io/c/split')
+  assert.equal(
+    calls[0].url,
+    'https://sandbox-api.bachs.io/v1/checkout-sessions'
+  )
+  assert.equal(calls[0].options.headers['X-Account-Id'], undefined)
+
+  const body = JSON.parse(calls[0].options.body)
+  assert.deepEqual(body.transfer_data, { destination: 'acct_123' })
+  assert.equal(body.platform_fee, '500.00')
+  assert.equal(body.connect, undefined)
+})
+
+test('checkout splits a product-less checkout session', 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/raw-split' })
+    }
+  })
+
+  const checkoutUrl = await checkout({
+    apiKey: 'sk_sandbox_123',
+    amount: '10500.00',
+    currency: 'NGN',
+    billingCurrency: 'NGN',
+    customer: { email: 'sponsor@example.com' },
+    reference: 'sponsorship_2',
+    connect: { destination: 'acct_123', platformFee: '500.00' }
+  })
+
+  assert.equal(checkoutUrl, 'https://pay.bachs.io/c/raw-split')
+  assert.equal(
+    calls[0].url,
+    'https://sandbox-api.bachs.io/v1/checkout-sessions'
+  )
+
+  const body = JSON.parse(calls[0].options.body)
+  assert.deepEqual(body.pricing, { currency: 'NGN', amount: '10500.00' })
+  assert.deepEqual(body.transfer_data, { destination: 'acct_123' })
+  assert.equal(body.platform_fee, '500.00')
+  assert.equal(body.billing_currency, 'NGN')
+  assert.equal('product_cart' in body, false)
+})
+
+test('a pure checkout without connect still posts to /checkouts', 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/raw' })
+    }
+  })
+
+  await checkout({
+    apiKey: 'sk_sandbox_123',
+    amount: '10500.00',
+    currency: 'NGN',
+    customer: { email: 'sponsor@example.com' }
+  })
+
+  assert.equal(calls[0].url, 'https://sandbox-api.bachs.io/v1/checkouts')
+})
+
+test('checkout without connect sends no split fields', 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/plain' })
+    }
+  })
+
+  await checkout({
+    apiKey: 'sk_sandbox_123',
+    items: [{ product: 'prod_abc123' }]
+  })
+
+  const body = JSON.parse(calls[0].options.body)
+  assert.equal('transfer_data' in body, false)
+  assert.equal('platform_fee' in body, false)
+})
+
+const invalidConnectCases = [
+  {
+    name: 'connect that is not an object',
+    inputs: { items: [{ product: 'prod_abc123' }], connect: 'acct_123' },
+    field: 'connect',
+    message: /must be an object/
+  },
+  {
+    name: 'connect without a destination',
+    inputs: {
+      items: [{ product: 'prod_abc123' }],
+      connect: { platformFee: '500.00' }
+    },
+    field: 'connect.destination',
+    message: /connected account ID/
+  },
+  {
+    name: 'connect without a platform fee',
+    inputs: {
+      items: [{ product: 'prod_abc123' }],
+      connect: { destination: 'acct_123' }
+    },
+    field: 'connect.platformFee',
+    message: /positive decimal string/
+  },
+  {
+    name: 'a numeric platform fee',
+    inputs: {
+      items: [{ product: 'prod_abc123' }],
+      connect: { destination: 'acct_123', platformFee: 500 }
+    },
+    field: 'connect.platformFee',
+    message: /positive decimal string/
+  },
+  {
+    name: 'a zero platform fee',
+    inputs: {
+      items: [{ product: 'prod_abc123' }],
+      connect: { destination: 'acct_123', platformFee: '0.00' }
+    },
+    field: 'connect.platformFee',
+    message: /positive decimal string/
+  },
+  {
+    name: 'an unknown connect field',
+    inputs: {
+      items: [{ product: 'prod_abc123' }],
+      connect: {
+        destination: 'acct_123',
+        platformFee: '500.00',
+        amount: '10000.00'
+      }
+    },
+    field: 'connect.amount',
+    message: /is not supported/
+  }
+]
+
+for (const invalidCase of invalidConnectCases) {
+  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', ...invalidCase.inputs }),
+      (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)
+  })
+}