genesys-cloud-streaming-client 17.2.7 → 17.2.8-develop.120

package/dist/es/utils.js

@@ -1,6 +1,24 @@
 import { __awaiter } from "tslib";
 import { v4 } from 'uuid';
 import { TimeoutError } from './types/timeout-error';
+import { StreamingClientErrorTypes } from './types/interfaces';
+export class StreamingClientError extends Error {
+    constructor(type, messageOrError, details) {
+        let message;
+        if (messageOrError instanceof Error) {
+            message = messageOrError.message;
+        }
+        else {
+            message = messageOrError;
+        }
+        super(message);
+        if (messageOrError instanceof Error) {
+            this.name = messageOrError.name;
+        }
+        this.type = type !== null && type !== void 0 ? type : StreamingClientErrorTypes.generic;
+        this.details = details;
+    }
+}
 /* istanbul ignore next */
 export function timeoutPromise(fn, timeoutMs, msg, details) {
     return new Promise(function (resolve, reject) {

package/dist/npm/CHANGELOG.md

@@ -5,6 +5,12 @@ 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/v17.2.7...HEAD)
+### Breaking Changes
+* The `connnect` method will now throw a StreamingClientError with a type indicated, rather than the passing through the underlying error. The error that was previously thrown will still be available via the `details` property.
+
+### Changed
+* [STREAM-162](https://inindca.atlassian.net/browse/STREAM-162) - Streaming-client should trigger re-auth for some SASL errors (and 401s) - this will be indicated by a StreamingClientError of type `.invalid-token`.
+
 # [v17.2.7](https://github.com/purecloudlabs/genesys-cloud-streaming-client/compare/v17.2.6..v17.2.7)
 ### Fixed
 * [STREAM-218](https://inindca.atlassian.net/browse/STREAM-218) - update the conversationId on sessions with reinvites

package/dist/npm/client.d.ts

@@ -56,6 +56,8 @@ export declare class Client extends EventEmitter {
     private getStartingDelay;
     connect(connectOpts?: StreamingClientConnectOptions): Promise<void>;
     private backoffConnectRetryHandler;
+    private networkErrorNeedsAuth;
+    private saslErrorIsRetryable;
     private makeConnectionAttempt;
     private setupConnectionMonitoring;
     private prepareForConnect;

package/dist/npm/client.js

@@ -11,6 +11,7 @@ const ping_1 = require("./ping");
 const server_monitor_1 = require("./server-monitor");
 const utils_1 = require("./utils");
 const http_client_1 = require("./http-client");
+const interfaces_1 = require("./types/interfaces");
 const events_1 = tslib_1.__importDefault(require("events"));
 const connection_manager_1 = require("./connection-manager");
 const exponential_backoff_1 = require("exponential-backoff");
@@ -331,15 +332,17 @@ class Client extends events_1.default {
             });
         }
         catch (err) {
-            let error = err;
+            let errorForThrowing;
+            let errorForLogging = err;
             if (!err) {
-                error = new Error('Streaming client connection attempted received and undefined error');
+                errorForThrowing = new utils_1.StreamingClientError(interfaces_1.StreamingClientErrorTypes.generic, 'Streaming client connection attempted and received an undefined error');
+                errorForLogging = errorForThrowing;
             }
             else if (err.name === 'AxiosError') {
                 const axiosError = err;
                 const config = axiosError.config || { url: undefined, method: undefined };
                 // sanitized error for logging
-                error = {
+                errorForLogging = {
                     config: {
                         url: config.url,
                         method: config.method
@@ -349,16 +352,26 @@ class Client extends events_1.default {
                     name: axiosError.name,
                     message: axiosError.message
                 };
+                errorForThrowing = new utils_1.StreamingClientError(interfaces_1.StreamingClientErrorTypes.generic, 'Failed to connect streaming client due to network error', err);
+                if (this.networkErrorNeedsAuth(err)) {
+                    errorForThrowing = new utils_1.StreamingClientError(interfaces_1.StreamingClientErrorTypes.invalid_token, 'Failed to connect streaming client due to invalid token', err);
+                }
             }
-            this.logger.error('Failed to connect streaming client', { error });
-            if (!err) {
-                throw error;
+            else if (err instanceof sasl_error_1.default) {
+                errorForThrowing = new utils_1.StreamingClientError(interfaces_1.StreamingClientErrorTypes.invalid_token, 'Failed to connect streaming client due to invalid token', err);
+                if (this.saslErrorIsRetryable(err)) {
+                    errorForThrowing = new utils_1.StreamingClientError(interfaces_1.StreamingClientErrorTypes.generic, 'Streaming client connection attempted and received a SASL error', err);
+                }
             }
-            throw err;
+            else {
+                errorForThrowing = new utils_1.StreamingClientError(interfaces_1.StreamingClientErrorTypes.generic, 'Streaming client connection attempted and received an unknown error', err);
+            }
+            this.logger.error('Failed to connect streaming client', { error: errorForLogging });
+            throw errorForThrowing;
         }
     }
     async backoffConnectRetryHandler(connectOpts, err, connectionAttempt) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         // if we exceed the `numOfAttempts` in the backoff config it still calls this retry fn and just ignores the result
         // if that's the case, we just want to bail out and ignore all the extra logging here.
         if (connectionAttempt >= connectOpts.maxConnectionAttempts) {
@@ -382,17 +395,25 @@ class Client extends events_1.default {
                 message: axiosError.message
             };
             additionalErrorDetails.error = sanitizedError;
-            if ([401, 403].includes(((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) || 0)) {
+            if (this.networkErrorNeedsAuth(err)) {
                 this.logger.error('Streaming client received an error that it can\'t recover from and will not attempt to reconnect', additionalErrorDetails);
                 return false;
             }
         }
-        // if we get a sasl error, that means we made it all the way to the point of trying to open a websocket and
-        // it was rejected for some reason. At this point we should do a hard reconnect then try again.
+        // If we get a sasl error, that means we made it all the way to the point of trying to open a websocket and
+        // it was rejected for some reason. Some errors might resolve if we try connecting again. Others need
+        // re-authentication.
         if (err instanceof sasl_error_1.default) {
-            this.logger.info('hardReconnectRequired set to true due to sasl error');
-            this.hardReconnectRequired = true;
-            Object.assign(additionalErrorDetails, { channelId: err.channelId, stanzaInstanceId: err.stanzaInstanceId });
+            if (this.saslErrorIsRetryable(err)) {
+                this.logger.info('hardReconnectRequired set to true due to sasl error');
+                this.hardReconnectRequired = true;
+                Object.assign(additionalErrorDetails, { channelId: err.channelId, stanzaInstanceId: err.stanzaInstanceId });
+            }
+            else {
+                additionalErrorDetails.error = err.condition;
+                this.logger.error('Streaming-client received a SASL error that it can\'t recover from and will not attempt to reconnect', additionalErrorDetails);
+                return false;
+            }
         }
         // we don't need to log the stack for a timeout message
         if (err instanceof timeout_error_1.TimeoutError) {
@@ -405,7 +426,7 @@ class Client extends events_1.default {
         if (err === null || err === void 0 ? void 0 : err.response) {
             // This *should* be an axios error according to typings, but it appears this could be an AxiosError *or* and XmlHttpRequest
             // we'll check both to be safe
-            const retryAfter = ((_c = err.response.headers) === null || _c === void 0 ? void 0 : _c['retry-after']) || ((_e = (_d = err.response).getResponseHeader) === null || _e === void 0 ? void 0 : _e.call(_d, 'retry-after'));
+            const retryAfter = ((_b = err.response.headers) === null || _b === void 0 ? void 0 : _b['retry-after']) || ((_d = (_c = err.response).getResponseHeader) === null || _d === void 0 ? void 0 : _d.call(_c, 'retry-after'));
             if (retryAfter) {
                 // retry after comes in seconds, we need to return milliseconds
                 let retryDelay = parseInt(retryAfter, 10) * 1000;
@@ -421,6 +442,14 @@ class Client extends events_1.default {
         this.logger.debug('debug: retry info', { expectedRetryInMs: connectionData.currentDelayMs, appName: this.config.appName, clientId: this.logger.clientId });
         return true;
     }
+    networkErrorNeedsAuth(error) {
+        var _a;
+        return [401, 403].includes(((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) || 0);
+    }
+    saslErrorIsRetryable(error) {
+        const retryConditions = ['encryption-required', 'incorrect-encoding', 'invalid-mechanism', 'malformed-request', 'mechanism-too-weak'];
+        return retryConditions.includes(error.condition);
+    }
     async makeConnectionAttempt() {
         var _a, _b;
         if (!navigator.onLine) {
@@ -550,7 +579,7 @@ class Client extends events_1.default {
         return Client.version;
     }
     static get version() {
-        return '17.2.7';
+        return '17.2.8';
     }
 }
 exports.Client = Client;

package/dist/npm/index.d.ts

@@ -6,5 +6,5 @@ export * from './types/media-session';
 export * from './types/interfaces';
 export * from './messenger';
 export { HttpClient } from './http-client';
-export { parseJwt } from './utils';
+export { StreamingClientError, parseJwt } from './utils';
 export default Client;

package/dist/npm/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJwt = exports.HttpClient = void 0;
+exports.parseJwt = exports.StreamingClientError = exports.HttpClient = void 0;
 const tslib_1 = require("tslib");
 /// <reference path="types/libs.ts" />
 const client_1 = require("./client");
@@ -12,5 +12,6 @@ tslib_1.__exportStar(require("./messenger"), exports);
 var http_client_1 = require("./http-client");
 Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return http_client_1.HttpClient; } });
 var utils_1 = require("./utils");
+Object.defineProperty(exports, "StreamingClientError", { enumerable: true, get: function () { return utils_1.StreamingClientError; } });
 Object.defineProperty(exports, "parseJwt", { enumerable: true, get: function () { return utils_1.parseJwt; } });
 exports.default = client_1.Client;

package/dist/npm/module.js

@@ -6,5 +6,5 @@ export * from './types/media-session';
 export * from './types/interfaces';
 export * from './messenger';
 export { HttpClient } from './http-client';
-export { parseJwt } from './utils';
+export { StreamingClientError, parseJwt } from './utils';
 export default Client;

package/dist/npm/types/interfaces.d.ts

@@ -101,6 +101,10 @@ export interface IResponseError extends IError {
     requestBody: string;
     url: string;
 }
+export declare enum StreamingClientErrorTypes {
+    generic = "generic",
+    invalid_token = "invalid_token"
+}
 export interface IError {
     message: string;
     name: string;

package/dist/npm/types/interfaces.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionTypes = void 0;
+exports.SessionTypes = exports.StreamingClientErrorTypes = void 0;
+var StreamingClientErrorTypes;
+(function (StreamingClientErrorTypes) {
+    StreamingClientErrorTypes["generic"] = "generic";
+    StreamingClientErrorTypes["invalid_token"] = "invalid_token";
+})(StreamingClientErrorTypes = exports.StreamingClientErrorTypes || (exports.StreamingClientErrorTypes = {}));
 var SessionTypes;
 (function (SessionTypes) {
     SessionTypes["softphone"] = "softphone";

package/dist/npm/utils.d.ts

@@ -1,3 +1,9 @@
+import { StreamingClientErrorTypes } from './types/interfaces';
+export declare class StreamingClientError extends Error {
+    type: StreamingClientErrorTypes;
+    details?: unknown;
+    constructor(type: StreamingClientErrorTypes | null, messageOrError: string | Error, details?: unknown);
+}
 export declare function timeoutPromise(fn: Function, timeoutMs: number, msg: string, details?: any): Promise<any>;
 export declare function delay(ms: number): Promise<void>;
 export declare function splitIntoIndividualTopics(topicString: string): string[];

package/dist/npm/utils.js

@@ -1,8 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.iceIsDifferent = exports.getIcePwdFromSdp = exports.getUfragFromSdp = exports.calculatePayloadSize = exports.parseJwt = exports.retryPromise = exports.isVideoJid = exports.isSoftphoneJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.delay = exports.timeoutPromise = void 0;
+exports.iceIsDifferent = exports.getIcePwdFromSdp = exports.getUfragFromSdp = exports.calculatePayloadSize = exports.parseJwt = exports.retryPromise = exports.isVideoJid = exports.isSoftphoneJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.delay = exports.timeoutPromise = exports.StreamingClientError = void 0;
 const uuid_1 = require("uuid");
 const timeout_error_1 = require("./types/timeout-error");
+const interfaces_1 = require("./types/interfaces");
+class StreamingClientError extends Error {
+    constructor(type, messageOrError, details) {
+        let message;
+        if (messageOrError instanceof Error) {
+            message = messageOrError.message;
+        }
+        else {
+            message = messageOrError;
+        }
+        super(message);
+        if (messageOrError instanceof Error) {
+            this.name = messageOrError.name;
+        }
+        this.type = type !== null && type !== void 0 ? type : interfaces_1.StreamingClientErrorTypes.generic;
+        this.details = details;
+    }
+}
+exports.StreamingClientError = StreamingClientError;
 /* istanbul ignore next */
 function timeoutPromise(fn, timeoutMs, msg, details) {
     return new Promise(function (resolve, reject) {