@engage_so/core 2.2.0 → 2.2.2

package/src/index.ts

@@ -1,365 +0,0 @@
-import { Buffer } from 'buffer'
-import fetch from 'cross-fetch'
-import { EngageError } from './error'
-
-if (typeof btoa === 'undefined') {
-  global.btoa = function (str) {
-    return Buffer.from(str).toString('base64')
-  }
-}
-
-export interface Key {
-  key?: string
-  secret?: string
-}
-export interface EventParameter {
-  event: string
-  value?: string | number | Date | boolean
-  properties?: {
-    [key: string]: string | number | Date | boolean
-  }
-  timestamp?: string | number | Date
-}
-export interface UserAttrParams {
-  [key: string]: string | number | Date | boolean
-}
-export type UserIdentifyParams = UserAttrParams & { id: string }
-type DataParameters = {
-  [key: string]: string | number | Date | boolean
-} & {
-  meta?: {
-    [key: string]: string | number | Date | boolean
-  }
-}
-type Methods = 'POST' | 'PUT' | 'DELETE' | 'GET'
-// type UserIdentifyParams = {
-//   id: string
-//   [key: string]: string | number | Date | boolean
-// }
-// type UserAttrParams = Omit<UserIdentifyParams, 'id'>
-
-// const rootURL = 'https://api.engage.so/v1'
-let auth: string = ''
-let currentUserId: string = ''
-const notMeta = ['created_at', 'is_account', 'number', 'device_token', 'device_platform', 'email', 'first_name', 'last_name', 'tz', 'app_version', 'app_build', 'app_last_active']
-const apiRoot = 'https://api.engage.so/v1'
-
-function isNull (v: any | null | undefined): boolean {
-  return (v === null || v === undefined)
-}
-function isNullString (v: string | null | undefined): boolean {
-  return (v === null || v === undefined || v === '')
-}
-
-function resolveUserId (uid?: string): string {
-  if (!isNullString(uid)) {
-    return uid as string
-  }
-  if (isNullString(currentUserId)) {
-    throw new EngageError('User ID missing. Call identify() first or provide a uid parameter.')
-  }
-  return currentUserId
-}
-
-async function _request (url: string, params: Record<string, any> | null | undefined, method: Methods): Promise<object> {
-  try {
-    const o: any = {
-      method,
-      headers: {
-        'Content-Type': 'application/json;charset=utf-8',
-        Authorization: `Basic ${auth}`
-      }
-      // throwHttpErrors: false,
-      // prefixUrl: rootURL
-    }
-    if (!isNull(params)) {
-      o.body = JSON.stringify(params)
-    }
-    // const response = await ky(url, o)
-    const response = await fetch(`${apiRoot}${url}`, o)
-    const body: any = await response.json()
-    let error = 'API connection error'
-    if (!response.ok) {
-      if (typeof body?.error === 'string') {
-        error = body.error
-      }
-      return { error }
-    }
-    return body
-  } catch (e) {
-    return { error: 'API connection error' }
-  }
-}
-// Alias of _request method
-// Same with _request for now but can later have modifications
-export async function request (url: string, params: Record<string, any> | null | undefined, method: Methods = 'GET'): Promise<object> {
-  return await _request(url, params, method)
-}
-
-export function init (key: Key | string): void {
-  if (isNull(key)) {
-    throw new EngageError('You need to pass in your API key(s).')
-  }
-
-  // Clear any stored user ID when reinitializing
-  currentUserId = ''
-
-  const options: Key = {
-    key: '',
-    secret: ''
-  }
-  if (typeof key === 'string') {
-    if (key === '') {
-      throw new EngageError('`key` is empty.')
-    }
-    options.key = key
-  } else {
-    if (isNullString(key.key)) {
-      throw new EngageError('`key` missing in object.')
-    }
-    options.key = key.key
-    if (!isNullString(key.secret)) {
-      options.secret = key.secret
-    }
-  }
-  // Set auth
-  auth = btoa(`${options.key ?? ''}:${options.secret ?? ''}`)
-}
-
-// Data tracking
-export async function identify (user: UserIdentifyParams): Promise<object> {
-  if (isNull(user)) {
-    throw new EngageError('You need to pass an object with at least an id.')
-  }
-  if (isNullString(user.id)) {
-    throw new EngageError('ID missing.')
-  }
-  if (!isNull(user.email) && (typeof user.email !== 'string' || !/^\S+@\S+$/.test(user.email))) {
-    throw new EngageError('Email invalid.')
-  }
-  const params: DataParameters = {}
-  params.meta = {}
-  for (const k in user) {
-    if (k === 'id' || notMeta.includes(k)) {
-      params[k] = user[k]
-    } else {
-      params.meta[k] = user[k]
-    }
-  }
-
-  // Store the user ID for use in other functions
-  currentUserId = user.id
-
-  return await _request(`/users/${user.id}`, params, 'PUT')
-}
-
-// Overloaded function signatures for addAttribute
-export async function addAttribute (attributes: UserAttrParams): Promise<object>
-export async function addAttribute (uid: string, attributes: UserAttrParams): Promise<object>
-export async function addAttribute (uidOrAttributes: string | UserAttrParams, attributes?: UserAttrParams): Promise<object> {
-  let uid: string
-  let attrs: UserAttrParams
-
-  // Handle overloaded parameters
-  if (typeof uidOrAttributes === 'string') {
-    uid = resolveUserId(uidOrAttributes)
-    if (isNull(attributes)) {
-      throw new EngageError('Attributes missing when uid is provided.')
-    }
-    attrs = attributes as UserAttrParams
-  } else {
-    uid = resolveUserId()
-    attrs = uidOrAttributes
-  }
-
-  if (isNull(attrs)) {
-    throw new EngageError('Attributes missing.')
-  }
-  if (Object.keys(attrs).length === 0) {
-    throw new EngageError('Attributes missing.')
-  }
-  const params: DataParameters = {}
-  params.meta = {}
-  for (const k in attrs) {
-    if (notMeta.includes(k)) {
-      params[k] = attrs[k]
-    } else {
-      params.meta[k] = attrs[k]
-    }
-  }
-  if (Object.keys(params.meta).length === 0) {
-    delete params.meta
-  }
-
-  return await _request(`/users/${uid}`, params, 'PUT')
-}
-
-// Overloaded function signatures for track
-export async function track (data: EventParameter): Promise<object>
-export async function track (uid: string, data: EventParameter): Promise<object>
-export async function track (uidOrData: string | EventParameter, data?: EventParameter): Promise<object> {
-  let uid: string
-  let eventData: EventParameter
-
-  // Handle overloaded parameters
-  if (typeof uidOrData === 'string') {
-    uid = resolveUserId(uidOrData)
-    if (isNull(data)) {
-      throw new EngageError('Event data missing when uid is provided.')
-    }
-    eventData = data as EventParameter
-  } else {
-    uid = resolveUserId()
-    eventData = uidOrData
-  }
-
-  if (isNull(eventData)) {
-    throw new EngageError('Event data missing.')
-  }
-  if (typeof eventData === 'string') {
-    eventData = {
-      event: eventData,
-      value: true
-    }
-  } else {
-    if (Object.keys(eventData).length === 0) {
-      throw new EngageError('Attributes missing.')
-    }
-  }
-
-  return await _request(`/users/${uid}/events`, eventData, 'POST')
-}
-
-// Overloaded function signatures for merge
-export async function merge (destinationUid: string): Promise<object>
-export async function merge (sourceUid: string, destinationUid: string): Promise<object>
-export async function merge (sourceOrDestinationUid: string, destinationUid?: string): Promise<object> {
-  let sourceUid: string
-  let destUid: string
-
-  // Handle overloaded parameters
-  if (isNullString(destinationUid)) {
-    // Called with one parameter: merge(destinationUid)
-    sourceUid = resolveUserId()
-    destUid = sourceOrDestinationUid
-  } else {
-    // Called with two parameters: merge(sourceUid, destinationUid)
-    sourceUid = resolveUserId(sourceOrDestinationUid)
-    destUid = destinationUid as string
-  }
-
-  if (isNullString(destUid)) {
-    throw new EngageError('Destination ID missing.')
-  }
-
-  return await _request('/users/merge', {
-    source: sourceUid,
-    destination: destUid
-  }, 'POST')
-}
-
-// Account functions
-export async function addToAccount (uid: string, accountId: string, role?: string): Promise<object> {
-  if (isNullString(uid)) {
-    throw new EngageError('User ID missing.')
-  }
-  if (isNullString(accountId)) {
-    throw new EngageError('Account ID missing.')
-  }
-  if (!isNull(role) && typeof role !== 'string') {
-    throw new EngageError('Role should be a text.')
-  }
-  const g: Record<string, string> = {
-    id: accountId
-  }
-  if (!isNullString(role)) {
-    g.role = role as string
-  }
-  return await _request(`/users/${uid}/accounts`, { accounts: [g] }, 'POST')
-}
-
-// Overloaded function signatures for removeFromAccount
-export async function removeFromAccount (accountId: string): Promise<object>
-export async function removeFromAccount (uid: string, accountId: string): Promise<object>
-export async function removeFromAccount (uidOrAccountId: string, accountId?: string): Promise<object> {
-  let uid: string
-  let acctId: string
-
-  // Handle overloaded parameters
-  if (isNullString(accountId)) {
-    // Called with one parameter: removeFromAccount(accountId)
-    uid = resolveUserId()
-    acctId = uidOrAccountId
-  } else {
-    // Called with two parameters: removeFromAccount(uid, accountId)
-    uid = resolveUserId(uidOrAccountId)
-    acctId = accountId as string
-  }
-
-  if (isNullString(acctId)) {
-    throw new EngageError('Account ID missing.')
-  }
-  return await _request(`/users/${uid}/accounts/${acctId}`, null, 'DELETE')
-}
-
-// Overloaded function signatures for changeAccountRole
-export async function changeAccountRole (accountId: string, role: string): Promise<object>
-export async function changeAccountRole (uid: string, accountId: string, role: string): Promise<object>
-export async function changeAccountRole (uidOrAccountId: string, accountIdOrRole: string, role?: string): Promise<object> {
-  let uid: string
-  let accountId: string
-  let newRole: string
-
-  // Handle overloaded parameters
-  if (isNullString(role)) {
-    // Called with two parameters: changeAccountRole(accountId, role)
-    uid = resolveUserId()
-    accountId = uidOrAccountId
-    newRole = accountIdOrRole
-  } else {
-    // Called with three parameters: changeAccountRole(uid, accountId, role)
-    uid = resolveUserId(uidOrAccountId)
-    accountId = accountIdOrRole
-    newRole = role as string
-  }
-
-  if (isNullString(accountId)) {
-    throw new EngageError('Account ID missing.')
-  }
-  if (isNullString(newRole)) {
-    throw new EngageError('New role missing.')
-  }
-  return await _request(`/users/${uid}/accounts/${accountId}`, { role: newRole }, 'PUT')
-}
-
-// Overloaded function signatures for convertToCustomer
-export async function convertToCustomer (): Promise<object>
-export async function convertToCustomer (uid?: string): Promise<object> {
-  const userId = resolveUserId(uid)
-  return await _request(`/users/${userId}/convert`, { type: 'customer' }, 'POST')
-}
-
-// Overloaded function signatures for convertToAccount
-export async function convertToAccount (): Promise<object>
-export async function convertToAccount (uid?: string): Promise<object> {
-  const userId = resolveUserId(uid)
-  return await _request(`/users/${userId}/convert`, { type: 'account' }, 'POST')
-}
-
-// Create an object containing all exports for easy access
-const EngageSDK = {
-  init,
-  identify,
-  addAttribute,
-  track,
-  merge,
-  addToAccount,
-  removeFromAccount,
-  changeAccountRole,
-  convertToCustomer,
-  convertToAccount,
-  request
-}
-
-// Export as default for import EngageSDK syntax
-export default EngageSDK

package/tests/index.test.ts

@@ -1,231 +0,0 @@
-import * as Engage from '../src/index'
-const id = 'uzl38704@omeie.com'
-const sid = 'a6236e83-f7c1-4003-8e1a-951f6e1d5c60'
-const gid = '7d1a5e27-5a6b-4b38-a8bd-e59b8a1b2f41'
-
-describe('Init', () => {
-  test('should throw if no parameters sent', () => {
-    expect(() => {
-      Engage.init()
-    }).toThrow('API')
-  })
-  test('should throw if parameter is empty object', () => {
-    expect(() => {
-      Engage.init({})
-    }).toThrow('key')
-  })
-  test('should throw if empty key sent', () => {
-    expect(() => {
-      Engage.init('')
-    }).toThrow()
-  })
-  test('should not throw if key/secret is sent', () => {
-    expect(() => {
-      Engage.init({
-        key: process.env.KEY,
-        secret: process.env.SECRET
-      })
-    }).not.toThrow()
-  })
-})
-
-describe('Add attribute', () => {
-  test('should throw if no parameter passed', async () => {
-    await expect(Engage.addAttribute()).rejects.toThrow(/id/i)
-  })
-  test('should throw if no data attribute passed', async () => {
-    await expect(Engage.addAttribute(id)).rejects.toThrow(/attributes/i)
-  })
-  test('should throw if empty object passed', async () => {
-    await expect(Engage.addAttribute(id, {})).rejects.toThrow(/attributes/i)
-  })
-  test('should resolve if parameters passed', async () => {
-    await expect(Engage.addAttribute(sid, {
-      first_name: 'Opeyemi',
-      active: true,
-      created_at: '2020-08-11'
-    })).resolves.toMatchObject({
-      uid: sid,
-      first_name: 'Opeyemi'
-    })
-  })
-  test('should turn to account if has is_account', async () => {
-    await expect(Engage.addAttribute(id, {
-      is_account: true
-    })).resolves.toMatchObject({
-      is_account: true
-    })
-  })
-  test('should turn to user if is_account is not added', async () => {
-    await expect(Engage.addAttribute(id, {
-      is_account: false
-    })).resolves.toMatchObject({
-      is_account: false
-    })
-  })
-})
-
-describe('Track', () => {
-  test('should throw if no parameter passed', async () => {
-    await expect(Engage.track()).rejects.toThrow(/id/i)
-  })
-  test('should throw if no data attribute passed', async () => {
-    await expect(Engage.track(id)).rejects.toThrow(/data/i)
-  })
-  test('should throw if empty object passed', async () => {
-    await expect(Engage.track(id, {})).rejects.toThrow(/attributes/i)
-  })
-  test('should pass if string property passed', async () => {
-    await expect(Engage.track(id, 'loggedin')).resolves.toMatchObject({
-      status: 'ok'
-    })
-  })
-  test('should pass if right parameters passed', async () => {
-    await expect(Engage.track(id, {
-      event: 'played',
-      value: 'vid_133',
-      timestamp: '2020-05-30T09:30:10Z'
-    })).resolves.toMatchObject({
-      status: 'ok'
-    })
-  })
-  test('should resolve if other variant passed', async () => {
-    await expect(Engage.track(id, {
-      event: 'loggedin',
-      properties: {
-        ip: '127.0.0.1',
-        referral: 'localhost'
-      }
-    })).resolves.toMatchObject({
-      status: 'ok'
-    })
-  })
-})
-
-describe('Merge users', () => {
-  test('should throw if no source id', async () => {
-    await expect(Engage.merge()).rejects.toThrow(/id/i)
-  })
-  test('should throw if no destination id', async () => {
-    await expect(Engage.merge(id)).rejects.toThrow(/id/i)
-  })
-  test('should merge if all is well', async () => {
-    await expect(Engage.merge(sid, id)).resolves.toMatchObject({
-      status: 'queued'
-    })
-  })
-})
-
-describe('Convert to account', () => {
-  test('should convert to account', async () => {
-    await expect(Engage.convertToAccount(gid)).resolves.toMatchObject({
-      is_account: true
-    })
-  })
-})
-
-describe('Convert to customer', () => {
-  test('should convert to customer', async () => {
-    await expect(Engage.convertToCustomer(gid)).resolves.toMatchObject({
-      is_account: false
-    })
-  })
-})
-
-describe('Add to account', () => {
-  test('should throw if no account id added', async () => {
-    await expect(Engage.addToAccount(id)).rejects.toThrow(/id/i)
-  })
-  test('should throw if role and role not string', async () => {
-    await expect(Engage.addToAccount(id, gid, [ 'something' ])).rejects.toThrow(/Role/)
-  })
-  test('should pass if account id added', async () => {
-    await expect(Engage.addToAccount(id, gid)).resolves.toMatchObject({
-      accounts: [{
-        id: gid
-      }]
-    })
-  })
-})
-
-describe('Change account role', () => {
-  test('should throw if no parameters', async () => {
-    await expect(Engage.changeAccountRole()).rejects.toThrow(/missing/)
-  })
-  test('should throw if no account id', async () => {
-    await expect(Engage.changeAccountRole(id)).rejects.toThrow(/missing/)
-  })
-  test('should throw if no role', async () => {
-    await expect(Engage.changeAccountRole(id, gid)).rejects.toThrow(/missing/)
-  })
-  test('should pass if all parameters set', async () => {
-    await expect(Engage.changeAccountRole(id, gid, 'owner')).resolves.toMatchObject({
-      accounts: [{
-        id: gid,
-        role: 'owner'
-      }]
-    })
-  })
-})
-
-describe('Remove from account', () => {
-  test('should throw if no parameters', async () => {
-    await expect(Engage.removeFromAccount()).rejects.toThrow(/missing/)
-  })
-  test('should throw if no account id', async () => {
-    await expect(Engage.removeFromAccount(id)).rejects.toThrow(/missing/)
-  })
-  test('should pass if all parameters set', async () => {
-    await expect(Engage.removeFromAccount(id, gid)).resolves.toMatchObject({
-      accounts: []
-    })
-  })
-})
-
-describe('Identify', () => {
-  test('should throw if no parameter passed', async () => {
-    await expect(Engage.identify()).rejects.toThrow('object')
-  })
-  test('should throw if empty string passed', async () => {
-    await expect(Engage.identify('')).rejects.toThrow('ID')
-  })
-  test('should throw if empty object passed', async () => {
-    await expect(Engage.identify({})).rejects.toThrow('ID')
-  })
-  test('should not throw if no email passed', async () => {
-    await expect(() => {
-      Engage.identify({ id: gid })
-    }).not.toThrow()
-  })
-  test('should throw if invalid email passed', async () => {
-    await expect(Engage.identify({
-      id,
-      email: 'invalid'
-    })).rejects.toThrow(/email/i)
-  })
-  test('should work if id and email passed', async () => {
-    await expect(Engage.identify({
-      id,
-      email: 'fickledreams@yahoo.com'
-    })).resolves.toMatchObject({
-      uid: id,
-      email: 'fickledreams@yahoo.com'
-    })
-  })
-  test('should turn to account if has is_account', async () => {
-    await expect(Engage.identify({
-      id,
-      is_account: true
-    })).resolves.toMatchObject({
-      is_account: true
-    })
-  })
-  test('should turn to user if is_account is false', async () => {
-    await expect(Engage.identify({
-      id,
-      is_account: false
-    })).resolves.toMatchObject({
-      is_account: false
-    })
-  })
-})

package/tests/oop.test.ts

@@ -1,41 +0,0 @@
-import * as Engage from '../src/index'
-import EngageSDK from '../src/index'
-
-describe('Object-Oriented Pattern', () => {
-  describe('Functional style imports', () => {
-    test('should work with named import init', () => {
-      expect(() => {
-        Engage.init('test-key')
-      }).not.toThrow()
-    })
-
-    test('should work with destructured init', () => {
-      const { init } = Engage
-      expect(() => {
-        init('test-key-2')
-      }).not.toThrow()
-    })
-  })
-
-  describe('Static class style imports', () => {
-    test('should work with default import init', () => {
-      expect(() => {
-        EngageSDK.init('test-key')
-      }).not.toThrow()
-    })
-
-    test('should have all expected methods on default export', () => {
-      expect(typeof EngageSDK.init).toBe('function')
-      expect(typeof EngageSDK.identify).toBe('function')
-      expect(typeof EngageSDK.addAttribute).toBe('function')
-      expect(typeof EngageSDK.track).toBe('function')
-      expect(typeof EngageSDK.merge).toBe('function')
-      expect(typeof EngageSDK.addToAccount).toBe('function')
-      expect(typeof EngageSDK.removeFromAccount).toBe('function')
-      expect(typeof EngageSDK.changeAccountRole).toBe('function')
-      expect(typeof EngageSDK.convertToCustomer).toBe('function')
-      expect(typeof EngageSDK.convertToAccount).toBe('function')
-      expect(typeof EngageSDK.request).toBe('function')
-    })
-  })
-})