@openfin/cloud-interop-core-api 0.0.1-alpha.938bfdd → 0.0.1-alpha.9655dc9

package/dist/index.cjs

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