@fat-zebra/sdk 1.0.0

package/src/shared/types.test.ts

@@ -0,0 +1,65 @@
+import { Customer } from './types'
+
+describe('Customer', () => {
+
+  const declareCustomer = (properties = {}) => {
+    const customer: Customer = properties
+    return customer
+  }
+
+  it('allows no properties', () => {
+    expect(() => declareCustomer()).not.toThrow()
+  })
+
+  it('allows any combination of properties', () => {
+    expect(() => declareCustomer({ firstName: 'Ziggy', lastName: 'Zebra' })).not.toThrow()
+    expect(() => declareCustomer({ firstName: 'Ziggy', email: 'ziggy.zebra@fatzebra.com' })).not.toThrow()
+    expect(() => declareCustomer({ address: '2/58-62 Kippax Street', city: 'Surry Hills' })).not.toThrow()
+  })
+
+  it('allows all properties', () => {
+    const properties = {
+      firstName: 'Ziggy',
+      lastName: 'Zebra',
+      email: 'ziggy.zebra@fatzebra.com',
+      address: '2/58-62 Kippax Street',
+      city: 'Surry Hills',
+      postcode: '2010',
+      state: 'NSW',
+      country: 'Australia'
+    }
+    expect(() => declareCustomer(properties)).not.toThrow()
+  })
+
+  it('allows only first name', () => {
+    expect(() => declareCustomer({ firstName: 'Ziggy' })).not.toThrow()
+  })
+
+  it('allows only last name', () => {
+    expect(() => declareCustomer({ lastName: 'Zebra' })).not.toThrow()
+  })
+
+  it('allows only email', () => {
+    expect(() => declareCustomer({ email: 'ziggy.zebra@fatzebra.com' })).not.toThrow()
+  })
+
+  it('allows only address', () => {
+    expect(() => declareCustomer({ address: '2/58-62 Kippax Street' })).not.toThrow()
+  })
+
+  it('allows only city', () => {
+    expect(() => declareCustomer({ city: 'Surry Hills' })).not.toThrow()
+  })
+
+  it('allows only postcode', () => {
+    expect(() => declareCustomer({ postcode: '2010' })).not.toThrow()
+  })
+
+  it('allows only state', () => {
+    expect(() => declareCustomer({ state: 'NSW' })).not.toThrow()
+  })
+
+  it('allows only country', () => {
+    expect(() => declareCustomer({ country: 'Australia' })).not.toThrow()
+  })
+})

package/src/shared/types.ts

@@ -0,0 +1,182 @@
+
+enum NODE_ENV {
+  LOCALDEV = 'localdev',
+  PRODUCTION = 'production',
+  SANDBOX = 'sandbox',
+  STAGING = 'staging',
+  TEST = 'test',
+}
+
+enum PublicEvent {
+  FORM_VALIDATION_ERROR = "fz.form_validation.error",
+  FORM_VALIDATION_SUCCESS = "fz.form_validation.success",
+  VALIDATION_ERROR = "fz.validation.error",
+  SCA_SUCCESS = "fz.sca.success",
+  SCA_ERROR = "fz.sca.error",
+  TOKENIZATION_SUCCESS = "fz.tokenization.success",
+  TOKENIZATION_ERROR = "fz.tokenization.error",
+  PAYMENT_SUCCESS = "fz.payment.success",
+  PAYMENT_ERROR = "fz.payment.error",
+  BIN_LOOKUP = "fz.bin.lookup",
+}
+
+enum BridgeEvent {
+  TOKENIZE_CARD_REQUEST = "fzi.tc_req",
+  TOKENIZE_CARD_RESPONSE = "fzi.tc_res",
+  CREATE_PAYMENT_REQUEST = "fzi.cp_req",
+  CREATE_PAYMENT_RESPONSE = "fzi.cp_res",
+  TRIGGER_PAYNOW_BUTTON = "fzi.pn_btn",
+  FORM_VALIDATION_ERROR = "fzi.form_validation_error",
+  FORM_VALIDATION_SUCCESS = "fzi.form_validation_success",
+  BIN_LOOKUP = "fzi.bin_lookup",
+}
+
+enum PaymentMethodType {
+  CARD = 'card',
+  CARD_ON_FILE = 'card_on_file',
+}
+
+interface Card {
+  number: string
+  holder: string
+  expiryMonth: string
+  expiryYear: string
+  cvv: string
+}
+
+interface CardOnFile {
+  token: string
+}
+
+interface Customer {
+  firstName?: string
+  lastName?: string
+  email?: string
+  address?: string
+  city?: string
+  postcode?: string
+  state?: string
+  country?: string
+}
+
+interface CustomerSnakeCase {
+  first_name?: string
+  last_name?: string
+  email?: string
+  address?: string
+  city?: string
+  state?: string
+  postcode?: string
+  country?: string
+}
+
+interface Payment {
+  amount: number
+  currency: string
+  reference: string,
+  hide_card_holder?: boolean;
+}
+
+interface PaymentIntent {
+  payment: Payment
+  verification: string // hamc_md5 of payment object
+}
+
+interface PaymentMethod {
+  type?: PaymentMethodType
+  data: Card | CardOnFile
+}
+
+interface ValidationResult {
+  valid: boolean
+  errors: string[]
+}
+
+type TokenizeCardResponse = {
+  bin: string;
+  token: string;
+  errors?: Array<string>;
+};
+
+type Callback = (event: any) => void;
+
+type Handlers = Partial<Record<PublicEvent, Callback>>;
+
+export type VerificationConfig = {
+  accessToken: string;
+  paymentIntent: PaymentIntent,
+  verification: string;
+  options?: Options;
+};
+
+export type PaymentConfig = {
+  accessToken: string;
+  payment: PaymentIntent;
+  options: Options;
+};
+
+type Options = Partial<{
+  css: string;
+  cssSignature: string;
+  enableSca: boolean;
+  tokenizeOnly: boolean;
+}>;
+
+
+export type TransactionPayload = {
+  transactionId: string;
+  responseCode: string;
+  message: string;
+  amount: number;
+  currency: string;
+  reference: string;
+  cardNumber: string;
+  cardHolder: string;
+  cardExpiry: string;
+  cardType: string;
+  verification: string;
+};
+
+export type CreatePaymentResponse = {
+  transaction_id: TransactionPayload["transactionId"];
+  response_code: TransactionPayload["responseCode"];
+  message: TransactionPayload["message"];
+  amount: TransactionPayload["amount"];
+  currency: TransactionPayload["currency"];
+  reference: TransactionPayload["reference"];
+  card_number: TransactionPayload["cardNumber"];
+  card_holder: TransactionPayload["cardHolder"];
+  card_expiry: TransactionPayload["cardExpiry"];
+  card_type: TransactionPayload["cardType"];
+  v: TransactionPayload["verification"];
+  errors?: Array<string>;
+};
+
+
+declare global {
+  interface Window {
+    ApplePaySession: any
+    Cardinal: any
+    FatZebra: any
+    HPP: any
+    MerchantUsername: string
+  }
+}
+
+export {
+  BridgeEvent,
+  PublicEvent,
+  NODE_ENV,
+  Card,
+  CardOnFile,
+  Customer,
+  CustomerSnakeCase,
+  Handlers,
+  Payment,
+  PaymentIntent,
+  PaymentMethod,
+  PaymentMethodType,
+  TokenizeCardResponse,
+
+  ValidationResult
+}

package/src/shared/util.test.ts

@@ -0,0 +1,164 @@
+import {
+  toCamelCase,
+  toSnakeCase,
+  toObjectWithCamelCaseKeys,
+  toObjectWithSnakeCaseKeys,
+} from './util'
+
+const objectWithCamelCaseKeys: any = {
+  stringKey: 'asdf',
+  nestedKey: {
+      firstName: 'John',
+      lastName: 'Doe',
+      nestedArray: [1, 2, 3],
+      nestedArray2: [
+        { itemName: 'a1', itemDesc: { partDesc: 'p1' }, subParts: [ {unitCost: 100}, {unitCost: 200} ] },
+        { itemName: 'a2', itemDesc: { partDesc: 'p2' }, subParts: [ {unitCost: 300}, {unitCost: 400} ] },
+      ]
+  },
+  arrayKey: ['asd', 'f12'],
+  nullKey: null,
+  undefinedKey: undefined,
+  emptyKey: '',
+}
+
+const objectWithSnakeCaseKeys: any = {
+  string_key: 'asdf',
+  nested_key: {
+      first_name: 'John',
+      last_name: 'Doe',
+      nested_array: [1, 2, 3],
+      nested_array2: [
+        { item_name: 'a1', item_desc: { part_desc: 'p1' }, sub_parts: [ {unit_cost: 100}, {unit_cost: 200} ] },
+        { item_name: 'a2', item_desc: { part_desc: 'p2' }, sub_parts: [ {unit_cost: 300}, {unit_cost: 400} ] },
+      ]
+  },
+  array_key: ['asd', 'f12'],
+  null_key: null,
+  undefined_key: undefined,
+  empty_key: '',
+}
+
+describe('toCamelCase', () => {
+  it('Convert snakecase string to camelcase string', () => {
+    const subject = 'snake_case'
+    const actual = toCamelCase(subject)
+    const expected = 'snakeCase'
+    expect(actual).toEqual(expected)
+  })
+
+  it('Leaves camelcase string intact', () => {
+    const subject = 'camelCase'
+    const actual = toCamelCase(subject)
+    const expected = 'camelCase'
+    expect(actual).toEqual(expected)
+  })
+})
+
+describe('toSnakeCase', () => {
+  it('Convert camelcase string to snakecase string', () => {
+    const subject = 'camelCase'
+    const actual = toSnakeCase(subject)
+    const expected = 'camel_case'
+    expect(actual).toEqual(expected)
+  })
+
+  it('Leaves snakecase string intact', () => {
+    const subject = 'snake_case'
+    const actual = toSnakeCase(subject)
+    const expected = 'snake_case'
+    expect(actual).toEqual(expected)
+  })
+})
+
+describe('toObjectWithCamelCaseKeys', () => {
+  it ('Converts object with snake case keys to camel case', () => {
+    const actual = toObjectWithCamelCaseKeys(objectWithSnakeCaseKeys)
+    const expected: any = {
+      stringKey: 'asdf',
+      nestedKey: {
+          firstName: 'John',
+          lastName: 'Doe',
+          nestedArray: [1, 2, 3],
+          nestedArray2: [
+            { itemName: 'a1', itemDesc: { partDesc: 'p1' }, subParts: [ {unitCost: 100}, {unitCost: 200} ] },
+            { itemName: 'a2', itemDesc: { partDesc: 'p2' }, subParts: [ {unitCost: 300}, {unitCost: 400} ] },
+          ]
+      },
+      arrayKey: ['asd', 'f12'],
+      nullKey: null,
+      undefinedKey: undefined,
+      emptyKey: '',
+    }
+
+    expect(actual).toMatchObject(expected)
+  })
+
+  it ('Leave object with camel case intact', () => {
+    const actual = toObjectWithCamelCaseKeys(objectWithCamelCaseKeys)
+    const expected: any = {
+      stringKey: 'asdf',
+      nestedKey: {
+          firstName: 'John',
+          lastName: 'Doe',
+          nestedArray: [1, 2, 3],
+          nestedArray2: [
+            { itemName: 'a1', itemDesc: { partDesc: 'p1' }, subParts: [ {unitCost: 100}, {unitCost: 200} ] },
+            { itemName: 'a2', itemDesc: { partDesc: 'p2' }, subParts: [ {unitCost: 300}, {unitCost: 400} ] },
+          ]
+      },
+      arrayKey: ['asd', 'f12'],
+      nullKey: null,
+      undefinedKey: undefined,
+      emptyKey: '',
+    }
+
+    expect(actual).toMatchObject(expected)
+  })
+})
+
+describe('toObjectWithSnakeCaseKeys', () => {
+  it ('Converts object with camel case keys to snake case', () => {
+    const actual = toObjectWithSnakeCaseKeys(objectWithCamelCaseKeys)
+    const expected: any = {
+      string_key: 'asdf',
+      nested_key: {
+          first_name: 'John',
+          last_name: 'Doe',
+          nested_array: [1, 2, 3],
+          nested_array2: [
+            { item_name: 'a1', item_desc: { part_desc: 'p1' }, sub_parts: [ {unit_cost: 100}, {unit_cost: 200} ] },
+            { item_name: 'a2', item_desc: { part_desc: 'p2' }, sub_parts: [ {unit_cost: 300}, {unit_cost: 400} ] },
+          ]
+      },
+      array_key: ['asd', 'f12'],
+      null_key: null,
+      undefined_key: undefined,
+      empty_key: '',
+    }
+
+    expect(actual).toMatchObject(expected)
+  })
+
+  it ('Leave object with snake case intact', () => {
+    const actual = toObjectWithSnakeCaseKeys(objectWithSnakeCaseKeys)
+    const expected: any = {
+      string_key: 'asdf',
+      nested_key: {
+          first_name: 'John',
+          last_name: 'Doe',
+          nested_array: [1, 2, 3],
+          nested_array2: [
+            { item_name: 'a1', item_desc: { part_desc: 'p1' }, sub_parts: [ {unit_cost: 100}, {unit_cost: 200} ] },
+            { item_name: 'a2', item_desc: { part_desc: 'p2' }, sub_parts: [ {unit_cost: 300}, {unit_cost: 400} ] },
+          ]
+      },
+      array_key: ['asd', 'f12'],
+      null_key: null,
+      undefined_key: undefined,
+      empty_key: '',
+    }
+
+    expect(actual).toMatchObject(expected)
+  })
+})

package/src/shared/util.ts

@@ -0,0 +1,98 @@
+const _package = require('../../package.json')
+
+const toCamelCase = (s: string): string => {
+  return s.replace(/_([a-z])/g, (g) =>  g[1].toUpperCase());
+}
+
+const toSnakeCase = (s: string): string => {
+  return s.replace(/[A-Z]/g, (char) => `_${char.toLowerCase()}`)
+}
+
+const primitiveTypes = ['string', 'number', 'boolean', 'undefined', 'symbol', 'bigint']
+
+const toObjectWithSnakeCaseKeys = (o: any): any => {
+  let objectType = typeof o
+  if (primitiveTypes.includes(objectType) || o == null){
+    return o
+  }
+
+  let converted: any = {}
+
+  for (let key in o) {
+    switch (typeof o[key]) {
+      case 'object':
+        if (Array.isArray(o[key])) {
+          converted[toSnakeCase(key)] = []
+          Object.keys(o[key]).forEach(function (k) {
+            let c = toObjectWithSnakeCaseKeys(o[key][k])
+            converted[toSnakeCase(key)].push(c)
+          })
+        } else {
+          if (o[key] == null) {
+            converted[toSnakeCase(key)] = o[key]
+          } else {
+            converted[toSnakeCase(key)] = toObjectWithSnakeCaseKeys(o[key])
+          }
+        }
+        break
+      case 'string':
+      case 'number':
+      case 'boolean':
+      case 'undefined':
+        converted[toSnakeCase(key)] = o[key]
+        break
+    }
+  }
+
+  return converted
+}
+
+const toObjectWithCamelCaseKeys = (o: any): any => {
+  let objectType = typeof o
+  if (primitiveTypes.includes(objectType) || o == null){
+    return o
+  }
+
+  let converted: any = {}
+
+  for (let key in o) {
+    switch (typeof o[key]) {
+      case 'object':
+        if (Array.isArray(o[key])) {
+          converted[toCamelCase(key)] = []
+          Object.keys(o[key]).forEach(function (k) {
+            let c = toObjectWithCamelCaseKeys(o[key][k])
+            converted[toCamelCase(key)].push(c)
+          })
+        } else {
+          if (o[key] == null) {
+            converted[toCamelCase(key)] = o[key]
+          } else {
+            converted[toCamelCase(key)] = toObjectWithCamelCaseKeys(o[key])
+          }
+        }
+        break
+      case 'string':
+      case 'number':
+      case 'boolean':
+      case 'undefined':
+        converted[toCamelCase(key)] = o[key]
+        break
+    }
+  }
+
+  return converted
+}
+
+
+const getSdkVersionNumber = () => {
+  return _package.version
+}
+
+export {
+  toCamelCase,
+  toSnakeCase,
+  toObjectWithCamelCaseKeys,
+  toObjectWithSnakeCaseKeys,
+  getSdkVersionNumber,
+}

package/tests/helpers/api-gateway-mock.ts

@@ -0,0 +1,46 @@
+import * as nock from 'nock'
+
+const apiGatewayUrl = process.env.API_GATEWAY_URL
+
+interface MockRequestConfig {
+  request: {
+    action: string,
+    path: string,
+    body: any
+  },
+  response: {
+    status: number,
+    body: any
+  }
+}
+
+const mockRequest = (config: MockRequestConfig) => {
+  nock(apiGatewayUrl)
+  .defaultReplyHeaders({
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Headers': 'Authorization, FZ-SDK-Version, fz-merchant-username',
+    "Content-Type": "application:json"
+  })
+  .options(config.request.path)
+  .reply(200, null)
+  .post(config.request.path, config.request.body)
+  .reply(config.response.status, config.response.body)
+}
+
+const mockCustomRequest = (config: MockRequestConfig) => {
+  nock(apiGatewayUrl)
+  .defaultReplyHeaders({
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Headers': 'Authorization',
+    "Content-Type": "application:json"
+  })
+  .options(config.request.path)
+  .reply(200, null)
+  .intercept(config.request.path, config.request.action, config.request.body)
+  .reply(config.response.status, config.response.body)
+}
+
+export {
+  mockRequest,
+  mockCustomRequest,
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "./dist/",
+    "jsx": "react",
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [
+      "es2019"
+    ]
+  },
+  "include": [
+    "./src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.test.ts"
+  ]
+}