@voicenter-team/events-sdk 0.0.29 → 0.0.30

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

@@ -1,355 +0,0 @@
-import md5 from '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 { StorageClass } from '@/classes/storage/storage.class'
-import { LoggerTypeEnum } from '@/enum/logger.enum'
-
-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({
-            ...options,
-            loggerSocketConnection: null 
-        }))
-
-        if (this.lastLoginTimestamp && this.lastLoginTimestamp + this.delay > new Date().getTime()) {
-            return
-        }
-
-        this.updateLastLoginTimestamp()
-
-        const isLoggedIn = await this.checkLoginStatus(this.storageKey)
-
-        if (!isLoggedIn) {
-            StorageClass.clearSessionStorage()
-
-            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<LoginSessionData>(key)
-
-        if (loginSessionData) {
-            this.eventsSdkClass.loggerClass.log(LoggerTypeEnum.INFO, 'got data from session', 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 (!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.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 (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.servers.length && loginSessionData.URLList) {
-            this.eventsSdkClass.URLList = loginSessionData.URLList
-        }
-        if (!this.eventsSdkClass.options.isNewStack && !this.eventsSdkClass.URLList.length && !this.eventsSdkClass.servers.length) {
-            throw new Error('Socket servers not defined')
-        }
-        if (this.eventsSdkClass.options.isNewStack && !this.eventsSdkClass.servers.length) {
-            throw new Error('Socket servers not defined')
-        }
-        if (this.eventsSdkClass.server) {
-            this.eventsSdkClass.socketIoClass.getSocketIoFunction(`v=${this.eventsSdkClass.server.Version}`)
-        }
-        if (!this.eventsSdkClass.server && this.eventsSdkClass.URLList.length) {
-            this.eventsSdkClass.socketIoClass.getSocketIoFunction(`v=${loginSessionData.Client}`)
-        }
-        if (loginSessionData.IdentityCode) {
-            this.token = loginSessionData.IdentityCode
-            this.eventsSdkClass.connect(ServerParameter.MAIN)
-        }
-        if (loginSessionData.Token) {
-            this.token = loginSessionData.Token
-            this.eventsSdkClass.connect(ServerParameter.MAIN)
-        }
-        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.loginType === LoginType.USER) {
-            this.eventsSdkClass.options.refreshToken = loginSessionData.RefreshToken
-            this.eventsSdkClass.options.tokenExpiry = loginSessionData.TokenExpiry
-            this.handleTokenExpiry()
-        }
-    }
-
-    public handleTokenExpiry () {
-        if (!this.eventsSdkClass.options.refreshTokenUrl) {
-            throw new Error('refreshTokenUrl not provided')
-        }
-
-        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>> {
-        if (!url) {
-            throw new Error('loginUrl not provided')
-        }
-
-        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 (this.eventsSdkClass.options.loginType === LoginType.TOKEN) {
-                body = JSON.stringify({ token })
-
-                url = `${url}/${LoginType.TOKEN}`
-            } else {
-                body = JSON.stringify({
-                    email,
-                    pin: password
-                })
-
-                url = `${url}/${LoginType.USER}`
-            }
-        }
-
-        try {
-            const res = await fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body,
-            })
-
-            if (!res.ok && res.status === 400) {
-                throw new Error('Bad body request. Login type or isNewStack values not correct or not provided')
-            }
-
-            if (!res.ok && res.status === 401) {
-                throw new Error('Unauthorized. Invalid token provided')
-            }
-
-            if (!res.ok && res.status === 403) {
-                throw new Error('Forbidden. Identity token not provided or not valid')
-            }
-
-            const data = await res.json()
-
-            if (data.error) {
-                throw new Error(data.error)
-            }
-            return data
-        } catch (error) {
-            this.eventsSdkClass.loggerClass.log(
-                LoggerTypeEnum.ERROR,
-                `External login ${url}`,
-                error
-            )
-
-            throw error
-        }
-    }
-
-    private async getSettings (token: string): Promise<Settings> {
-        try {
-            if (!this.eventsSdkClass.options.getSettingsUrl) {
-                throw new Error('getSettingsUrl not provided')
-            }
-
-            const res = await fetch(this.eventsSdkClass.options.getSettingsUrl, {
-                headers: {
-                    Authorization: `Bearer ${token}`
-                }
-            })
-
-            if (!res.ok && res.status === 401) {
-                throw new Error('Unauthorized. Access token not provided or not valid')
-            }
-
-            return res.json()
-        } catch (error) {
-            this.eventsSdkClass.loggerClass.log(
-                LoggerTypeEnum.ERROR,
-                `Get settings ${this.eventsSdkClass.options.getSettingsUrl}`,
-                error
-            )
-
-            throw error
-        }
-    }
-
-    private async refreshToken<T> (refreshTokenUrl: string, oldRefreshToken: string): Promise<ExternalLoginResponse<T>> {
-        try {
-            const res = await fetch(refreshTokenUrl, {
-                method: 'GET',
-
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${oldRefreshToken}`
-                }
-            })
-            return res.json()
-        } catch (error) {
-            this.eventsSdkClass.loggerClass.log(
-                LoggerTypeEnum.ERROR,
-                `Refresh token ${refreshTokenUrl}`,
-                error
-            )
-
-            throw error
-        }
-    }
-}
-
-export default AuthClass

package/src/classes/event-emitter/event-emitter.class.ts

@@ -1,73 +0,0 @@
-import {
-    EventCallbackListenersMap,
-    EventSpecificCallback,
-    EventTypeData,
-    EventTypeNames,
-    GenericEventWrapper
-} from '@/types/events'
-import { EventsEnum } from '@voicenter-team/real-time-events-types'
-import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
-
-export class EventEmitterClass{
-    private listeners: EventCallbackListenersMap = {
-        [EventsEnum.ALL_EXTENSION_STATUS]: [],
-        [EventsEnum.ALL_DIALER_STATUS]: [],
-        [EventsEnum.ALL_USERS_STATUS]: [],
-        [EventsEnum.QUEUE_EVENT]: [],
-        [EventsEnum.EXTENSION_EVENT]: [],
-        [EventsEnum.DIALER_EVENT]: [],
-        [EventsEnum.LOGIN_SUCCESS]: [],
-        [EventsEnum.LOGIN_STATUS]: [],
-        [EventsEnum.KEEP_ALIVE_RESPONSE]: [],
-        [EventsEnum.ONLINE_STATUS_EVENT]: [],
-        [EventsEnum.EXTENSIONS_UPDATED]: []
-    }
-    private allListeners: Array<(data: GenericEventWrapper) => void> = []
-
-    constructor (private readonly eventsSdkClass: EventsSdkClass) {
-        this.eventsSdkClass = eventsSdkClass
-    }
-
-    public on<T extends EventTypeNames> (event: T, callback: EventSpecificCallback<T>): void
-    public on (event: '*', callback: (data: GenericEventWrapper) => void): void
-    public on (event: unknown, callback: unknown) {
-        if (event === '*') {
-            this.allListeners.push(callback as (data: GenericEventWrapper) => void)
-        } else {
-            // Handle specific event type with strong typing
-            this.listeners[event as EventTypeNames].push(callback as EventSpecificCallback<EventTypeNames>)
-        }
-    }
-
-    public off<T extends EventTypeNames> (event: T, callback: EventSpecificCallback<T>): void
-    public off (event: '*', callback: (data: GenericEventWrapper) => void): void
-    public off (event: unknown, callback: unknown) {
-        if (event === '*') {
-            this.allListeners = this.allListeners.filter(item => item !== callback)
-        } else {
-            const data = this.listeners[event as EventTypeNames] as Array<EventSpecificCallback<EventTypeNames>>
-            const filtered = data.filter(item => item !== callback)
-
-            this.listeners = {
-                ...this.listeners,
-                [event as EventTypeNames]: filtered
-            }
-        }
-    }
-
-    public emit <T extends EventTypeNames> (event: T, data: EventTypeData<T>) {
-        this.eventsSdkClass.socketIoClass.lastEventTimestamp = new Date().getTime()
-
-        this.listeners[event].forEach(callback => callback({
-            name: event,
-            data
-        }))
-
-        const allEventData: GenericEventWrapper = {
-            name: event,
-            data: data as any
-        }
-
-        this.allListeners.forEach((callback) => callback(allEventData))
-    }
-}

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

@@ -1,34 +0,0 @@
-import { EventsSdkOptions } from '@/classes/events-sdk/events-sdk.types'
-
-export const eventsSdkDefaultOptions: Partial<EventsSdkOptions> = {
-    isNewStack: false,
-    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: true,
-    loggerServer: 'http://socketlog.voicenter.co',
-    loggerConfig: {
-        logToConsole: true,
-        overloadGlobalConsole: false,
-        namespace: 'events-sdk',
-        socketEmitInterval: 10000,
-    },
-    loggerConnectOptions: {
-        reconnection: true,
-        reconnectionDelay: 5000,
-        reconnectionAttempts: 10,
-        perMessageDeflate: undefined,
-        upgrade: false,
-        transports: [ 'websocket' ],
-        debug: false
-    },
-}

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

@@ -1,208 +0,0 @@
-import AuthClass from '@/classes/auth/auth.class'
-import { debounce } from 'lodash'
-import { eventsSdkDefaultOptions } from '@/classes/events-sdk/events-sdk-default-options'
-import { SocketIoClass } from '@/classes/socket-io/socket-io.class'
-import { EventsSdkOptions, ReconnectOptions, Server, ServerParameter } from '@/classes/events-sdk/events-sdk.types'
-import { SocketTyped } from '@/types/socket'
-import {
-    EventSpecificCallback,
-    EventTypeNames,
-    GenericEventWrapper,
-} from '@/types/events'
-import { EventsEnum } from '@voicenter-team/real-time-events-types'
-import { LoggerClass } from '@/classes/logger/logger.class'
-import { EventEmitterClass } from '@/classes/event-emitter/event-emitter.class'
-
-class EventsSdkClass{
-    private argumentOptions: EventsSdkOptions
-    public readonly options: EventsSdkOptions
-    public servers: Server[] = []
-    public URLList: string[] = []
-    public server: Server
-    public URL: string | undefined
-    public socket: SocketTyped | undefined
-    private mainServer: Server | undefined
-
-    private alreadyAttemptedOtherServers: Array<number | string> = []
-
-    public authClass = new AuthClass(this)
-    public socketIoClass = new SocketIoClass(this)
-    public loggerClass = new LoggerClass(this)
-    public eventEmitterClass = new EventEmitterClass(this)
-
-    public reconnectOptions: ReconnectOptions
-
-    public retryConnection
-
-    constructor (options: EventsSdkOptions) {
-        this.options = {
-            ...eventsSdkDefaultOptions,
-            ...options
-        }
-
-        this.reconnectOptions = {
-            retryCount: 1,
-            maxReconnectAttempts: this.options.maxReconnectAttempts,
-            reconnectionDelay: this.options.reconnectionDelay, // 10 seconds. After each re-connection attempt this number will increase (minReconnectionDelay * attempts) => 10, 20, 30, 40 seconds ... up to 5min
-            minReconnectionDelay: this.options.reconnectionDelay, // 10 seconds
-            maxReconnectionDelay: 60000 * 5 // 5 minutes
-        }
-
-        this.server = this.options.fallbackServer
-
-        this.retryConnection = debounce(this.connect.bind(this), this.reconnectOptions.reconnectionDelay, {
-            leading: true,
-            trailing: false
-        })
-
-        this.argumentOptions = {
-            ...options
-        }
-    }
-
-    public on<T extends EventTypeNames> (event: T, callback: EventSpecificCallback<T>): void
-    public on (event: '*', callback: (data: GenericEventWrapper) => void): void {
-        this.eventEmitterClass.on(event, callback)
-    }
-
-    public emit (event: EventsEnum, data: unknown) {
-        if (this.socketIoClass.io) {
-            this.socketIoClass.io.emit(event, data)
-        }
-    }
-
-    public connect (serverParameter: ServerParameter) {
-        // if (server === ServerParameter.DEFAULT) {
-        //     serverToConnect = this.findCurrentServer()
-        // }
-        //
-        // if (server === ServerParameter.NEXT) {
-        //     serverToConnect = this.findNextAvailableServer()
-        // }
-        //
-        // if (server === ServerParameter.PREVIOUS) {
-        //     serverToConnect = this.findMaxPriorityServer()
-        // }
-
-        if (serverParameter === ServerParameter.MAIN) {
-            this.findMainServer()
-        }
-
-        if (serverParameter === ServerParameter.NEXT) {
-            this.findNextServer()
-        }
-
-        this.socketIoClass.doReconnect = true
-
-        this.socketIoClass.initSocketConnection()
-
-        this.socketIoClass.initSocketEvents()
-
-        this.socketIoClass.initKeepAlive()
-
-        this.loggerClass.init()
-    }
-
-    public disconnect () {
-        this.socketIoClass.doReconnect = false
-        this.socketIoClass.closeAllConnections()
-    }
-
-    public clearKeepAliveInterval () {
-        this.socketIoClass.clearKeepAliveInterval()
-    }
-
-    private findMainServer () {
-        if (this.servers.length) {
-            this.mainServer = this.servers.reduce((prev, cur) => {
-                return cur.Priority > prev.Priority ? cur : prev
-            })
-
-            this.server = this.mainServer
-        } else {
-            if (this.URLList.length) {
-                this.URL = this.URLList[0]
-            }
-        }
-    }
-
-    private findNextServer () {
-        if (this.servers.length) {
-            if (this.server.Priority === this.mainServer!.Priority) {
-                let filteredServers = this.servers.filter(
-                    server =>
-                        server.Priority !== this.mainServer!.Priority &&
-                        this.alreadyAttemptedOtherServers.indexOf(server.Priority) + 1 === 0
-                )
-
-                if (!filteredServers.length) {
-                    this.alreadyAttemptedOtherServers = []
-
-                    filteredServers = this.servers.filter(
-                        server =>
-                            server.Priority !== this.mainServer!.Priority &&
-                            this.alreadyAttemptedOtherServers.indexOf(server.Priority) + 1 === 0
-                    )
-                }
-
-                if (filteredServers.length) {
-                    this.server = filteredServers.reduce((prev, cur) => {
-                        return cur.Priority > prev.Priority ? cur : prev
-                    })
-
-                    this.alreadyAttemptedOtherServers.push(this.server.Priority)
-                }
-            } else {
-                this.server = this.mainServer!
-            }
-        } else {
-            if (this.URLList.length) {
-                if (this.URL === this.URLList[0]) {
-                    let filteredServers = this.URLList.filter(
-                        url =>
-                            url !== this.URLList[0] &&
-                            this.alreadyAttemptedOtherServers.indexOf(url) + 1 === 0
-                    )
-
-                    if (!filteredServers.length) {
-                        this.alreadyAttemptedOtherServers = []
-
-                        filteredServers = this.URLList.filter(
-                            url =>
-                                url !== this.URLList[0] &&
-                                this.alreadyAttemptedOtherServers.indexOf(url) + 1 === 0
-                        )
-                    }
-
-                    if (filteredServers.length) {
-                        this.URL = filteredServers[0]
-
-                        this.alreadyAttemptedOtherServers.push(this.URL)
-                    }
-                } else {
-                    this.URL = this.URLList[0]
-                }
-            }
-        }
-    }
-
-    public async init () {
-        if (this.socket) {
-            // this.emit(eventTypes.CLOSE);
-        }
-
-        await this.authClass.login(this.options)
-
-        this.getServers()
-
-        return true
-    }
-
-    private getServers () {
-        if (this.options.serverFetchStrategy === 'static' && this.argumentOptions.servers && Array.isArray(this.argumentOptions.servers) && this.argumentOptions.servers.length > 1) {
-            this.servers = this.argumentOptions.servers
-        }
-    }
-}
-
-export default EventsSdkClass

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

@@ -1,17 +0,0 @@
-import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
-import { LoginType } from '@/enum/auth.enum'
-
-describe('EventsSdkClass', () => {
-    it('should be true', () => {
-        const eventsSdkClass = new EventsSdkClass({
-            loginUrl: 'https://loginapidev.voicenter.co.il/Auth/Login/Voicenter/Monitor',
-            refreshTokenUrl: 'https://loginapidev.voicenter.co.il/Auth/RefreshToken',
-            loginType: LoginType.TOKEN, // <=== "User" or "Token"
-            token: 'QMSVU9dwNYC9Le9VCBqx24AB9TYyWj9Xn5aCPV0GFHIWoShQqfPtnAPmnw24xpJIUSsDDtlac2OPpjx0t3MSkxH3AhiQGHCeGZ8e',
-            getSettingsUrl: 'https://loginapidev.voicenter.co.il/Application/GetSettings',
-            isNewStack: true,
-        })
-
-        expect(eventsSdkClass.init()).toBe(true)
-    })
-})