@meshconnect/web-link-sdk 3.2.14 → 3.2.15

package/jest.setup.ts

@@ -0,0 +1,4 @@
+import { TextEncoder, TextDecoder } from 'util';
+
+global.TextEncoder = TextEncoder;
+global.TextDecoder = TextDecoder;

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@meshconnect/web-link-sdk",
-  "version": "3.2.14",
+  "version": "3.2.15",
   "description": "A client-side JS library for integrating with Mesh Connect",
-  "exports": "./index.js",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "exports": "./src/index.ts",
+  "types": "./src/index.ts",
+  "type": "module",
   "license": "MIT",
   "repository": "https://github.com/FrontFin/mesh-web-sdk.git",
   "homepage": "https://github.com/FrontFin/mesh-web-sdk",
@@ -22,12 +26,23 @@
     "util": "^0.12.4"
   },
   "dependencies": {
-    "@meshconnect/node-api": "^2.0.22",
+    "@meshconnect/node-api": "^2.0.16",
     "@meshconnect/solana-web3.js": "^1.0.4",
     "bs58": "^5.0.0",
     "buffer": "^6.0.3",
     "ethers": "^6.11.1"
   },
+  "scripts": {
+    "build": "yarn updateVersion && rimraf dist && yarn build:esm && yarn copy",
+    "build:esm": "tsc --outDir dist",
+    "typecheck": "tsc --noEmit --skipLibCheck",
+    "lint": "eslint **/*.ts",
+    "copy": "node ./tools/copy",
+    "updateVersion": "node ./tools/update-version",
+    "publish:npm": "yarn build && cd dist && yarn publish --access public",
+    "test": "jest",
+    "test:cov": "jest --ci --coverage"
+  },
   "jest": {
     "preset": "ts-jest",
     "testEnvironment": "jsdom",
@@ -56,8 +71,5 @@
     "testEnvironmentOptions": {
       "url": "http://localhost/"
     }
-  },
-  "module": "./index.js",
-  "main": "./index.js",
-  "types": "./index.d.ts"
-}
+  }
+}

package/src/Link.test.ts

@@ -0,0 +1,434 @@
+import { createLink } from './Link'
+import { DoneEvent, LinkEventType } from './utils/event-types'
+import {
+  AccessTokenPayload,
+  DelayedAuthPayload,
+  EventType,
+  LinkPayload,
+  IntegrationAccessToken,
+  TransferFinishedPayload
+} from './utils/types'
+
+type EventPayload = {
+  type: EventType
+  payload?: AccessTokenPayload | DelayedAuthPayload | TransferFinishedPayload
+  message?: string
+  link?: string
+}
+
+const BASE64_ENCODED_URL = Buffer.from('http://localhost/1').toString('base64')
+
+describe('createLink tests', () => {
+  window.open = jest.fn()
+
+  beforeEach(() => {
+    document.getElementsByTagName('html')[0].innerHTML = ''
+  })
+
+  test('createLink when invalid link provided should not open popup', () => {
+    const exitFunction = jest.fn<void, [string | undefined]>()
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: jest.fn(),
+      onExit: exitFunction
+    })
+
+    frontConnection.openLink('')
+
+    expect(exitFunction).toHaveBeenCalledWith('Invalid link token!')
+    const iframeElement = document.getElementById('mesh-link-popup__iframe')
+    expect(iframeElement).toBeFalsy()
+  })
+
+  test('createLink when valid link provided should open popup', () => {
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: jest.fn(),
+      language: 'en'
+    })
+
+    frontConnection.openLink(BASE64_ENCODED_URL)
+    const iframeElement = document.getElementById('mesh-link-popup__iframe')
+    expect(iframeElement).toBeTruthy()
+    expect(iframeElement?.attributes.getNamedItem('src')?.nodeValue).toBe(
+      'http://localhost/1?lng=en'
+    )
+  })
+
+  test('createLink system language is requested then should open popup with correct language', () => {
+    jest.spyOn(navigator, 'language', 'get').mockReturnValue('es-US')
+
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: jest.fn(),
+      language: 'system'
+    })
+
+    frontConnection.openLink(BASE64_ENCODED_URL)
+    const iframeElement = document.getElementById('mesh-link-popup__iframe')
+    expect(iframeElement).toBeTruthy()
+    expect(iframeElement?.attributes.getNamedItem('src')?.nodeValue).toBe(
+      'http://localhost/1?lng=es-US'
+    )
+  })
+
+  test('createLink when valid link provided should open popup with custom iframe id', () => {
+    const customIframeId = 'custom-iframe-id'
+    const customIframeElement = document.createElement('iframe')
+    customIframeElement.id = customIframeId
+    document.body.appendChild(customIframeElement)
+
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: jest.fn(),
+      language: 'en'
+    })
+
+    frontConnection.openLink(BASE64_ENCODED_URL, customIframeId)
+    const iframeElement = document.getElementById('mesh-link-popup__iframe')
+    expect(iframeElement).toBeFalsy()
+
+    expect(customIframeElement.attributes.getNamedItem('src')?.nodeValue).toBe(
+      'http://localhost/1?lng=en'
+    )
+  })
+
+  test('createLink closePopup should close popup', () => {
+    const exitFunction = jest.fn<void, [string | undefined]>()
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: jest.fn(),
+      onExit: exitFunction
+    })
+
+    frontConnection.openLink(BASE64_ENCODED_URL)
+    frontConnection.closeLink()
+
+    const iframeElement = document.getElementById('mesh-link-popup__iframe')
+    expect(iframeElement).toBeFalsy()
+
+    expect(exitFunction).toHaveBeenCalled()
+  })
+
+  test.each(['close', 'done'] as const)(
+    'createLink "%s" event should close popup',
+    eventName => {
+      const exitFunction = jest.fn<void, [string | undefined]>()
+      const frontConnection = createLink({
+        clientId: 'test',
+        onIntegrationConnected: jest.fn(),
+        onExit: exitFunction
+      })
+
+      const payload: DoneEvent['payload'] = {
+        page: 'some page',
+        errorMessage: 'some msg'
+      }
+      frontConnection.openLink(BASE64_ENCODED_URL)
+      window.dispatchEvent(
+        new MessageEvent<LinkEventType>('message', {
+          data: {
+            type: eventName,
+            payload: payload
+          },
+          origin: 'http://localhost'
+        })
+      )
+
+      const iframeElement = document.getElementById('mesh-link-popup__iframe')
+      expect(iframeElement).toBeFalsy()
+
+      expect(exitFunction).toHaveBeenCalledWith('some msg', payload)
+    }
+  )
+
+  test('createLink "brokerageAccountAccessToken" event should send tokens', () => {
+    const onEventHandler = jest.fn<void, [LinkEventType]>()
+    const onBrokerConnectedHandler = jest.fn<void, [LinkPayload]>()
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: onBrokerConnectedHandler,
+      onEvent: onEventHandler
+    })
+
+    frontConnection.openLink(BASE64_ENCODED_URL)
+
+    const payload: AccessTokenPayload = {
+      accountTokens: [],
+      brokerBrandInfo: { brokerLogo: '' },
+      brokerType: 'robinhood',
+      brokerName: 'R'
+    }
+    window.dispatchEvent(
+      new MessageEvent<EventPayload>('message', {
+        data: {
+          type: 'brokerageAccountAccessToken',
+          payload: payload
+        },
+        origin: 'http://localhost'
+      })
+    )
+
+    expect(onEventHandler).toHaveBeenCalledWith({
+      type: 'integrationConnected',
+      payload: { accessToken: payload }
+    })
+    expect(onBrokerConnectedHandler).toHaveBeenCalledWith({
+      accessToken: payload
+    })
+  })
+
+  test('createLink "delayedAuthentication" event should send dalayed tokens', () => {
+    const onEventHandler = jest.fn<void, [LinkEventType]>()
+    const onBrokerConnectedHandler = jest.fn<void, [LinkPayload]>()
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: onBrokerConnectedHandler,
+      onEvent: onEventHandler
+    })
+
+    frontConnection.openLink(BASE64_ENCODED_URL)
+
+    const payload: DelayedAuthPayload = {
+      brokerBrandInfo: { brokerLogo: '' },
+      brokerType: 'robinhood',
+      brokerName: 'R',
+      refreshToken: 'rt'
+    }
+    window.dispatchEvent(
+      new MessageEvent<EventPayload>('message', {
+        data: {
+          type: 'delayedAuthentication',
+          payload: payload
+        },
+        origin: 'http://localhost'
+      })
+    )
+
+    expect(onEventHandler).toHaveBeenCalledWith({
+      type: 'integrationConnected',
+      payload: { delayedAuth: payload }
+    })
+    expect(onBrokerConnectedHandler).toHaveBeenCalledWith({
+      delayedAuth: payload
+    })
+  })
+
+  test('createLink "transferFinished" event should send transfer payload', () => {
+    const onEventHandler = jest.fn<void, [LinkEventType]>()
+    const onTransferFinishedHandler = jest.fn<void, [TransferFinishedPayload]>()
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: jest.fn(),
+      onEvent: onEventHandler,
+      onTransferFinished: onTransferFinishedHandler
+    })
+
+    frontConnection.openLink(BASE64_ENCODED_URL)
+
+    const payload: TransferFinishedPayload = {
+      status: 'success',
+      txId: 'tid',
+      fromAddress: 'fa',
+      toAddress: 'ta',
+      symbol: 'BTC',
+      amount: 0.001,
+      networkId: 'nid',
+      amountInFiat: 9.77,
+      totalAmountInFiat: 10.02,
+      networkName: 'Bitcoin',
+      txHash: 'txHash',
+      transferId: 'trid'
+    }
+    window.dispatchEvent(
+      new MessageEvent<EventPayload>('message', {
+        data: {
+          type: 'transferFinished',
+          payload: payload
+        },
+        origin: 'http://localhost'
+      })
+    )
+
+    expect(onEventHandler).toHaveBeenCalledWith({
+      type: 'transferCompleted',
+      payload: payload
+    })
+    expect(onTransferFinishedHandler).toHaveBeenCalledWith(payload)
+  })
+
+  test('createLink "loaded" event should trigger the passing for tokens', () => {
+    const tokens: IntegrationAccessToken[] = [
+      {
+        accessToken: 'at',
+        accountId: 'aid',
+        accountName: 'an',
+        brokerType: 'acorns',
+        brokerName: 'A'
+      }
+    ]
+    const destinationTokens: IntegrationAccessToken[] = [
+      {
+        accessToken: 'ttoken',
+        accountId: 'tid',
+        accountName: 'tname',
+        brokerType: 'acorns',
+        brokerName: 'tbrokername'
+      }
+    ]
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: jest.fn(),
+      accessTokens: tokens,
+      transferDestinationTokens: destinationTokens
+    })
+
+    frontConnection.openLink(BASE64_ENCODED_URL)
+
+    const iframeElement = document.getElementById(
+      'mesh-link-popup__iframe'
+    ) as HTMLIFrameElement | null
+    expect(iframeElement?.contentWindow).toBeTruthy()
+
+    const postMessageSpy = jest.spyOn(
+      iframeElement?.contentWindow as Window,
+      'postMessage'
+    )
+
+    window.dispatchEvent(
+      new MessageEvent<EventPayload>('message', {
+        data: {
+          type: 'loaded'
+        },
+        origin: 'http://localhost'
+      })
+    )
+
+    const packageJSONContent = JSON.parse(
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      require('fs').readFileSync('package.json', 'utf8')
+    )
+    expect(postMessageSpy).toHaveBeenCalledWith(
+      {
+        type: 'meshSDKSpecs',
+        payload: {
+          platform: 'web',
+          version: packageJSONContent.version,
+          origin: 'http://localhost'
+        }
+      },
+      'http://localhost'
+    )
+
+    expect(postMessageSpy).toHaveBeenCalledWith(
+      { type: 'frontAccessTokens', payload: tokens },
+      'http://localhost'
+    )
+
+    expect(postMessageSpy).toHaveBeenCalledWith(
+      { type: 'frontTransferDestinationTokens', payload: destinationTokens },
+      'http://localhost'
+    )
+  })
+
+  test('createLink "integrationConnected" event should send event', () => {
+    const onEventHandler = jest.fn<void, [LinkEventType]>()
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: jest.fn(),
+      onEvent: onEventHandler
+    })
+
+    frontConnection.openLink(BASE64_ENCODED_URL)
+
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: {
+          type: 'integrationConnected'
+        },
+        origin: 'http://localhost'
+      })
+    )
+
+    expect(onEventHandler).toHaveBeenCalled()
+  })
+
+  test('createLink unknown event should not send any events', () => {
+    const onEventHandler = jest.fn<void, [LinkEventType]>()
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: jest.fn(),
+      onEvent: onEventHandler
+    })
+
+    frontConnection.openLink(BASE64_ENCODED_URL)
+
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: {
+          type: 'unknown'
+        },
+        origin: 'http://localhost'
+      })
+    )
+
+    expect(onEventHandler).not.toHaveBeenCalled()
+  })
+
+  test('createLink "brokerageAccountAccessToken" event should send tokens - used with openLink function', () => {
+    const onEventHandler = jest.fn<void, [LinkEventType]>()
+    const onBrokerConnectedHandler = jest.fn<void, [LinkPayload]>()
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: onBrokerConnectedHandler,
+      onEvent: onEventHandler
+    })
+
+    frontConnection.openLink(
+      Buffer.from('http://localhost/1').toString('base64')
+    )
+
+    const payload: AccessTokenPayload = {
+      accountTokens: [],
+      brokerBrandInfo: { brokerLogo: '' },
+      brokerType: 'robinhood',
+      brokerName: 'R'
+    }
+    window.dispatchEvent(
+      new MessageEvent<EventPayload>('message', {
+        data: {
+          type: 'brokerageAccountAccessToken',
+          payload: payload
+        },
+        origin: 'http://localhost'
+      })
+    )
+
+    expect(onEventHandler).toHaveBeenCalledWith({
+      type: 'integrationConnected',
+      payload: { accessToken: payload }
+    })
+    expect(onBrokerConnectedHandler).toHaveBeenCalledWith({
+      accessToken: payload
+    })
+  })
+
+  test('createLink closeLink should close popup', () => {
+    const exitFunction = jest.fn<void, [string | undefined]>()
+    const frontConnection = createLink({
+      clientId: 'test',
+      onIntegrationConnected: jest.fn(),
+      onExit: exitFunction
+    })
+
+    frontConnection.openLink(
+      Buffer.from('http://localhost/1').toString('base64')
+    )
+    frontConnection.closeLink()
+
+    const iframeElement = document.getElementById('mesh-link-popup__iframe')
+    expect(iframeElement).toBeFalsy()
+
+    expect(exitFunction).toHaveBeenCalled()
+  })
+})