@voicenter-team/events-sdk 0.0.13 → 0.0.14

package/package.json

@@ -1,57 +1,54 @@
-{
-  "name": "@voicenter-team/events-sdk",
-  "version": "0.0.13",
-  "description": "",
-  "main": "dist/voicenter-events-sdk.cjs.js",
-  "jsdelivr": "dist/voicenter-events-sdk.umd.js",
-  "module": "dist/voicenter-events-sdk.es.js",
-  "unpkg": "dist/voicenter-events-sdk.umd.js",
-  "types": "dist/index.d.ts",
-  "type": "module",
-  "scripts": {
-    "build": "vite build",
-    "dev": "cd docs && yarn && yarn run dev",
-    "build:documentation": "cd docs && npm install && npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "ts-check": "tsc --noEmit",
-    "lint": "eslint . --ext .js,.jsx,.cjs,.mjs,.ts --fix --ignore-path .gitignore"
-  },
-  "engines": {
-    "node": ">= 16",
-    "npm": ">= 9.6.7",
-    "yarn": ">= 1.22.4"
-  },
-  "files": [
-    "dist"
-  ],
-  "precommit": "ts-check, lint",
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "devDependencies": {
-    "@types/chrome": "0.0.259",
-    "@types/jest": "29.5.11",
-    "@types/js-md5": "^0.7.2",
-    "@types/lodash": "^4.14.200",
-    "@types/node": "20.11.13",
-    "@typescript-eslint/eslint-plugin": "6.20.0",
-    "@typescript-eslint/parser": "6.20.0",
-    "@voicenter-team/eslint-config-ts": "^1.0.22",
-    "dotenv": "16.4.1",
-    "eslint": "8.56.0",
-    "eslint-plugin-jest": "27.6.3",
-    "jest": "^29.7.0",
-    "pre-commit": "^1.2.2",
-    "socket.io-client": "4.7.4",
-    "swagger-axios-codegen": "0.16.8",
-    "ts-jest": "29.1.2",
-    "tsc-alias": "^1.8.6",
-    "typescript": "5.3.3",
-    "vite": "5.0.12",
-    "vite-plugin-dts": "3.7.2"
-  },
-  "dependencies": {
-    "js-md5": "0.8.3",
-    "lodash": "^4.17.21"
-  }
-}
+{
+  "name": "@voicenter-team/events-sdk",
+  "version": "0.0.14",
+  "description": "",
+  "main": "dist/voicenter-events-sdk.cjs.js",
+  "jsdelivr": "dist/voicenter-events-sdk.umd.js",
+  "module": "dist/voicenter-events-sdk.es.js",
+  "unpkg": "dist/voicenter-events-sdk.umd.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "vite build",
+    "dev": "cd docs && yarn && yarn run dev",
+    "build:documentation": "cd docs && npm install && npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "ts-check": "tsc --noEmit",
+    "lint": "eslint . --ext .js,.jsx,.cjs,.mjs,.ts --fix --ignore-path .gitignore"
+  },
+  "engines": {
+    "node": ">= 16",
+    "npm": ">= 9.6.7",
+    "yarn": ">= 1.22.4"
+  },
+  "precommit": "ts-check, lint",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/chrome": "0.0.259",
+    "@types/jest": "29.5.11",
+    "@types/js-md5": "^0.7.2",
+    "@types/lodash": "^4.14.200",
+    "@types/node": "20.11.13",
+    "@typescript-eslint/eslint-plugin": "6.20.0",
+    "@typescript-eslint/parser": "6.20.0",
+    "@voicenter-team/eslint-config-ts": "^1.0.22",
+    "dotenv": "16.4.1",
+    "eslint": "8.56.0",
+    "eslint-plugin-jest": "27.6.3",
+    "jest": "^29.7.0",
+    "pre-commit": "^1.2.2",
+    "socket.io-client": "4.7.4",
+    "swagger-axios-codegen": "0.16.8",
+    "ts-jest": "29.1.2",
+    "tsc-alias": "^1.8.6",
+    "typescript": "5.3.3",
+    "vite": "5.0.12",
+    "vite-plugin-dts": "3.7.2"
+  },
+  "dependencies": {
+    "js-md5": "0.8.3",
+    "lodash": "^4.17.21"
+  }
+}

package/src/classes/auth/auth.class.ts

@@ -0,0 +1,272 @@
+import md5 from 'js-md5'
+
+import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
+import { EventsSdkOptions, ServerParameter } from '@/classes/events-sdk/events-sdk.types'
+import {
+    ExternalLoginNewStackResponseData,
+    ExternalLoginOldStackResponseData,
+    ExternalLoginResponse,
+    LoginSessionData,
+    LoginSessionPayload,
+    Settings
+} from '@/types/auth'
+import { LoginType } from '@/enum/auth.enum'
+import { getSettingsUrl } from '@/classes/auth/auth.urls'
+import { StorageClass } from '@/classes/storage/storage.class'
+
+class AuthClass{
+    constructor (private readonly eventsSdkClass: EventsSdkClass) {
+        this.eventsSdkClass = eventsSdkClass
+
+        this.storageKey = ''
+    }
+
+    private delay = 1000
+    public lastLoginTimestamp: number | undefined
+    public token: string | undefined
+
+    private storageKey: string
+
+    public async login (options: EventsSdkOptions) {
+        const payload: LoginSessionPayload = {
+            token: options.token,
+            email: options.email,
+            password: options.password
+        }
+
+        this.storageKey = md5(JSON.stringify(payload))
+
+        if (this.lastLoginTimestamp && this.lastLoginTimestamp + this.delay > new Date().getTime()) {
+            return
+        }
+
+        this.updateLastLoginTimestamp()
+
+        const isLoggedIn = await this.checkLoginStatus(this.storageKey)
+
+        if (!isLoggedIn) {
+            await this.userLoginFunction(payload, this.storageKey, options.loginType)
+        }
+    }
+
+    public updateLastLoginTimestamp () {
+        this.lastLoginTimestamp = new Date().getTime()
+    }
+
+    private async checkLoginStatus (key: string): Promise<boolean> {
+        const loginSessionData = await StorageClass.getSessionStorageDataByKey(key)
+
+        if (loginSessionData) {
+            this.onLoginResponse(loginSessionData)
+
+            return true
+        }
+
+        return false
+    }
+
+    private async userLoginFunction (
+        payload: LoginSessionPayload,
+        key: string,
+        loginType: LoginType,
+    ) {
+        let externalLoginResponse
+
+        let settings
+
+        let loginSessionData: Partial<LoginSessionData>
+
+        if (this.eventsSdkClass.options.isNewStack) {
+            externalLoginResponse = await this.externalLogin<ExternalLoginNewStackResponseData>(
+                this.eventsSdkClass.options.loginUrl,
+                payload,
+                loginType,
+            )
+
+            settings = await this.getSettings(externalLoginResponse.Data.AccessToken)
+
+            loginSessionData = {
+                ...externalLoginResponse.Data,
+                ...settings
+            }
+        } else {
+            externalLoginResponse = await this.externalLogin<ExternalLoginOldStackResponseData>(
+                this.eventsSdkClass.options.loginUrl,
+                payload,
+                loginType,
+            )
+
+            loginSessionData = {
+                ...externalLoginResponse.Data.Socket,
+            }
+        }
+
+        this.onLoginResponse(loginSessionData)
+
+        await StorageClass.updateSessionStorageKey(key, loginSessionData)
+    }
+
+    private onLoginResponse (loginSessionData: Partial<LoginSessionData>) {
+        if (loginSessionData.MonitorList && loginSessionData.MonitorList.length) {
+            this.eventsSdkClass.servers = [ ...loginSessionData.MonitorList ]
+            this.eventsSdkClass.server = this.eventsSdkClass.servers.reduce((prev, current) =>
+                (prev.Priority > current.Priority) ? prev : current
+            )
+        }
+        if (!this.eventsSdkClass.options.isNewStack && this.eventsSdkClass.options.servers) {
+            this.eventsSdkClass.servers = [ ...this.eventsSdkClass.options.servers ]
+            this.eventsSdkClass.server = this.eventsSdkClass.servers.reduce((prev, current) =>
+                (prev.Priority > current.Priority) ? prev : current
+            )
+        }
+        if (this.eventsSdkClass.server) {
+            this.eventsSdkClass.socketIoClass.getSocketIoFunction(`v=${this.eventsSdkClass.server.Version}`)
+        }
+        if (loginSessionData.IdentityCode) {
+            this.token = loginSessionData.IdentityCode
+            this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
+        }
+        if (loginSessionData.Token) {
+            this.token = loginSessionData.Token
+            this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
+        }
+        if (loginSessionData.RefreshToken && loginSessionData.IdentityCodeExpiry && this.eventsSdkClass.options.loginType === LoginType.USER) {
+            this.eventsSdkClass.options.refreshToken = loginSessionData.RefreshToken
+            this.eventsSdkClass.options.tokenExpiry = loginSessionData.IdentityCodeExpiry
+            this.handleTokenExpiry()
+        }
+        if (loginSessionData.RefreshToken && loginSessionData.TokenExpiry) {
+            this.eventsSdkClass.options.refreshToken = loginSessionData.RefreshToken
+            this.eventsSdkClass.options.tokenExpiry = loginSessionData.TokenExpiry
+            this.handleTokenExpiry()
+        }
+    }
+
+    public handleTokenExpiry () {
+        let date: Date
+
+        if (this.eventsSdkClass.options.tokenExpiry) {
+            date = new Date(this.eventsSdkClass.options.tokenExpiry)
+        } else {
+            return
+        }
+
+        const timeout = date.getTime() - new Date().getTime() - 5000 // 5 seconds before expire
+
+        const maxAllowedTimeout = Math.min(timeout, 0x7FFFFFFF)
+
+        setTimeout(
+            async () => {
+                if (this.eventsSdkClass.options.refreshToken) {
+                    this.eventsSdkClass.socketIoClass.closeAllConnections()
+
+                    let settings
+
+                    let loginSessionData: Partial<LoginSessionData>
+
+                    if (this.eventsSdkClass.options.isNewStack) {
+                        const refreshTokenResponse = await this.refreshToken<ExternalLoginNewStackResponseData>(
+                            this.eventsSdkClass.options.refreshTokenUrl,
+                            this.eventsSdkClass.options.refreshToken
+                        )
+
+                        settings = await this.getSettings(refreshTokenResponse.Data.AccessToken)
+
+                        loginSessionData = {
+                            ...refreshTokenResponse.Data,
+                            ...settings
+                        }
+                    } else {
+                        const refreshTokenResponse = await this.refreshToken<ExternalLoginOldStackResponseData>(
+                            this.eventsSdkClass.options.refreshTokenUrl,
+                            this.eventsSdkClass.options.refreshToken
+                        )
+
+                        loginSessionData = {
+                            ...refreshTokenResponse.Data.Socket,
+                        }
+                    }
+
+                    this.onLoginResponse(loginSessionData)
+
+                    await StorageClass.updateSessionStorageKey(this.storageKey, loginSessionData)
+                }
+            },
+            maxAllowedTimeout)
+    }
+
+    private async externalLogin<T> (
+        url: string,
+        { password, token, email }: LoginSessionPayload,
+        loginType: LoginType,
+    ): Promise<ExternalLoginResponse<T>> {
+        let body: string
+
+        if (this.eventsSdkClass.options.isNewStack) {
+            if (loginType === LoginType.TOKEN) {
+                body = JSON.stringify({
+                    identityType: LoginType.TOKEN,
+                    token
+                })
+            } else {
+                body = JSON.stringify({
+                    identityType: LoginType.USER,
+                    username: email,
+                    password,
+                })
+            }
+        } else {
+            if (token) {
+                body = JSON.stringify({ token })
+
+                url = `${url}/Token`
+            } else {
+                body = JSON.stringify({
+                    email,
+                    pin: password
+                })
+
+                url = `${url}/User`
+            }
+        }
+
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body,
+        })
+
+        const data = await res.json()
+
+        if (data.error) {
+            throw new Error(data.error)
+        }
+        return data
+    }
+
+    private async getSettings (token: string): Promise<Settings> {
+        const res = await fetch(getSettingsUrl, {
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        })
+
+        return res.json()
+    }
+
+    private async refreshToken<T> (refreshTokenUrl: string, oldRefreshToken: string): Promise<ExternalLoginResponse<T>> {
+        const res = await fetch(refreshTokenUrl, {
+            method: 'GET',
+
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${oldRefreshToken}`
+            }
+        })
+        return res.json()
+    }
+}
+
+export default AuthClass

package/src/classes/auth/auth.urls.ts

@@ -0,0 +1,8 @@
+const getSettingsUrl = 'https://loginapidev.voicenter.co.il/Application/GetSettings'
+const refreshTokenUrl = 'https://loginapidev.voicenter.co.il/Auth/RefreshToken'
+
+
+export {
+    getSettingsUrl,
+    refreshTokenUrl
+}

package/src/classes/events-sdk/events-sdk-default-options.ts

@@ -0,0 +1,60 @@
+import { EventsSdkOptions } from '@/classes/events-sdk/events-sdk.types'
+import { LoginType } from '@/enum/auth.enum'
+
+export const eventsSdkDefaultOptions: EventsSdkOptions = {
+    isNewStack: false,
+    servers: [ {
+        URLID: 1,
+        Priority: 5,
+        Version: '1.3.7',
+        Domain: 'monitor1.comms24x7.com' 
+    },{
+        URLID: 2,
+        Priority: 4,
+        Version: '1.3.7',
+        Domain: 'monitor2.comms24x7.com' 
+    } ],
+    loginUrl: 'https://loginapi.comms24x7.com/monitorAPI/Login',
+    refreshTokenUrl: 'https://loginapi.comms24x7.com/monitorAPI/RefreshIdentityToken',
+    fallbackServer: {
+        Domain: 'monitor5.voicenter.co.il',
+        Priority: 0,
+        Version: '1.3.7',
+        URLID: 1
+    },
+    token: '',
+    loginType: LoginType.TOKEN,
+    forceNew: true,
+    reconnectionDelay: 10000,
+    reconnectionDelayMax: 10000,
+    maxReconnectAttempts: 5,
+    timeout: 10000,
+    keepAliveTimeout: 60000,
+    idleInterval: 60000 * 5,
+    protocol: 'https',
+    transports: [ 'websocket' ],
+    upgrade: false,
+    serverFetchStrategy: 'static',
+    serverType: 0,
+    useLogger: false,
+    loggerSocketConnection: '',
+    loggerServer: 'http://127.0.0.1:3000/',
+    loggerConfig: {
+        logToConsole: true,
+        overloadGlobalConsole: false,
+        namespace: 'events-sdk',
+        socketEmitInterval: 10000,
+    },
+    loggerConnectOptions: {
+        reconnection: true,
+        reconnectionDelay: 5000,
+        reconnectionAttempts: 10,
+        perMessageDeflate: false,
+        upgrade: false,
+        transports: [ 'websocket' ],
+        debug: false
+    },
+    username: 'username',
+    password: '92455783085',
+    email: 'sasha.za@starkey.co.il',
+}