@engage_so/core 2.1.1 → 2.2.0

package/.github/workflows/test.yml

@@ -0,0 +1,75 @@
+name: Test
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch: # Allow manual trigger
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x, 22.x]
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Setup Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    
+    - name: Install dependencies
+      run: npm ci
+    
+    - name: Build project
+      run: npm run build
+    
+    - name: Run tests
+      run: npm test
+      env:
+        KEY: ${{ secrets.ENGAGE_API_KEY }}
+        SECRET: ${{ secrets.ENGAGE_API_SECRET }}
+    
+    - name: Upload test results
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: test-results-node-${{ matrix.node-version }}
+        path: |
+          coverage/
+          test-results.xml
+        retention-days: 7
+
+  build-check:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.x'
+        cache: 'npm'
+    
+    - name: Install dependencies
+      run: npm ci
+    
+    - name: Build project
+      run: npm run build
+    
+    - name: Check build output
+      run: |
+        echo "Checking if dist files were created..."
+        ls -la dist/
+        echo "Checking TypeScript declaration files..."
+        ls -la dist/*.d.ts
+        echo "Build successful!"

package/README.md

@@ -0,0 +1,14 @@
+# Engage JavaScript SDK
+
+Engage is all you need to deliver personalized customer messaging and marketing automation through email, SMS and in-app messaging. The JavaScript SDK allows you to automatically capture user attributes and actions on your site or application.
+
+[Learn more about the JavaScript SDK](https://docs.engage.so/en-us/a/62bbdd2f5bfea4dca4834046-javascript)
+
+## Getting Started
+
+- [Create an Engage account](https://engage.so/) and setup an account to get your API key
+- Follow the [integration guide](https://docs.engage.so/en-us/a/62bbdd2f5bfea4dca4834046-javascript)
+
+## License
+
+MIT

package/jest.config.js

@@ -4,4 +4,4 @@ module.exports = {
   },
   testRegex: '/tests/.*\\.(test|spec)?\\.(ts|tsx)$',
   moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node']
-};
+}

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "@engage_so/core",
-  "version": "2.1.1",
-  "description": "Engage JS core.",
+  "version": "2.2.0",
+  "description": "Engage JavaScript SDK (core)",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
     "test": "NODE_OPTIONS=--experimental-vm-modules jest",
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build"
-  },
-  "publishConfig": {
-    "access": "public"
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "prepare": "npm run build"
   },
   "author": "Engage",
   "license": "MIT",
@@ -23,8 +20,6 @@
     "ts-standard": "^12.0.2"
   },
   "dependencies": {
-    "buffer": "^6.0.3",
     "cross-fetch": "^4.0.0"
-  },
-  "gitHead": "6900dcf5defb812e5182bca56762860c838f5266"
+  }
 }

package/src/index.ts

@@ -8,11 +8,11 @@ if (typeof btoa === 'undefined') {
   }
 }
 
-interface Key {
+export interface Key {
   key?: string
   secret?: string
 }
-interface EventParameter {
+export interface EventParameter {
   event: string
   value?: string | number | Date | boolean
   properties?: {
@@ -20,10 +20,10 @@ interface EventParameter {
   }
   timestamp?: string | number | Date
 }
-type UserAttrParams = {
+export interface UserAttrParams {
   [key: string]: string | number | Date | boolean
 }
-type UserIdentifyParams = UserAttrParams & { id: string }
+export type UserIdentifyParams = UserAttrParams & { id: string }
 type DataParameters = {
   [key: string]: string | number | Date | boolean
 } & {
@@ -31,7 +31,7 @@ type DataParameters = {
     [key: string]: string | number | Date | boolean
   }
 }
-type Methods = 'POST' | 'PUT' | 'DELETE'
+type Methods = 'POST' | 'PUT' | 'DELETE' | 'GET'
 // type UserIdentifyParams = {
 //   id: string
 //   [key: string]: string | number | Date | boolean
@@ -40,21 +40,39 @@ type Methods = 'POST' | 'PUT' | 'DELETE'
 
 // 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'
 
-async function _request (url: string, params: Record<string, any> | null, method: Methods) {
+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 (params) {
+    if (!isNull(params)) {
       o.body = JSON.stringify(params)
     }
     // const response = await ky(url, o)
@@ -62,7 +80,7 @@ async function _request (url: string, params: Record<string, any> | null, method
     const body: any = await response.json()
     let error = 'API connection error'
     if (!response.ok) {
-      if (body && body.error) {
+      if (typeof body?.error === 'string') {
         error = body.error
       }
       return { error }
@@ -74,45 +92,49 @@ async function _request (url: string, params: Record<string, any> | null, method
 }
 // 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 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) {
-  if (!key) {
+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: undefined,
+    key: '',
     secret: ''
   }
   if (typeof key === 'string') {
+    if (key === '') {
+      throw new EngageError('`key` is empty.')
+    }
     options.key = key
   } else {
-    if (!key.key) {
+    if (isNullString(key.key)) {
       throw new EngageError('`key` missing in object.')
     }
-    if (key.key) {
-      options.key = `${key.key}`
-    }
-    if (key.secret) {
-      options.secret = `${key.secret}`
+    options.key = key.key
+    if (!isNullString(key.secret)) {
+      options.secret = key.secret
     }
   }
   // Set auth
-  // auth = Buffer.from(`${options.key}:${options.secret}`).toString('base64')
-  auth = btoa(`${options.key}:${options.secret}`)
+  auth = btoa(`${options.key ?? ''}:${options.secret ?? ''}`)
 }
 
 // Data tracking
-export async function identify (user: UserIdentifyParams) {
-  if (!user) {
+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 (!user.id) {
+  if (isNullString(user.id)) {
     throw new EngageError('ID missing.')
   }
-  if (user.email && (typeof user.email !== 'string' || !/^\S+@\S+$/.test(user.email))) {
+  if (!isNull(user.email) && (typeof user.email !== 'string' || !/^\S+@\S+$/.test(user.email))) {
     throw new EngageError('Email invalid.')
   }
   const params: DataParameters = {}
@@ -125,117 +147,219 @@ export async function identify (user: UserIdentifyParams) {
     }
   }
 
-  return _request(`/users/${user.id}`, params, 'PUT')
+  // Store the user ID for use in other functions
+  currentUserId = user.id
+
+  return await _request(`/users/${user.id}`, params, 'PUT')
 }
-export async function addAttribute (uid: string, attributes: UserAttrParams) {
-  if (!uid) {
-    throw new EngageError('User ID missing.')
+
+// 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 (!attributes) {
+
+  if (isNull(attrs)) {
     throw new EngageError('Attributes missing.')
   }
-  if (!Object.keys(attributes).length) {
+  if (Object.keys(attrs).length === 0) {
     throw new EngageError('Attributes missing.')
   }
   const params: DataParameters = {}
   params.meta = {}
-  for (const k in attributes) {
+  for (const k in attrs) {
     if (notMeta.includes(k)) {
-      params[k] = attributes[k]
+      params[k] = attrs[k]
     } else {
-      params.meta[k] = attributes[k]
+      params.meta[k] = attrs[k]
     }
   }
-  if (!Object.keys(params.meta).length) {
+  if (Object.keys(params.meta).length === 0) {
     delete params.meta
   }
 
-  return _request(`/users/${uid}`, params, 'PUT')
+  return await _request(`/users/${uid}`, params, 'PUT')
 }
-export async function track (uid: string, data: EventParameter) {
-  if (!uid) {
-    throw new EngageError('User ID missing.')
+
+// 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 (!data) {
+
+  if (isNull(eventData)) {
     throw new EngageError('Event data missing.')
   }
-  if (typeof data === 'string') {
-    data = {
-      event: data,
+  if (typeof eventData === 'string') {
+    eventData = {
+      event: eventData,
       value: true
     }
   } else {
-    if (!Object.keys(data).length) {
+    if (Object.keys(eventData).length === 0) {
       throw new EngageError('Attributes missing.')
     }
   }
 
-  return _request(`/users/${uid}/events`, data, 'POST')
+  return await _request(`/users/${uid}/events`, eventData, 'POST')
 }
 
-export async function merge (sourceUid: string, destinationUid: string) {
-  if (!sourceUid) {
-    throw new EngageError('Source ID missing.')
+// 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 (!destinationUid) {
+
+  if (isNullString(destUid)) {
     throw new EngageError('Destination ID missing.')
   }
 
-  return _request(`/users/merge`, {
+  return await _request('/users/merge', {
     source: sourceUid,
-    destination: destinationUid
+    destination: destUid
   }, 'POST')
 }
 
 // Account functions
-export async function addToAccount(uid: string, accountId: string, role: string) {
-  if (!uid) {
+export async function addToAccount (uid: string, accountId: string, role?: string): Promise<object> {
+  if (isNullString(uid)) {
     throw new EngageError('User ID missing.')
   }
-  if (!accountId) {
+  if (isNullString(accountId)) {
     throw new EngageError('Account ID missing.')
   }
-  if (role && typeof role !== 'string') {
+  if (!isNull(role) && typeof role !== 'string') {
     throw new EngageError('Role should be a text.')
   }
   const g: Record<string, string> = {
     id: accountId
   }
-  if (role) {
-    g.role = role
+  if (!isNullString(role)) {
+    g.role = role as string
   }
-  return _request(`/users/${uid}/accounts`, { accounts: [g] }, 'POST')
+  return await _request(`/users/${uid}/accounts`, { accounts: [g] }, 'POST')
 }
-export async function removeFromAccount (uid: string, accountId: string){
-  if (!uid) {
-    throw new EngageError('User ID missing.')
+
+// 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 (!accountId) {
+
+  if (isNullString(acctId)) {
     throw new EngageError('Account ID missing.')
   }
-  return _request(`/users/${uid}/accounts/${accountId}`, null, 'DELETE')
+  return await _request(`/users/${uid}/accounts/${acctId}`, null, 'DELETE')
 }
-export async function changeAccountRole (uid: string, accountId: string, role: string) {
-  if (!uid) {
-    throw new EngageError('User ID missing.')
+
+// 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 (!accountId) {
+
+  if (isNullString(accountId)) {
     throw new EngageError('Account ID missing.')
   }
-  if (!role) {
+  if (isNullString(newRole)) {
     throw new EngageError('New role missing.')
   }
-  return _request(`/users/${uid}/accounts/${accountId}`, { role }, 'PUT')
+  return await _request(`/users/${uid}/accounts/${accountId}`, { role: newRole }, 'PUT')
 }
-export async function convertToCustomer (uid: string) {
-  if (!uid) {
-    throw new EngageError('User ID missing.')
-  }
-  return _request(`/users/${uid}/convert`, { type: 'customer' }, 'POST')
+
+// 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')
 }
-export async function convertToAccount (uid: string) {
-  if (!uid) {
-    throw new EngageError('User ID missing.')
-  }
-  return _request(`/users/${uid}/convert`, { type: 'account' }, '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

@@ -29,57 +29,9 @@ describe('Init', () => {
   })
 })
 
-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')
+    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)
@@ -115,7 +67,7 @@ describe('Add attribute', () => {
 
 describe('Track', () => {
   test('should throw if no parameter passed', async () => {
-    await expect(Engage.track()).rejects.toThrow('ID')
+    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)
@@ -229,3 +181,51 @@ describe('Remove from account', () => {
     })
   })
 })
+
+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

@@ -0,0 +1,41 @@
+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')
+    })
+  })
+})

package/tests/overloads.test.ts

@@ -0,0 +1,133 @@
+import * as Engage from '../src/index'
+
+describe('Function Overloads', () => {
+  beforeEach(() => {
+    // Initialize SDK before each test
+    Engage.init({ key: 'test-key', secret: 'test-secret' })
+  })
+
+  describe('Identify and stored user ID', () => {
+    test('should store user ID when identify is called', async () => {
+      await expect(Engage.identify({ id: 'test-user-123', email: 'test@example.com' }))
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+  })
+
+  describe('addAttribute overloads', () => {
+    test('should work with uid parameter', async () => {
+      await expect(Engage.addAttribute('test-user-123', { name: 'John' }))
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+
+    test('should work without uid parameter after identify', async () => {
+      // First identify to store user ID
+      await Engage.identify({ id: 'test-user-123', email: 'test@example.com' })
+      
+      // Then use addAttribute without uid
+      await expect(Engage.addAttribute({ name: 'John' }))
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+
+    test('should throw error if no stored uid and no uid provided', async () => {
+      // Reset any stored user ID by re-initializing
+      Engage.init({ key: 'test-key', secret: 'test-secret' })
+      
+      await expect(Engage.addAttribute({ name: 'John' }))
+        .rejects.toThrow('User ID missing. Call identify() first or provide a uid parameter.')
+    })
+  })
+
+  describe('track overloads', () => {
+    test('should work with uid parameter', async () => {
+      await expect(Engage.track('test-user-123', { event: 'login' }))
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+
+    test('should work without uid parameter after identify', async () => {
+      // First identify to store user ID
+      await Engage.identify({ id: 'test-user-123', email: 'test@example.com' })
+      
+      // Then use track without uid
+      await expect(Engage.track({ event: 'login' }))
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+
+    test('should throw error if no stored uid and no uid provided', async () => {
+      // Reset any stored user ID by re-initializing
+      Engage.init({ key: 'test-key', secret: 'test-secret' })
+      
+      await expect(Engage.track({ event: 'login' }))
+        .rejects.toThrow('User ID missing. Call identify() first or provide a uid parameter.')
+    })
+  })
+
+  describe('convertToCustomer overloads', () => {
+    test('should work with uid parameter', async () => {
+      await expect((Engage.convertToCustomer as any)('test-user-123'))
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+
+    test('should work without uid parameter after identify', async () => {
+      // First identify to store user ID
+      await Engage.identify({ id: 'test-user-123', email: 'test@example.com' })
+      
+      // Then use convertToCustomer without uid
+      await expect(Engage.convertToCustomer())
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+
+    test('should throw error if no stored uid and no uid provided', async () => {
+      // Reset any stored user ID by re-initializing
+      Engage.init({ key: 'test-key', secret: 'test-secret' })
+      
+      await expect(Engage.convertToCustomer())
+        .rejects.toThrow('User ID missing. Call identify() first or provide a uid parameter.')
+    })
+  })
+
+  describe('merge overloads', () => {
+    test('should work with both source and destination uid', async () => {
+      await expect(Engage.merge('source-user', 'dest-user'))
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+
+    test('should work with destination uid only after identify', async () => {
+      // First identify to store user ID (source)
+      await Engage.identify({ id: 'source-user', email: 'test@example.com' })
+      
+      // Then merge with destination only
+      await expect(Engage.merge('dest-user'))
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+
+    test('should throw error if no stored uid and only destination provided', async () => {
+      // Reset any stored user ID by re-initializing
+      Engage.init({ key: 'test-key', secret: 'test-secret' })
+      
+      await expect(Engage.merge('dest-user'))
+        .rejects.toThrow('User ID missing. Call identify() first or provide a uid parameter.')
+    })
+  })
+
+  describe('account management overloads', () => {
+    test('removeFromAccount should work with both signatures', async () => {
+      await expect(Engage.removeFromAccount('user-id', 'account-id'))
+        .resolves.toMatchObject({ error: expect.any(String) })
+      
+      // After identify
+      await Engage.identify({ id: 'user-id', email: 'test@example.com' })
+      await expect(Engage.removeFromAccount('account-id'))
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+
+    test('changeAccountRole should work with both signatures', async () => {
+      await expect(Engage.changeAccountRole('user-id', 'account-id', 'owner'))
+        .resolves.toMatchObject({ error: expect.any(String) })
+      
+      // After identify
+      await Engage.identify({ id: 'user-id', email: 'test@example.com' })
+      await expect(Engage.changeAccountRole('account-id', 'owner'))
+        .resolves.toMatchObject({ error: expect.any(String) })
+    })
+  })
+})

package/tests/overriding.test.ts

@@ -0,0 +1,121 @@
+import * as Engage from '../src/index'
+import EngageSDK from '../src/index'
+
+describe('Method Overriding', () => {
+  describe('Individual function exports', () => {
+    test('should allow access to original init function', () => {
+      expect(() => {
+        Engage.init('test-key')
+      }).not.toThrow()
+    })
+
+    test('should allow method overriding by replacing function', async () => {
+      // Save original function
+      const originalTrack = Engage.track
+
+      // Create a mock function to override with
+      const customTrack = jest.fn().mockImplementation(async (uidOrData: any, data?: any) => {
+        // Call original function for proper behavior
+        const result = await originalTrack(uidOrData, data)
+        // Add custom flag to result
+        return { ...result, customFlag: 'overridden' }
+      })
+
+      // Override the function
+      ;(Engage as any).track = customTrack
+
+      // Test the overridden function
+      try {
+        const result = await (Engage as any).track('user123', { event: 'test-event' })
+        expect(result).toHaveProperty('customFlag', 'overridden')
+        expect(customTrack).toHaveBeenCalledWith('user123', { event: 'test-event' })
+      } catch (error) {
+        // Expected to fail due to API authentication, but should still call our custom function
+        expect(customTrack).toHaveBeenCalledWith('user123', { event: 'test-event' })
+      }
+
+      // Restore original function
+      ;(Engage as any).track = originalTrack
+    })
+
+    test('should maintain function reference integrity', () => {
+      const trackFunction = Engage.track
+      expect(typeof trackFunction).toBe('function')
+      expect(trackFunction).toBe(Engage.track)
+    })
+  })
+
+  describe('Default export overriding', () => {
+    test('should work with default export init', () => {
+      expect(() => {
+        EngageSDK.init('test-key-2')
+      }).not.toThrow()
+    })
+
+    test('should allow method overriding on default export', async () => {
+      // Save original function
+      const originalIdentify = EngageSDK.identify
+
+      // Create a mock function
+      const customIdentify = jest.fn().mockImplementation(async (user: any) => {
+        const result = await originalIdentify(user)
+        return { ...result, customProcessed: true }
+      })
+
+      // Override the function
+      ;(EngageSDK as any).identify = customIdentify
+
+      // Test the overridden function
+      try {
+        const result = await (EngageSDK as any).identify({ id: 'test-user', email: 'test@example.com' })
+        expect(result).toHaveProperty('customProcessed', true)
+        expect(customIdentify).toHaveBeenCalledWith({ id: 'test-user', email: 'test@example.com' })
+      } catch (error) {
+        // Expected to fail due to API authentication, but should still call our custom function
+        expect(customIdentify).toHaveBeenCalledWith({ id: 'test-user', email: 'test@example.com' })
+      }
+
+      // Restore original function
+      ;(EngageSDK as any).identify = originalIdentify
+    })
+
+    test('should have consistent function references between named and default exports', () => {
+      expect(typeof EngageSDK.init).toBe('function')
+      expect(typeof EngageSDK.track).toBe('function')
+      expect(typeof EngageSDK.identify).toBe('function')
+    })
+  })
+
+  describe('Overriding behavior validation', () => {
+    test('should allow chaining of overridden methods', async () => {
+      const originalAddAttribute = Engage.addAttribute
+
+      // First override
+      const firstOverride = jest.fn().mockImplementation(async (uidOrAttrs: any, attrs?: any) => {
+        const result = await (originalAddAttribute as any)(uidOrAttrs, attrs)
+        return { ...result, step1: 'complete' }
+      })
+
+      // Second override that calls first override
+      const secondOverride = jest.fn().mockImplementation(async (uidOrAttrs: any, attrs?: any) => {
+        const result = await firstOverride(uidOrAttrs, attrs)
+        return { ...result, step2: 'complete' }
+      })
+
+      ;(Engage as any).addAttribute = secondOverride
+
+      try {
+        await (Engage as any).addAttribute('test-user', { name: 'Test' })
+        expect(secondOverride).toHaveBeenCalled()
+        expect(firstOverride).toHaveBeenCalled()
+      } catch (error) {
+        // Expected to fail but should still call our functions
+        expect(secondOverride).toHaveBeenCalled()
+        expect(firstOverride).toHaveBeenCalled()
+      }
+
+      // Restore
+      ;(Engage as any).addAttribute = originalAddAttribute
+    })
+  })
+})

package/tsconfig.json

@@ -4,7 +4,7 @@
     "module": "NodeNext",
     "declaration": true,
     "declarationMap": true,
-    "outDir": "./dist",
+    "outDir": "./dist/",
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "strict": true,
@@ -12,7 +12,6 @@
   },
   "exclude": [
     "node_modules",
-    "tests",
-    "dist"
+    "tests"
   ]
 }

package/.eslintignore

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

package/dist/error.d.ts

@@ -1,4 +0,0 @@
-export declare class EngageError extends Error {
-    constructor(message: string);
-}
-//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAY,SAAQ,KAAK;gBACvB,OAAO,EAAE,MAAM;CAI7B"}

package/dist/error.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EngageError = void 0;
-class EngageError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'EngageError';
-    }
-}
-exports.EngageError = EngageError;

package/dist/index.d.ts

@@ -1,32 +0,0 @@
-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 Methods = 'POST' | 'PUT' | 'DELETE';
-export declare function request(url: string, params: Record<string, any> | null, method: Methods): object;
-export declare function init(key: Key | string): void;
-export declare function identify(user: UserIdentifyParams): Promise<any>;
-export declare function addAttribute(uid: string, attributes: UserAttrParams): Promise<any>;
-export declare function track(uid: string, data: EventParameter): Promise<any>;
-export declare function merge(sourceUid: string, destinationUid: string): Promise<any>;
-export declare function addToAccount(uid: string, accountId: string, role: string): Promise<any>;
-export declare function removeFromAccount(uid: string, accountId: string): Promise<any>;
-export declare function changeAccountRole(uid: string, accountId: string, role: string): Promise<any>;
-export declare function convertToCustomer(uid: string): Promise<any>;
-export declare function convertToAccount(uid: string): Promise<any>;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,UAAU,GAAG;IACX,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AACD,UAAU,cAAc;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,CAAA;IACxC,UAAU,CAAC,EAAE;QACX,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,CAAA;KAChD,CAAA;IACD,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;CACnC;AACD,KAAK,cAAc,GAAG;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,CAAA;CAChD,CAAA;AACD,KAAK,kBAAkB,GAAG,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAQzD,KAAK,OAAO,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAA;AA2CxC,wBAAgB,OAAO,CAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAEjG;AAED,wBAAgB,IAAI,CAAE,GAAG,EAAE,GAAG,GAAG,MAAM,QAwBtC;AAGD,wBAAsB,QAAQ,CAAE,IAAI,EAAE,kBAAkB,gBAqBvD;AACD,wBAAsB,YAAY,CAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,gBAwB1E;AACD,wBAAsB,KAAK,CAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,gBAmB7D;AAED,wBAAsB,KAAK,CAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,gBAYrE;AAGD,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,gBAiB9E;AACD,wBAAsB,iBAAiB,CAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,gBAQtE;AACD,wBAAsB,iBAAiB,CAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,gBAWpF;AACD,wBAAsB,iBAAiB,CAAE,GAAG,EAAE,MAAM,gBAKnD;AACD,wBAAsB,gBAAgB,CAAE,GAAG,EAAE,MAAM,gBAKlD"}

package/dist/index.js

@@ -1,256 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToAccount = exports.convertToCustomer = exports.changeAccountRole = exports.removeFromAccount = exports.addToAccount = exports.merge = exports.track = exports.addAttribute = exports.identify = exports.init = exports.request = void 0;
-const buffer_1 = require("buffer");
-const cross_fetch_1 = __importDefault(require("cross-fetch"));
-const error_1 = require("./error");
-if (typeof btoa === 'undefined') {
-    global.btoa = function (str) {
-        return buffer_1.Buffer.from(str).toString('base64');
-    };
-}
-// type UserIdentifyParams = {
-//   id: string
-//   [key: string]: string | number | Date | boolean
-// }
-// type UserAttrParams = Omit<UserIdentifyParams, 'id'>
-// const rootURL = 'https://api.engage.so/v1'
-let auth = '';
-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 _request(url, params, method) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const o = {
-                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 = yield (0, cross_fetch_1.default)(`${apiRoot}${url}`, o);
-            const body = yield 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
-function request(url, params, method) {
-    return _request(url, params, method);
-}
-exports.request = request;
-function init(key) {
-    if (!key) {
-        throw new error_1.EngageError('You need to pass in your API key(s).');
-    }
-    const options = {
-        key: undefined,
-        secret: ''
-    };
-    if (typeof key === 'string') {
-        options.key = key;
-    }
-    else {
-        if (!key.key) {
-            throw new error_1.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}`);
-}
-exports.init = init;
-// Data tracking
-function identify(user) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!user) {
-            throw new error_1.EngageError('You need to pass an object with at least an id.');
-        }
-        if (!user.id) {
-            throw new error_1.EngageError('ID missing.');
-        }
-        if (user.email && (typeof user.email !== 'string' || !/^\S+@\S+$/.test(user.email))) {
-            throw new error_1.EngageError('Email invalid.');
-        }
-        const params = {};
-        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');
-    });
-}
-exports.identify = identify;
-function addAttribute(uid, attributes) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!uid) {
-            throw new error_1.EngageError('User ID missing.');
-        }
-        if (!attributes) {
-            throw new error_1.EngageError('Attributes missing.');
-        }
-        if (!Object.keys(attributes).length) {
-            throw new error_1.EngageError('Attributes missing.');
-        }
-        const params = {};
-        params.meta = {};
-        for (const k in attributes) {
-            if (notMeta.includes(k)) {
-                params[k] = attributes[k];
-            }
-            else {
-                params.meta[k] = attributes[k];
-            }
-        }
-        if (!Object.keys(params.meta).length) {
-            delete params.meta;
-        }
-        return _request(`/users/${uid}`, params, 'PUT');
-    });
-}
-exports.addAttribute = addAttribute;
-function track(uid, data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!uid) {
-            throw new error_1.EngageError('User ID missing.');
-        }
-        if (!data) {
-            throw new error_1.EngageError('Event data missing.');
-        }
-        if (typeof data === 'string') {
-            data = {
-                event: data,
-                value: true
-            };
-        }
-        else {
-            if (!Object.keys(data).length) {
-                throw new error_1.EngageError('Attributes missing.');
-            }
-        }
-        return _request(`/users/${uid}/events`, data, 'POST');
-    });
-}
-exports.track = track;
-function merge(sourceUid, destinationUid) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!sourceUid) {
-            throw new error_1.EngageError('Source ID missing.');
-        }
-        if (!destinationUid) {
-            throw new error_1.EngageError('Destination ID missing.');
-        }
-        return _request(`/users/merge`, {
-            source: sourceUid,
-            destination: destinationUid
-        }, 'POST');
-    });
-}
-exports.merge = merge;
-// Account functions
-function addToAccount(uid, accountId, role) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!uid) {
-            throw new error_1.EngageError('User ID missing.');
-        }
-        if (!accountId) {
-            throw new error_1.EngageError('Account ID missing.');
-        }
-        if (role && typeof role !== 'string') {
-            throw new error_1.EngageError('Role should be a text.');
-        }
-        const g = {
-            id: accountId
-        };
-        if (role) {
-            g.role = role;
-        }
-        return _request(`/users/${uid}/accounts`, { accounts: [g] }, 'POST');
-    });
-}
-exports.addToAccount = addToAccount;
-function removeFromAccount(uid, accountId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!uid) {
-            throw new error_1.EngageError('User ID missing.');
-        }
-        if (!accountId) {
-            throw new error_1.EngageError('Account ID missing.');
-        }
-        return _request(`/users/${uid}/accounts/${accountId}`, null, 'DELETE');
-    });
-}
-exports.removeFromAccount = removeFromAccount;
-function changeAccountRole(uid, accountId, role) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!uid) {
-            throw new error_1.EngageError('User ID missing.');
-        }
-        if (!accountId) {
-            throw new error_1.EngageError('Account ID missing.');
-        }
-        if (!role) {
-            throw new error_1.EngageError('New role missing.');
-        }
-        return _request(`/users/${uid}/accounts/${accountId}`, { role }, 'PUT');
-    });
-}
-exports.changeAccountRole = changeAccountRole;
-function convertToCustomer(uid) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!uid) {
-            throw new error_1.EngageError('User ID missing.');
-        }
-        return _request(`/users/${uid}/convert`, { type: 'customer' }, 'POST');
-    });
-}
-exports.convertToCustomer = convertToCustomer;
-function convertToAccount(uid) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!uid) {
-            throw new error_1.EngageError('User ID missing.');
-        }
-        return _request(`/users/${uid}/convert`, { type: 'account' }, 'POST');
-    });
-}
-exports.convertToAccount = convertToAccount;