santoid-sdk 1.0.6 → 2.0.0

package/src/esm/liveness/index.ts

@@ -1,156 +0,0 @@
-import { type TPositions, type IWebSocketMessage, type TWebSDKOptions } from './utils/types'
-import { SEND_FRAMES_INTERVAL_MS } from '../../utils/constants'
-import { builtInGetNextFrame, type builtInGetNextFrameReturn } from './utils/getNextFrame'
-
-import { connectToWebSocket, disconnectFromWebSocket } from './utils/websocket'
-
-export * from './utils/types'
-
-async function onWebSocketMessage (options: TWebSDKOptions, event: MessageEvent) {
-  const message = event.data
-
-  let messageObj: IWebSocketMessage | undefined
-
-  try {
-    messageObj = JSON.parse(message)
-  } catch (err) {
-    console.error('Cannot parse API message', err)
-  }
-
-  if (messageObj?.next_step && !messageObj.error) {
-    await options.nextStepCallback?.(messageObj.next_step)
-    await options[`${messageObj.next_step}Callback`]?.()
-  }
-
-  if (messageObj?.error) {
-    await options.errorCallback?.({ code: 'wrong-position' })
-  }
-
-  return messageObj
-}
-
-export async function livenessDetection (options: TWebSDKOptions) {
-  type FrameType = Blob | null | undefined
-
-  let websocketClosedBySDK = false
-  let builtInGetNextFrameReturn: builtInGetNextFrameReturn | undefined
-  let validationSuccess = false
-  let endCalled = false
-  let canSendNextBytes = true
-
-  const successFrames: Record<TPositions, FrameType> = {
-    front: undefined,
-    right: undefined,
-    left: undefined,
-    up: undefined,
-    bottom: undefined,
-  }
-
-  let lastSentBytes: FrameType
-  let currentStep: TPositions = 'front'
-
-  async function stopLivenessDetection (options: TWebSDKOptions, websocket?: WebSocket, intervalKey?: any) {
-    if (intervalKey) {
-      clearInterval(intervalKey)
-    }
-
-    if (websocket) {
-      disconnectFromWebSocket(websocket)
-    }
-
-    if (builtInGetNextFrameReturn) {
-      builtInGetNextFrameReturn.stopGetNextFrame()
-    }
-
-    !endCalled && await options.endCallback?.()
-    endCalled = true
-
-    websocketClosedBySDK = true
-  }
-
-  let sendFramesIntervalKey: any
-  let websocket: WebSocket | undefined
-
-  try {
-    websocket = await connectToWebSocket(options)
-
-    await options.nextStepCallback?.('front')
-    await options.frontCallback?.()
-
-    if (!options.getNextFrame && !builtInGetNextFrameReturn) {
-      builtInGetNextFrameReturn = await builtInGetNextFrame()
-    }
-
-    sendFramesIntervalKey = setInterval(async () => {
-      try {
-        if (canSendNextBytes) {
-          let bytes
-
-          if (options.getNextFrame) {
-            bytes = await options.getNextFrame()
-          } else {
-            bytes = await builtInGetNextFrameReturn?.getNextFrame()
-          }
-
-          if (bytes) {
-            websocket?.send(bytes)
-            lastSentBytes = bytes
-            canSendNextBytes = false
-          }
-        }
-      } catch (err) {
-        await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
-      }
-    }, SEND_FRAMES_INTERVAL_MS)
-
-    websocket.addEventListener('message', async (event) => {
-      const parsedMessage = await onWebSocketMessage(options, event)
-
-      if (parsedMessage) {
-        canSendNextBytes = !!parsedMessage?.can_send_next_bytes
-      }
-
-      if (parsedMessage?.validation && currentStep) {
-        successFrames[currentStep] = lastSentBytes
-      }
-
-      if (parsedMessage?.next_step) {
-        currentStep = parsedMessage.next_step
-      }
-
-      if (parsedMessage?.success) {
-        successFrames.bottom = lastSentBytes
-
-        validationSuccess = true
-        await options.successCallback?.<FrameType>({ livenessId: parsedMessage.livenessId, successFrames })
-        await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
-      }
-    })
-
-    websocket.addEventListener('error', async () => {
-      !validationSuccess && options.errorCallback?.({ code: 'internal-error' })
-      await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
-    })
-
-    websocket.addEventListener('close', async () => {
-      if (!websocketClosedBySDK) {
-        !validationSuccess && options.errorCallback?.({ code: 'internal-error' })
-        await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
-      }
-    })
-
-    return {
-      stopLivenessDetection: async () => { await stopLivenessDetection(options, websocket, sendFramesIntervalKey) },
-      videoStream: builtInGetNextFrameReturn?.videoStream,
-    }
-  } catch (err) {
-    !validationSuccess && options.errorCallback?.({ code: 'internal-error' })
-    await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
-    throw err
-  }
-}
-
-// Class for use in browsers
-export default class SantoiDSDK {
-  static livenessDetection = livenessDetection
-}

package/src/esm/liveness/utils/getNextFrame.ts

@@ -1,76 +0,0 @@
-export interface builtInGetNextFrameReturn {
-  getNextFrame: () => Promise<Blob | null>
-  stopGetNextFrame: () => void
-  videoStream: MediaStream | undefined
-}
-
-export async function builtInGetNextFrame (): Promise<builtInGetNextFrameReturn> {
-  let videoStream: MediaStream | undefined
-  let videoElement: HTMLVideoElement | undefined
-  let canvasElement: HTMLCanvasElement | undefined
-  let canvasContext: CanvasRenderingContext2D | null | undefined
-
-  async function getNextFrame (): Promise<Blob | null> {
-    if (canvasElement && videoElement) {
-      canvasElement.width = videoElement.videoWidth
-      canvasElement.height = videoElement.videoHeight
-
-      canvasContext?.drawImage(videoElement, 0, 0, canvasElement.width, canvasElement.height)
-
-      return await new Promise((resolve, reject) => {
-        if (!canvasElement) {
-          resolve(null)
-          return
-        }
-
-        canvasElement.toBlob((blob) => {
-          resolve(blob)
-        })
-      })
-    } else {
-      throw new Error('Cannot found video element')
-    }
-  }
-
-  function stopGetNextFrame () {
-    if (videoElement) {
-      document.body.removeChild(videoElement)
-      videoElement = undefined
-    }
-
-    if (canvasElement) {
-      canvasElement = undefined
-    }
-
-    if (canvasContext) {
-      canvasContext = undefined
-    }
-
-    videoStream?.getTracks().forEach(track => { track.stop() })
-    videoStream = undefined
-  }
-
-  if (!videoStream || !videoElement || !canvasElement) {
-    videoStream = await navigator.mediaDevices.getUserMedia({ video: true })
-
-    videoElement = document.createElement('video')
-    videoElement.setAttribute('autoplay', 'true')
-
-    videoElement.style.transform = 'scale(-1, 1)'
-    videoElement.style.position = 'absolute'
-    videoElement.style.left = '99999px'
-
-    document.body.appendChild(videoElement)
-
-    videoElement.srcObject = videoStream
-
-    canvasElement = document.createElement('canvas')
-    canvasContext = canvasElement.getContext('2d')
-  }
-
-  return {
-    getNextFrame,
-    stopGetNextFrame,
-    videoStream,
-  }
-}

package/src/esm/liveness/utils/index.ts

@@ -1,16 +0,0 @@
-export function decodeJwt (token: string) {
-  const base64Url = token.split('.')[1]
-  const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/')
-
-  const jsonPayload = decodeURIComponent(
-    window
-      .atob(base64)
-      .split('')
-      .map((c) => {
-        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)
-      })
-      .join(''),
-  )
-
-  return JSON.parse(jsonPayload)
-}

package/src/esm/liveness/utils/types.ts

@@ -1,7 +0,0 @@
-import { type ISDKOptions } from '../../../utils/types'
-
-export type TWebSDKOptions = ISDKOptions & {
-  getNextFrame?: () => Promise<Blob | null>
-}
-
-export * from '../../../utils/types'

package/src/esm/liveness/utils/websocket.ts

@@ -1,33 +0,0 @@
-import { decodeJwt } from '.'
-import { WEBSOCKET_BASE_URL } from '../../../utils/constants'
-import { type IDecodedToken, type TWebSDKOptions } from './types'
-
-async function waitForWebSocketConnection (websocket: WebSocket) {
-  await new Promise<void>((resolve) => {
-    const intervalKey = setInterval(() => {
-      if ([3, 1].includes(websocket.readyState)) {
-        clearInterval(intervalKey)
-        resolve()
-      }
-    }, 5)
-  })
-
-  if (websocket.readyState === 3) {
-    throw new Error('Cannot connect to server')
-  }
-}
-
-export async function connectToWebSocket (options: TWebSDKOptions) {
-  const decodedToken: IDecodedToken = decodeJwt(options.token)
-  const query = `?x_endpoint_api_userinfo=${options.token}&domain=${options.domain ?? decodedToken.claims.domain}&track=${options.track}&customerRequestId=${options.customId}`
-
-  const websocket = new WebSocket(`${options.customWebSocketUrl ?? WEBSOCKET_BASE_URL}${query}`)
-  await waitForWebSocketConnection(websocket)
-  return websocket
-}
-
-export function disconnectFromWebSocket (websocket: WebSocket) {
-  if (![2, 3].includes(websocket.readyState)) {
-    websocket.close?.()
-  }
-}

package/src/node/auth/index.ts

@@ -1,43 +0,0 @@
-import fs from 'fs'
-import { API_GATEWAY_URL } from '../../utils/constants'
-
-export interface IInitalizeOptions {
-  customApiUrl?: string
-  credentials?: string | Record<string, string>
-}
-
-export async function initialize (options?: IInitalizeOptions) {
-  let credentialsBase64
-
-  if (options?.credentials) {
-    if (typeof options?.credentials === 'string') {
-      credentialsBase64 = options?.credentials
-    } else if (typeof options?.credentials === 'object') {
-      credentialsBase64 = Buffer.from(JSON.stringify(options?.credentials)).toString('base64')
-    } else {
-      throw new Error('Invalid credentials')
-    }
-  } else {
-    if (process.env.SANTOID_SDK_CREDENTIALS) {
-      credentialsBase64 = fs.readFileSync(process.env.SANTOID_SDK_CREDENTIALS, { encoding: 'base64' })
-    } else {
-      throw new Error('Credentials not found')
-    }
-  }
-
-  if (credentialsBase64) {
-    const response = await fetch(options?.customApiUrl ?? API_GATEWAY_URL, {
-      method: 'POST',
-      body: JSON.stringify({ service_account_base64: credentialsBase64 }),
-      headers: { 'Content-Type': 'application/json' },
-    })
-
-    const token = await response.json()
-
-    if (typeof token !== 'string') {
-      throw new Error('Cannot generate token')
-    }
-
-    return token
-  }
-}

package/src/node/liveness/index.ts

@@ -1,135 +0,0 @@
-import type WebSocket from 'ws'
-import { type Data } from 'ws'
-
-import { type TPositions, type IWebSocketMessage, type TNodeSDKOptions } from './utils/types'
-import { SEND_FRAMES_INTERVAL_MS } from '../../utils/constants'
-import { connectToWebSocket, disconnectFromWebSocket } from './utils/websocket'
-
-async function onWebSocketMessage (options: TNodeSDKOptions, event: { data: string }) {
-  const message = event.data
-
-  let messageObj: IWebSocketMessage | undefined
-
-  try {
-    messageObj = JSON.parse(message)
-  } catch (err) {
-    console.error('Cannot parse API message', err)
-  }
-
-  if (messageObj?.next_step && !messageObj.error) {
-    await options.nextStepCallback?.(messageObj.next_step)
-    await options[`${messageObj.next_step}Callback`]?.()
-  }
-
-  if (messageObj?.error) {
-    await options.errorCallback?.({ code: 'wrong-position' })
-  }
-
-  return messageObj
-}
-
-export async function livenessDetection (options: TNodeSDKOptions) {
-  type FrameType = Data | null | undefined
-
-  let websocketClosedBySDK = false
-  let validationSuccess = false
-  let endCalled = false
-  let canSendNextBytes = true
-
-  const successFrames: Record<TPositions, FrameType> = {
-    front: undefined,
-    right: undefined,
-    left: undefined,
-    up: undefined,
-    bottom: undefined,
-  }
-
-  let lastSentBytes: FrameType
-  let currentStep: TPositions = 'front'
-
-  async function stopLivenessDetection (options: TNodeSDKOptions, websocket?: WebSocket, intervalKey?: any) {
-    if (intervalKey) {
-      clearInterval(intervalKey)
-    }
-
-    if (websocket) {
-      disconnectFromWebSocket(websocket)
-    }
-
-    !endCalled && await options.endCallback?.()
-    endCalled = true
-
-    websocketClosedBySDK = true
-  }
-
-  let sendFramesIntervalKey: any
-  let websocket: WebSocket | undefined
-
-  try {
-    websocket = await connectToWebSocket(options)
-
-    await options.nextStepCallback?.('front')
-    await options.frontCallback?.()
-
-    sendFramesIntervalKey = setInterval(async () => {
-      try {
-        if (canSendNextBytes) {
-          const bytes = await options.getNextFrame()
-
-          if (bytes) {
-            websocket?.send(bytes)
-            lastSentBytes = bytes
-            canSendNextBytes = false
-          }
-        }
-      } catch (err) {
-        await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
-      }
-    }, SEND_FRAMES_INTERVAL_MS)
-
-    websocket.on('message', async (data: string) => {
-      const parsedMessage = await onWebSocketMessage(options, { data: Buffer.from(data).toString() })
-
-      if (parsedMessage) {
-        canSendNextBytes = !!parsedMessage?.can_send_next_bytes
-      }
-
-      if (parsedMessage?.validation && currentStep) {
-        successFrames[currentStep] = lastSentBytes
-      }
-
-      if (parsedMessage?.next_step) {
-        currentStep = parsedMessage.next_step
-      }
-
-      if (parsedMessage?.success) {
-        successFrames.bottom = lastSentBytes
-
-        validationSuccess = true
-        await options.successCallback?.<FrameType>({ livenessId: parsedMessage.livenessId, successFrames })
-        await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
-      }
-    })
-
-    websocket.on('error', async (event) => {
-      !validationSuccess && options.errorCallback?.({ code: 'internal-error' })
-      await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
-    })
-
-    websocket.on('close', async () => {
-      if (!websocketClosedBySDK) {
-        !validationSuccess && options.errorCallback?.({ code: 'internal-error' })
-        await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
-      }
-    })
-
-    return {
-      stopLivenessDetection: async () => { await stopLivenessDetection(options, websocket, sendFramesIntervalKey) },
-    }
-  } catch (err) {
-    console.error('catch error', err)
-    !validationSuccess && options.errorCallback?.({ code: 'internal-error' })
-    await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
-    throw err
-  }
-}

package/src/node/liveness/utils/index.ts

@@ -1,3 +0,0 @@
-export function decodeJwt (token: string) {
-  return JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString())
-}

package/src/node/liveness/utils/types.ts

@@ -1,8 +0,0 @@
-import { type Data } from 'ws'
-import { type ISDKOptions } from '../../../utils/types'
-
-export type TNodeSDKOptions = ISDKOptions & {
-  getNextFrame: () => Promise<Data | null>
-}
-
-export * from '../../../utils/types'

package/src/node/liveness/utils/websocket.ts

@@ -1,35 +0,0 @@
-import WebSocket from 'ws'
-
-import { decodeJwt } from '.'
-import { WEBSOCKET_BASE_URL } from '../../../utils/constants'
-import { type IDecodedToken, type TNodeSDKOptions } from './types'
-
-export async function waitForWebSocketConnection (websocket: WebSocket) {
-  await new Promise<void>((resolve) => {
-    const intervalKey = setInterval(() => {
-      if ([3, 1].includes(websocket.readyState)) {
-        clearInterval(intervalKey)
-        resolve()
-      }
-    }, 5)
-  })
-
-  if (websocket.readyState === 3) {
-    throw new Error('Cannot connect to server')
-  }
-}
-
-export async function connectToWebSocket (options: TNodeSDKOptions) {
-  const decodedToken: IDecodedToken = decodeJwt(options.token)
-  const query = `?x_endpoint_api_userinfo=${options.token}&domain=${options.domain ?? decodedToken.claims.domain}&track=${options.track}&customerRequestId=${options.customId}`
-
-  const websocket = new WebSocket(`${options.customWebSocketUrl ?? WEBSOCKET_BASE_URL}${query}`)
-  await waitForWebSocketConnection(websocket)
-  return websocket
-}
-
-export function disconnectFromWebSocket (websocket: WebSocket) {
-  if (![2, 3].includes(websocket.readyState)) {
-    websocket.close?.()
-  }
-}

package/src/utils/constants.ts

@@ -1,3 +0,0 @@
-export const WEBSOCKET_BASE_URL = 'wss://santoid-liveness-w4ynos5dlq-ue.a.run.app/api/v1/liveness/ws'
-export const API_GATEWAY_URL = 'https://api.santoid.com.br/api/v1/service-account/refresh-token'
-export const SEND_FRAMES_INTERVAL_MS = 100

package/src/utils/types.ts

@@ -1,46 +0,0 @@
-export type TCallbackFunction = (...args: any[]) => void | Promise<void>
-
-export type TPositions = 'front' | 'right' | 'left' | 'up' | 'bottom'
-
-export type TErrorCode = 'wrong-position' | 'internal-error'
-
-export interface IDecodedToken {
-  claims: {
-    domain: string
-  }
-}
-
-interface ILivenessResults<FrameType> {
-  livenessId: string
-  successFrames: Record<TPositions, FrameType>
-}
-
-export interface ISDKOptions {
-  token: string
-  track: string
-  customId?: string
-  domain?: string
-
-  nextStepCallback?: (step: TPositions) => void | Promise<void>
-  frontCallback?: TCallbackFunction
-  rightCallback?: TCallbackFunction
-  leftCallback?: TCallbackFunction
-  upCallback?: TCallbackFunction
-  bottomCallback?: TCallbackFunction
-  errorCallback?: (error: { code: TErrorCode }) => void | Promise<void>
-  successCallback?: <FrameType>(results: ILivenessResults<FrameType>) => void | Promise<void>
-  endCallback?: TCallbackFunction
-
-  customWebSocketUrl?: string
-}
-
-export interface IWebSocketMessage {
-  can_send_next_bytes?: boolean
-  next_step?: TPositions
-  validation?: boolean
-
-  error?: boolean
-
-  success?: boolean
-  livenessId: string
-}