@voicenter-team/events-sdk 0.0.29 → 0.0.30

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

@@ -1,75 +0,0 @@
-import { Socket } from 'socket.io-client'
-import { LoginType } from '@/enum/auth.enum'
-import { LoggerOptions } from '@voicenter-team/socketio-storage-logger/dist/storage-logger'
-
-export interface EventsSdkOptions {
-    isNewStack?: boolean,
-    servers?: Server[],
-    loginUrl: string,
-    getSettingsUrl?: string
-    fallbackServer: Server,
-    refreshTokenUrl: string,
-    refreshToken?: 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?: Socket,
-    loggerServer: string,
-    loggerConfig: LoggerOptions,
-    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?: {
-        threshold: number
-    },
-    upgrade?: boolean,
-    transports?: string[],
-    debug?: boolean
-}
-
-export interface ReconnectOptions {
-    retryCount: number,
-    maxReconnectAttempts: number,
-    reconnectionDelay: number,
-    minReconnectionDelay: number,
-    maxReconnectionDelay: number
-}
-
-export enum ServerParameter {
-    MAIN = 'main',
-    NEXT = 'next'
-}

package/src/classes/logger/logger.class.ts

@@ -1,61 +0,0 @@
-import { Socket } from 'socket.io-client'
-import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
-import { LoggerTypeEnum } from '@/enum/logger.enum'
-import { EventsEnum } from '@voicenter-team/real-time-events-types'
-import StorageLogger from '@voicenter-team/socketio-storage-logger'
-
-export class LoggerClass{
-    constructor (private readonly eventsSdkClass: EventsSdkClass) {
-        this.eventsSdkClass = eventsSdkClass
-    }
-
-    public io: Socket | undefined
-    private storageLogger: StorageLogger | undefined
-
-    public init () {
-        if (!this.eventsSdkClass.options.useLogger) {
-            return
-        }
-
-        if (this.eventsSdkClass.options.loggerSocketConnection) {
-            this.io = this.eventsSdkClass.options.loggerSocketConnection
-        } else {
-            if (this.eventsSdkClass.socketIoClass.ioFunction) {
-                this.io = this.eventsSdkClass.socketIoClass.ioFunction(
-                    this.eventsSdkClass.options.loggerServer,
-                    this.eventsSdkClass.options.loggerConnectOptions
-                )
-            }
-        }
-
-        if (this.io) {
-            this.storageLogger = new StorageLogger({
-                socket: this.io,
-                loggerOptions: this.eventsSdkClass.options.loggerConfig
-            })
-        } else {
-            this.storageLogger = new StorageLogger({
-                url: this.eventsSdkClass.options.loggerServer,
-                socketOptions: this.eventsSdkClass.options.loggerConnectOptions,
-                loggerOptions: this.eventsSdkClass.options.loggerConfig
-            })
-        }
-    }
-
-    public log (type: LoggerTypeEnum, event: EventsEnum | string, ...data: unknown[]) {
-        const result = [ event, ...data ]
-        if (this.storageLogger) {
-            if (type === LoggerTypeEnum.INFO) {
-                this.storageLogger.log(result)
-            } else if (type === LoggerTypeEnum.ERROR) {
-                this.storageLogger.error(result)
-            }
-        } else {
-            if (type === LoggerTypeEnum.INFO) {
-                console.log(result)
-            } else if (type === LoggerTypeEnum.ERROR) {
-                console.error(result)
-            }
-        }
-    }
-}

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

@@ -1,220 +0,0 @@
-import { ManagerOptions, Socket, 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, KeepAliveResponseEvent } from '@voicenter-team/real-time-events-types'
-import { StorageClass } from '@/classes/storage/storage.class'
-import { LoggerTypeEnum } from '@/enum/logger.enum'
-// import { LoggerTypeEnum } from '@/enum/logger.enum'
-
-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 ? server.Domain : this.eventsSdkClass.URL
-
-            const url = server ? `${protocol}://${domain}` : this.eventsSdkClass.URL
-
-            this.eventsSdkClass.loggerClass.log(
-                LoggerTypeEnum.INFO,
-                'Connecting to..',
-                url
-            )
-
-            this.eventsSdkClass.eventEmitterClass.emit(
-                EventsEnum.ONLINE_STATUS_EVENT,
-                {
-                    isSocketConnected: false,
-                    attemptToConnect: url
-                }
-            )
-
-            const options: Partial<ManagerOptions & SocketOptions> = {
-                reconnection: false,
-                upgrade: false,
-                transports: [ 'websocket' ],
-                forceNew: true,
-                query: {
-                    token
-                },
-                timeout: this.eventsSdkClass.options.timeout
-            }
-
-            if (token) {
-                options.query = {
-                    token
-                }
-            }
-
-            if (this.ioFunction && url) {
-                this.io = this.ioFunction(url, options)
-            } else {
-                throw new Error('Socket server url no defined')
-            }
-        } catch (error) {
-            this.eventsSdkClass.loggerClass.log(LoggerTypeEnum.ERROR, 'init socket connection error', error)
-        }
-    }
-
-    public initSocketEvents () {
-        if (this.io) {
-            this.io
-                .on(EventsEnum.LOGIN_SUCCESS, (data) => this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.LOGIN_SUCCESS, data))
-                .on(EventsEnum.QUEUE_EVENT, (data) => this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.QUEUE_EVENT, data))
-                .on(EventsEnum.EXTENSION_EVENT, (data) => this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.EXTENSION_EVENT, data))
-                .on(EventsEnum.DIALER_EVENT, (data) => this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.DIALER_EVENT, data))
-                .on(EventsEnum.LOGIN_STATUS, (data) => this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.LOGIN_STATUS, data))
-                .on(EventsEnum.ALL_EXTENSION_STATUS, (data) => this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.ALL_EXTENSION_STATUS, data))
-                .on(EventsEnum.ALL_DIALER_STATUS, (data) => this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.ALL_DIALER_STATUS, data))
-                .on(EventsEnum.KEEP_ALIVE_RESPONSE, (data) => this.onKeepAliveResponse(data))
-                .on(EventsEnum.CONNECT, () => this.onConnect())
-                .on(EventsEnum.DISCONNECT, (data) => this.onDisconnect(data))
-                .on(EventsEnum.CONNECT_ERROR_EVENT, (data) => this.onConnectError(data))
-                .on(EventsEnum.EXTENSIONS_UPDATED, (data) => {
-                    this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.EXTENSIONS_UPDATED, data)
-                })
-        }
-    }
-
-    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.eventsSdkClass.emit(EventsEnum.KEEP_ALIVE, this.eventsSdkClass.authClass.token)
-
-                this.eventsSdkClass.loggerClass.log(LoggerTypeEnum.INFO, `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) {
-        this.eventsSdkClass.loggerClass.log(LoggerTypeEnum.INFO, EventsEnum.KEEP_ALIVE_RESPONSE)
-
-        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.loggerClass.log(
-            LoggerTypeEnum.INFO,
-            EventsEnum.CONNECT,
-            this.eventsSdkClass.reconnectOptions
-        )
-
-        this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: true })
-    }
-
-    private onDisconnect (reason: Socket.DisconnectReason) {
-        this.connected = false
-
-        this.eventsSdkClass.loggerClass.log(
-            LoggerTypeEnum.INFO,
-            EventsEnum.DISCONNECT,
-            reason
-        )
-
-        this.closeAllConnections()
-
-        this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: false })
-
-        if (!this.doReconnect) {
-            return
-        }
-
-        console.log('attempt to connect...')
-        this.eventsSdkClass.connect(ServerParameter.NEXT)
-    }
-
-    private onConnectError (data: Error) {
-        this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: false })
-
-        this.eventsSdkClass.loggerClass.log(
-            LoggerTypeEnum.ERROR,
-            EventsEnum.CONNECT_ERROR_EVENT,
-            data
-        )
-
-        setTimeout(() => {
-            this.eventsSdkClass.connect(ServerParameter.NEXT)
-        },this.eventsSdkClass.options.reconnectionDelay)
-    }
-}

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
-}