@voicenter-team/events-sdk 0.0.22 → 0.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voicenter-team/events-sdk",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "",
   "main": "dist/voicenter-events-sdk.cjs.js",
   "jsdelivr": "dist/voicenter-events-sdk.umd.js",

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

@@ -34,7 +34,10 @@ class AuthClass{
             password: options.password
         }
 
-        this.storageKey = md5(JSON.stringify(options))
+        this.storageKey = md5(JSON.stringify({
+            ...options,
+            loggerSocketConnection: null 
+        }))
 
         if (this.lastLoginTimestamp && this.lastLoginTimestamp + this.delay > new Date().getTime()) {
             return
@@ -59,6 +62,8 @@ class AuthClass{
         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

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

@@ -0,0 +1,72 @@
+import {
+    EventCallbackListenersMap,
+    EventSpecificCallback,
+    EventTypeData,
+    EventTypeNames,
+    GenericEventWrapper
+} from '@/types/events'
+import { EventsEnum } from '@/enum/events.enum'
+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]: []
+    }
+    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.class.ts

@@ -5,14 +5,13 @@ 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 {
-    EventCallbackListenersMap,
     EventSpecificCallback,
-    EventTypeData,
     EventTypeNames,
     GenericEventWrapper,
 } from '@/types/events'
 import { EventsEnum } from '@/enum/events.enum'
 import { LoggerClass } from '@/classes/logger/logger.class'
+import { EventEmitterClass } from '@/classes/event-emitter/event-emitter.class'
 
 class EventsSdkClass{
     private argumentOptions: EventsSdkOptions
@@ -29,25 +28,12 @@ class EventsSdkClass{
     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
 
-    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> = []
-
     constructor (options: EventsSdkOptions) {
         this.options = {
             ...eventsSdkDefaultOptions,
@@ -75,48 +61,16 @@ class 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 on (event: '*', callback: (data: GenericEventWrapper) => void): void {
+        this.eventEmitterClass.on(event, callback)
     }
 
-    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 (event: EventsEnum, data: unknown) {
+        if (this.socketIoClass.io) {
+            this.socketIoClass.io.emit(event, data)
         }
     }
 
-    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 (serverParameter: ServerParameter) {
         // if (server === ServerParameter.DEFAULT) {
         //     serverToConnect = this.findCurrentServer()
@@ -230,22 +184,6 @@ class EventsSdkClass{
         }
     }
 
-    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);

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

@@ -1,4 +1,4 @@
-import { ManagerOptions, SocketOptions } from 'socket.io-client'
+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'
@@ -6,6 +6,7 @@ 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'
+import { LoggerTypeEnum } from '@/enum/logger.enum'
 // import { LoggerTypeEnum } from '@/enum/logger.enum'
 
 export class SocketIoClass{
@@ -43,14 +44,13 @@ export class SocketIoClass{
 
             const url = server ? `${protocol}://${domain}` : this.eventsSdkClass.URL
 
-            // this.eventsSdkClass.loggerClass.log(
-            //     LoggerTypeEnum.INFO,
-            //     EventsEnum.CONNECT,
-            //     'Connecting to..',
-            //     url
-            // )
+            this.eventsSdkClass.loggerClass.log(
+                LoggerTypeEnum.INFO,
+                'Connecting to..',
+                url
+            )
 
-            this.eventsSdkClass.emit(
+            this.eventsSdkClass.eventEmitterClass.emit(
                 EventsEnum.ONLINE_STATUS_EVENT,
                 {
                     isSocketConnected: false,
@@ -80,30 +80,25 @@ export class SocketIoClass{
             } else {
                 throw new Error('Socket server url no defined')
             }
-        } catch (e) {
-            // this.log(ERROR, e);
+        } 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.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.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, () => this.onDisconnect())
-                .on(EventsEnum.CONNECT_ERROR_EVENT, () => {
-                    this.eventsSdkClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: false })
-                    setTimeout(() => {
-                        this.eventsSdkClass.connect(ServerParameter.NEXT)
-                    },this.eventsSdkClass.options.reconnectionDelay)
-                })
+                .on(EventsEnum.DISCONNECT, (data) => this.onDisconnect(data))
+                .on(EventsEnum.CONNECT_ERROR_EVENT, (data) => this.onConnectError(data))
         }
     }
 
@@ -132,7 +127,9 @@ export class SocketIoClass{
             // }
 
             if (now > this.lastEventTimestamp + this.eventsSdkClass.options.keepAliveTimeout && this.io) {
-                this.io.emit(EventsEnum.KEEP_ALIVE, this.eventsSdkClass.authClass.token)
+                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
             }
@@ -153,6 +150,8 @@ export class SocketIoClass{
     }
 
     private onKeepAliveResponse (data: KeepAliveResponseEvent) {
+        this.eventsSdkClass.loggerClass.log(LoggerTypeEnum.INFO, EventsEnum.KEEP_ALIVE_RESPONSE)
+
         if (data.errorCode) {
             this.initSocketConnection()
 
@@ -173,15 +172,27 @@ export class SocketIoClass{
 
         this.connected = true
 
-        this.eventsSdkClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: true })
+        this.eventsSdkClass.loggerClass.log(
+            LoggerTypeEnum.INFO,
+            EventsEnum.CONNECT,
+            this.eventsSdkClass.reconnectOptions
+        )
+
+        this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: true })
     }
 
-    private onDisconnect () {
+    private onDisconnect (reason: Socket.DisconnectReason) {
         this.connected = false
 
+        this.eventsSdkClass.loggerClass.log(
+            LoggerTypeEnum.INFO,
+            EventsEnum.DISCONNECT,
+            reason
+        )
+
         this.closeAllConnections()
 
-        this.eventsSdkClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: false })
+        this.eventsSdkClass.eventEmitterClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: false })
 
         if (!this.doReconnect) {
             return
@@ -190,4 +201,18 @@ export class SocketIoClass{
         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)
+    }
 }