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

package/dist/es/connection-manager.d.ts

@@ -0,0 +1,18 @@
+import Logger from 'genesys-cloud-client-logger';
+import { IClientConfig } from './types/interfaces';
+import { NamedAgent } from './types/named-agent';
+export declare class ConnectionManager {
+    private logger;
+    private config;
+    currentStanzaInstance?: NamedAgent;
+    constructor(logger: Logger, config: IClientConfig);
+    setConfig(config: IClientConfig): void;
+    getNewStanzaConnection(): Promise<NamedAgent>;
+    private handleSessionStarted;
+    private handleSessionSasl;
+    private handleSessionDisconnected;
+    private checkForErrorStanza;
+    private getStanzaOptions;
+    private getJwtOptions;
+    private getStandardOptions;
+}

package/dist/es/connection-manager.js

@@ -0,0 +1,124 @@
+// so the idea here is any time stanza gets disconnected, we are effectively going to kill that instance of
+// stanza and never reuse it. We may reuse the config for a given stanza client, but every connection attempt
+// will merit its own brand new client. The purpose of this is because the stanza.connect() is not transactional
+// and failed connection attempts trigger `disconnect` events either by timeout or some actual error. This is
+// a problem because it effectively means we can get multiple disconnect events for a single connection attempt
+// which makes trying to reconnect a stanza instance an tricky endeavor because we don't know if a disconnect
+// event applies to a past connection attempt or if it applies to the most recent connection attempt. For this
+// reason, we want a vanilla instance of stanza every time we call `connect` so wires don't get crossed.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createClient } from 'stanza';
+import SaslError from './types/sasl-error';
+import { parseJwt, timeoutPromise } from './utils';
+export class ConnectionManager {
+    constructor(logger, config) {
+        this.logger = logger;
+        this.config = config;
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    getNewStanzaConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = this.getStanzaOptions();
+            const stanza = createClient({});
+            this.currentStanzaInstance = stanza;
+            // this is a hack because stanza messes up the auth mechanism priority.
+            stanza.sasl.mechanisms.find(mech => mech.name === 'ANONYMOUS').priority = 0;
+            stanza.sasl.mechanisms = stanza.sasl.mechanisms.sort((a, b) => b.priority - a.priority);
+            // we are going to give the stanza instance an id for tracking and logging purposes
+            stanza.id = globalThis.crypto.randomUUID();
+            const channelId = stanza.channelId = this.config.channelId;
+            let boundCheckForErrorStanza;
+            let boundSessionStarted;
+            let boundSessionSasl;
+            let boundSessionDisconnected;
+            const connectionAttemptPromise = timeoutPromise((resolve, reject) => {
+                boundCheckForErrorStanza = this.checkForErrorStanza.bind(this, stanza);
+                stanza.on('raw:incoming', boundCheckForErrorStanza);
+                boundSessionStarted = this.handleSessionStarted.bind(this, stanza, resolve);
+                stanza.on('session:started', boundSessionStarted);
+                boundSessionSasl = this.handleSessionSasl.bind(this, stanza, reject);
+                stanza.on('sasl', boundSessionSasl);
+                boundSessionDisconnected = this.handleSessionDisconnected.bind(this, stanza, reject);
+                stanza.on('disconnected', boundSessionDisconnected);
+                stanza.updateConfig(options);
+                stanza.connect();
+            }, 15 * 1000, 'connecting to streaming service', { channelId, stanzaInstanceId: stanza.id });
+            connectionAttemptPromise.catch(() => stanza.disconnect());
+            return connectionAttemptPromise.finally(() => {
+                stanza.off('raw:incoming', boundCheckForErrorStanza);
+                stanza.off('session:started', boundSessionStarted);
+                stanza.off('sasl', boundSessionSasl);
+                stanza.off('disconnected', boundSessionDisconnected);
+            });
+        });
+    }
+    handleSessionStarted(stanza, resolve) {
+        this.logger.info('new stanza instance connected', { stanzaInstanceId: stanza.id, channelId: stanza.channelId });
+        resolve(stanza);
+    }
+    handleSessionSasl(stanza, reject, sasl) {
+        if (sasl.type === 'failure') {
+            reject(new SaslError(sasl.condition, stanza.channelId, stanza.id));
+        }
+    }
+    handleSessionDisconnected(stanza, reject) {
+        this.logger.error('stanza disconnected', { stanzaInstanceId: stanza.id, channelId: stanza.channelId });
+        reject();
+    }
+    checkForErrorStanza(stanza, rawStanza) {
+        if (rawStanza.includes('error')) {
+            this.logger.error('Received a stanza during setup that tripped the error filter', { rawStanza, stanzaInstanceId: stanza.id, channelId: stanza.channelId });
+        }
+    }
+    getStanzaOptions() {
+        if (this.config.jwt) {
+            return this.getJwtOptions();
+        }
+        return this.getStandardOptions();
+    }
+    getJwtOptions() {
+        const config = this.config;
+        const jwt = parseJwt(config.jwt);
+        let jidDomain;
+        const jwtJid = jwt.data.jid;
+        try {
+            jidDomain = jwtJid.split('@')[1].replace('conference.', '');
+        }
+        catch (e) {
+            throw new Error('failed to parse jid');
+        }
+        const wsHost = config.host.replace(/\/$/, '');
+        return {
+            resource: config.jidResource,
+            transports: {
+                websocket: `${wsHost}/stream/jwt/${config.jwt}`
+            },
+            server: jidDomain
+        };
+    }
+    getStandardOptions() {
+        const config = this.config;
+        const wsHost = config.host.replace(/\/$/, '');
+        return {
+            jid: config.jid,
+            resource: config.jidResource,
+            credentials: {
+                username: config.jid,
+                password: `authKey:${config.authToken}`
+            },
+            transports: {
+                websocket: `${wsHost}/stream/channels/${config.channelId}`
+            }
+        };
+    }
+}

package/dist/es/connection-transfer.d.ts

@@ -0,0 +1,7 @@
+import { Client } from './client';
+import { NamedAgent } from './types/named-agent';
+export declare class ConnectionTransfer {
+    private client;
+    private stanzaInstance;
+    constructor(client: Client, stanzaInstance: NamedAgent);
+}

package/dist/es/connection-transfer.js

@@ -0,0 +1,16 @@
+import { connectionTransfer } from './stanza-definitions/xep0051';
+export class ConnectionTransfer {
+    constructor(client, stanzaInstance) {
+        this.client = client;
+        this.stanzaInstance = stanzaInstance;
+        stanzaInstance.stanzas.define(connectionTransfer);
+        // Hawk maps `v2.system.socket_closing` to XEP-0051 Connection Transfer
+        // The docs says we have up to one minute to disconnect and connect a new WebSocket, so we should be proactive in reconnecting.
+        stanzaInstance.on('iq:set:connectionTransfer', (iq) => {
+            client.logger.warn('connection transfer (socket_closing) event received', { stanzaInstanceId: stanzaInstance.id, channelId: stanzaInstance.channelId });
+            void client.disconnect();
+            client.emit('disconnected', { reconnecting: true });
+            void client.connect({ keepTryingOnFailure: true });
+        });
+    }
+}

package/dist/es/http-client.d.ts

@@ -0,0 +1,18 @@
+import { RetryPromise } from './utils';
+import { RequestApiOptions, ISuperagentNetworkError, ISuperagentResponseError, INetworkError, IResponseError, ICustomHeader, IHttpClientOptions } from './types/interfaces';
+export declare class HttpClient {
+    customHeaders?: ICustomHeader;
+    private _httpRetryingRequests;
+    static retryStatusCodes: Set<number>;
+    static retryNetworkErrorCodes: Set<string>;
+    constructor(httpClientOptions?: IHttpClientOptions);
+    requestApiWithRetry<T = any>(path: string, opts: RequestApiOptions, retryInterval?: number): RetryPromise<T>;
+    requestApi(path: string, opts: RequestApiOptions): Promise<any>;
+    private handleResponse;
+    stopAllRetries(): void;
+    cancelRetryRequest(retryId: string): true;
+    formatRequestError(error: Error | ISuperagentNetworkError | ISuperagentResponseError): Error | INetworkError | IResponseError;
+    private isSuperagentNetworkError;
+    private isSuperagentResponseError;
+    private _buildUri;
+}

package/dist/es/http-client.js

@@ -0,0 +1,194 @@
+import axios, { AxiosError } from 'axios';
+import { retryPromise } from './utils';
+const correlationIdHeaderName = 'inin-correlation-id';
+export class HttpClient {
+    constructor(httpClientOptions) {
+        this._httpRetryingRequests = new Map();
+        this.customHeaders = httpClientOptions === null || httpClientOptions === void 0 ? void 0 : httpClientOptions.customHeaders;
+    }
+    requestApiWithRetry(path, opts, retryInterval) {
+        const maxRetries = opts.maxAttempts || 10;
+        let retryCount = 0;
+        const retry = retryPromise(this.requestApi.bind(this, path, opts), (error) => {
+            var _a, _b, _c;
+            retryCount++;
+            if (retryCount >= maxRetries) {
+                (opts.logger || console).info('Max retries reached, will not retry.', { maxRetries, retryCount, path });
+                return false;
+            }
+            let retryValue = false;
+            if (error === null || error === void 0 ? void 0 : error.response) {
+                retryValue = HttpClient.retryStatusCodes.has(error.response.status || 0);
+                // 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 = ((_a = error.response.headers) === null || _a === void 0 ? void 0 : _a['retry-after']) || ((_c = (_b = error.response).getResponseHeader) === null || _c === void 0 ? void 0 : _c.call(_b, 'retry-after'));
+                if (retryAfter) {
+                    (opts.logger || console).debug('retry-after header found on response. setting retry delay', { retryAfter });
+                    // retry after comes in seconds, we need to return milliseconds
+                    retryValue = parseInt(retryAfter, 10) * 1000;
+                }
+            }
+            // Check network error codes independently - error may have both response (with status 0) and a network error code.
+            if ((error === null || error === void 0 ? void 0 : error.code) && retryValue === false) {
+                // Retry on network error codes - request didn't make it to the server or no response was received
+                if (HttpClient.retryNetworkErrorCodes.has(error.code)) {
+                    (opts.logger || console).debug('Retry network error code found, will retry.', { code: error.code });
+                    retryValue = true;
+                }
+            }
+            return retryValue;
+        }, retryInterval, opts.logger);
+        this._httpRetryingRequests.set(retry._id, retry);
+        retry.promise.then(() => this.cancelRetryRequest(retry._id), () => this.cancelRetryRequest(retry._id));
+        return retry;
+    }
+    requestApi(path, opts) {
+        const logger = opts.logger || console;
+        const start = new Date().getTime();
+        opts.customHeaders = Object.assign(Object.assign({}, (this.customHeaders || {})), (opts.customHeaders || {}));
+        const url = this._buildUri(opts.host, path, opts.version);
+        const headers = Object.assign({ 'content-type': opts.contentType || 'application/json' }, opts.customHeaders);
+        const params = {
+            method: opts.method,
+            url,
+            data: opts.data,
+            responseType: opts.responseType,
+            timeout: opts.requestTimeout || 30000,
+            headers,
+            signal: opts.signal
+        };
+        // default to include auth header
+        if (!opts.noAuthHeader) {
+            params.headers.Authorization = `Bearer ${opts.authToken}`;
+        }
+        const boundHandler = this.handleResponse.bind(this, logger, start, params);
+        return axios(params)
+            .then(boundHandler, boundHandler);
+    }
+    handleResponse(logger, start, params, res) {
+        var _a, _b, _c;
+        const now = new Date().getTime();
+        const elapsed = (now - start) + 'ms';
+        if (res instanceof AxiosError) {
+            // sanitize the auth token
+            if ((_b = (_a = res.config) === null || _a === void 0 ? void 0 : _a.headers) === null || _b === void 0 ? void 0 : _b.Authorization) {
+                res.config.headers.Authorization = 'redacted';
+            }
+            // handles request timeout
+            if (res.code === 'ECONNABORTED') {
+                logger.debug(`request error: ${params.url}`, {
+                    message: res.message,
+                    now,
+                    elapsed
+                }, { skipServer: true });
+                return Promise.reject(res);
+            }
+            /* istanbul ignore next */
+            const response = res.response || {};
+            const status = response.status;
+            const correlationId = response.headers && response.headers[correlationIdHeaderName];
+            const body = response.data;
+            const error = Object.assign(Object.assign({}, res), { text: (_c = response.request) === null || _c === void 0 ? void 0 : _c.response });
+            logger.debug(`request error: ${params.url}`, {
+                message: res.message,
+                now,
+                elapsed,
+                status,
+                correlationId,
+                body
+            }, { skipServer: true });
+            return Promise.reject(error);
+        }
+        const status = res.status;
+        const correlationId = res.headers[correlationIdHeaderName];
+        const body = JSON.stringify(res.data);
+        logger.debug(`response: ${params.method.toUpperCase()} ${params.url}`, {
+            now,
+            status,
+            elapsed,
+            correlationId,
+            body
+        }, { skipServer: true });
+        return Promise.resolve(res);
+    }
+    stopAllRetries() {
+        Array.from(this._httpRetryingRequests.keys())
+            .forEach(key => this.cancelRetryRequest(key));
+    }
+    cancelRetryRequest(retryId) {
+        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.cancel(new Error('Retry request cancelled'));
+            this._httpRetryingRequests.delete(retryId);
+        }
+        return true;
+    }
+    formatRequestError(error) {
+        /* if network error */
+        if (this.isSuperagentNetworkError(error)) {
+            return {
+                status: error.status,
+                method: error.method,
+                url: error.url,
+                crossDomain: error.crossDomain,
+                message: error.message,
+                name: error.name,
+                stack: error.stack
+            };
+        }
+        /* if superagent response error */
+        if (this.isSuperagentResponseError(error)) {
+            const res = error.response;
+            return {
+                status: error.status,
+                correlationId: res.headers['inin-correlation-id'],
+                // Potentially could contain PII
+                // responseBody: res.text,
+                // requestBody: res.req._data,
+                // url: res.error.url,
+                message: 'Error making HTTP request',
+                method: res.req.method,
+                name: res.error.name,
+                stack: res.error.stack
+            };
+        }
+        /* if we don't have a superagent error */
+        return error;
+    }
+    isSuperagentNetworkError(error) {
+        return (error &&
+            // these properties may have the value of `undefined` but they will still be set
+            error.hasOwnProperty('status') &&
+            error.hasOwnProperty('method') &&
+            error.hasOwnProperty('url'));
+    }
+    isSuperagentResponseError(error) {
+        return !!(error &&
+            error.response &&
+            error.response.body &&
+            error.response.req);
+    }
+    _buildUri(host, path, version = 'v2') {
+        path = path.replace(/^\/+|\/+$/g, ''); // trim leading/trailing /
+        if (host.indexOf('http') === 0) {
+            return `${host}/api/${version}/${path}`;
+        }
+        return `https://api.${host}/api/${version}/${path}`;
+    }
+}
+HttpClient.retryStatusCodes = new Set([
+    408,
+    413,
+    429,
+    500,
+    502,
+    503,
+    504
+]);
+HttpClient.retryNetworkErrorCodes = new Set([
+    'ECONNABORTED',
+    'ECONNRESET',
+    'ERR_NETWORK',
+    'ETIMEDOUT'
+]);