@aws-amplify/predictions 5.5.6-api-v6-models.b3abc9b.0 → 6.0.0

package/src/Predictions.ts

@@ -1,251 +1,64 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+import { ConsoleLogger as Logger } from '@aws-amplify/core';
+import {
+	AmazonAIConvertPredictionsProvider,
+	AmazonAIIdentifyPredictionsProvider,
+	AmazonAIInterpretPredictionsProvider,
+} from './providers';
 import {
-	PredictionsOptions,
-	TranslateTextInput,
-	TranslateTextOutput,
-	TextToSpeechInput,
-	ProviderOptions,
-	TextToSpeechOutput,
-	SpeechToTextInput,
-	SpeechToTextOutput,
-	IdentifyTextInput,
-	IdentifyTextOutput,
-	IdentifyLabelsOutput,
-	IdentifyLabelsInput,
 	IdentifyEntitiesInput,
 	IdentifyEntitiesOutput,
-	InterpretTextOutput,
+	IdentifyLabelsInput,
+	IdentifyLabelsOutput,
+	IdentifyTextInput,
+	IdentifyTextOutput,
 	InterpretTextInput,
+	InterpretTextOutput,
+	SpeechToTextInput,
+	SpeechToTextOutput,
+	TextToSpeechInput,
+	TextToSpeechOutput,
+	TranslateTextInput,
+	TranslateTextOutput,
 } from './types';
-import {
-	AbstractConvertPredictionsProvider,
-	AbstractIdentifyPredictionsProvider,
-	AbstractInterpretPredictionsProvider,
-	AbstractPredictionsProvider,
-} from './types/Providers';
-import { Amplify, ConsoleLogger as Logger } from '@aws-amplify/core';
 
 const logger = new Logger('Predictions');
 
 export class PredictionsClass {
-	private _options: PredictionsOptions;
-
-	private _convertPluggables: AbstractConvertPredictionsProvider[];
-	private _identifyPluggables: AbstractIdentifyPredictionsProvider[];
-	private _interpretPluggables: AbstractInterpretPredictionsProvider[];
-
-	/**
-	 * Initialize Predictions with AWS configurations
-	 * @param {PredictionsOptions} options - Configuration object for Predictions
-	 */
-	constructor(options: PredictionsOptions) {
-		this._options = options;
-		this._convertPluggables = [];
-		this._identifyPluggables = [];
-		this._interpretPluggables = [];
-	}
+	private convertProvider = new AmazonAIConvertPredictionsProvider();
+	private identifyProvider = new AmazonAIIdentifyPredictionsProvider();
+	private interpretProvider = new AmazonAIInterpretPredictionsProvider();
 
 	public getModuleName() {
 		return 'Predictions';
 	}
 
-	/**
-	 * add plugin/pluggable into Predictions category
-	 * @param {Object} pluggable - an instance of the plugin/pluggable
-	 **/
-	public addPluggable(pluggable: AbstractPredictionsProvider) {
-		if (this.getPluggable(pluggable.getProviderName())) {
-			throw new Error(
-				`Pluggable with name ${pluggable.getProviderName()} has already been added.`
-			);
-		}
-		let pluggableAdded: boolean = false;
-		if (this.implementsConvertPluggable(pluggable)) {
-			this._convertPluggables.push(pluggable);
-			pluggableAdded = true;
-		}
-		if (this.implementsIdentifyPluggable(pluggable)) {
-			this._identifyPluggables.push(pluggable);
-			pluggableAdded = true;
-		}
-		if (this.implementsInterpretPluggable(pluggable)) {
-			this._interpretPluggables.push(pluggable);
-			pluggableAdded = true;
-		}
-		if (pluggableAdded) {
-			this.configurePluggable(pluggable);
-		}
-	}
-
-	/**
-	 * Get the plugin object
-	 * @param providerName - the name of the plugin
-	 */
-	public getPluggable(providerName: string): AbstractPredictionsProvider {
-		const pluggable = this.getAllProviders().find(
-			pluggable => pluggable.getProviderName() === providerName
-		);
-		if (pluggable === undefined) {
-			logger.debug('No plugin found with providerName=>', providerName);
-			return null;
-		} else return pluggable;
-	}
-
-	/**
-	 * Remove the plugin object
-	 * @param providerName - the name of the plugin
-	 */
-	public removePluggable(providerName: string) {
-		this._convertPluggables = this._convertPluggables.filter(
-			pluggable => pluggable.getProviderName() !== providerName
-		);
-		this._identifyPluggables = this._identifyPluggables.filter(
-			pluggable => pluggable.getProviderName() !== providerName
-		);
-		this._interpretPluggables = this._interpretPluggables.filter(
-			pluggable => pluggable.getProviderName() !== providerName
-		);
-		return;
-	}
-
-	/**
-	 * To make both top level providers and category level providers work with same interface and configuration
-	 * this method duplicates Predictions config into parent level config (for top level provider) and
-	 * category level config (such as convert, identify etc) and pass both to each provider.
-	 */
-	configure(options: PredictionsOptions) {
-		let predictionsConfig = options ? options.predictions || options : {};
-		predictionsConfig = { ...predictionsConfig, ...options };
-		this._options = Object.assign({}, this._options, predictionsConfig);
-		logger.debug('configure Predictions', this._options);
-		this.getAllProviders().forEach(pluggable =>
-			this.configurePluggable(pluggable)
-		);
+	public interpret(input: InterpretTextInput): Promise<InterpretTextOutput> {
+		return this.interpretProvider.interpret(input);
 	}
 
-	public interpret(
-		input: InterpretTextInput,
-		options?: ProviderOptions
-	): Promise<InterpretTextOutput>;
-	public interpret(
-		input: InterpretTextInput,
-		options?: ProviderOptions
-	): Promise<InterpretTextOutput> {
-		const pluggableToExecute = this.getPluggableToExecute(
-			this._interpretPluggables,
-			options
-		);
-		return pluggableToExecute.interpret(input);
-	}
-
-	public convert(
-		input: TranslateTextInput,
-		options?: ProviderOptions
-	): Promise<TranslateTextOutput>;
+	public convert(input: TranslateTextInput): Promise<TranslateTextOutput>;
+	public convert(input: TextToSpeechInput): Promise<TextToSpeechOutput>;
+	public convert(input: SpeechToTextInput): Promise<SpeechToTextOutput>;
 	public convert(
-		input: TextToSpeechInput,
-		options?: ProviderOptions
-	): Promise<TextToSpeechOutput>;
-	public convert(
-		input: SpeechToTextInput,
-		options?: ProviderOptions
-	): Promise<SpeechToTextOutput>;
-	public convert(
-		input: TranslateTextInput | TextToSpeechInput | SpeechToTextInput,
-		options?: ProviderOptions
+		input: TranslateTextInput | TextToSpeechInput | SpeechToTextInput
 	): Promise<TranslateTextOutput | TextToSpeechOutput | SpeechToTextOutput> {
-		const pluggableToExecute = this.getPluggableToExecute(
-			this._convertPluggables,
-			options
-		);
-		return pluggableToExecute.convert(input);
+		return this.convertProvider.convert(input);
 	}
 
+	public identify(input: IdentifyTextInput): Promise<IdentifyTextOutput>;
+	public identify(input: IdentifyLabelsInput): Promise<IdentifyLabelsOutput>;
 	public identify(
-		input: IdentifyTextInput,
-		options?: ProviderOptions
-	): Promise<IdentifyTextOutput>;
-	public identify(
-		input: IdentifyLabelsInput,
-		options?: ProviderOptions
-	): Promise<IdentifyLabelsOutput>;
-	public identify(
-		input: IdentifyEntitiesInput,
-		options?: ProviderOptions
+		input: IdentifyEntitiesInput
 	): Promise<IdentifyEntitiesOutput>;
 	public identify(
-		input: IdentifyTextInput | IdentifyLabelsInput | IdentifyEntitiesInput,
-		options: ProviderOptions
+		input: IdentifyTextInput | IdentifyLabelsInput | IdentifyEntitiesInput
 	): Promise<
 		IdentifyTextOutput | IdentifyLabelsOutput | IdentifyEntitiesOutput
 	> {
-		const pluggableToExecute = this.getPluggableToExecute(
-			this._identifyPluggables,
-			options
-		);
-		return pluggableToExecute.identify(input);
-	}
-
-	// tslint:disable-next-line: max-line-length
-	private getPluggableToExecute<T extends AbstractPredictionsProvider>(
-		pluggables: T[],
-		providerOptions: ProviderOptions
-	): T {
-		// Give preference to provider name first since it is more specific to this call, even if
-		// there is only one provider configured to error out if the name provided is not the one matched.
-		if (providerOptions && providerOptions.providerName) {
-			return [...pluggables].find(
-				pluggable =>
-					pluggable.getProviderName() === providerOptions.providerName
-			);
-		} else {
-			if (pluggables.length === 1) {
-				return pluggables[0];
-			} else {
-				throw new Error(
-					'More than one or no providers are configured, ' +
-						'Either specify a provider name or configure exactly one provider'
-				);
-			}
-		}
-	}
-
-	private getAllProviders() {
-		return [
-			...this._convertPluggables,
-			...this._identifyPluggables,
-			...this._interpretPluggables,
-		];
-	}
-
-	private configurePluggable(pluggable: AbstractPredictionsProvider) {
-		const categoryConfig = Object.assign(
-			{},
-			this._options['predictions'], // Parent predictions config for the top level provider
-			this._options[pluggable.getCategory().toLowerCase()] // Actual category level config
-		);
-		pluggable.configure(categoryConfig);
-	}
-
-	private implementsConvertPluggable(
-		obj: any
-	): obj is AbstractConvertPredictionsProvider {
-		return obj && typeof obj.convert === 'function';
-	}
-
-	private implementsIdentifyPluggable(
-		obj: any
-	): obj is AbstractIdentifyPredictionsProvider {
-		return obj && typeof obj.identify === 'function';
-	}
-
-	private implementsInterpretPluggable(
-		obj: any
-	): obj is AbstractInterpretPredictionsProvider {
-		return obj && typeof obj.interpret === 'function';
+		return this.identifyProvider.identify(input);
 	}
 }
 
-export const Predictions = new PredictionsClass({});
-Amplify.register(Predictions);
+export const Predictions = new PredictionsClass();

package/src/errors/PredictionsError.ts

@@ -0,0 +1,16 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import {
+	AmplifyError,
+	AmplifyErrorParams,
+} from '@aws-amplify/core/internals/utils';
+
+export class PredictionsError extends AmplifyError {
+	constructor(params: AmplifyErrorParams) {
+		super(params);
+
+		// TODO: Delete the following 2 lines after we change the build target to >= es2015
+		this.constructor = PredictionsError;
+		Object.setPrototypeOf(this, PredictionsError.prototype);
+	}
+}

package/src/errors/types/validation.ts

@@ -0,0 +1,51 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AmplifyErrorMap } from '@aws-amplify/core/internals/utils';
+
+export enum PredictionsValidationErrorCode {
+	CelebrityDetectionNotEnabled = 'CelebrityDetectionNotEnabled',
+	InvalidInput = 'InvalidInput',
+	InvalidSource = 'InvalidSource',
+	NoCredentials = 'NoCredentials',
+	NoLanguage = 'NoLanguage',
+	NoRegion = 'NoRegion',
+	NoSource = 'NoSource',
+	NoSourceLanguage = 'NoSourceLanguage',
+	NoTargetLanguage = 'NoTargetLanguage',
+	NoVoiceId = 'NoVoiceId',
+}
+
+export const validationErrorMap: AmplifyErrorMap<PredictionsValidationErrorCode> =
+	{
+		[PredictionsValidationErrorCode.CelebrityDetectionNotEnabled]: {
+			message: 'Celebrity Detection must be enabled.',
+		},
+		[PredictionsValidationErrorCode.InvalidInput]: {
+			message: 'Input does not conform to expected type.',
+		},
+		[PredictionsValidationErrorCode.InvalidSource]: {
+			message: 'Source type not supported.',
+		},
+		[PredictionsValidationErrorCode.NoCredentials]: {
+			message: 'Credentials should not be empty.',
+		},
+		[PredictionsValidationErrorCode.NoLanguage]: {
+			message: 'Missing language.',
+		},
+		[PredictionsValidationErrorCode.NoRegion]: {
+			message: 'Missing region.',
+		},
+		[PredictionsValidationErrorCode.NoSource]: {
+			message: 'Missing source.',
+		},
+		[PredictionsValidationErrorCode.NoSourceLanguage]: {
+			message: 'Missing source language for translation.',
+		},
+		[PredictionsValidationErrorCode.NoTargetLanguage]: {
+			message: 'Missing target language for translation.',
+		},
+		[PredictionsValidationErrorCode.NoVoiceId]: {
+			message: 'Missing voice id.',
+		},
+	};

package/src/errors/utils/assertValidationError.ts

@@ -0,0 +1,18 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PredictionsError } from '../PredictionsError';
+import {
+	PredictionsValidationErrorCode,
+	validationErrorMap,
+} from '../types/validation';
+
+export function assertValidationError(
+	assertion: boolean,
+	name: PredictionsValidationErrorCode
+): asserts assertion {
+	if (!assertion) {
+		const { message, recoverySuggestion } = validationErrorMap[name];
+		throw new PredictionsError({ name, message, recoverySuggestion });
+	}
+}

package/src/index.ts

@@ -1,20 +1,20 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { Predictions } from './Predictions';
-
-import {
-	AmazonAIConvertPredictionsProvider,
-	AmazonAIIdentifyPredictionsProvider,
-	AmazonAIPredictionsProvider,
-	AmazonAIInterpretPredictionsProvider,
-} from './Providers';
-
-export * from './types';
+export { Predictions } from './Predictions';
 
 export {
-	Predictions,
-	AmazonAIIdentifyPredictionsProvider,
-	AmazonAIConvertPredictionsProvider,
-	AmazonAIPredictionsProvider,
-	AmazonAIInterpretPredictionsProvider,
-};
+	IdentifyEntitiesInput,
+	IdentifyEntitiesOutput,
+	IdentifyLabelsInput,
+	IdentifyLabelsOutput,
+	IdentifyTextInput,
+	IdentifyTextOutput,
+	InterpretTextInput,
+	InterpretTextOutput,
+	SpeechToTextInput,
+	SpeechToTextOutput,
+	TextToSpeechInput,
+	TextToSpeechOutput,
+	TranslateTextInput,
+	TranslateTextOutput,
+} from './types';