santoid-sdk 1.0.0

package/src/node/liveness/index.ts

@@ -0,0 +1,112 @@
+import type WebSocket from 'ws'
+
+import { 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) {
+  let websocketClosedBySDK = false
+  let validationSuccess = false
+  let endCalled = false
+
+  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?.()
+
+    let lastMessage: IWebSocketMessage | undefined
+
+    sendFramesIntervalKey = setInterval(async () => {
+      try {
+        if (lastMessage?.can_send_next_bytes) {
+          const bytes = await options.getNextFrame()
+
+          if (bytes) {
+            websocket?.send(bytes)
+          }
+        }
+      } 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) {
+        lastMessage = parsedMessage
+      }
+
+      if (parsedMessage?.success) {
+        validationSuccess = true
+        await options.successCallback?.()
+        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)
+      }
+    })
+
+    lastMessage = { can_send_next_bytes: true }
+
+    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

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

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,35 @@
+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=${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

@@ -0,0 +1,3 @@
+export const WEBSOCKET_BASE_URL = 'ws://santoid-liveness-w4ynos5dlq-ue.a.run.app/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

@@ -0,0 +1,36 @@
+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
+  }
+}
+
+export interface ISDKOptions {
+  token: string
+  track: string
+  customId?: 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?: TCallbackFunction
+  endCallback?: TCallbackFunction
+
+  customWebSocketUrl?: string
+}
+
+export interface IWebSocketMessage {
+  success?: boolean
+  error?: boolean
+  can_send_next_bytes?: boolean
+  next_step?: TPositions
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "typeRoots": ["@types", "./node_modules/@types"],
+    "module": "commonjs",
+    "target": "es2017",
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "baseUrl": "./",
+    "declaration": true,
+    "esModuleInterop": true,
+    "strictNullChecks": true,
+  },
+
+  "include": ["**/*.ts", "./.eslintrc.js", "./webpack.config.cjs"],
+}

package/webpack.config.cjs

@@ -0,0 +1,56 @@
+const path = require('path')
+
+const { CleanWebpackPlugin } = require('clean-webpack-plugin')
+
+const generalConfig = {
+  watchOptions: {
+    aggregateTimeout: 600,
+    ignored: /node_modules/,
+  },
+  plugins: [
+    new CleanWebpackPlugin({
+      cleanStaleWebpackAssets: false,
+      cleanOnceBeforeBuildPatterns: [
+        path.resolve(__dirname, './dist/browser/liveness'),
+      ],
+    }),
+  ],
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+    ],
+  },
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js'],
+  },
+}
+
+const browserConfig = {
+  entry: './src/esm/liveness/index.ts',
+  target: 'web',
+  output: {
+    path: path.resolve(__dirname, './dist/browser/liveness'),
+    filename: 'index.js',
+    libraryTarget: 'umd',
+    globalObject: 'this',
+    libraryExport: 'default',
+    umdNamedDefine: true,
+    library: 'SantoiDSDK',
+  },
+}
+
+module.exports = (env, argv) => {
+  if (argv.mode === 'development') {
+    generalConfig.devtool = 'cheap-module-source-map'
+  } else if (argv.mode !== 'production') {
+    throw new Error('Specify env')
+  }
+
+  Object.assign(browserConfig, generalConfig)
+
+  return [browserConfig]
+}