genesys-cloud-streaming-client 14.1.1-develop.14 → 14.1.1-develop.15

package/dist/es/utils.d.ts

@@ -1,9 +1,16 @@
-export { retryPromise, RetryPromise } from './types/retry-utils';
 export declare function timeoutPromise(fn: Function, timeoutMs: number, msg: string, details?: any): Promise<void>;
 export declare function splitIntoIndividualTopics(topicString: string): string[];
 export declare const isAcdJid: (jid: string) => boolean;
 export declare const isScreenRecordingJid: (jid: string) => boolean;
 export declare const isSoftphoneJid: (jid: string) => boolean;
 export declare const isVideoJid: (jid: string) => boolean;
+export declare type RetryPromise<T = any> = {
+    promise: Promise<T>;
+    cancel: (reason?: string | Error) => void;
+    complete: (value?: T) => void;
+    hasCompleted: () => boolean;
+    _id: string;
+};
+export declare function retryPromise<T = any>(promiseFn: () => Promise<T>, retryFn: (error?: Error | any) => boolean, retryInterval?: number, logger?: any): RetryPromise<T>;
 export declare const parseJwt: (token: string) => any;
 export declare function calculatePayloadSize(trace: any): number;

package/dist/es/utils.js

@@ -1,4 +1,5 @@
-export { retryPromise, RetryPromise } from './types/retry-utils';
+import { __awaiter } from "tslib";
+import { v4 } from 'uuid';
 export function timeoutPromise(fn, timeoutMs, msg, details) {
     return new Promise(function (resolve, reject) {
         const timeout = setTimeout(function () {
@@ -45,6 +46,48 @@ export const isSoftphoneJid = function (jid) {
 export const isVideoJid = function (jid) {
     return !!(jid && jid.match(/@conference/) && !isAcdJid(jid));
 };
+export function retryPromise(promiseFn, retryFn, retryInterval = 15000, logger = console) {
+    let timeout;
+    let cancel;
+    let complete;
+    let tryPromiseFn;
+    let _hasCompleted = false;
+    const promise = new Promise((resolve, reject) => {
+        tryPromiseFn = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const val = yield promiseFn();
+                complete(val);
+            }
+            catch (error) {
+                if (retryFn(error)) {
+                    logger.debug('Retrying promise', error);
+                    timeout = setTimeout(tryPromiseFn, retryInterval);
+                }
+                else {
+                    cancel(error);
+                }
+            }
+        });
+        complete = (value) => {
+            clearTimeout(timeout);
+            _hasCompleted = true;
+            resolve(value);
+        };
+        cancel = (reason) => {
+            clearTimeout(timeout);
+            _hasCompleted = true;
+            reject(reason);
+        };
+        tryPromiseFn();
+    });
+    return {
+        promise,
+        cancel,
+        complete,
+        _id: v4(),
+        hasCompleted: () => _hasCompleted
+    };
+}
 // from https://stackoverflow.com/questions/38552003/how-to-decode-jwt-token-in-javascript
 export const parseJwt = (token) => {
     const base64Url = token.split('.')[1];

package/dist/npm/CHANGELOG.md

@@ -5,6 +5,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 # [Unreleased](https://github.com/purecloudlabs/genesys-cloud-streaming-client/compare/v14.1.0...HEAD)
 
+### Fixed
+* [PCM-1943](https://inindca.atlassian.net/browse/PCM-1943) – Reverted faulty connect/retry logic introduced with [PCM-1908](https://inindca.atlassian.net/browse/PCM-1908) (v14.0.0)
+
 ### Added
 * [PCM-1935](https://inindca.atlassian.net/browse/PCM-1935) – added build, deploy, and publish notifications to the Jenkinsfile
 

package/dist/npm/client.d.ts

@@ -40,7 +40,6 @@ export declare class Client {
     disconnect(): Promise<void>;
     reconnect(): Promise<void>;
     connect(): Promise<void>;
-    _connectStanza(): Promise<void>;
     stopServerLogging(): void;
     startServerLogging(): void;
     setAccessToken(token: string): void;

package/dist/npm/client.js

@@ -60,7 +60,7 @@ class Client {
     constructor(options) {
         this.connected = false;
         this.connecting = false;
-        this.autoReconnect = false;
+        this.autoReconnect = true;
         this.hardReconnectCount = 0;
         this.reconnectLeakTime = 1000 * 60 * 10; // 10 minutes
         this.deadChannels = [];
@@ -126,9 +126,8 @@ class Client {
         this.on('connected', async (event) => {
             this.streamId = event.resource;
             this._ping.start();
-            this._reconnector.stop();
-            this.autoReconnect = true;
             this.connected = true;
+            this._reconnector.stop();
             this.connecting = false;
         });
         // remapped session:end
@@ -276,7 +275,16 @@ class Client {
         this.logger.info('streamingClient.connect was called');
         this.connecting = true;
         if (this.config.jwt) {
-            return this._connectStanza();
+            return utils_1.timeoutPromise(resolve => {
+                this.once('connected', resolve);
+                const options = stanzaOptionsJwt(this.config);
+                this._stanzaio.updateConfig(options);
+                this._stanzaio.connect();
+            }, 10 * 1000, 'connecting to streaming service with jwt')
+                .catch((err) => {
+                this.connecting = false;
+                return Promise.reject(err);
+            });
         }
         let jidPromise;
         if (this.config.jid) {
@@ -304,46 +312,17 @@ class Client {
             .then(([jid, channelId]) => {
             this.config.jid = jid;
             this.config.channelId = channelId;
-            return this._connectStanza();
-        });
-    }
-    async _connectStanza() {
-        const guestConnection = !!this.config.jwt;
-        const timeoutMsg = 'connecting to streaming service';
-        const options = guestConnection ? stanzaOptionsJwt(this.config) : stanzaioOptions(this.config);
-        const timeoutDetails = guestConnection
-            ? { usingJwt: true }
-            : { channelId: this.config.channelId, jidResource: this.config.jidResource };
-        /* if we already have a WS, we need to wait for the 2nd disconnect */
-        let skipDisconnectEvent = !!this._stanzaio.transport;
-        let rejectCallback;
-        return utils_1.timeoutPromise((resolve, reject) => {
-            rejectCallback = () => {
-                if (skipDisconnectEvent) {
-                    this.logger.debug('received a --transport-disconnected event from existing WS. Not rejecting new attempt to connect WS.');
-                    skipDisconnectEvent = false;
-                }
-                else {
-                    this.logger.debug('received a --transport-disconnected event while attempting to connect new WS. rejecting new attempt to connect WS.');
-                    reject(new Error('unexpected disconnect from the WebSocket connecting streaming service'));
-                }
-            };
-            /* if stanza runs into an error, we want to reject right away. There is no reason to wait for our timeout */
-            this._stanzaio.on('--transport-disconnected', rejectCallback);
-            this.once('connected', resolve);
-            this._stanzaio.updateConfig(options);
-            this._stanzaio.connect();
-        }, 10 * 1000, timeoutMsg, timeoutDetails)
+            this.autoReconnect = true;
+            return utils_1.timeoutPromise(resolve => {
+                this.once('connected', resolve);
+                const options = stanzaioOptions(this.config);
+                this._stanzaio.updateConfig(options);
+                this._stanzaio.connect();
+            }, 10 * 1000, 'connecting to streaming service', { jid, channelId });
+        })
             .catch((err) => {
             this.connecting = false;
-            /* if _we_ timed out but stanza is still trying to connect, we need to stop stanza's WS */
-            if (err.message === `Timeout: ${timeoutMsg}` && this._stanzaio.transport) {
-                this._stanzaio.disconnect();
-                this.logger.debug('timing out WS connect(), calling through to stanza to disconnect');
-            }
-            throw err;
-        }).finally(() => {
-            this._stanzaio.off('--transport-disconnected', rejectCallback);
+            return Promise.reject(err);
         });
     }
     stopServerLogging() {

package/dist/npm/http-client.js

@@ -75,7 +75,7 @@ class HttpClient {
         const value = this._httpRetryingRequests.get(retryId);
         if (value) {
             /* if the promise has already completed, this will do nothing. Still need to remove it from the map */
-            value.reject(new Error('Retry request cancelled'));
+            value.cancel(new Error('Retry request cancelled'));
             this._httpRetryingRequests.delete(retryId);
         }
         return true;

package/dist/npm/reconnector.d.ts

@@ -10,7 +10,7 @@ export declare class Reconnector {
     _backoffActive: boolean;
     _hardReconnectRetryInfo: null | RetryPromise<void>;
     constructor(client: any);
-    hardReconnect(maxAttempts?: number, interval?: number): Promise<void>;
+    hardReconnect(): Promise<void>;
     cleanupReconnect(): void;
     start(): void;
     stop(error?: Error | string): void;

package/dist/npm/reconnector.js

@@ -95,15 +95,13 @@ class Reconnector {
         });
         this._backoffActive = false;
     }
-    async hardReconnect(maxAttempts, interval = HARD_RECONNECT_RETRY_MS) {
+    async hardReconnect() {
         if (this._hardReconnectRetryInfo) {
             return this._hardReconnectRetryInfo.promise;
         }
         this.cleanupReconnect();
         this._hasConnected = false;
-        this._hardReconnectRetryInfo = utils_1.retryPromise(this._attemptHardReconnect.bind(this), (error, retryCount) => {
-            return this._shouldRetryError(error, retryCount, maxAttempts);
-        }, interval, this.client.logger);
+        this._hardReconnectRetryInfo = utils_1.retryPromise(this._attemptHardReconnect.bind(this), this._shouldRetryError.bind(this), HARD_RECONNECT_RETRY_MS, this.client.logger);
         try {
             await this._hardReconnectRetryInfo.promise;
             this._stopHardReconnect();
@@ -138,32 +136,22 @@ class Reconnector {
             if (typeof error === 'string') {
                 error = new Error(error);
             }
-            this._hardReconnectRetryInfo.reject(error);
+            this._hardReconnectRetryInfo.cancel(error);
         }
         else {
-            this._hardReconnectRetryInfo.resolve();
+            this._hardReconnectRetryInfo.complete();
         }
         this._hardReconnectRetryInfo = null;
     }
-    _attemptHardReconnect() {
+    async _attemptHardReconnect() {
         /* if we aren't online, don't retry the new channel */
         if (!navigator.onLine) {
             throw new Error(OFFLINE_ERROR);
         }
         this.client.logger.info('Attempting to reconnect with new channel.');
-        return this.client.connect();
+        await this.client.connect();
     }
-    _shouldRetryError(error, attemptNumber, maxAttempts) {
-        if (typeof maxAttempts === 'number' && typeof attemptNumber === 'number') {
-            if (attemptNumber > maxAttempts) {
-                this.client.logger.debug('Max retry attempts reached trying to connect to new channel. Stopping retry', { attemptNumber, maxAttempts });
-                return false;
-            }
-            else {
-                this.client.logger.debug('Max retry attempts NOT reached trying to connect to new channel. Retrying', { attemptNumber, maxAttempts });
-                return true;
-            }
-        }
+    _shouldRetryError(error) {
         /* we throw this is we are offline */
         if (error.message === OFFLINE_ERROR) {
             this.client.logger.debug('Browser is offline. Not attempting to reconnect with new channel.');

package/dist/npm/utils.d.ts

@@ -1,9 +1,16 @@
-export { retryPromise, RetryPromise } from './types/retry-utils';
 export declare function timeoutPromise(fn: Function, timeoutMs: number, msg: string, details?: any): Promise<void>;
 export declare function splitIntoIndividualTopics(topicString: string): string[];
 export declare const isAcdJid: (jid: string) => boolean;
 export declare const isScreenRecordingJid: (jid: string) => boolean;
 export declare const isSoftphoneJid: (jid: string) => boolean;
 export declare const isVideoJid: (jid: string) => boolean;
+export declare type RetryPromise<T = any> = {
+    promise: Promise<T>;
+    cancel: (reason?: string | Error) => void;
+    complete: (value?: T) => void;
+    hasCompleted: () => boolean;
+    _id: string;
+};
+export declare function retryPromise<T = any>(promiseFn: () => Promise<T>, retryFn: (error?: Error | any) => boolean, retryInterval?: number, logger?: any): RetryPromise<T>;
 export declare const parseJwt: (token: string) => any;
 export declare function calculatePayloadSize(trace: any): number;

package/dist/npm/utils.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculatePayloadSize = exports.parseJwt = exports.isVideoJid = exports.isSoftphoneJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.timeoutPromise = exports.RetryPromise = exports.retryPromise = void 0;
-var retry_utils_1 = require("./types/retry-utils");
-Object.defineProperty(exports, "retryPromise", { enumerable: true, get: function () { return retry_utils_1.retryPromise; } });
-Object.defineProperty(exports, "RetryPromise", { enumerable: true, get: function () { return retry_utils_1.RetryPromise; } });
+exports.calculatePayloadSize = exports.parseJwt = exports.retryPromise = exports.isVideoJid = exports.isSoftphoneJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.timeoutPromise = void 0;
+const uuid_1 = require("uuid");
 function timeoutPromise(fn, timeoutMs, msg, details) {
     return new Promise(function (resolve, reject) {
         const timeout = setTimeout(function () {
@@ -56,6 +54,49 @@ const isVideoJid = function (jid) {
     return !!(jid && jid.match(/@conference/) && !exports.isAcdJid(jid));
 };
 exports.isVideoJid = isVideoJid;
+function retryPromise(promiseFn, retryFn, retryInterval = 15000, logger = console) {
+    let timeout;
+    let cancel;
+    let complete;
+    let tryPromiseFn;
+    let _hasCompleted = false;
+    const promise = new Promise((resolve, reject) => {
+        tryPromiseFn = async () => {
+            try {
+                const val = await promiseFn();
+                complete(val);
+            }
+            catch (error) {
+                if (retryFn(error)) {
+                    logger.debug('Retrying promise', error);
+                    timeout = setTimeout(tryPromiseFn, retryInterval);
+                }
+                else {
+                    cancel(error);
+                }
+            }
+        };
+        complete = (value) => {
+            clearTimeout(timeout);
+            _hasCompleted = true;
+            resolve(value);
+        };
+        cancel = (reason) => {
+            clearTimeout(timeout);
+            _hasCompleted = true;
+            reject(reason);
+        };
+        tryPromiseFn();
+    });
+    return {
+        promise,
+        cancel,
+        complete,
+        _id: uuid_1.v4(),
+        hasCompleted: () => _hasCompleted
+    };
+}
+exports.retryPromise = retryPromise;
 // from https://stackoverflow.com/questions/38552003/how-to-decode-jwt-token-in-javascript
 const parseJwt = (token) => {
     const base64Url = token.split('.')[1];