@openfin/cloud-interop-core-api 0.0.1-alpha.979385f → 0.0.1-alpha.97cea20

package/dist/index.cjs

@@ -1,473 +0,0 @@
-'use strict';
-
-var mqtt = require('mqtt');
-
-class CloudInteropAPIError extends Error {
-    code;
-    constructor(message = 'An unexpected error has occurred', code = 'UNEXPECTED_ERROR', cause) {
-        super(message, { cause: cause });
-        this.name = this.constructor.name;
-        this.code = code;
-    }
-}
-class AuthorizationError extends CloudInteropAPIError {
-    constructor(message = 'Not authorized', code = 'ERR_UNAUTHORIZED') {
-        super(message, code, undefined);
-    }
-}
-
-// Error codes as defined in https://docs.emqx.com/en/cloud/latest/connect_to_deployments/mqtt_client_error_codes.html
-const BadUserNamePasswordError = 134;
-/**
- * Represents a single connection to a Cloud Interop service
- *
- * @export
- * @class CloudInteropAPI
- * @implements {Client}
- */
-class CloudInteropAPI {
-    #cloudInteropSettings;
-    #sessionDetails;
-    #mqttClient;
-    #reconnectRetryLimit = 30;
-    #keepAliveIntervalSeconds = 30;
-    #logger = (level, message) => {
-        console[level](message);
-    };
-    #reconnectRetries = 0;
-    #connectionParams;
-    #eventListeners = new Map();
-    #attemptingToReconnect = false;
-    #currentIntentDiscoveryId;
-    constructor(cloudInteropSettings) {
-        this.#cloudInteropSettings = cloudInteropSettings;
-    }
-    get sessionDetails() {
-        return this.#sessionDetails;
-    }
-    get mqttClient() {
-        return this.#mqttClient;
-    }
-    /**
-     * Connects and creates a session on the Cloud Interop service
-     *
-     * @param {ConnectParameters} parameters - The parameters to use to connect
-     * @return {*}  {Promise<void>}
-     * @memberof CloudInteropAPI
-     * @throws {CloudInteropAPIError} - If an error occurs during connection
-     * @throws {AuthorizationError} - If the connection is unauthorized
-     */
-    async connect(parameters) {
-        this.#validateConnectParams(parameters);
-        this.#connectionParams = parameters;
-        this.#reconnectRetryLimit = parameters.reconnectRetryLimit || this.#reconnectRetryLimit;
-        this.#keepAliveIntervalSeconds = parameters.keepAliveIntervalSeconds || this.#keepAliveIntervalSeconds;
-        this.#logger = parameters.logger || this.#logger;
-        const { sourceId, platformId } = this.#connectionParams;
-        const createSessionResponse = await fetch(`${this.#cloudInteropSettings.url}/api/sessions`, {
-            method: 'POST',
-            headers: this.#getRequestHeaders(),
-            body: JSON.stringify({ sourceId, platformId }),
-        });
-        if (!createSessionResponse.ok) {
-            if (createSessionResponse.status === 401 || createSessionResponse.status === 403) {
-                throw new AuthorizationError();
-            }
-            throw new CloudInteropAPIError();
-        }
-        if (createSessionResponse.status !== 201) {
-            throw new CloudInteropAPIError(`Failed to connect to the Cloud Interop service: ${this.#cloudInteropSettings.url}`, 'ERR_CONNECT', new Error(createSessionResponse.statusText));
-        }
-        this.#sessionDetails = (await createSessionResponse.json());
-        const sessionRootTopic = this.#sessionDetails.sessionRootTopic;
-        const clientOptions = {
-            keepalive: this.#keepAliveIntervalSeconds,
-            clientId: this.#sessionDetails.sessionId,
-            clean: true,
-            protocolVersion: 5,
-            // The "will" message will be published on an unexpected disconnection
-            // The server can then tidy up.  So it needs every for this client to do that, the session details is perfect
-            will: {
-                topic: 'interop/lastwill',
-                payload: Buffer.from(JSON.stringify(this.#sessionDetails)),
-                qos: 0,
-                retain: false,
-            },
-            username: this.#sessionDetails.token,
-        };
-        this.#mqttClient = await mqtt.connectAsync(this.#sessionDetails.url, clientOptions);
-        this.#logger('log', `Cloud Interop successfully connected to ${this.#cloudInteropSettings.url}`);
-        this.#mqttClient.on('error', async (error) => {
-            // We will receive errors for each failed reconnection attempt
-            // We don't won't to disconnect on these else we will never reconnect
-            if (!this.#attemptingToReconnect) {
-                await this.#disconnect(false);
-            }
-            if (error instanceof mqtt.ErrorWithReasonCode) {
-                switch (error.code) {
-                    case BadUserNamePasswordError: {
-                        await this.#disconnect(false);
-                        this.#logger('warn', `Session expired`);
-                        this.#emitEvent('session-expired');
-                        return;
-                    }
-                    default: {
-                        this.#logger('error', `Unknown Infrastructure Error Code ${error.code} : ${error.message}${this.#attemptingToReconnect ? ' during reconnection attempt' : ''}`);
-                        // As we are in the middle of a reconnect, lets not emit an error to cut down on the event noise
-                        if (!this.#attemptingToReconnect) {
-                            this.#emitEvent('error', new CloudInteropAPIError(`Unknown Infrastructure Error Code ${error.code} : ${error.message}`, 'ERR_INFRASTRUCTURE', error));
-                            break;
-                        }
-                    }
-                }
-            }
-            else {
-                this.#logger('error', `Unknown Error${this.#attemptingToReconnect ? ' during reconnection attempt' : ''}: ${error}`);
-                // As we are in the middle of a reconnect, lets not emit an error to cut down on the event noise
-                if (!this.#attemptingToReconnect) {
-                    this.#emitEvent('error', new CloudInteropAPIError(`Unknown Error`, 'ERR_UNKNOWN', error));
-                }
-            }
-        });
-        this.#mqttClient.on('reconnect', () => {
-            this.#attemptingToReconnect = true;
-            this.#reconnectRetries += 1;
-            this.#logger('debug', `Cloud Interop attempting reconnection - ${this.#reconnectRetries}...`);
-            if (this.#reconnectRetries === this.#reconnectRetryLimit) {
-                this.#logger('warn', `Cloud Interop reached max reconnection attempts - ${this.#reconnectRetryLimit}...`);
-                this.#disconnect(true);
-            }
-            this.#emitEvent('reconnecting', this.#reconnectRetries);
-        });
-        // Does not fire on initial connection, only successful reconnection attempts
-        this.#mqttClient.on('connect', () => {
-            this.#logger('debug', `Cloud Interop successfully reconnected after ${this.#reconnectRetries} attempts`);
-            this.#reconnectRetries = 0;
-            this.#attemptingToReconnect = false;
-            this.#emitEvent('reconnected');
-        });
-        this.#mqttClient.on('message', (topic, message) => {
-            if (!this.#sessionDetails) {
-                this.#logger('warn', 'Received message when session not connected');
-                return;
-            }
-            this.#handleMessage(topic, message, this.#sessionDetails);
-        });
-        // Subscribe to all context groups
-        this.#mqttClient.subscribe(`${sessionRootTopic}/context-groups/#`);
-        // Listen out for global commands
-        this.#mqttClient.subscribe(`${sessionRootTopic}/commands`);
-    }
-    /**
-     * Disconnects from the Cloud Interop service
-     *
-     * @return {*}  {Promise<void>}
-     * @memberof CloudInteropAPI
-     * @throws {CloudInteropAPIError} - If an error occurs during disconnection
-     */
-    async disconnect() {
-        await this.#disconnect(true);
-    }
-    /**
-     * Publishes a new context for the given context group to the other connected sessions
-     *
-     * @param {string} contextGroup - The context group to publish to
-     * @param {object} context - The context to publish
-     * @return {*}  {Promise<void>}
-     * @memberof CloudInteropAPI
-     */
-    async setContext(contextGroup, context) {
-        if (!this.#sessionDetails || !this.#connectionParams) {
-            throw new Error('Session not connected');
-        }
-        const payload = {
-            context,
-            timestamp: Date.now(),
-        };
-        const postResponse = await fetch(`${this.#cloudInteropSettings.url}/api/context-groups/${this.#sessionDetails.sessionId}/${contextGroup}`, {
-            method: 'POST',
-            headers: this.#getRequestHeaders(),
-            body: JSON.stringify(payload),
-        });
-        if (!postResponse.ok) {
-            throw new CloudInteropAPIError(`Error setting context for ${contextGroup}`, 'ERR_SETTING_CONTEXT', new Error(postResponse.statusText));
-        }
-    }
-    /**
-     * Starts an intent discovery operation
-     *
-     * @return {*}  {Promise<void>}
-     * @memberof CloudInteropAPI
-     * @throws {CloudInteropAPIError} - If an error occurs during intent discovery
-     */
-    async startIntentDiscovery() {
-        if (!this.#sessionDetails || !this.#connectionParams) {
-            throw new Error('Session not connected');
-        }
-        if (!this.#mqttClient) {
-            throw new Error('MQTT client not connected');
-        }
-        if (this.#currentIntentDiscoveryId) {
-            throw new Error('Intent discovery already in progress');
-        }
-        try {
-            const startResponse = await fetch(`${this.#cloudInteropSettings.url}/api/intents/${this.#sessionDetails.sessionId}`, {
-                method: 'POST',
-                headers: this.#getRequestHeaders(),
-            });
-            if (!startResponse.ok) {
-                throw new Error(startResponse.statusText);
-            }
-            const json = await startResponse.json();
-            this.#currentIntentDiscoveryId = json.discoveryId;
-            // Listen out for discovery results directly send to us
-            await this.#mqttClient.subscribeAsync(`${this.#sessionDetails.sessionRootTopic}/commands/${this.#currentIntentDiscoveryId}`);
-        }
-        catch (error) {
-            throw new CloudInteropAPIError('Error starting intent discovery', 'ERR_STARTING_INTENT_DISCOVERY', error);
-        }
-    }
-    /**
-     * Ends an intent discovery operation
-     *
-     * @return {*}  {Promise<void>}
-     * @memberof CloudInteropAPI
-     * @throws {CloudInteropAPIError} - If an error occurs during stopping intent discovery
-     */
-    async endIntentDiscovery() {
-        if (!this.#sessionDetails || !this.#connectionParams) {
-            throw new Error('Session not connected');
-        }
-        if (!this.#currentIntentDiscoveryId) {
-            throw new Error('Intent discovery not already in progress');
-        }
-        if (!this.#mqttClient) {
-            throw new Error('MQTT client not connected');
-        }
-        try {
-            await this.#mqttClient.unsubscribeAsync(`${this.#sessionDetails.sessionRootTopic}/commands/${this.#currentIntentDiscoveryId}`);
-            const deleteResponse = await fetch(`${this.#cloudInteropSettings.url}/api/intents/${this.#sessionDetails.sessionId}/${this.#currentIntentDiscoveryId}`, {
-                method: 'DELETE',
-                headers: this.#getRequestHeaders(),
-            });
-            if (!deleteResponse.ok) {
-                throw new Error(deleteResponse.statusText);
-            }
-            this.#currentIntentDiscoveryId = undefined;
-        }
-        catch (error) {
-            throw new CloudInteropAPIError('Error ending intent discovery', 'ERR_ENDING_INTENT_DISCOVERY', error);
-        }
-    }
-    async raiseIntent(intent, targetSessionId) {
-        if (!this.#sessionDetails || !this.#connectionParams) {
-            throw new Error('Session not connected');
-        }
-        const postResponse = await fetch(`${this.#cloudInteropSettings.url}/api/intents/${this.#sessionDetails.sessionId}/sessions/${targetSessionId}`, {
-            method: 'POST',
-            headers: this.#getRequestHeaders(),
-            body: JSON.stringify({ intent }),
-        });
-        if (!postResponse.ok) {
-            throw new CloudInteropAPIError(`Error raising intent: ${intent.intentMetadata.name}`, 'ERR_RAISING_INTENT', new Error(postResponse.statusText));
-        }
-    }
-    async reportSupportedIntents(discoveryId, intents) {
-        if (!this.#sessionDetails || !this.#connectionParams) {
-            throw new Error('Session not connected');
-        }
-        const reportResponse = await fetch(`${this.#cloudInteropSettings.url}/api/intents/${this.#sessionDetails.sessionId}/${discoveryId}`, {
-            method: 'POST',
-            headers: this.#getRequestHeaders(),
-            body: JSON.stringify({ intents }),
-        });
-        if (!reportResponse.ok) {
-            throw new CloudInteropAPIError('Error starting intent discovery', 'ERR_REPORTING_INTENTS', new Error(reportResponse.statusText));
-        }
-    }
-    async sendIntentResult(resultEvent) {
-        if (!this.#sessionDetails || !this.#connectionParams) {
-            throw new Error('Session not connected');
-        }
-        const { initiatingSessionId, result, sessionId } = resultEvent;
-        const resultResponse = await fetch(`${this.#cloudInteropSettings.url}/api/intents/${initiatingSessionId}/result/${sessionId}`, {
-            method: 'POST',
-            headers: this.#getRequestHeaders(),
-            body: JSON.stringify({ result }),
-        });
-        if (!resultResponse.ok) {
-            throw new CloudInteropAPIError('Error sending intent result', 'ERR_SENDING_INTENT_RESULT', new Error(resultResponse.statusText));
-        }
-    }
-    addEventListener(type, callback) {
-        const listeners = this.#eventListeners.get(type) || [];
-        listeners.push(callback);
-        this.#eventListeners.set(type, listeners);
-    }
-    removeEventListener(type, callback) {
-        const listeners = this.#eventListeners.get(type) || [];
-        const index = listeners.indexOf(callback);
-        if (index !== -1) {
-            listeners.splice(index, 1);
-        }
-        this.#eventListeners.set(type, listeners);
-    }
-    async #disconnect(fireDisconnectedEvent) {
-        if (!this.#sessionDetails) {
-            return;
-        }
-        try {
-            const disconnectResponse = await fetch(`${this.#cloudInteropSettings.url}/api/sessions/${this.#sessionDetails.sessionId}`, {
-                method: 'DELETE',
-                headers: this.#getRequestHeaders(),
-            });
-            if (disconnectResponse.status !== 200) {
-                throw new CloudInteropAPIError('Error during session tear down - unexpected status', 'ERR_DISCONNECT', new Error(disconnectResponse.statusText));
-            }
-        }
-        catch (error) {
-            throw new CloudInteropAPIError('Error during disconnection', 'ERR_DISCONNECT', error);
-        }
-        finally {
-            this.#mqttClient?.removeAllListeners();
-            await this.#mqttClient?.endAsync(true);
-            this.#sessionDetails = undefined;
-            this.#mqttClient = undefined;
-            this.#reconnectRetries = 0;
-            this.#attemptingToReconnect = false;
-            this.#currentIntentDiscoveryId = undefined;
-            if (fireDisconnectedEvent) {
-                this.#emitEvent('disconnected');
-            }
-        }
-    }
-    #handleMessage(topic, message, sessionDetails) {
-        if (message.length === 0 || !sessionDetails) {
-            // Ignore clean up messages
-            return;
-        }
-        const messageEnvelope = JSON.parse(message.toString());
-        if (topic.startsWith(`${sessionDetails.sessionRootTopic}/context-groups/`)) {
-            if (messageEnvelope.source.sessionId === sessionDetails.sessionId) {
-                return;
-            }
-            const { channelName: contextGroup, payload: context, source, history } = messageEnvelope;
-            this.#emitEvent('context', { contextGroup, context, source, history: { ...history, clientReceived: Date.now() } });
-        }
-        else if (topic.startsWith(`${sessionDetails.sessionRootTopic}/commands`)) {
-            this.#handleCommandMessage(messageEnvelope);
-        }
-    }
-    #handleCommandMessage(message) {
-        switch (message.command) {
-            case 'report-intents': {
-                if (message.initiatingSessionId === this.#sessionDetails?.sessionId) {
-                    // Ignore if this originated from us
-                    return;
-                }
-                this.#emitEvent('report-intents', {
-                    discoveryId: message.discoveryId,
-                    initiatingSessionId: message.initiatingSessionId,
-                    sessionId: message.sessionId,
-                });
-                break;
-            }
-            case 'intent-details': {
-                if (message.discoveryId !== this.#currentIntentDiscoveryId) {
-                    // Ignore if its any other discovery id for some reason
-                    return;
-                }
-                this.#emitEvent('intent-details', {
-                    discoveryId: message.discoveryId,
-                    initiatingSessionId: message.initiatingSessionId,
-                    sessionId: message.sessionId,
-                    intents: message.intents,
-                });
-                break;
-            }
-            case 'end-report-intents': {
-                if (message.initiatingSessionId === this.#sessionDetails?.sessionId) {
-                    // Ignore if this originated from us
-                    return;
-                }
-                this.#emitEvent('end-report-intents', {
-                    discoveryId: message.discoveryId,
-                    initiatingSessionId: message.initiatingSessionId,
-                    sessionId: message.sessionId,
-                });
-                break;
-            }
-            case 'invoke-intent': {
-                if (message.sessionId === this.#sessionDetails?.sessionId) {
-                    this.#emitEvent('invoke-intent', {
-                        initiatingSessionId: message.initiatingSessionId,
-                        intent: message.intent,
-                        sessionId: message.sessionId,
-                    });
-                }
-                break;
-            }
-            case 'intent-result': {
-                if (message.initiatingSessionId === this.#sessionDetails?.sessionId) {
-                    // Return result to originator and end discovery
-                    const { command: _, ...resultEvent } = message;
-                    this.#emitEvent('intent-result', resultEvent);
-                    this.endIntentDiscovery().catch(() => undefined);
-                }
-                break;
-            }
-            default: {
-                this.#logger('warn', `Unknown command message received: ${message}`);
-                break;
-            }
-        }
-    }
-    #emitEvent(type, ...args) {
-        const listeners = this.#eventListeners.get(type) || [];
-        listeners.forEach((listener) => listener(...args));
-    }
-    #validateConnectParams = (parameters) => {
-        if (!parameters) {
-            throw new Error('Connect parameters must be provided');
-        }
-        if (!parameters.sourceId) {
-            throw new Error('sourceId must be provided');
-        }
-        if (!parameters.platformId) {
-            throw new Error('platformId must be provided');
-        }
-        if (parameters.authenticationType === 'jwt' &&
-            (!parameters.jwtAuthenticationParameters?.jwtRequestCallback || !parameters.jwtAuthenticationParameters?.authenticationId)) {
-            throw new Error('jwtAuthenticationParameters must be provided when using jwt authentication');
-        }
-        if (parameters.authenticationType === 'basic' &&
-            (!parameters.basicAuthenticationParameters?.username || !parameters.basicAuthenticationParameters?.password)) {
-            throw new Error('basicAuthenticationParameters must be provided when using basic authentication');
-        }
-    };
-    #getRequestHeaders = () => {
-        if (!this.#connectionParams) {
-            throw new Error('Connect parameters must be provided');
-        }
-        const headers = {};
-        headers['Content-Type'] = 'application/json';
-        if (this.#connectionParams.authenticationType === 'jwt' && this.#connectionParams.jwtAuthenticationParameters) {
-            const tokenResult = this.#connectionParams.jwtAuthenticationParameters.jwtRequestCallback();
-            if (!tokenResult) {
-                throw new Error('jwtRequestCallback must return a token');
-            }
-            headers['x-of-auth-id'] = this.#connectionParams.jwtAuthenticationParameters.authenticationId;
-            headers['Authorization'] =
-                typeof tokenResult === 'string' ? `Bearer ${tokenResult}` : `Bearer ${Buffer.from(JSON.stringify(tokenResult)).toString('base64')}`;
-        }
-        if (this.#connectionParams.authenticationType === 'basic' && this.#connectionParams.basicAuthenticationParameters) {
-            const { username, password } = this.#connectionParams.basicAuthenticationParameters;
-            headers['Authorization'] = `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`;
-        }
-        return headers;
-    };
-}
-
-exports.AuthorizationError = AuthorizationError;
-exports.CloudInteropAPI = CloudInteropAPI;
-exports.CloudInteropAPIError = CloudInteropAPIError;