@voicenter-team/events-sdk 0.0.6 → 0.0.7

package/docs/src/.vuepress/components/Demo.vue

@@ -26,7 +26,7 @@ import EventsSdkClass from '@/index'
 import {eventsSdkDefaultOptions} from '@/classes/events-sdk/events-sdk-default-options'
 import {EventsEnum} from '@/enum/events.enum'
 import {EventTypeData} from '@/types/events'
-import {LoginTypeNewStackEnum, LoginTypeOldStackEnum} from "@/enum/auth.enum";
+import {LoginType} from "@/enum/auth.enum";
 
 /* Data */
 const token = ref('QMSVU9dwNYC9Le9VCBqx24AB9TYyWj9Xn5aCPV0GFHIWoShQqfPtnAPmnw24xpJIUSsDDtlac2OPpjx0t3MSkxH3AhiQGHCeGZ8e')
@@ -45,8 +45,7 @@ async function login() {
     const sdk = new EventsSdkClass({
         ...eventsSdkDefaultOptions,
         token: token.value,
-        loginType: LoginTypeNewStackEnum.USER,
-        newStack: true
+        loginType: LoginType.USER,
     })
 
     await sdk.init()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voicenter-team/events-sdk",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "",
   "main": "dist/voicenter-events-sdk.cjs.js",
   "jsdelivr": "dist/voicenter-events-sdk.umd.js",
@@ -26,29 +26,29 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "@types/chrome": "^0.0.253",
-    "@types/jest": "^29.5.10",
+    "@types/chrome": "0.0.259",
+    "@types/jest": "29.5.11",
     "@types/js-md5": "^0.7.2",
     "@types/lodash": "^4.14.200",
-    "@types/node": "^18.14.2",
-    "@typescript-eslint/eslint-plugin": "^5.53.0",
-    "@typescript-eslint/parser": "^5.53.0",
+    "@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.0.3",
-    "eslint": "^8.35.0",
-    "eslint-plugin-jest": "^27.6.0",
+    "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.2",
-    "swagger-axios-codegen": "^0.14.0",
-    "ts-jest": "^29.1.1",
+    "socket.io-client": "4.7.4",
+    "swagger-axios-codegen": "0.16.8",
+    "ts-jest": "29.1.2",
     "tsc-alias": "^1.8.6",
-    "typescript": "^4.9.5",
-    "vite": "4.3.9",
-    "vite-plugin-dts": "^3.6.0"
+    "typescript": "5.3.3",
+    "vite": "5.0.12",
+    "vite-plugin-dts": "3.7.2"
   },
   "dependencies": {
-    "js-md5": "^0.7.3",
+    "js-md5": "0.8.3",
     "lodash": "^4.17.21"
   }
 }

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

@@ -1,36 +1,39 @@
 import md5 from 'js-md5'
 
 import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
-import { Environment, EventsSdkOptions, ServerParameter } from '@/classes/events-sdk/events-sdk.types'
+import { EventsSdkOptions, ServerParameter } from '@/classes/events-sdk/events-sdk.types'
 import {
+    ExternalLoginRequestBody,
     ExternalLoginResponse,
-    ExternalLoginResponseDataNewStack,
-    ExternalLoginResponseDataOldStack,
     LoginSessionData,
     LoginSessionPayload,
     Settings
 } from '@/types/auth'
-import { LoginTypeNewStackEnum, LoginTypeOldStackEnum } from '@/enum/auth.enum'
-import { getSettingsUrl, newLoginUrl, oldLoginUrl } from '@/classes/auth/auth.urls'
+import { LoginType } from '@/enum/auth.enum'
+import { getSettingsUrl, newLoginUrl, refreshTokenUrl } 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,
-            username: options.username,
             password: options.password
         }
 
-        const key = md5(JSON.stringify(payload))
+        this.storageKey = md5(JSON.stringify(payload))
 
         if (this.lastLoginTimestamp && this.lastLoginTimestamp + this.delay > new Date().getTime()) {
             return
@@ -38,10 +41,10 @@ class AuthClass{
 
         this.updateLastLoginTimestamp()
 
-        const isLoggedIn = await this.checkLoginStatus(options.environment, key)
+        const isLoggedIn = await this.checkLoginStatus(this.storageKey)
 
         if (!isLoggedIn) {
-            await this.userLoginFunction(payload, key, options.loginType, options.newStack)
+            await this.userLoginFunction(payload, this.storageKey, options.loginType)
         }
     }
 
@@ -49,144 +52,62 @@ class AuthClass{
         this.lastLoginTimestamp = new Date().getTime()
     }
 
-    private async checkLoginStatus (environment: Environment, key: string): Promise<boolean> {
-        let loginSessionData: LoginSessionData
-        if (environment === Environment.BROWSER && window) {
-            const loginSessionKey = window.sessionStorage.getItem(key)
+    private async checkLoginStatus (key: string): Promise<boolean> {
+        const loginSessionData = await StorageClass.getSessionStorageDataByKey(key)
 
-            if (loginSessionKey) {
-                loginSessionData = JSON.parse(loginSessionKey)
+        if (loginSessionData) {
+            this.onLoginResponse(loginSessionData)
 
-                this.onLoginResponse(loginSessionData)
-
-                return true
-            }
+            return true
         }
-        if (environment === Environment.CHROME_EXTENSION && chrome) {
-            const loginSessionKey = await chrome.storage.session.get(key)
 
-            if (loginSessionKey[key]) {
-                loginSessionData = JSON.parse(loginSessionKey[key])
+        return false
+    }
 
-                this.onLoginResponse(loginSessionData)
+    private async userLoginFunction (
+        payload: LoginSessionPayload,
+        key: string,
+        loginType: LoginType,
+    ) {
+        const externalLoginResponse = await this.externalLogin(
+            newLoginUrl,
+            payload,
+            loginType,
+        )
 
-                return true
-            }
+        const settings = await this.getSettings(externalLoginResponse.Data.AccessToken)
+
+        const loginSessionData: LoginSessionData = {
+            ...externalLoginResponse.Data,
+            ...settings
         }
-        return false
+
+        this.onLoginResponse(loginSessionData)
+
+        await StorageClass.updateSessionStorageKey(key, loginSessionData)
     }
 
-    private onLoginResponse (loginSessionData: Partial<LoginSessionData>) {
-        if (loginSessionData.Client) {
-            this.eventsSdkClass.socketIoClass.getSocketIoFunction(loginSessionData.Client)
-        }
-        if (loginSessionData.Url) {
-            this.eventsSdkClass.server = {
-                Priority: 0,
-                Domain: loginSessionData.Url.replace('https://', '')
-            }
-        }
-        if (loginSessionData.URLList) {
-            this.eventsSdkClass.servers = loginSessionData.URLList.map((url, index) => {
-                return {
-                    Priority: index,
-                    Domain: url.replace('https://', '')
-                }
-            })
-        }
-        if (loginSessionData.MonitorList) {
+    private onLoginResponse (loginSessionData: 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 (!loginSessionData.Url) {
-            this.eventsSdkClass.server = this.eventsSdkClass.servers[0]
-        }
-        if (!loginSessionData.Client) {
+        if (this.eventsSdkClass.server) {
             this.eventsSdkClass.socketIoClass.getSocketIoFunction(`v=${this.eventsSdkClass.server.Version}`)
         }
-        if (loginSessionData.Token) {
-            // this.options.token = loginSessionData.Token
-            this.token = loginSessionData.Token
-            this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
-        }
         if (loginSessionData.IdentityCode) {
             this.token = loginSessionData.IdentityCode
             this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
         }
-        if (loginSessionData.RefreshToken && loginSessionData.TokenExpiry && this.eventsSdkClass.options.loginType === 'user') {
-            this.eventsSdkClass.options.refreshToken = loginSessionData.RefreshToken
-            this.eventsSdkClass.options.tokenExpiry = loginSessionData.TokenExpiry
-            this.handleTokenExpiry()
-        }
-        if (loginSessionData.RefreshToken && loginSessionData.IdentityCodeExpiry && this.eventsSdkClass.options.loginType === LoginTypeNewStackEnum.USER) {
+        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()
         }
     }
 
-    private async userLoginFunction (
-        payload: LoginSessionPayload,
-        key: string,
-        loginType: LoginTypeNewStackEnum | LoginTypeOldStackEnum,
-        newStack: boolean
-    ) {
-        const externalLoginUrl = this.getExternalLoginUrl(
-            loginType,
-            newStack
-        )
-
-        if (!externalLoginUrl) {
-            throw new Error('External login url not found. Check provided options')
-        }
-
-        if (newStack) {
-            const externalLoginResponse = await this.externalLogin<ExternalLoginResponseDataNewStack>(
-                externalLoginUrl,
-                payload,
-                loginType,
-                newStack
-            )
-
-            const settings = await this.getSettings(externalLoginResponse.Data.AccessToken)
-
-            this.onLoginResponse({
-                ...externalLoginResponse.Data,
-                ...settings 
-            })
-
-            if (this.eventsSdkClass.options.environment === Environment.BROWSER) {
-                window.sessionStorage.setItem(key, JSON.stringify({
-                    ...externalLoginResponse.Data,
-                    ...settings
-                }))
-            }
-            if (this.eventsSdkClass.options.environment === Environment.CHROME_EXTENSION) {
-                await chrome.storage.session.set({
-                    [key]: JSON.stringify({
-                        ...externalLoginResponse.Data,
-                        ...settings
-                    }) 
-                })
-            }
-        } else {
-            const externalLoginResponse = await this.externalLogin<ExternalLoginResponseDataOldStack>(
-                externalLoginUrl,
-                payload,
-                loginType,
-                newStack
-            )
-
-            this.onLoginResponse(externalLoginResponse.Data.Socket)
-
-            if (this.eventsSdkClass.options.environment === Environment.BROWSER) {
-                window.sessionStorage.setItem(key, JSON.stringify(externalLoginResponse.Data.Socket))
-            }
-            if (this.eventsSdkClass.options.environment === Environment.CHROME_EXTENSION) {
-                await chrome.storage.session.set({ [key]: JSON.stringify(externalLoginResponse.Data.Socket) })
-            }
-        }
-    }
-
     public handleTokenExpiry () {
         let date: Date
 
@@ -202,68 +123,43 @@ class AuthClass{
 
         setTimeout(
             async () => {
-                if (this.eventsSdkClass.options.refreshTokenUrl && this.eventsSdkClass.options.refreshToken) {
-                    let Socket = null
-                    const res = await this.refreshToken(this.eventsSdkClass.options.refreshTokenUrl, this.eventsSdkClass.options.refreshToken)
+                if (refreshTokenUrl && this.eventsSdkClass.options.refreshToken) {
+                    this.eventsSdkClass.socketIoClass.closeAllConnections()
+
+                    const refreshTokenResponse = await this.refreshToken(refreshTokenUrl, this.eventsSdkClass.options.refreshToken)
 
-                    if (res.Data) {
-                        Socket = res.Data.Socket
-                        return this.onLoginResponse(Socket)
+                    const settings = await this.getSettings(refreshTokenResponse.Data.AccessToken)
+
+                    const loginSessionData: LoginSessionData = {
+                        ...refreshTokenResponse.Data,
+                        ...settings
                     }
 
-                    throw new Error('Error on refreshToken')
+                    this.onLoginResponse(loginSessionData)
+
+                    await StorageClass.updateSessionStorageKey(this.storageKey, loginSessionData)
                 }
             },
             maxAllowedTimeout)
     }
 
-    private getExternalLoginUrl (
-        loginType: LoginTypeNewStackEnum | LoginTypeOldStackEnum,
-        newStack: boolean
-    ) {
-        if (newStack) {
-            return newLoginUrl
-        } else {
-            if (loginType === LoginTypeOldStackEnum.TOKEN) {
-                return `${oldLoginUrl}/Token`
-            }
-            if (loginType === LoginTypeOldStackEnum.USER) {
-                return `${oldLoginUrl}/User`
-            }
-        }
-    }
-
-    private async externalLogin<T> (
+    private async externalLogin (
         url: string,
         { password, token, email }: LoginSessionPayload,
-        loginType: LoginTypeNewStackEnum | LoginTypeOldStackEnum,
-        newStack: boolean
-    ): Promise<ExternalLoginResponse<T>> {
-        let body: string
-
-        if (newStack) {
-            if (loginType === LoginTypeNewStackEnum.TOKEN) {
-                body = JSON.stringify({
-                    type: Number(LoginTypeNewStackEnum.TOKEN),
-                    token
-                })
-            } else {
-                body = JSON.stringify({
-                    type: Number(LoginTypeNewStackEnum.USER),
-                    username: email,
-                    password,
-                })
+        loginType: LoginType,
+    ): Promise<ExternalLoginResponse> {
+        let body: ExternalLoginRequestBody
+
+        if (loginType === LoginType.TOKEN) {
+            body = {
+                identityType: LoginType.TOKEN,
+                token
             }
         } else {
-            if (loginType === LoginTypeOldStackEnum.TOKEN) {
-                body = JSON.stringify({
-                    token
-                })
-            } else {
-                body = JSON.stringify({
-                    email,
-                    pin: password
-                })
+            body = {
+                identityType: LoginType.USER,
+                username: email,
+                password,
             }
         }
 
@@ -272,7 +168,7 @@ class AuthClass{
             headers: {
                 'Content-Type': 'application/json'
             },
-            body,
+            body: JSON.stringify(body),
         })
 
         const data = await res.json()
@@ -293,7 +189,7 @@ class AuthClass{
         return res.json()
     }
 
-    private async refreshToken (refreshTokenUrl: string, oldRefreshToken: string) {
+    private async refreshToken (refreshTokenUrl: string, oldRefreshToken: string): Promise<ExternalLoginResponse> {
         const res = await fetch(refreshTokenUrl, {
             method: 'GET',
 

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

@@ -1,10 +1,10 @@
-const oldLoginUrl = 'https://loginapi.voicenter.co.il/monitorAPI/Login'
 const newLoginUrl = 'http://loginapidev.voicenter.co.il/Auth/Login/Voicenter/Monitor'
 const getSettingsUrl = 'http://loginapidev.voicenter.co.il/Application/GetSettings'
+const refreshTokenUrl = 'http://loginapidev.voicenter.co.il/Auth/RefreshToken'
 
 
 export {
-    oldLoginUrl,
     newLoginUrl,
-    getSettingsUrl
+    getSettingsUrl,
+    refreshTokenUrl
 }

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

@@ -1,17 +1,15 @@
-import { Environment, EventsSdkOptions } from '@/classes/events-sdk/events-sdk.types'
-import { LoginTypeOldStackEnum } from '@/enum/auth.enum'
+import { EventsSdkOptions } from '@/classes/events-sdk/events-sdk.types'
+import { LoginType } from '@/enum/auth.enum'
 
 export const eventsSdkDefaultOptions: EventsSdkOptions = {
-    url: 'https://monitorapi.voicenter.co.il/monitorAPI/getMonitorUrls',
-    environment: Environment.BROWSER,
     fallbackServer: {
         Domain: 'monitor5.voicenter.co.il',
         Priority: 0,
+        Version: '1.3.7',
+        URLID: 1
     },
-    refreshTokenUrl: 'https://loginapi.voicenter.co.il/monitorAPI/RefreshIdentityToken',
-    // servers: defaultServers, // commented temporary
     token: '',
-    loginType: LoginTypeOldStackEnum.TOKEN,
+    loginType: LoginType.TOKEN,
     forceNew: true,
     reconnectionDelay: 10000,
     reconnectionDelayMax: 10000,
@@ -22,10 +20,6 @@ export const eventsSdkDefaultOptions: EventsSdkOptions = {
     protocol: 'https',
     transports: [ 'websocket' ],
     upgrade: false,
-    store: '',
-    extensionsModuleName: 'sdkExtensions',
-    queuesModuleName: 'sdkQueues',
-    dialersModuleName: 'sdkDialers',
     serverFetchStrategy: 'static',
     serverType: 0,
     useLogger: false,
@@ -49,5 +43,4 @@ export const eventsSdkDefaultOptions: EventsSdkOptions = {
     username: 'username',
     password: '78253050510',
     email: 'test2@status.com',
-    newStack: false,
 }

package/src/classes/events-sdk/events-sdk.types.ts

@@ -1,15 +1,13 @@
-import { LoginTypeNewStackEnum, LoginTypeOldStackEnum } from 'enum/auth.enum'
+import { LoginType } from 'enum/auth.enum'
 
 export interface EventsSdkOptions {
-    url?: string,
-    environment: Environment,
     fallbackServer: Server,
     refreshTokenUrl?: string,
     refreshToken?: string,
     servers?: string,
     token: string,
     tokenExpiry?: Date,
-    loginType: LoginTypeNewStackEnum | LoginTypeOldStackEnum,
+    loginType: LoginType,
     forceNew?: boolean,
     reconnectionDelay: number,
     reconnectionDelayMax?: number,
@@ -20,10 +18,6 @@ export interface EventsSdkOptions {
     protocol: string,
     transports?: string[],
     upgrade?: boolean,
-    store?: string,
-    extensionsModuleName?: string,
-    queuesModuleName?: string,
-    dialersModuleName?: string,
     serverFetchStrategy?: string,
     serverType?: number,
     useLogger?: boolean,
@@ -34,19 +28,13 @@ export interface EventsSdkOptions {
     email: string,
     password: string,
     username: string,
-    newStack: boolean
-}
-
-export enum Environment {
-    BROWSER = 'browser',
-    CHROME_EXTENSION = 'chrome-extension'
 }
 
 export interface Server {
     Priority: number,
     Domain: string,
-    URLID?: number,
-    Version?: string,
+    URLID: number,
+    Version: string,
 }
 
 export interface LoggerConfig {
@@ -78,4 +66,4 @@ export enum ServerParameter {
     DEFAULT = 'default',
     NEXT = 'next',
     PREVIOUS = 'previous'
-}
+}

package/src/classes/socket-io/socket-io.class.ts

@@ -2,9 +2,10 @@ import { ManagerOptions, SocketOptions } from 'socket.io-client'
 import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
 import sockets, { TypedSocketIo } from '@/classes/socket-io/versions'
 import { SocketTyped } from '@/types/socket'
-import { Environment, ServerParameter } from '@/classes/events-sdk/events-sdk.types'
+import { ServerParameter } from '@/classes/events-sdk/events-sdk.types'
 import { EventsEnum } from '@/enum/events.enum'
 import { KeepAliveResponseEvent } from '@/types/events'
+import { StorageClass } from '@/classes/storage/storage.class'
 
 export class SocketIoClass{
     constructor (private readonly eventsSdkClass: EventsSdkClass) {
@@ -125,12 +126,7 @@ export class SocketIoClass{
             this.io = undefined
         }
 
-        if (this.eventsSdkClass.options.environment === Environment.BROWSER && window) {
-            window.sessionStorage.clear()
-        }
-        if (this.eventsSdkClass.options.environment === Environment.CHROME_EXTENSION && chrome) {
-            chrome.storage.session.clear()
-        }
+        StorageClass.clearSessionStorage()
     }
 
     private onKeepAliveResponse (data: KeepAliveResponseEvent) {

package/src/classes/storage/storage.class.ts

@@ -0,0 +1,43 @@
+import { LoginSessionData } from '@/types/auth'
+
+export class StorageClass{
+    public static async getSessionStorageDataByKey (key: string): Promise<LoginSessionData | undefined> {
+        if (typeof chrome !== 'undefined' && typeof chrome.storage !== 'undefined') {
+            const loginSessionKey = await chrome.storage.session.get(key)
+
+            if (loginSessionKey[key]) {
+                return JSON.parse(loginSessionKey[key])
+            }
+        }
+
+        if (typeof window !== 'undefined') {
+            const loginSessionKey = window.sessionStorage.getItem(key)
+
+            if (loginSessionKey) {
+                return JSON.parse(loginSessionKey)
+            }
+        }
+    }
+
+    public static async updateSessionStorageKey (key: string, storageData: LoginSessionData) {
+        if (typeof chrome !== 'undefined' && typeof chrome.storage !== 'undefined') {
+            await chrome.storage.session.set({
+                [key]: JSON.stringify(storageData)
+            })
+        }
+
+        if (typeof window !== 'undefined') {
+            window.sessionStorage.setItem(key, JSON.stringify(storageData))
+        }
+    }
+
+    public static clearSessionStorage () {
+        if (typeof chrome !== 'undefined' && typeof chrome.storage !== 'undefined') {
+            chrome.storage.session.clear()
+        }
+
+        if (typeof window !== 'undefined') {
+            window.sessionStorage.clear()
+        }
+    }
+}

package/src/enum/auth.enum.ts

@@ -1,9 +1,4 @@
-export enum LoginTypeNewStackEnum {
-    USER = '2',
-    TOKEN = '3'
-}
-
-export enum LoginTypeOldStackEnum {
-    USER = 'user',
-    TOKEN = 'token'
+export enum LoginType {
+    USER = 'User',
+    TOKEN = 'Token'
 }

package/src/index.ts

@@ -1,9 +1,6 @@
 import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
-import { Environment } from '@/classes/events-sdk/events-sdk.types'
 import { EventsEnum } from '@/enum/events.enum'
 
-export {
-    Environment,
-    EventsEnum
-}
+export { EventsEnum }
+
 export default EventsSdkClass