@openfin/cloud-interop-core-api 0.0.1-alpha.384d88e → 0.0.1-alpha.3cbe14e

package/dist/{src/api.d.ts → api.d.ts}

@@ -1,6 +1,5 @@
-import { EndReportIntentsEvent, Intent, IntentDetailsEvent, IntentResultEvent, InvokeIntentEvent, ReportIntentsEvent } from '@openfin-direct/shared-utils';
 import mqtt from 'mqtt';
-import { CloudInteropSettings, ConnectParameters, ContextEvent } from './interfaces';
+import { CloudInteropSettings, ConnectParameters as ConnectParameters, ContextEvent } from './interfaces';
 type CreateSessionResponse = {
     sessionId: string;
     sessionRootTopic: string;
@@ -18,11 +17,6 @@ type EventMap = {
     reconnecting: (attemptNo: number) => void;
     error: (error: Error) => void;
     'session-expired': () => void;
-    'report-intents': (event: ReportIntentsEvent) => void;
-    'end-report-intents': (event: EndReportIntentsEvent) => void;
-    'intent-details': (event: IntentDetailsEvent) => void;
-    'invoke-intent': (event: InvokeIntentEvent) => void;
-    'intent-result': (event: IntentResultEvent) => void;
 };
 /**
  * Represents a single connection to a Cloud Interop service
@@ -63,25 +57,6 @@ export declare class CloudInteropAPI {
      * @memberof CloudInteropAPI
      */
     setContext(contextGroup: string, context: object): Promise<void>;
-    /**
-     * Starts an intent discovery operation
-     *
-     * @return {*}  {Promise<void>}
-     * @memberof CloudInteropAPI
-     * @throws {CloudInteropAPIError} - If an error occurs during intent discovery
-     */
-    startIntentDiscovery(): Promise<void>;
-    /**
-     * Ends an intent discovery operation
-     *
-     * @return {*}  {Promise<void>}
-     * @memberof CloudInteropAPI
-     * @throws {CloudInteropAPIError} - If an error occurs during stopping intent discovery
-     */
-    endIntentDiscovery(): Promise<void>;
-    raiseIntent(intent: Intent, targetSessionId: string): Promise<void>;
-    reportSupportedIntents(discoveryId: string, intents: Intent[]): Promise<void>;
-    sendIntentResult(resultEvent: IntentResultEvent): Promise<void>;
     addEventListener<K extends keyof EventMap>(type: K, callback: EventMap[K]): void;
     removeEventListener<K extends keyof EventMap>(type: K, callback: EventMap[K]): void;
 }

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var axios = require('axios');
 var mqtt = require('mqtt');
 
 class CloudInteropAPIError extends Error {
@@ -38,7 +39,6 @@ class CloudInteropAPI {
     #connectionParams;
     #eventListeners = new Map();
     #attemptingToReconnect = false;
-    #currentIntentDiscoveryId;
     constructor(cloudInteropSettings) {
         this.#cloudInteropSettings = cloudInteropSettings;
     }
@@ -64,99 +64,105 @@ class CloudInteropAPI {
         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);
+        try {
+            const createSessionResponse = await axios.post(`${this.#cloudInteropSettings.url}/api/sessions`, {
+                sourceId,
+                platformId,
+            }, {
+                headers: this.#getRequestHeaders(),
+            });
+            if (createSessionResponse.status !== 201) {
+                throw new CloudInteropAPIError(`Failed to connect to the Cloud Interop service: ${this.#cloudInteropSettings.url}`, 'ERR_CONNECT', createSessionResponse.status);
             }
-            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;
+            this.#sessionDetails = createSessionResponse.data;
+            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));
+                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.#handleCommand(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`);
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                if (error.response?.status === 401 || error.response?.status === 403) {
+                    throw new AuthorizationError();
+                }
+                throw new CloudInteropAPIError();
             }
-        });
-        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`);
+            throw error;
+        }
     }
     /**
      * Disconnects from the Cloud Interop service
@@ -184,120 +190,9 @@ class CloudInteropAPI {
             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',
+        await axios.post(`${this.#cloudInteropSettings.url}/api/context-groups/${this.#sessionDetails.sessionId}/${contextGroup}`, payload, {
             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) || [];
@@ -317,16 +212,15 @@ class CloudInteropAPI {
             return;
         }
         try {
-            const disconnectResponse = await fetch(`${this.#cloudInteropSettings.url}/api/sessions/${this.#sessionDetails.sessionId}`, {
-                method: 'DELETE',
+            const disconnectResponse = await axios.delete(`${this.#cloudInteropSettings.url}/api/sessions/${this.#sessionDetails.sessionId}`, {
                 headers: this.#getRequestHeaders(),
             });
             if (disconnectResponse.status !== 200) {
-                throw new CloudInteropAPIError('Error during session tear down - unexpected status', 'ERR_DISCONNECT', new Error(disconnectResponse.statusText));
+                throw new CloudInteropAPIError('Error during session tear down - unexpected status', 'ERR_DISCONNECT', disconnectResponse.status);
             }
         }
-        catch (error) {
-            throw new CloudInteropAPIError('Error during disconnection', 'ERR_DISCONNECT', error);
+        catch {
+            throw new CloudInteropAPIError('Error during disconnection', 'ERR_DISCONNECT');
         }
         finally {
             this.#mqttClient?.removeAllListeners();
@@ -335,13 +229,12 @@ class CloudInteropAPI {
             this.#mqttClient = undefined;
             this.#reconnectRetries = 0;
             this.#attemptingToReconnect = false;
-            this.#currentIntentDiscoveryId = undefined;
             if (fireDisconnectedEvent) {
                 this.#emitEvent('disconnected');
             }
         }
     }
-    #handleMessage(topic, message, sessionDetails) {
+    #handleCommand(topic, message, sessionDetails) {
         if (message.length === 0 || !sessionDetails) {
             // Ignore clean up messages
             return;
@@ -354,73 +247,6 @@ class CloudInteropAPI {
             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) || [];
@@ -449,7 +275,7 @@ class CloudInteropAPI {
         if (!this.#connectionParams) {
             throw new Error('Connect parameters must be provided');
         }
-        const headers = {};
+        const headers = new axios.AxiosHeaders();
         headers['Content-Type'] = 'application/json';
         if (this.#connectionParams.authenticationType === 'jwt' && this.#connectionParams.jwtAuthenticationParameters) {
             const tokenResult = this.#connectionParams.jwtAuthenticationParameters.jwtRequestCallback();