@voicenter-team/events-sdk 0.0.8 → 0.0.10

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

@@ -1,250 +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 {
-    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.DIALER_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.doReconnect = true
-
-        this.socketIoClass.initSocketConnection()
-
-        this.socketIoClass.initSocketEvents()
-
-        this.socketIoClass.initKeepAlive()
-
-        // TODO: check if it is needed here
-        if (skipLogin) {
-            return
-        }
-    }
-
-    public disconnect () {
-        this.socketIoClass.doReconnect = false
-        this.socketIoClass.closeAllConnections()
-    }
-
-    public clearKeepAliveInterval () {
-        this.socketIoClass.clearKeepAliveInterval()
-    }
-
-    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

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

@@ -1,69 +0,0 @@
-import { LoginType } from 'enum/auth.enum'
-
-export interface EventsSdkOptions {
-    fallbackServer: Server,
-    refreshTokenUrl?: string,
-    refreshToken?: string,
-    servers?: string,
-    token: string,
-    tokenExpiry?: Date,
-    loginType: LoginType,
-    forceNew?: boolean,
-    reconnectionDelay: number,
-    reconnectionDelayMax?: number,
-    maxReconnectAttempts: number,
-    timeout?: number,
-    keepAliveTimeout: number,
-    idleInterval?: number,
-    protocol: string,
-    transports?: string[],
-    upgrade?: boolean,
-    serverFetchStrategy?: string,
-    serverType?: number,
-    useLogger?: boolean,
-    loggerSocketConnection?: string,
-    loggerServer?: string,
-    loggerConfig?: LoggerConfig,
-    loggerConnectOptions?: LoggerConnectOptions,
-    email: string,
-    password: string,
-    username: string,
-}
-
-export interface Server {
-    Priority: number,
-    Domain: string,
-    URLID: number,
-    Version: 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

@@ -1,172 +0,0 @@
-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 { 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) {
-        this.eventsSdkClass = eventsSdkClass
-    }
-
-    public io: SocketTyped | undefined
-    public ioFunction: TypedSocketIo | undefined
-    public lastEventTimestamp = new Date().getTime()
-    public doReconnect = true
-    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.DIALER_EVENT, (data) => this.eventsSdkClass.emit(EventsEnum.DIALER_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 clearKeepAliveInterval () {
-        if (this.keepAliveInterval) {
-            clearInterval(this.keepAliveInterval)
-        }
-    }
-
-    public initKeepAlive () {
-        this.clearKeepAliveInterval()
-
-        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
-        }
-
-        StorageClass.clearSessionStorage()
-    }
-
-    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 })
-
-        if (!this.doReconnect) {
-            return
-        }
-
-        this.keepReconnectInterval = setInterval(() => {
-            console.log('attempt to connect...')
-            this.eventsSdkClass.connect(ServerParameter.NEXT, true)
-        }, 15000)
-    }
-}

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

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

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

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