@engage_so/core 1.6.0 → 2.0.0

package/.eslintignore

@@ -0,0 +1,3 @@
+dist
+node_modules
+tests

package/jest.config.js

@@ -0,0 +1,7 @@
+module.exports = {
+  transform: {
+    '^.+\\.ts?$': ['ts-jest', { diagnostics: false }]
+  },
+  testRegex: '/tests/.*\\.(test|spec)?\\.(ts|tsx)$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node']
+};

package/package.json

@@ -1,22 +1,29 @@
 {
   "name": "@engage_so/core",
-  "version": "1.6.0",
-  "description": "Event driven customer segmentation and targeted engagement.",
-  "main": "index.js",
+  "version": "2.0.0",
+  "description": "Engage JS core.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "test": "jest"
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
   },
   "publishConfig": {
     "access": "public"
   },
   "author": "Engage",
   "license": "MIT",
-  "dependencies": {
-    "buffer": "^6.0.3",
-    "cross-fetch": "^3.1.5"
-  },
   "devDependencies": {
-    "jest": "^26.4.2"
+    "@tsconfig/recommended": "^1.0.3",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.19",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-standard": "^12.0.2"
+  },
+  "dependencies": {
+    "cross-fetch": "^4.0.0"
   },
-  "gitHead": "7db0b36d47cee47daf1bb9412ced6bec0f23462b"
+  "gitHead": "ecc6ef9a3277da36b56fb4169dbfafbdde9b926b"
 }

package/src/error.ts

@@ -0,0 +1,6 @@
+export class EngageError extends Error {
+  constructor (message: string) {
+    super(message)
+    this.name = 'EngageError'
+  }
+}

package/src/index.ts

@@ -0,0 +1,242 @@
+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')
+  }
+}
+
+interface Key {
+  key?: string
+  secret?: string
+}
+interface EventParameter {
+  event: string
+  value?: string | number | Date | boolean
+  properties?: {
+    [key: string]: string | number | Date | boolean
+  }
+  timestamp?: string | number | Date
+}
+type UserAttrParams = {
+  [key: string]: string | number | Date | boolean
+}
+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'
+// 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 = ''
+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/'
+
+async function _request (url: string, params: Record<string, any> | null, method: Methods) {
+  try {
+    const o: any = {
+      method,
+      headers: {
+        'Content-Type': 'application/json;charset=utf-8',
+        Authorization: `Basic ${auth}`
+      },
+      // throwHttpErrors: false,
+      // prefixUrl: rootURL
+    }
+    if (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 (body && body.error) {
+        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 function request (url: string, params: Record<string, any> | null, method: Methods): object {
+  return _request(url, params, method)
+}
+
+export function init (key: Key | string) {
+  if (!key) {
+    throw new EngageError('You need to pass in your API key(s).')
+  }
+  const options: Key = {
+    key: undefined,
+    secret: ''
+  }
+  if (typeof key === 'string') {
+    options.key = key
+  } else {
+    if (!key.key) {
+      throw new EngageError('`key` missing in object.')
+    }
+    if (key.key) {
+      options.key = `${key.key}`
+    }
+    if (key.secret) {
+      options.secret = `${key.secret}`
+    }
+  }
+  // Set auth
+  // auth = Buffer.from(`${options.key}:${options.secret}`).toString('base64')
+  auth = btoa(`${options.key}:${options.secret}`)
+}
+
+// Data tracking
+export async function identify (user: UserIdentifyParams) {
+  if (!user) {
+    throw new EngageError('You need to pass an object with at least an id.')
+  }
+  if (!user.id) {
+    throw new EngageError('ID missing.')
+  }
+  if (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]
+    }
+  }
+
+  return _request(`users/${user.id}`, params, 'PUT')
+}
+export async function addAttribute (uid: string, attributes: UserAttrParams) {
+  if (!uid) {
+    throw new EngageError('User ID missing.')
+  }
+  if (!attributes) {
+    throw new EngageError('Attributes missing.')
+  }
+  if (!Object.keys(attributes).length) {
+    throw new EngageError('Attributes missing.')
+  }
+  const params: DataParameters = {}
+  params.meta = {}
+  for (const k in attributes) {
+    if (notMeta.includes(k)) {
+      params[k] = attributes[k]
+    } else {
+      params.meta[k] = attributes[k]
+      Object.assign(params.meta, k, attributes[k])
+    }
+  }
+  if (Object.keys(params.meta).length) {
+    delete params.meta
+  }
+
+  return _request(`users/${uid}`, params, 'PUT')
+}
+export async function track (uid: string, data: EventParameter) {
+  if (!uid) {
+    throw new EngageError('User ID missing.')
+  }
+  if (!data) {
+    throw new EngageError('Event data missing.')
+  }
+  if (typeof data === 'string') {
+    data = {
+      event: data,
+      value: true
+    }
+  } else {
+    if (!Object.keys(data).length) {
+      throw new EngageError('Attributes missing.')
+    }
+  }
+
+  return _request(`users/${uid}/events`, data, 'POST')
+}
+
+export async function merge (sourceUid: string, destinationUid: string) {
+  if (!sourceUid) {
+    throw new EngageError('Source ID missing.')
+  }
+  if (!destinationUid) {
+    throw new EngageError('Destination ID missing.')
+  }
+
+  return _request(`users/merge`, {
+    source: sourceUid,
+    destination: destinationUid
+  }, 'POST')
+}
+
+// Account functions
+export async function addToAccount(uid: string, accountId: string, role: string) {
+  if (!uid) {
+    throw new EngageError('User ID missing.')
+  }
+  if (!accountId) {
+    throw new EngageError('Account ID missing.')
+  }
+  if (role && typeof role !== 'string') {
+    throw new EngageError('Role should be a text.')
+  }
+  const g: Record<string, string> = {
+    id: accountId
+  }
+  if (role) {
+    g.role = role
+  }
+  return _request(`users/${uid}/accounts`, { accounts: [g] }, 'POST')
+}
+export async function removeFromAccount (uid: string, accountId: string){
+  if (!uid) {
+    throw new EngageError('User ID missing.')
+  }
+  if (!accountId) {
+    throw new EngageError('Account ID missing.')
+  }
+  return _request(`users/${uid}/accounts/${accountId}`, null, 'DELETE')
+}
+export async function changeAccountRole (uid: string, accountId: string, role: string) {
+  if (!uid) {
+    throw new EngageError('User ID missing.')
+  }
+  if (!accountId) {
+    throw new EngageError('Account ID missing.')
+  }
+  if (!role) {
+    throw new EngageError('New role missing.')
+  }
+  return _request(`users/${uid}/accounts/${accountId}`, { role }, 'PUT')
+}
+export async function convertToCustomer (uid: string) {
+  if (!uid) {
+    throw new EngageError('User ID missing.')
+  }
+  return _request(`users/${uid}/convert`, { type: 'customer' }, 'POST')
+}
+export async function convertToAccount (uid: string) {
+  if (!uid) {
+    throw new EngageError('User ID missing.')
+  }
+  return _request(`users/${uid}/convert`, { type: 'account' }, 'POST')
+}

package/tests/index.test.ts

@@ -0,0 +1,231 @@
+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('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/i)
+  })
+  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
+    })
+  })
+})
+
+describe('Add attribute', () => {
+  test('should throw if no parameter passed', async () => {
+    await expect(Engage.addAttribute()).rejects.toThrow('id')
+  })
+  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')
+  })
+  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: []
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2015",
+    "module": "NodeNext",
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "exclude": [
+    "node_modules",
+    "tests",
+    "dist"
+  ]
+}

package/error.js

@@ -1,8 +0,0 @@
-class EngageError extends Error {
-  constructor (message, cause) {
-    super(message)
-    this.cause = cause
-    this.name = 'EngageError'
-  }
-}
-module.exports = EngageError

package/index.js

@@ -1,204 +0,0 @@
-const fetch = require('cross-fetch')
-const Buffer = require('buffer/').Buffer
-const EngageError = require('./error')
-const root = 'https://api.engage.so/v1'
-if (typeof btoa === 'undefined') {
-  global.btoa = function (str) {
-    return Buffer.from(str).toString('base64')
-  }
-}
-
-const options = {
-  key: null,
-  secret: ''
-}
-
-async function _request (url, params, method) {
-  try {
-    const o = {
-      method,
-      headers: {
-        'Content-Type': 'application/json;charset=utf-8',
-        Authorization: `Basic ${btoa(`${options.key}:${options.secret}`)}`
-      },
-    }
-    if (params) {
-      o.body = JSON.stringify(params)
-    }
-    const response = await fetch(url, o)
-    const body = await response.json()
-    let error = 'API connection error'
-    if (!response.ok) {
-      if (body && body.error) {
-        error = body.error
-      }
-      return { error }
-    }
-    return body
-  } catch (e) {
-    // console.log(e)
-    return { error: 'API connection error' }
-  }
-}
-
-// Alias of _request method
-// Same with _request for now but can later have modifications
-const request = (url, params, method) => {
-  return _request(`${root}${url}`, params, method)
-}
-
-const init = (o) => {
-  if (!o) {
-    throw new EngageError('You need to pass in your API key.')
-  }
-  if (typeof o === 'string') {
-    options.key = o
-    return
-  }
-
-  if (!o.key) {
-    throw new EngageError('`key` missing in object.')
-  }
-  if (o.key) {
-    options.key = `${o.key}`
-  }
-  if (o.secret) {
-    options.secret = `${o.secret}`
-  }
-}
-
-const identify = async (o) => {
-  if (!o) {
-    throw new EngageError('You need to pass an object with at least an id and email.')
-  }
-  if (!o.id) {
-    throw new EngageError('ID missing.')
-  }
-  if (o.email && !/^\S+@\S+$/.test(o.email)) {
-    throw new EngageError('Email invalid.')
-  }
-  const allowed = ['id', 'is_account', 'email', 'number', 'created_at', 'device_token', 'device_platform', 'first_name', 'last_name']
-  const params = {
-    meta: {}
-  }
-  for (const k in o) {
-    if (allowed.includes(k)) {
-      params[k] = o[k]
-    } else {
-      params.meta[k] = o[k]
-    }
-  }
-
-  return _request(`${root}/users/${o.id}`, params, 'PUT')
-}
-
-const addAttribute = async (uid, data) => {
-  if (!uid) {
-    throw new EngageError('User id missing.')
-  }
-  if (!data) {
-    throw new EngageError('Attributes missing.')
-  }
-  if (!Object.keys(data).length) {
-    throw new EngageError('Attributes missing.')
-  }
-  const notMeta = ['created_at', 'is_account', 'number', 'device_token', 'device_platform', 'email', 'first_name', 'last_name']
-  const params = { meta: {} }
-  for (const k in data) {
-    if (notMeta.includes(k)) {
-      params[k] = data[k]
-    } else {
-      params.meta[k] = data[k]
-    }
-  }
-
-  return _request(`${root}/users/${uid}`, params, 'PUT')
-}
-
-const track = async (uid, data) => {
-  if (!uid) {
-    throw new EngageError('User id missing.')
-  }
-  if (!data) {
-    throw new EngageError('Attributes missing.')
-  }
-  if (typeof data === 'string') {
-    data = {
-      event: data,
-      value: true
-    }
-  } else {
-    if (!Object.keys(data).length) {
-      throw new EngageError('Attributes missing.')
-    }
-  }
-
-  return _request(`${root}/users/${uid}/events`, data, 'POST')
-}
-
-const addToAccount = async (uid, gid, role) => {
-  if (!uid) {
-    throw new EngageError('User id missing.')
-  }
-  if (!gid) {
-    throw new EngageError('Account id missing.')
-  }
-  if (role && typeof role !== 'string') {
-    throw new EngageError('Role should be a text.')
-  }
-  const g = {
-    id: gid
-  }
-  if (role) {
-    g.role = role
-  }
-  return _request(`${root}/users/${uid}/accounts`, { accounts: [g] }, 'POST')
-}
-const removeFromAccount = async (uid, gid) => {
-  if (!uid) {
-    throw new EngageError('User id missing.')
-  }
-  if (!gid) {
-    throw new EngageError('Account id missing.')
-  }
-  return _request(`${root}/users/${uid}/accounts/${gid}`, null, 'DELETE')
-}
-
-const changeAccountRole = async (uid, gid, role) => {
-  if (!uid) {
-    throw new EngageError('User id missing.')
-  }
-  if (!gid) {
-    throw new EngageError('Account id missing.')
-  }
-  if (!role) {
-    throw new EngageError('New role missing.')
-  }
-  return _request(`${root}/users/${uid}/accounts/${gid}`, { role }, 'PUT')
-}
-
-const convertToCustomer = async (uid) => {
-  if (!uid) {
-    throw new EngageError('User id missing.')
-  }
-  return _request(`${root}/users/${uid}/convert`, { type: 'customer' }, 'POST')
-}
-const convertToAccount = async (uid) => {
-  if (!uid) {
-    throw new EngageError('User id missing.')
-  }
-  return _request(`${root}/users/${uid}/convert`, { type: 'account' }, 'POST')
-}
-
-module.exports = {
-  init,
-  identify,
-  addAttribute,
-  track,
-  request,
-  addToAccount,
-  removeFromAccount,
-  changeAccountRole,
-  convertToCustomer,
-  convertToAccount
-}