@voicenter-team/events-sdk 0.0.19 → 0.0.20

package/docs/src/.vuepress/components/Demo.vue

@@ -64,12 +64,24 @@ async function login() {
     loading.value = true
 
     const sdk = new EventsSdkClass({
-      loginUrl: "https://loginapidev.voicenter.co.il/Auth/Login/Voicenter/Monitor",
-      refreshTokenUrl: "https://loginapidev.voicenter.co.il/Auth/RefreshToken",
+      loginUrl: "https://loginapi.voicenter.co.il/monitorAPI/Login",
+      refreshTokenUrl: "https://loginapi.voicenter.co.il/monitorAPI/RefreshIdentityToken",
       loginType: LoginType.TOKEN, // <=== "User" or "Token"
       token: 'QMSVU9dwNYC9Le9VCBqx24AB9TYyWj9Xn5aCPV0GFHIWoShQqfPtnAPmnw24xpJIUSsDDtlac2OPpjx0t3MSkxH3AhiQGHCeGZ8e',
-      getSettingsUrl: "https://loginapidev.voicenter.co.il/Application/GetSettings",
-      isNewStack: true,
+      servers: [
+        {
+          URLID: 1,
+          Priority: 1,
+          Version: "1.3.7",
+          Domain: "monitor5.voicenter.co.il"
+        },
+        {
+          URLID: 2,
+          Priority: 2,
+          Version: "1.3.7",
+          Domain: "monitor6.voicenter.co.il"
+        }
+      ],
     })
 
     await sdk.init()

package/package.json

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

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

@@ -120,17 +120,23 @@ class AuthClass{
                 (prev.Priority > current.Priority) ? prev : current
             )
         }
+        if (!this.eventsSdkClass.options.isNewStack && !this.eventsSdkClass.servers.length && loginSessionData.URLList) {
+            this.eventsSdkClass.URLList = loginSessionData.URLList
+        }
         if (this.eventsSdkClass.server) {
             this.eventsSdkClass.socketIoClass.getSocketIoFunction(`v=${this.eventsSdkClass.server.Version}`)
             this.eventsSdkClass.loggerClass.init()
         }
+        if (!this.eventsSdkClass.server && this.eventsSdkClass.URLList.length) {
+            this.eventsSdkClass.socketIoClass.getSocketIoFunction(`v=${loginSessionData.Client}`)
+        }
         if (loginSessionData.IdentityCode) {
             this.token = loginSessionData.IdentityCode
-            this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
+            this.eventsSdkClass.connect(ServerParameter.MAIN)
         }
         if (loginSessionData.Token) {
             this.token = loginSessionData.Token
-            this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
+            this.eventsSdkClass.connect(ServerParameter.MAIN)
         }
         if (loginSessionData.RefreshToken && loginSessionData.IdentityCodeExpiry && this.eventsSdkClass.options.loginType === LoginType.USER) {
             this.eventsSdkClass.options.refreshToken = loginSessionData.RefreshToken

package/src/classes/events-sdk/events-sdk-default-options.ts

@@ -26,7 +26,7 @@ export const eventsSdkDefaultOptions: Partial<EventsSdkOptions> = {
         reconnection: true,
         reconnectionDelay: 5000,
         reconnectionAttempts: 10,
-        perMessageDeflate: false,
+        perMessageDeflate: undefined,
         upgrade: false,
         transports: [ 'websocket' ],
         debug: false

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

@@ -5,53 +5,34 @@ 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,
+    EventSpecificCallback,
     EventTypeData,
     EventTypeNames,
+    GenericEventWrapper,
 } from '@/types/events'
 import { EventsEnum } from '@/enum/events.enum'
 import { LoggerClass } from '@/classes/logger/logger.class'
 
 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 readonly options: EventsSdkOptions
     public servers: Server[] = []
+    public URLList: string[] = []
     public server: Server
+    public URL: string | undefined
     public socket: SocketTyped | undefined
+    private mainServer: Server | undefined
+
+    private alreadyAttemptedOtherServers: Array<number | string> = []
 
     public authClass = new AuthClass(this)
     public socketIoClass = new SocketIoClass(this)
     public loggerClass = new LoggerClass(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 reconnectOptions: ReconnectOptions
 
-    public retryConnection = debounce(this.connect.bind(this), this.reconnectOptions.reconnectionDelay, {
-        leading: true,
-        trailing: false
-    })
+    public retryConnection
 
     private listeners: EventCallbackListenersMap = {
         [EventsEnum.ALL_EXTENSION_STATUS]: [],
@@ -67,6 +48,32 @@ class EventsSdkClass{
     }
     private allListeners: Array<(data: GenericEventWrapper) => void> = []
 
+    constructor (options: EventsSdkOptions) {
+        this.options = {
+            ...eventsSdkDefaultOptions,
+            ...options
+        }
+
+        this.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
+        }
+
+        this.server = this.options.fallbackServer
+
+        this.retryConnection = debounce(this.connect.bind(this), this.reconnectOptions.reconnectionDelay, {
+            leading: true,
+            trailing: false
+        })
+
+        this.argumentOptions = {
+            ...options
+        }
+    }
+
     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) {
@@ -110,23 +117,25 @@ class EventsSdkClass{
         this.allListeners.forEach((callback) => callback(allEventData))
     }
 
-    public connect (server: ServerParameter = ServerParameter.DEFAULT) {
-        let serverToConnect: Server | undefined
-
-        if (server === ServerParameter.DEFAULT) {
-            serverToConnect = this.findCurrentServer()
+    public connect (serverParameter: ServerParameter) {
+        // if (server === ServerParameter.DEFAULT) {
+        //     serverToConnect = this.findCurrentServer()
+        // }
+        //
+        // if (server === ServerParameter.NEXT) {
+        //     serverToConnect = this.findNextAvailableServer()
+        // }
+        //
+        // if (server === ServerParameter.PREVIOUS) {
+        //     serverToConnect = this.findMaxPriorityServer()
+        // }
+
+        if (serverParameter === ServerParameter.MAIN) {
+            this.findMainServer()
         }
 
-        if (server === ServerParameter.NEXT) {
-            serverToConnect = this.findNextAvailableServer()
-        }
-
-        if (server === ServerParameter.PREVIOUS) {
-            serverToConnect = this.findMaxPriorityServer()
-        }
-
-        if (!serverToConnect) {
-            this.server = this.findCurrentServer()
+        if (serverParameter === ServerParameter.NEXT) {
+            this.findNextServer()
         }
 
         this.socketIoClass.doReconnect = true
@@ -147,66 +156,78 @@ class EventsSdkClass{
         this.socketIoClass.clearKeepAliveInterval()
     }
 
-    private findCurrentServer (): Server {
+    private findMainServer () {
         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');
+            this.mainServer = this.servers.reduce((prev, cur) => {
+                return cur.Priority > prev.Priority ? cur : prev
+            })
 
-        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
+            this.server = this.mainServer
+        } else {
+            if (this.URLList.length) {
+                this.URL = this.URLList[0]
+            }
         }
-
-        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
+    private findNextServer () {
+        if (this.servers.length) {
+            if (this.server.Priority === this.mainServer!.Priority) {
+                let filteredServers = this.servers.filter(
+                    server =>
+                        server.Priority !== this.mainServer!.Priority &&
+                        this.alreadyAttemptedOtherServers.indexOf(server.Priority) + 1 === 0
+                )
+
+                if (!filteredServers.length) {
+                    this.alreadyAttemptedOtherServers = []
+
+                    filteredServers = this.servers.filter(
+                        server =>
+                            server.Priority !== this.mainServer!.Priority &&
+                            this.alreadyAttemptedOtherServers.indexOf(server.Priority) + 1 === 0
+                    )
+                }
+
+                if (filteredServers.length) {
+                    this.server = filteredServers.reduce((prev, cur) => {
+                        return cur.Priority > prev.Priority ? cur : prev
+                    })
+
+                    this.alreadyAttemptedOtherServers.push(this.server.Priority)
+                }
+            } else {
+                this.server = this.mainServer!
+            }
+        } else {
+            if (this.URLList.length) {
+                if (this.URL === this.URLList[0]) {
+                    let filteredServers = this.URLList.filter(
+                        url =>
+                            url !== this.URLList[0] &&
+                            this.alreadyAttemptedOtherServers.indexOf(url) + 1 === 0
+                    )
+
+                    if (!filteredServers.length) {
+                        this.alreadyAttemptedOtherServers = []
+
+                        filteredServers = this.URLList.filter(
+                            url =>
+                                url !== this.URLList[0] &&
+                                this.alreadyAttemptedOtherServers.indexOf(url) + 1 === 0
+                        )
+                    }
+
+                    if (filteredServers.length) {
+                        this.URL = filteredServers[0]
+
+                        this.alreadyAttemptedOtherServers.push(this.URL)
+                    }
+                } else {
+                    this.URL = this.URLList[0]
+                }
+            }
         }
-
-        return this.server
     }
 
     public getServerWithHighestPriority (servers: Server[]): Server {

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

@@ -1,9 +1,17 @@
 import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
-import { eventsSdkDefaultOptions } from '@/classes/events-sdk/events-sdk-default-options'
+import { LoginType } from '@/enum/auth.enum'
 
 describe('EventsSdkClass', () => {
     it('should be true', () => {
-        const eventsSdkClass = new EventsSdkClass(eventsSdkDefaultOptions)
+        const eventsSdkClass = new EventsSdkClass({
+            loginUrl: 'https://loginapidev.voicenter.co.il/Auth/Login/Voicenter/Monitor',
+            refreshTokenUrl: 'https://loginapidev.voicenter.co.il/Auth/RefreshToken',
+            loginType: LoginType.TOKEN, // <=== "User" or "Token"
+            token: 'QMSVU9dwNYC9Le9VCBqx24AB9TYyWj9Xn5aCPV0GFHIWoShQqfPtnAPmnw24xpJIUSsDDtlac2OPpjx0t3MSkxH3AhiQGHCeGZ8e',
+            getSettingsUrl: 'https://loginapidev.voicenter.co.il/Application/GetSettings',
+            isNewStack: true,
+        })
+
         expect(eventsSdkClass.init()).toBe(true)
     })
-})
+})

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

@@ -4,7 +4,7 @@ import { LoginType } from '@/enum/auth.enum'
 
 export interface EventsSdkOptions {
     isNewStack?: boolean,
-    servers: Server[],
+    servers?: Server[],
     loginUrl: string,
     getSettingsUrl?: string
     fallbackServer: Server,
@@ -70,7 +70,6 @@ export interface ReconnectOptions {
 }
 
 export enum ServerParameter {
-    DEFAULT = 'default',
-    NEXT = 'next',
-    PREVIOUS = 'previous'
+    MAIN = 'main',
+    NEXT = 'next'
 }

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

@@ -39,9 +39,9 @@ export class SocketIoClass{
         const server = this.eventsSdkClass.server
 
         try {
-            const domain = server.Domain
+            const domain = server ? server.Domain : this.eventsSdkClass.URL
 
-            const url = `${protocol}://${domain}`
+            const url = server ? `${protocol}://${domain}` : this.eventsSdkClass.URL
 
             // this.eventsSdkClass.loggerClass.log(
             //     LoggerTypeEnum.INFO,
@@ -74,8 +74,10 @@ export class SocketIoClass{
                 }
             }
 
-            if (this.ioFunction) {
+            if (this.ioFunction && url) {
                 this.io = this.ioFunction(url, options)
+            } else {
+                throw new Error('Socket server url no defined')
             }
         } catch (e) {
             // this.log(ERROR, e);
@@ -97,7 +99,9 @@ export class SocketIoClass{
                 .on(EventsEnum.DISCONNECT, () => this.onDisconnect())
                 .on(EventsEnum.CONNECT_ERROR_EVENT, () => {
                     this.eventsSdkClass.emit(EventsEnum.ONLINE_STATUS_EVENT, { isSocketConnected: false })
-                    this.eventsSdkClass.connect(ServerParameter.NEXT)
+                    setTimeout(() => {
+                        this.eventsSdkClass.connect(ServerParameter.NEXT)
+                    },this.eventsSdkClass.options.reconnectionDelay)
                 })
         }
     }
@@ -182,9 +186,7 @@ export class SocketIoClass{
             return
         }
 
-        this.keepReconnectInterval = setInterval(() => {
-            console.log('attempt to connect...')
-            this.eventsSdkClass.connect(ServerParameter.NEXT, true)
-        }, 15000)
+        console.log('attempt to connect...')
+        this.eventsSdkClass.connect(ServerParameter.NEXT)
     }
 }