@voicenter-team/events-sdk 0.0.1

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

@@ -0,0 +1,237 @@
+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 {
+    GenericEventWrapper,
+    EventSpecificCallback,
+    EventCallbackListenersMap,
+    EventTypeData,
+    EventTypeNames,
+} from '@/types/events'
+import { EventsEnum } from '@/enum/events.enum'
+
+class EventsSdkClass{
+    constructor (options: EventsSdkOptions) {
+        this.options = {
+            ...eventsSdkDefaultOptions,
+            ...options
+        }
+
+        this.server = this.options.fallbackServer
+
+        this.argumentOptions = {
+            ...options
+        }
+    }
+
+    private argumentOptions: EventsSdkOptions
+    public readonly options: EventsSdkOptions = {
+        ...eventsSdkDefaultOptions
+    }
+    public servers: Server[] = []
+    public server: Server
+    public socket: SocketTyped | undefined
+
+    public authClass = new AuthClass(this)
+    public socketIoClass = new SocketIoClass(this)
+
+    public reconnectOptions: 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
+    }
+
+    public retryConnection = debounce(this.connect.bind(this), this.reconnectOptions.reconnectionDelay, {
+        leading: true,
+        trailing: false
+    })
+
+    private listeners: EventCallbackListenersMap = {
+        [EventsEnum.ALL_EXTENSION_STATUS]: [],
+        [EventsEnum.ALL_DIALER_STATUS]: [],
+        [EventsEnum.ALL_USERS_STATUS]: [],
+        [EventsEnum.QUEUE_EVENT]: [],
+        [EventsEnum.EXTENSION_EVENT]: [],
+        [EventsEnum.LOGIN_SUCCESS]: [],
+        [EventsEnum.LOGIN_STATUS]: [],
+        [EventsEnum.KEEP_ALIVE_RESPONSE]: [],
+        [EventsEnum.ONLINE_STATUS_EVENT]: []
+    }
+    private allListeners: Array<(data: GenericEventWrapper) => void> = []
+
+    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.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))
+    }
+
+    public connect (server: ServerParameter = ServerParameter.DEFAULT, skipLogin = false) {
+        let serverToConnect: Server | undefined
+
+        if (server === ServerParameter.DEFAULT) {
+            serverToConnect = this.findCurrentServer()
+        }
+
+        if (server === ServerParameter.NEXT) {
+            serverToConnect = this.findNextAvailableServer()
+        }
+
+        if (server === ServerParameter.PREVIOUS) {
+            serverToConnect = this.findMaxPriorityServer()
+        }
+
+        if (!serverToConnect) {
+            this.server = this.findCurrentServer()
+        }
+
+        this.socketIoClass.initSocketConnection()
+
+        this.socketIoClass.initSocketEvents()
+
+        this.socketIoClass.initKeepAlive()
+
+        if (skipLogin) {
+            return
+        }
+    }
+
+    private findCurrentServer (): Server {
+        if (this.servers.length) {
+            this.server = this.servers[0]
+        }
+        if (!this.server) {
+            this.server = this.options.fallbackServer
+        }
+        return this.server
+    }
+
+    private findNextAvailableServer (): Server {
+        // this.log(INFO, 'Failover -> Trying to find another server');
+
+        const currentServerPriority = this.server.Priority
+
+        const nextServerPriority = currentServerPriority + 1
+
+        const nextServer = this.servers.find(server => server.Priority === nextServerPriority) || this.findMinPriorityServer()
+
+        this.server = { ...nextServer }
+
+        // this.log(INFO, 'Failover -> Found new server. Connecting to it...', this.server);
+
+        return this.server
+    }
+
+    private findMaxPriorityServer (): Server {
+        // this.log(INFO, 'Fallback -> Trying to find previous server');
+
+        const maxPriorityServer = this.getServerWithHighestPriority(this.servers)
+
+        if (!this.server) {
+            this.server = maxPriorityServer
+
+            return this.server
+        }
+
+        if (this.server && maxPriorityServer.Domain !== this.server.Domain) {
+            this.server = maxPriorityServer
+
+            // this.log(INFO, 'Fallback -> Trying to find previous server');
+
+            return this.server
+        }
+
+        return this.server
+    }
+
+    private findMinPriorityServer (): Server {
+        const minPriority = Math.min(...this.servers.map(server => server.Priority))
+
+        const server = this.servers.find(server => server.Priority === minPriority)
+
+        if (server) {
+            this.server = server
+
+            return this.server
+        }
+
+        return this.server
+    }
+
+    public getServerWithHighestPriority (servers: Server[]): Server {
+        let chosenServer: Server | undefined
+
+        let maxPriority = Number.MAX_SAFE_INTEGER
+
+        chosenServer = servers.find(server => {
+            if (server.Priority < maxPriority) {
+                maxPriority = server.Priority
+
+                chosenServer = server
+            }
+        })
+
+        return chosenServer ? chosenServer : this.server
+    }
+
+    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

@@ -0,0 +1,9 @@
+import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
+import { eventsSdkDefaultOptions } from '@/classes/events-sdk/events-sdk-default-options'
+
+describe('EventsSdkClass', () => {
+    it('should be true', () => {
+        const eventsSdkClass = new EventsSdkClass(eventsSdkDefaultOptions)
+        expect(eventsSdkClass.init()).toBe(true)
+    })
+})

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

@@ -0,0 +1,77 @@
+export interface EventsSdkOptions {
+    url?: string,
+    environment?: string,
+    fallbackServer: Server,
+    loginUrl: string,
+    refreshTokenUrl?: string,
+    refreshToken?: string,
+    servers?: string,
+    token: string,
+    tokenExpiry?: Date,
+    loginType: string,
+    forceNew?: boolean,
+    reconnectionDelay: number,
+    reconnectionDelayMax?: number,
+    maxReconnectAttempts: number,
+    timeout?: number,
+    keepAliveTimeout: number,
+    idleInterval?: number,
+    protocol: string,
+    transports?: string[],
+    upgrade?: boolean,
+    store?: string,
+    extensionsModuleName?: string,
+    queuesModuleName?: string,
+    dialersModuleName?: string,
+    serverFetchStrategy?: string,
+    serverType?: number,
+    useLogger?: boolean,
+    loggerSocketConnection?: string,
+    loggerServer?: string,
+    loggerConfig?: LoggerConfig,
+    loggerConnectOptions?: LoggerConnectOptions,
+    email: string,
+    password: string,
+    username: string
+}
+
+export enum Environment {
+    BROWSER = 'browser',
+    CHROME_EXTENSION = 'chrome-extension'
+}
+
+export interface Server {
+    Priority: number,
+    Domain: string
+}
+
+export interface LoggerConfig {
+    logToConsole?: boolean,
+    overloadGlobalConsole?: boolean,
+    namespace?: string,
+    socketEmitInterval?: number
+}
+
+export interface LoggerConnectOptions {
+    reconnection?: boolean,
+    reconnectionDelay?: number,
+    reconnectionAttempts?: number,
+    perMessageDeflate?: boolean,
+    upgrade?: boolean,
+    transports?: string[],
+    debug?: boolean
+}
+
+export interface ReconnectOptions {
+    retryCount: number,
+    maxReconnectAttempts: number,
+    reconnectionDelay: number,
+    minReconnectionDelay: number,
+    maxReconnectionDelay: number
+}
+
+export enum ServerParameter {
+    DEFAULT = 'default',
+    NEXT = 'next',
+    PREVIOUS = 'previous'
+}

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

@@ -0,0 +1,166 @@
+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 { EventsEnum } from '@/enum/events.enum'
+import { KeepAliveResponseEvent } from '@/types/events'
+
+export class SocketIoClass{
+    constructor (private readonly eventsSdkClass: EventsSdkClass) {
+        this.eventsSdkClass = eventsSdkClass
+    }
+
+    public io: SocketTyped | undefined
+    public ioFunction: TypedSocketIo | undefined
+    public lastEventTimestamp = new Date().getTime()
+    private keepAliveInterval: ReturnType<typeof setInterval> | undefined
+    private keepReconnectInterval: ReturnType<typeof setInterval> | undefined
+    private connected = false
+
+    public getSocketIoFunction (Client: string) {
+        const parsedArray = Client.split('v=')
+
+        const version = 'v'
+            .concat(parsedArray[parsedArray.length - 1])
+            .replaceAll('.', '_')
+
+        this.ioFunction = sockets.getSocketVersion(version)
+    }
+
+    public initSocketConnection () {
+        const token = this.eventsSdkClass.authClass.token
+
+        const protocol = this.eventsSdkClass.options.protocol
+
+        const server = this.eventsSdkClass.server
+
+        try {
+            const domain = server.Domain
+
+            const url = `${protocol}://${domain}`
+
+            // this.log(INFO, 'Connecting to..', url);
+
+            const options: Partial<ManagerOptions & SocketOptions> = {
+                reconnection: false,
+                upgrade: false,
+                transports: [ 'websocket' ],
+                forceNew: true,
+                query: {
+                    token
+                }
+            }
+
+            if (token) {
+                options.query = {
+                    token
+                }
+            }
+
+            if (this.ioFunction) {
+                this.io = this.ioFunction(url, options)
+            }
+        } catch (e) {
+            // this.log(ERROR, e);
+        }
+    }
+
+    public initSocketEvents () {
+        if (this.io) {
+            this.io
+                .on(EventsEnum.LOGIN_SUCCESS, (data) => this.eventsSdkClass.emit(EventsEnum.LOGIN_SUCCESS, data))
+                .on(EventsEnum.QUEUE_EVENT, (data) => this.eventsSdkClass.emit(EventsEnum.QUEUE_EVENT, data))
+                .on(EventsEnum.EXTENSION_EVENT, (data) => this.eventsSdkClass.emit(EventsEnum.EXTENSION_EVENT, data))
+                .on(EventsEnum.LOGIN_STATUS, (data) => this.eventsSdkClass.emit(EventsEnum.LOGIN_STATUS, data))
+                .on(EventsEnum.ALL_EXTENSION_STATUS, (data) => this.eventsSdkClass.emit(EventsEnum.ALL_EXTENSION_STATUS, data))
+                .on(EventsEnum.ALL_DIALER_STATUS, (data) => this.eventsSdkClass.emit(EventsEnum.ALL_DIALER_STATUS, data))
+                .on(EventsEnum.KEEP_ALIVE_RESPONSE, (data) => this.onKeepAliveResponse(data))
+                .on(EventsEnum.CONNECT, () => this.onConnect())
+                .on(EventsEnum.DISCONNECT, () => this.onDisconnect())
+        }
+    }
+
+    public initKeepAlive () {
+        if (this.keepAliveInterval) {
+            clearInterval(this.keepAliveInterval)
+        }
+
+        this.keepAliveInterval = setInterval(async () => {
+            const now = new Date().getTime()
+
+            // if (now > this.lastEventTimestamp + delta) {
+            //     this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
+            //
+            //     return
+            // }
+            //
+            // if (!this.io) {
+            //     this.initSocketConnection()
+            //
+            //     return
+            // }
+
+            if (now > this.lastEventTimestamp + this.eventsSdkClass.options.keepAliveTimeout && this.io) {
+                this.io.emit(EventsEnum.KEEP_ALIVE, this.eventsSdkClass.authClass.token)
+
+                return
+            }
+
+        }, this.eventsSdkClass.options.keepAliveTimeout)
+    }
+
+    public closeAllConnections () {
+        if (this.io) {
+            this.io.close()
+
+            this.io.disconnect()
+
+            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()
+        }
+    }
+
+    private onKeepAliveResponse (data: KeepAliveResponseEvent) {
+        if (data.errorCode) {
+            this.initSocketConnection()
+
+            return
+        }
+
+        if (this.connected) {
+            this.lastEventTimestamp = new Date().getTime()
+        } else {
+            this.initSocketConnection()
+        }
+    }
+
+    private onConnect () {
+        if (this.keepReconnectInterval) {
+            clearInterval(this.keepReconnectInterval)
+        }
+
+        this.connected = true
+
+        this.eventsSdkClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: true })
+    }
+
+    private onDisconnect () {
+        this.connected = false
+
+        this.closeAllConnections()
+
+        this.eventsSdkClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: false })
+
+        this.keepReconnectInterval = setInterval(() => {
+            console.log('attempt to connect...')
+            this.eventsSdkClass.connect(ServerParameter.NEXT, true)
+        }, 15000)
+    }
+}

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

@@ -0,0 +1,10 @@
+export interface SocketIoOptions {
+    reconnection: boolean,
+    perMessageDeflate: boolean,
+    upgrade: boolean,
+    transports: string[],
+    debug: boolean,
+    query: {
+        token: string
+    }
+}

package/src/classes/socket-io/versions/index.ts

@@ -0,0 +1,52 @@
+import { io } from 'socket.io-client'
+import { SocketTyped } from '@/types/socket'
+
+const importModules: Record<string, { default?: unknown }> = import.meta.glob(
+    './v*.js',
+    { eager: true }
+)
+
+const SOCKET_NAME_REGEX = /v\d+_\d+_\d+/
+
+export type TypedSocketIo = (...args: Parameters<typeof io>) => SocketTyped
+
+type SocketIoFn = () => TypedSocketIo
+
+function isSocketIoFn (socket: unknown): socket is SocketIoFn {
+    return typeof socket === 'function'
+}
+
+const sockets = Object.entries(importModules)
+    .reduce<Record<string, TypedSocketIo>>(
+        (acc, currentValue) => {
+            const module = currentValue[1].default
+            const moduleName = currentValue[0].match(SOCKET_NAME_REGEX)?.[0]
+
+            if (isSocketIoFn(module) && moduleName) {
+                acc[moduleName] = module()
+            }
+
+            return acc
+        },
+        {}
+    )
+
+const getSocketVersion = (version: string) => {
+    if (version in sockets) {
+        return sockets[version]
+    } else {
+        throw new Error(`Socket version ${version} not found`)
+    }
+}
+
+const makeSocketVersion = (version: string, ...args: Parameters<typeof io>) => {
+    const socket = getSocketVersion(version)
+
+    return socket(...args)
+}
+
+export default {
+    ...sockets,
+    getSocketVersion,
+    makeSocketVersion
+}