@voicenter-team/events-sdk 0.0.12 → 0.0.14

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

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