@fat-zebra/sdk 1.0.1 → 1.0.3

package/src/shared/types.test.ts

@@ -1,65 +0,0 @@
-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

@@ -1,182 +0,0 @@
-
-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

@@ -1,164 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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,
-}