@sails-pay/bachs 0.0.2 → 0.0.4

package/machines/connect/payout/create.js

@@ -0,0 +1,114 @@
+const fetch = require('../../../helpers/fetch')
+const parameters = require('../../../helpers/parameters')
+const { toPayout } = require('../../../helpers/connect')
+
+module.exports = require('machine').build({
+  friendlyName: 'Create connected account payout',
+  description:
+    "Withdraws from a connected account's balance to one of its payout destinations, defaulting to the account's default destination for the currency.",
+  moreInfoUrl: 'https://docs.bachs.io/connect/payouts',
+  inputs: {
+    apiKey: parameters.BACHS_API_KEY,
+    baseUrl: parameters.BACHS_BASE_URL,
+    account: {
+      type: 'string',
+      required: true,
+      description: 'The connected account withdrawing.'
+    },
+    amount: {
+      type: 'string',
+      required: true,
+      description: 'Decimal amount the destination should receive.'
+    },
+    currency: {
+      type: 'string',
+      description:
+        'ISO 4217 currency. Required when destination is omitted, so the default destination can be found.'
+    },
+    destination: {
+      type: 'string',
+      description: 'A payout destination ID. Omit to use the default one.'
+    },
+    reference: {
+      type: 'string',
+      maxLength: 128,
+      description: 'Your reference for the payout.'
+    },
+    idempotencyKey: {
+      type: 'string',
+      description: 'Prevents a retry from paying out twice.'
+    }
+  },
+  exits: {
+    success: {
+      description: 'The payout accepted for delivery.',
+      outputVariableName: 'payout',
+      outputType: 'ref'
+    },
+    noDestination: {
+      description:
+        'No destination was given and the account has no usable destination for the currency.',
+      outputVariableName: 'error',
+      outputType: 'ref'
+    },
+    couldNotCreatePayout: {
+      description: 'The payout could not be created.',
+      outputVariableName: 'error',
+      outputType: 'ref'
+    }
+  },
+  fn: async function (inputs, exits) {
+    const adapterConfig = require('../../../adapter').config
+    const request = {
+      apiKey: inputs.apiKey || adapterConfig.apiKey,
+      baseUrl: inputs.baseUrl || adapterConfig.baseUrl,
+      headers: { 'X-Account-Id': inputs.account }
+    }
+
+    let destination = inputs.destination
+    if (!destination) {
+      if (!inputs.currency) {
+        return exits.noDestination({
+          message: 'Pass a destination, or a currency to use the default one.'
+        })
+      }
+
+      try {
+        const { destinations = [] } = await fetch(
+          `/payouts/destinations?currency=${encodeURIComponent(
+            inputs.currency
+          )}`,
+          { method: 'GET', ...request }
+        )
+        const usable = destinations.filter((candidate) => candidate.is_usable)
+        const chosen =
+          usable.find((candidate) => candidate.is_default) || usable[0]
+        if (!chosen) {
+          return exits.noDestination({
+            message: `The account has no usable ${inputs.currency} payout destination.`
+          })
+        }
+        destination = chosen.id
+      } catch (error) {
+        return exits.couldNotCreatePayout(error.bachs || error)
+      }
+    }
+
+    try {
+      const payout = await fetch('/payouts', {
+        method: 'POST',
+        ...request,
+        idempotencyKey: inputs.idempotencyKey || inputs.reference,
+        body: {
+          destination,
+          amount: inputs.amount,
+          ...(inputs.reference && { reference: inputs.reference })
+        }
+      })
+
+      return exits.success(toPayout(payout, { account: inputs.account }))
+    } catch (error) {
+      return exits.couldNotCreatePayout(error.bachs || error)
+    }
+  }
+})

package/machines/connect/transfer/create.js

@@ -0,0 +1,71 @@
+const fetch = require('../../../helpers/fetch')
+const parameters = require('../../../helpers/parameters')
+const { toTransfer } = require('../../../helpers/connect')
+
+module.exports = require('machine').build({
+  friendlyName: 'Create transfer',
+  description:
+    "Moves funds from the platform balance into a connected account's balance.",
+  moreInfoUrl: 'https://docs.bachs.io/connect/transfers',
+  inputs: {
+    apiKey: parameters.BACHS_API_KEY,
+    baseUrl: parameters.BACHS_BASE_URL,
+    account: {
+      type: 'string',
+      required: true,
+      description: 'The connected account receiving the funds.'
+    },
+    amount: {
+      type: 'string',
+      required: true,
+      description: 'Decimal amount, e.g. "10000.00".'
+    },
+    currency: {
+      type: 'string',
+      required: true,
+      description: 'ISO 4217 currency, e.g. "NGN".'
+    },
+    group: {
+      type: 'string',
+      description: 'Groups related transfers, e.g. one payrun.'
+    },
+    idempotencyKey: {
+      type: 'string',
+      description: 'Prevents a retry from transferring twice.'
+    }
+  },
+  exits: {
+    success: {
+      description: 'The created transfer.',
+      outputVariableName: 'transfer',
+      outputType: 'ref'
+    },
+    couldNotCreateTransfer: {
+      description: 'The transfer could not be created.',
+      outputVariableName: 'error',
+      outputType: 'ref'
+    }
+  },
+  fn: async function (inputs, exits) {
+    const adapterConfig = require('../../../adapter').config
+
+    try {
+      const transfer = await fetch('/transfers', {
+        method: 'POST',
+        apiKey: inputs.apiKey || adapterConfig.apiKey,
+        baseUrl: inputs.baseUrl || adapterConfig.baseUrl,
+        idempotencyKey: inputs.idempotencyKey,
+        body: {
+          destination: inputs.account,
+          amount: inputs.amount,
+          currency: inputs.currency,
+          ...(inputs.group && { transfer_group: inputs.group })
+        }
+      })
+
+      return exits.success(toTransfer(transfer))
+    } catch (error) {
+      return exits.couldNotCreateTransfer(error.bachs || error)
+    }
+  }
+})

package/machines/index.js

@@ -4,6 +4,22 @@ checkout.get = require('./checkout/get')
 
 module.exports = {
   checkout,
+  connect: {
+    account: {
+      create: require('./connect/account/create'),
+      get: require('./connect/account/get'),
+      link: require('./connect/account/link')
+    },
+    transfer: {
+      create: require('./connect/transfer/create')
+    },
+    balance: {
+      get: require('./connect/balance/get')
+    },
+    payout: {
+      create: require('./connect/payout/create')
+    }
+  },
   customer: {
     portal: require('./customer/portal')
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sails-pay/bachs",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "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()
 })