genesys-cloud-streaming-client 20.0.0 → 20.0.1-release.1

package/README.md

@@ -2,22 +2,46 @@
 [![Test Matrix](https://github.com/purecloudlabs/genesys-cloud-streaming-client/actions/workflows/matrix.yml/badge.svg)](https://github.com/purecloudlabs/genesys-cloud-streaming-client/actions/workflows/matrix.yml)
 
 ### Overview
-Client library for streaming-service
+Client library for Genesys Cloud streaming services (websocket/XMPP interface).
 
 ### Installation
-Run `npm install` in order to install all the dependencies
+```bash
+npm install genesys-cloud-streaming-client
+```
 
-### Testing
-Run the tests using `npm test` in the command line
+### Quick Start
+```ts
+import StreamingClient from 'genesys-cloud-streaming-client';
+
+const client = new StreamingClient({
+  host: 'wss://streaming.mypurecloud.com',
+  authToken: 'your-access-token',
+});
+
+await client.connect();
+```
+
+> If you're using this in a browser with a bundler like Vite or Webpack 5, you'll
+> need polyfills for `global`, `events`, and possibly `process`. See the
+> [full documentation](doc/documentation.md#browser-usage--polyfills) for details.
 
-**In order to see code coverage run `npm run test:coverage`**
+### Documentation
+See [doc/documentation.md](doc/documentation.md) for the full API reference,
+browser polyfill setup, and known issues.
+
+### Development
+
+Run `npm install` to install dependencies.
+
+### Testing
+Run the tests using `npm test` in the command line.
 
 ### Build for Local Use
-Run the script `npm run build`
+Run `npm run build`
 
 ### Linting and Style
-semistandard has been added and you can run linting through the command line via `npm run lint` script
+ESLint with the semistandard config has been added and you can run linting through the command line via `npm run lint`
 
 To fix minor styling errors, run `npm run lint:fix`
 
-**If you can configure you editor to run linting while typing or on save this is preferrable**
+**If you can configure your editor to run linting while typing or on save, this is preferable.**

package/dist/cjs/alerting-leader.d.ts

@@ -7,13 +7,14 @@ export declare class AlertingLeaderExtension extends EventEmitter implements Str
     private client;
     private connectionId?;
     private alertableInteractionTypes;
-    private abortController?;
+    private getLeaderAbortController?;
     private leaderStatus;
     constructor(client: Client, options: IClientOptions);
     handleStanzaInstanceChange(stanzaInstance: NamedAgent): void;
     private setupAlertingLeader;
     private subscribeToAlertingLeader;
     private markAsAlertable;
+    private getAlertingLeaderEarly;
     private getAlertingLeader;
     private claimAlertingLeader;
     get expose(): AlertingLeaderApi;

package/dist/cjs/alerting-leader.js

@@ -22,12 +22,13 @@ class AlertingLeaderExtension extends events_1.EventEmitter {
     async setupAlertingLeader() {
         if (this.alertableInteractionTypes.length !== 0) {
             try {
+                this.getAlertingLeaderEarly();
                 await this.subscribeToAlertingLeader();
                 await this.markAsAlertable();
                 await this.getAlertingLeader();
             }
             catch (err) {
-                this.client.logger.warn('Failed to setup alerting leader; falling back to the default of acting as the alerting leader');
+                this.client.logger.warn('Failed to setup alerting leader; falling back to acting as the leader');
                 // Fail 'open' so users don't miss calls
                 this.leaderStatus = { voice: { alerting: true, configured: false } };
                 this.emit('alertingLeaderChanged', this.leaderStatus);
@@ -38,9 +39,9 @@ class AlertingLeaderExtension extends events_1.EventEmitter {
         const topic = `v2.users.${this.client.config.userId}.alertingleader`;
         this.client.on(`notify:${topic}`, (event) => {
             var _a, _b;
-            (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+            (_a = this.getLeaderAbortController) === null || _a === void 0 ? void 0 : _a.abort();
             if ((_b = event.eventBody) === null || _b === void 0 ? void 0 : _b.connectionId) {
-                // We should alert if our connection is the alerting leader connection
+                // The consuming client should be the one alerting if our connection is the current leader
                 const alerting = event.eventBody.connectionId === this.connectionId;
                 const clientType = event.eventBody.clientType;
                 let voice = { alerting, configured: true };
@@ -79,21 +80,36 @@ class AlertingLeaderExtension extends events_1.EventEmitter {
         }, 500, this.client.logger);
         return retry.promise
             .catch(() => {
-            this.client.logger.warn('Could not mark this connection as alertable; this client may not alert for incoming interactions');
+            this.client.logger.warn('Could not mark this connection as alertable');
         });
     }
+    async getAlertingLeaderEarly() {
+        try {
+            await this.getAlertingLeader();
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && error.status === 400) {
+                this.client.logger.info('The org has not configured alerting leader functionality or there are not yet any active alertable connections; falling back to acting as the leader');
+                this.leaderStatus = { voice: { alerting: true, configured: false } };
+                this.emit('alertingLeaderChanged', this.leaderStatus);
+            }
+        }
+    }
     async getAlertingLeader() {
-        this.abortController = new AbortController();
+        var _a;
+        // If an early request is still in-flight, cancel it and get more recent data
+        (_a = this.getLeaderAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+        this.getLeaderAbortController = new AbortController();
         const leaderRequestOptions = {
             method: 'get',
             host: this.client.config.apiHost,
             authToken: this.client.config.authToken,
             logger: this.client.logger,
-            signal: this.abortController.signal
+            signal: this.getLeaderAbortController.signal
         };
         try {
-            const currentLeader = await this.client.http.requestApi('users/alertingleader', leaderRequestOptions);
-            // We should alert if our connection is the alerting leader connection
+            const currentLeader = await this.client.http.requestApiWithRetry('users/alertingleader', leaderRequestOptions, 1000).promise;
+            // The consuming client should be the one alerting if our connection is the current leader
             const alerting = currentLeader.data.connectionId === this.connectionId;
             const clientType = currentLeader.data.clientType;
             let voice = { alerting, configured: true };

package/dist/cjs/client.js

@@ -670,7 +670,7 @@ class Client extends events_1.default {
         return Client.version;
     }
     static get version() {
-        return '20.0.0';
+        return '20.0.1';
     }
 }
 exports.Client = Client;

package/dist/cjs/notifications.d.ts

@@ -12,6 +12,8 @@ export declare class Notifications implements StreamingClientExtension {
     debouncedResubscribe: () => Promise<BulkSubscribeResult>;
     enablePartialBulkResubscribe: boolean;
     private internalSubscriptions;
+    private pendingBulkSubscribeRetry?;
+    private pendingConnectedWait?;
     constructor(client: any, options?: IClientOptions);
     get pubsubHost(): string;
     handleStanzaInstanceChange(stanza: NamedAgent): void;

package/dist/cjs/notifications.js

@@ -178,20 +178,57 @@ class Notifications {
         }
         return keptTopics;
     }
-    makeBulkSubscribeRequest(topics, options) {
+    async makeBulkSubscribeRequest(topics, options) {
+        // Cancel any in-flight retry or connected-wait from a previous bulk subscribe.
+        // If the topic list has changed (subscribe/unsubscribe called between retries),
+        // the stale request would send an outdated topic list. Since bulk subscribes with
+        // replace=true use PUT (full replacement), only the most recent request matters.
+        if (this.pendingConnectedWait) {
+            this.pendingConnectedWait.cancel(new Error('Superseded by newer bulk subscribe request'));
+            this.pendingConnectedWait = undefined;
+        }
+        if (this.pendingBulkSubscribeRetry && !this.pendingBulkSubscribeRetry.hasCompleted()) {
+            this.client.logger.info('Cancelling previous bulk subscribe retry — new request supersedes it');
+            this.pendingBulkSubscribeRetry.cancel(new Error('Superseded by newer bulk subscribe request'));
+        }
+        // If the client is not connected, wait for reconnection before attempting the request.
+        // This prevents firing requests against a dead/stale channel ID which would result in
+        // 400 errors (notification.unable.to.get.channel.id). After reconnection, the stanza
+        // instance will have the fresh channel ID from the new connection.
+        if (!this.client.connected) {
+            this.client.logger.info('Client not connected, waiting for reconnection before bulk subscribe', {
+                topicCount: topics.length
+            });
+            await new Promise((resolve, reject) => {
+                const onConnected = () => {
+                    this.pendingConnectedWait = undefined;
+                    resolve();
+                };
+                this.client.once('connected', onConnected);
+                this.pendingConnectedWait = {
+                    cancel: (reason) => {
+                        this.client.off('connected', onConnected);
+                        reject(reason);
+                    }
+                };
+            });
+        }
         const requestOptions = {
             method: options.replace ? 'put' : 'post',
             host: this.client.config.apiHost,
             authToken: this.client.config.authToken,
             data: JSON.stringify(this.mapCombineTopics(topics)),
-            logger: this.client.logger
+            logger: this.client.logger,
+            maxAttempts: 3
         };
         const channelId = this.stanzaInstance.channelId;
         let path = `notifications/channels/${channelId}/subscriptions`;
         if (this.enablePartialBulkResubscribe) {
             path += '?ignoreErrors=true';
         }
-        return this.client.http.requestApi(path, requestOptions);
+        const retry = this.client.http.requestApiWithRetry(path, requestOptions, 2000);
+        this.pendingBulkSubscribeRetry = retry;
+        return retry.promise;
     }
     createSubscription(topic, handler) {
         const topics = (0, utils_1.splitIntoIndividualTopics)(topic);
@@ -366,7 +403,7 @@ class Notifications {
         return this.xmppUnsubscribe(topic);
     }
     async bulkSubscribe(topics, options = { replace: false, force: false }, priorities = {}) {
-        var _a;
+        var _a, _b;
         this.setTopicPriorities(priorities);
         let toSubscribe = mergeAndDedup(topics, this.internalSubscriptions);
         if (options.replace && !options.force) {
@@ -377,7 +414,24 @@ class Notifications {
             // if it's a forcible bulk subscribe, wipe out individual subscriptions
             this.subscriptions = {};
         }
-        const response = await this.makeBulkSubscribeRequest(toSubscribe, options);
+        let response;
+        try {
+            response = await this.makeBulkSubscribeRequest(toSubscribe, options);
+        }
+        catch (err) {
+            // If this request was cancelled because a newer bulk subscribe superseded it,
+            // return an 'Unknown' state for all topics. The superseding request will carry
+            // the current desired topic list and handle the actual subscription.
+            if ((_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.includes('Superseded by newer bulk subscribe request')) {
+                this.client.logger.debug('Bulk subscribe was superseded, deferring to newer request');
+                const result = {};
+                for (const topic of toSubscribe) {
+                    result[topic] = { topic, state: 'Unknown' };
+                }
+                return result;
+            }
+            throw err;
+        }
         let topicResponseEntities = [];
         if (response && response.data && 'entities' in response.data && Array.isArray(response.data.entities)) {
             topicResponseEntities = response.data.entities;
@@ -415,7 +469,7 @@ class Notifications {
         // With partial bulk resubscribe enabled missing result means "Unknown" state but when not
         // enabled the fallback is "Permitted" for backward compatibility (success response means OK).
         for (const topic of toSubscribe) {
-            (_a = result[topic]) !== null && _a !== void 0 ? _a : (result[topic] = { topic, state: this.enablePartialBulkResubscribe ? 'Unknown' : 'Permitted' });
+            (_b = result[topic]) !== null && _b !== void 0 ? _b : (result[topic] = { topic, state: this.enablePartialBulkResubscribe ? 'Unknown' : 'Permitted' });
         }
         return result;
     }

package/dist/deploy-info.json

@@ -1,13 +1,13 @@
 {
-  "version": "20.0.0",
-  "build": "12",
-  "buildDate": "2026-06-05T11:16:47.414Z",
+  "version": "release/v20.0.1",
+  "build": "1",
+  "buildDate": "2026-06-23T16:09:25.734Z",
   "indexFiles": [
     {
-      "file": "v20.0.0/streaming-client.browser.js"
+      "file": "v20.0.1/streaming-client.browser.js"
     },
     {
-      "file": "v20.0.0/streaming-client.browser.js.LICENSE.txt"
+      "file": "v20.0.1/streaming-client.browser.js.LICENSE.txt"
     },
     {
       "file": "v20/streaming-client.browser.js"

package/dist/es/alerting-leader.d.ts

@@ -7,13 +7,14 @@ export declare class AlertingLeaderExtension extends EventEmitter implements Str
     private client;
     private connectionId?;
     private alertableInteractionTypes;
-    private abortController?;
+    private getLeaderAbortController?;
     private leaderStatus;
     constructor(client: Client, options: IClientOptions);
     handleStanzaInstanceChange(stanzaInstance: NamedAgent): void;
     private setupAlertingLeader;
     private subscribeToAlertingLeader;
     private markAsAlertable;
+    private getAlertingLeaderEarly;
     private getAlertingLeader;
     private claimAlertingLeader;
     get expose(): AlertingLeaderApi;

package/dist/es/alerting-leader.js

@@ -20,12 +20,13 @@ export class AlertingLeaderExtension extends EventEmitter {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.alertableInteractionTypes.length !== 0) {
                 try {
+                    this.getAlertingLeaderEarly();
                     yield this.subscribeToAlertingLeader();
                     yield this.markAsAlertable();
                     yield this.getAlertingLeader();
                 }
                 catch (err) {
-                    this.client.logger.warn('Failed to setup alerting leader; falling back to the default of acting as the alerting leader');
+                    this.client.logger.warn('Failed to setup alerting leader; falling back to acting as the leader');
                     // Fail 'open' so users don't miss calls
                     this.leaderStatus = { voice: { alerting: true, configured: false } };
                     this.emit('alertingLeaderChanged', this.leaderStatus);
@@ -38,9 +39,9 @@ export class AlertingLeaderExtension extends EventEmitter {
             const topic = `v2.users.${this.client.config.userId}.alertingleader`;
             this.client.on(`notify:${topic}`, (event) => {
                 var _a, _b;
-                (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+                (_a = this.getLeaderAbortController) === null || _a === void 0 ? void 0 : _a.abort();
                 if ((_b = event.eventBody) === null || _b === void 0 ? void 0 : _b.connectionId) {
-                    // We should alert if our connection is the alerting leader connection
+                    // The consuming client should be the one alerting if our connection is the current leader
                     const alerting = event.eventBody.connectionId === this.connectionId;
                     const clientType = event.eventBody.clientType;
                     let voice = { alerting, configured: true };
@@ -81,23 +82,40 @@ export class AlertingLeaderExtension extends EventEmitter {
             }, 500, this.client.logger);
             return retry.promise
                 .catch(() => {
-                this.client.logger.warn('Could not mark this connection as alertable; this client may not alert for incoming interactions');
+                this.client.logger.warn('Could not mark this connection as alertable');
             });
         });
     }
+    getAlertingLeaderEarly() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.getAlertingLeader();
+            }
+            catch (error) {
+                if (axios.isAxiosError(error) && error.status === 400) {
+                    this.client.logger.info('The org has not configured alerting leader functionality or there are not yet any active alertable connections; falling back to acting as the leader');
+                    this.leaderStatus = { voice: { alerting: true, configured: false } };
+                    this.emit('alertingLeaderChanged', this.leaderStatus);
+                }
+            }
+        });
+    }
     getAlertingLeader() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.abortController = new AbortController();
+            // If an early request is still in-flight, cancel it and get more recent data
+            (_a = this.getLeaderAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+            this.getLeaderAbortController = new AbortController();
             const leaderRequestOptions = {
                 method: 'get',
                 host: this.client.config.apiHost,
                 authToken: this.client.config.authToken,
                 logger: this.client.logger,
-                signal: this.abortController.signal
+                signal: this.getLeaderAbortController.signal
             };
             try {
-                const currentLeader = yield this.client.http.requestApi('users/alertingleader', leaderRequestOptions);
-                // We should alert if our connection is the alerting leader connection
+                const currentLeader = yield this.client.http.requestApiWithRetry('users/alertingleader', leaderRequestOptions, 1000).promise;
+                // The consuming client should be the one alerting if our connection is the current leader
                 const alerting = currentLeader.data.connectionId === this.connectionId;
                 const clientType = currentLeader.data.clientType;
                 let voice = { alerting, configured: true };

package/dist/es/client.js

@@ -684,6 +684,6 @@ export class Client extends EventEmitter {
         return Client.version;
     }
     static get version() {
-        return '20.0.0';
+        return '20.0.1';
     }
 }