@aws-amplify/interactions 4.0.48 → 4.0.49-next.13

package/src/Interactions.ts

@@ -31,7 +31,7 @@ export class InteractionsClass {
 	 *
 	 * @param {InteractionsOptions} options - Configuration object for Interactions
 	 */
-	constructor(options: InteractionsOptions) {
+	constructor(options: InteractionsOptions = {}) {
 		this._options = options;
 		logger.debug('Interactions Options', this._options);
 		this._pluggables = {};
@@ -44,9 +44,9 @@ export class InteractionsClass {
 	/**
 	 *
 	 * @param {InteractionsOptions} options - Configuration object for Interactions
-	 * @return {Object} - The current configuration
+	 * @return {InteractionsOptions} - The current configuration
 	 */
-	configure(options: InteractionsOptions) {
+	public configure(options: InteractionsOptions): InteractionsOptions {
 		const opt = options ? options.Interactions || options : {};
 		logger.debug('configure Interactions', { opt });
 		this._options = { bots: {}, ...opt, ...opt.Interactions };
@@ -63,19 +63,27 @@ export class InteractionsClass {
 			}
 		}
 
-		// Check if AWSLex provider is already on pluggables
-		if (
-			!this._pluggables.AWSLexProvider &&
-			bots_config &&
-			Object.keys(bots_config)
-				.map(key => bots_config[key])
-				.find(bot => !bot.providerName || bot.providerName === 'AWSLexProvider')
-		) {
-			this._pluggables.AWSLexProvider = new AWSLexProvider();
-		}
+		// configure bots to their specific providers
+		Object.keys(bots_config).forEach(botKey => {
+			const bot = bots_config[botKey];
+			const providerName = bot.providerName || 'AWSLexProvider';
+
+			// add default provider if required
+			if (
+				!this._pluggables.AWSLexProvider &&
+				providerName === 'AWSLexProvider'
+			) {
+				this._pluggables.AWSLexProvider = new AWSLexProvider();
+			}
 
-		Object.keys(this._pluggables).map(key => {
-			this._pluggables[key].configure(this._options.bots);
+			// configure bot with it's respective provider
+			if (this._pluggables[providerName]) {
+				this._pluggables[providerName].configure({ [bot.name]: bot });
+			} else {
+				logger.debug(
+					`bot ${bot.name} was not configured as ${providerName} provider was not found`
+				);
+			}
 		});
 
 		return this._options;
@@ -84,12 +92,23 @@ export class InteractionsClass {
 	public addPluggable(pluggable: InteractionsProvider) {
 		if (pluggable && pluggable.getCategory() === 'Interactions') {
 			if (!this._pluggables[pluggable.getProviderName()]) {
-				pluggable.configure(this._options.bots);
+				// configure bots for the new plugin
+				Object.keys(this._options.bots)
+					.filter(
+						botKey =>
+							this._options.bots[botKey].providerName ===
+							pluggable.getProviderName()
+					)
+					.forEach(botKey => {
+						const bot = this._options.bots[botKey];
+						pluggable.configure({ [bot.name]: bot });
+					});
+
 				this._pluggables[pluggable.getProviderName()] = pluggable;
 				return;
 			} else {
 				throw new Error(
-					'Bot ' + pluggable.getProviderName() + ' already plugged'
+					'Pluggable ' + pluggable.getProviderName() + ' already plugged'
 				);
 			}
 		}
@@ -112,14 +131,14 @@ export class InteractionsClass {
 		message: string | object
 	): Promise<InteractionsResponse> {
 		if (!this._options.bots || !this._options.bots[botname]) {
-			throw new Error('Bot ' + botname + ' does not exist');
+			return Promise.reject('Bot ' + botname + ' does not exist');
 		}
 
 		const botProvider =
 			this._options.bots[botname].providerName || 'AWSLexProvider';
 
 		if (!this._pluggables[botProvider]) {
-			throw new Error(
+			return Promise.reject(
 				'Bot ' +
 					botProvider +
 					' does not have valid pluggin did you try addPluggable first?'
@@ -128,7 +147,10 @@ export class InteractionsClass {
 		return await this._pluggables[botProvider].sendMessage(botname, message);
 	}
 
-	public onComplete(botname: string, callback: (err, confirmation) => void) {
+	public onComplete(
+		botname: string,
+		callback: (err, confirmation) => void
+	): void {
 		if (!this._options.bots || !this._options.bots[botname]) {
 			throw new Error('Bot ' + botname + ' does not exist');
 		}
@@ -146,5 +168,5 @@ export class InteractionsClass {
 	}
 }
 
-export const Interactions = new InteractionsClass(null);
+export const Interactions = new InteractionsClass();
 Amplify.register(Interactions);

package/src/Providers/AWSLexProvider.ts

@@ -10,27 +10,40 @@
  * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
  * and limitations under the License.
  */
-
 import { AbstractInteractionsProvider } from './InteractionsProvider';
 import {
 	InteractionsOptions,
+	AWSLexProviderOptions,
 	InteractionsResponse,
 	InteractionsMessage,
 } from '../types';
 import {
 	LexRuntimeServiceClient,
 	PostTextCommand,
+	PostTextCommandInput,
+	PostTextCommandOutput,
 	PostContentCommand,
+	PostContentCommandInput,
+	PostContentCommandOutput,
 } from '@aws-sdk/client-lex-runtime-service';
 import {
 	ConsoleLogger as Logger,
 	Credentials,
 	getAmplifyUserAgent,
 } from '@aws-amplify/core';
-import { convert } from './AWSLexProviderHelper/convert';
+import { convert } from './AWSLexProviderHelper/utils';
 
 const logger = new Logger('AWSLexProvider');
 
+interface PostContentCommandOutputFormatted
+	extends Omit<PostContentCommandOutput, 'audioStream'> {
+	audioStream?: Uint8Array;
+}
+
+type AWSLexProviderSendResponse =
+	| PostTextCommandOutput
+	| PostContentCommandOutputFormatted;
+
 export class AWSLexProvider extends AbstractInteractionsProvider {
 	private lexRuntimeServiceClient: LexRuntimeServiceClient;
 	private _botsCompleteCallback: object;
@@ -44,7 +57,27 @@ export class AWSLexProvider extends AbstractInteractionsProvider {
 		return 'AWSLexProvider';
 	}
 
-	reportBotStatus(data, botname) {
+	configure(config: AWSLexProviderOptions = {}): AWSLexProviderOptions {
+		const propertiesToTest = ['name', 'alias', 'region'];
+
+		Object.keys(config).forEach(botKey => {
+			const botConfig = config[botKey];
+
+			// is bot config correct
+			if (!propertiesToTest.every(x => x in botConfig)) {
+				throw new Error('invalid bot configuration');
+			}
+		});
+		return super.configure(config);
+	}
+
+	/**
+	 * @private
+	 * @deprecated
+	 * This is used internally by 'sendMessage' to call onComplete callback
+	 * for a bot if configured
+	 */
+	reportBotStatus(data: AWSLexProviderSendResponse, botname: string) {
 		// Check if state is fulfilled to resolve onFullfilment promise
 		logger.debug('postContent state', data.dialogState);
 		if (
@@ -52,21 +85,14 @@ export class AWSLexProvider extends AbstractInteractionsProvider {
 			data.dialogState === 'Fulfilled'
 		) {
 			if (typeof this._botsCompleteCallback[botname] === 'function') {
-				setTimeout(
-					() =>
-						this._botsCompleteCallback[botname](null, { slots: data.slots }),
-					0
-				);
+				setTimeout(() => this._botsCompleteCallback[botname](null, data), 0);
 			}
 
 			if (
 				this._config &&
 				typeof this._config[botname].onComplete === 'function'
 			) {
-				setTimeout(
-					() => this._config[botname].onComplete(null, { slots: data.slots }),
-					0
-				);
+				setTimeout(() => this._config[botname].onComplete(null, data), 0);
 			}
 		}
 
@@ -94,11 +120,16 @@ export class AWSLexProvider extends AbstractInteractionsProvider {
 		botname: string,
 		message: string | InteractionsMessage
 	): Promise<InteractionsResponse> {
+		// check if bot exists
 		if (!this._config[botname]) {
 			return Promise.reject('Bot ' + botname + ' does not exist');
 		}
-		const credentials = await Credentials.get();
-		if (!credentials) {
+
+		// check if credentials are present
+		let credentials;
+		try {
+			credentials = await Credentials.get();
+		} catch (error) {
 			return Promise.reject('No credentials');
 		}
 
@@ -108,7 +139,7 @@ export class AWSLexProvider extends AbstractInteractionsProvider {
 			customUserAgent: getAmplifyUserAgent(),
 		});
 
-		let params;
+		let params: PostTextCommandInput | PostContentCommandInput;
 		if (typeof message === 'string') {
 			params = {
 				botAlias: this._config[botname].alias,
@@ -118,10 +149,10 @@ export class AWSLexProvider extends AbstractInteractionsProvider {
 			};
 
 			logger.debug('postText to lex', message);
-
 			try {
 				const postTextCommand = new PostTextCommand(params);
 				const data = await this.lexRuntimeServiceClient.send(postTextCommand);
+
 				this.reportBotStatus(data, botname);
 				return data;
 			} catch (err) {
@@ -133,15 +164,24 @@ export class AWSLexProvider extends AbstractInteractionsProvider {
 				options: { messageType },
 			} = message;
 			if (messageType === 'voice') {
+				if (typeof content !== 'object') {
+					return Promise.reject('invalid content type');
+				}
+				const inputStream =
+					content instanceof Uint8Array ? content : await convert(content);
+
 				params = {
 					botAlias: this._config[botname].alias,
 					botName: botname,
-					contentType: 'audio/x-l16; sample-rate=16000',
-					inputStream: content,
+					contentType: 'audio/x-l16; sample-rate=16000; channel-count=1',
 					userId: credentials.identityId,
 					accept: 'audio/mpeg',
+					inputStream,
 				};
 			} else {
+				if (typeof content !== 'string')
+					return Promise.reject('invalid content type');
+
 				params = {
 					botAlias: this._config[botname].alias,
 					botName: botname,
@@ -157,18 +197,25 @@ export class AWSLexProvider extends AbstractInteractionsProvider {
 				const data = await this.lexRuntimeServiceClient.send(
 					postContentCommand
 				);
-				const audioArray = await convert(data.audioStream);
-				this.reportBotStatus(data, botname);
-				return { ...data, ...{ audioStream: audioArray } };
+
+				const audioArray = data.audioStream
+					? await convert(data.audioStream)
+					: undefined;
+
+				const response = { ...data, ...{ audioStream: audioArray } };
+
+				this.reportBotStatus(response, botname);
+				return response;
 			} catch (err) {
 				return Promise.reject(err);
 			}
 		}
 	}
 
-	onComplete(botname: string, callback) {
+	onComplete(botname: string, callback: (err, confirmation) => void) {
+		// does bot exist
 		if (!this._config[botname]) {
-			throw new ErrorEvent('Bot ' + botname + ' does not exist');
+			throw new Error('Bot ' + botname + ' does not exist');
 		}
 		this._botsCompleteCallback[botname] = callback;
 	}

package/src/Providers/AWSLexProviderHelper/commonUtils.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2017-2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+import { base64ToArrayBuffer, gzipDecompressToString } from './utils';
+
+export const unGzipBase64AsJson = async (gzipBase64: string | undefined) => {
+	if (typeof gzipBase64 === 'undefined') return undefined;
+
+	try {
+		const decodedArrayBuffer = base64ToArrayBuffer(gzipBase64);
+
+		const objString: string = await gzipDecompressToString(decodedArrayBuffer);
+
+		return JSON.parse(objString);
+	} catch (error) {
+		return Promise.reject('unable to decode and decompress ' + error);
+	}
+};

package/src/Providers/AWSLexProviderHelper/utils.native.ts

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2017-2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+
+import { decode } from 'base-64';
+import { ungzip } from 'pako';
+
+export const convert = async (stream: object): Promise<Uint8Array> => {
+	if (!(stream instanceof Blob)) {
+		return Promise.reject('Invalid content type');
+	}
+
+	return new Promise(async (resolve, reject) => {
+		try {
+			const fileReaderInstance = new FileReader();
+			fileReaderInstance.readAsDataURL(stream);
+			fileReaderInstance.onload = async () => {
+				const blobURL = fileReaderInstance.result as string;
+
+				const base64Blob = blobURL.split(/,(.*)/s)[1];
+
+				const decodedArrayBuffer = base64ToArrayBuffer(base64Blob);
+				resolve(decodedArrayBuffer);
+			};
+		} catch (error) {
+			reject('unable to convert blob to arrayBuffer: ' + error);
+		}
+	});
+};
+
+export const base64ToArrayBuffer = (base64: string): Uint8Array => {
+	const binaryString: string = decode(base64);
+	return Uint8Array.from(binaryString, c => c.charCodeAt(0));
+};
+
+export const gzipDecompressToString = async (
+	data: Uint8Array
+): Promise<string> => {
+	return new Promise((resolve, reject) => {
+		try {
+			const result: string = ungzip(data, { to: 'string' });
+			resolve(result);
+		} catch (error) {
+			reject('unable to decompress' + error);
+		}
+	});
+};

package/src/Providers/AWSLexProviderHelper/utils.ts

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2017-2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+
+import { gunzip, strFromU8 } from 'fflate';
+
+export const convert = async (stream: object): Promise<Uint8Array> => {
+	if (stream instanceof Blob || stream instanceof ReadableStream) {
+		return new Response(stream)
+			.arrayBuffer()
+			.then(buffer => new Uint8Array(buffer));
+	} else {
+		return Promise.reject('Invalid content type');
+	}
+};
+
+export const base64ToArrayBuffer = (base64: string): Uint8Array => {
+	return Uint8Array.from(window.atob(base64), c => c.charCodeAt(0));
+};
+
+export const gzipDecompressToString = async (
+	data: Uint8Array
+): Promise<string> => {
+	return await new Promise((resolve, reject) => {
+		gunzip(data, (err, resp) => {
+			if (err) reject(err);
+			else resolve(strFromU8(resp));
+		});
+	});
+};