@ohos-ports/genesys-cloud-streaming-client 20.1.0-beta.1

package/README.md

@@ -0,0 +1,47 @@
+## Streaming Client
+[![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 Genesys Cloud streaming services (websocket/XMPP interface).
+
+### Installation
+```bash
+npm install genesys-cloud-streaming-client
+```
+
+### 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.
+
+### 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 `npm run build`
+
+### Linting and Style
+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 your editor to run linting while typing or on save, this is preferable.**

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

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { IClientOptions, ILeaderStatus, StreamingClientExtension } from './types/interfaces';
+import { Client } from './client';
+import { EventEmitter } from 'events';
+import { NamedAgent } from './types/named-agent';
+export declare class AlertingLeaderExtension extends EventEmitter implements StreamingClientExtension {
+    private client;
+    private connectionId?;
+    private alertableInteractionTypes;
+    private getLeaderAbortController?;
+    private leaderStatus;
+    private debouncedClaimAlertingLeader;
+    constructor(client: Client, options: IClientOptions);
+    handleStanzaInstanceChange(stanzaInstance: NamedAgent): void;
+    private setupAlertingLeader;
+    private subscribeToAlertingLeader;
+    private markAsAlertable;
+    private getAlertingLeaderEarly;
+    private getAlertingLeader;
+    private claimAlertingLeader;
+    get expose(): AlertingLeaderApi;
+}
+export interface AlertingLeaderApi {
+    on: (event: string, handler: (...args: any) => void) => void;
+    off: (event: string, handler: (...args: any) => void) => void;
+    claimAlertingLeader(): Promise<void>;
+    getLeaderStatus(): ILeaderStatus;
+    leaderStatus: ILeaderStatus;
+}

package/dist/cjs/alerting-leader.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertingLeaderExtension = void 0;
+const axios_1 = __importDefault(require("axios"));
+const debounce_promise_1 = __importDefault(require("debounce-promise"));
+const interfaces_1 = require("./types/interfaces");
+const events_1 = require("events");
+const utils_1 = require("./utils");
+class AlertingLeaderExtension extends events_1.EventEmitter {
+    constructor(client, options) {
+        var _a;
+        super();
+        this.client = client;
+        this.leaderStatus = {};
+        this.alertableInteractionTypes = (_a = options.alertableInteractionTypes) !== null && _a !== void 0 ? _a : [];
+        this.debouncedClaimAlertingLeader = (0, debounce_promise_1.default)(this.claimAlertingLeader.bind(this), 300);
+    }
+    handleStanzaInstanceChange(stanzaInstance) {
+        var _a, _b;
+        this.connectionId = (_b = (_a = stanzaInstance.transport) === null || _a === void 0 ? void 0 : _a.stream) === null || _b === void 0 ? void 0 : _b.id;
+        this.setupAlertingLeader();
+    }
+    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 acting as the leader');
+                // Fail 'open' so users don't miss calls
+                this.leaderStatus = { voice: { alerting: true, configured: false } };
+                this.emit('alertingLeaderChanged', this.leaderStatus);
+            }
+        }
+    }
+    async subscribeToAlertingLeader() {
+        const topic = `v2.users.${this.client.config.userId}.alertingleader`;
+        this.client.on(`notify:${topic}`, (event) => {
+            var _a, _b;
+            (_a = this.getLeaderAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+            if ((_b = event.eventBody) === null || _b === void 0 ? void 0 : _b.connectionId) {
+                // 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 };
+                if (clientType) {
+                    voice = { ...voice, clientType };
+                }
+                this.leaderStatus = { voice };
+                this.emit('alertingLeaderChanged', this.leaderStatus);
+            }
+        });
+        return this.client._notifications._subscribeInternal(topic);
+    }
+    async markAsAlertable() {
+        const userId = this.client.config.userId;
+        const connectionsRequestOptions = {
+            method: 'patch',
+            host: this.client.config.apiHost,
+            authToken: this.client.config.authToken,
+            logger: this.client.logger,
+            data: {
+                alertable: true
+            }
+        };
+        // STREAM-1204
+        // There's a race condition between the backend service knowing about the connection
+        // and us marking the connection as alertable. For now, we'll just retry with some delay.
+        const maxRetries = 16;
+        let retryCount = 0;
+        const retry = (0, utils_1.retryPromise)(() => this.client.http.requestApi(`apps/users/${userId}/connections/${this.connectionId}`, connectionsRequestOptions), () => {
+            retryCount++;
+            if (retryCount >= maxRetries) {
+                this.client.logger.info('Max retries reached for marking connection as alertable');
+                return false;
+            }
+            return true;
+        }, 500, this.client.logger);
+        return retry.promise
+            .catch(() => {
+            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() {
+        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.getLeaderAbortController.signal
+        };
+        try {
+            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 };
+            if (clientType) {
+                voice = { ...voice, clientType };
+            }
+            this.leaderStatus = { voice };
+            this.emit('alertingLeaderChanged', this.leaderStatus);
+        }
+        catch (err) {
+            if (axios_1.default.isCancel(err)) {
+                return;
+            }
+            throw err;
+        }
+    }
+    async claimAlertingLeader() {
+        if (this.alertableInteractionTypes.length === 0) {
+            this.client.logger.info('This client is not configured for any alertable interactions and will not attempt to claim alerting leader');
+            throw new utils_1.StreamingClientError(interfaces_1.StreamingClientErrorTypes.generic, 'Unable to claim alerting leader; this client is not configured for any alertable interactions');
+        }
+        const leaderRequestOptions = {
+            method: 'put',
+            host: this.client.config.apiHost,
+            authToken: this.client.config.authToken,
+            logger: this.client.logger,
+            data: {
+                connectionId: this.connectionId
+            }
+        };
+        return this.client.http.requestApi('users/alertingleader', leaderRequestOptions)
+            .catch((err) => {
+            this.client.logger.warn('Unable to claim alerting leader; this client may not alert for incoming interactions');
+            throw new utils_1.StreamingClientError(interfaces_1.StreamingClientErrorTypes.generic, 'Unable to claim alerting leader', err);
+        });
+    }
+    get expose() {
+        return {
+            on: this.on.bind(this),
+            off: this.off.bind(this),
+            claimAlertingLeader: this.debouncedClaimAlertingLeader,
+            getLeaderStatus: () => { return this.leaderStatus; },
+            leaderStatus: this.leaderStatus
+        };
+    }
+}
+exports.AlertingLeaderExtension = AlertingLeaderExtension;

package/dist/cjs/client.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+import { Logger } from 'genesys-cloud-client-logger';
+import './polyfills';
+import { AlertingLeaderExtension, AlertingLeaderApi } from './alerting-leader';
+import { Notifications, NotificationsAPI } from './notifications';
+import { WebrtcExtension, WebrtcExtensionAPI } from './webrtc';
+import { Ping } from './ping';
+import { StreamingClientExtension } from './types/streaming-client-extension';
+import { HttpClient } from './http-client';
+import { IClientOptions, IClientConfig, StreamingClientConnectOptions } from './types/interfaces';
+import { NamedAgent } from './types/named-agent';
+import EventEmitter from 'events';
+import { MessengerExtensionApi, MessengerExtension } from './messenger';
+export declare class Client extends EventEmitter {
+    activeStanzaInstance?: NamedAgent;
+    connected: boolean;
+    connecting: boolean;
+    hardReconnectRequired: boolean;
+    reconnectOnNoLongerSubscribed: boolean;
+    useServerSidePings: boolean;
+    logger: Logger;
+    config: IClientConfig;
+    isGuest: boolean;
+    backgroundAssistantMode: boolean;
+    private autoReconnect;
+    private cancelConnectionAttempt;
+    private extensions;
+    private connectionManager;
+    private channelReuses;
+    private backoffReductionTimer;
+    private hasMadeInitialAttempt;
+    private jidResource;
+    private boundStanzaDisconnect?;
+    private boundStanzaNoLongerSubscribed?;
+    private boundStanzaDuplicateId?;
+    http: HttpClient;
+    notifications: NotificationsAPI;
+    _notifications: Notifications;
+    webrtcSessions: WebrtcExtensionAPI;
+    _webrtcSessions: WebrtcExtension;
+    messenger: MessengerExtension;
+    _messenger: MessengerExtensionApi;
+    alertingLeader: AlertingLeaderApi;
+    _alertingLeader: AlertingLeaderExtension;
+    _ping: Ping;
+    constructor(options: IClientOptions);
+    private handleSendEventFromExtension;
+    private checkIsBackgroundAssistant;
+    private addInateEventHandlers;
+    private removeStanzaBoundEventHandlers;
+    private proxyStanzaEvents;
+    private handleStanzaDisconnectedEvent;
+    private handleNoLongerSubscribed;
+    private handleDuplicateId;
+    disconnect(): Promise<any>;
+    private getSessionStoreKey;
+    private getConnectionData;
+    private setConnectionData;
+    private increaseBackoff;
+    private decreaseBackoff;
+    private getStartingDelay;
+    connect(connectOpts?: StreamingClientConnectOptions): Promise<void>;
+    private backoffConnectRetryHandler;
+    private networkErrorNeedsAuth;
+    private saslErrorIsRetryable;
+    /**
+     * Performs an active network connectivity check by querying the API.
+     * navigator.onLine is unreliable (VPNs, virtual adapters, etc.), so we
+     * actually reach out to verify we can talk to the server.
+     *
+     * Returns true if connectivity is confirmed, false otherwise.
+     * This is advisory only — it does not gate connection attempts.
+     */
+    checkNetworkConnectivity(): Promise<boolean>;
+    private makeConnectionAttempt;
+    private setupConnectionMonitoring;
+    private prepareForConnect;
+    stopServerLogging(): void;
+    startServerLogging(): void;
+    setAccessToken(token: string): void;
+    static extend(namespace: any, extension: StreamingClientExtension | ((client: Client) => void)): void;
+    get version(): string;
+    static get version(): string;
+}