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

package/src/{Providers → providers}/AmazonAIIdentifyPredictionsProvider.ts

@@ -1,73 +1,103 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import {
-	Category,
-	Credentials,
+	Amplify,
 	ConsoleLogger as Logger,
+	fetchAuthSession,
+} from '@aws-amplify/core';
+import {
+	Category,
 	PredictionsAction,
 	getAmplifyUserAgentObject,
-} from '@aws-amplify/core';
-import { Storage } from '@aws-amplify/storage';
-import { AbstractIdentifyPredictionsProvider } from '../types/Providers';
+} from '@aws-amplify/core/internals/utils';
+import { getUrl } from '@aws-amplify/storage';
 import {
-	RekognitionClient,
-	SearchFacesByImageCommand,
-	DetectTextCommand,
-	DetectTextCommandInput,
+	DetectFacesCommand,
 	DetectLabelsCommand,
 	DetectLabelsCommandInput,
-	DetectFacesCommand,
 	DetectModerationLabelsCommand,
 	DetectModerationLabelsCommandInput,
+	DetectTextCommand,
+	DetectTextCommandInput,
 	RecognizeCelebritiesCommand,
+	RekognitionClient,
+	SearchFacesByImageCommand,
 } from '@aws-sdk/client-rekognition';
 import {
+	AnalyzeDocumentCommand,
+	AnalyzeDocumentCommandInput,
+	DetectDocumentTextCommand,
+	DetectDocumentTextCommandInput,
+	TextractClient,
+} from '@aws-sdk/client-textract';
+import { PredictionsValidationErrorCode } from '../errors/types/validation';
+import { assertValidationError } from '../errors/utils/assertValidationError';
+import {
+	BoundingBox,
+	FaceAttributes,
+	FeatureTypes,
+	IdentifyEntitiesInput,
+	IdentifyEntitiesOutput,
+	IdentifyEntity,
+	IdentifyFromCollection,
 	IdentifyLabelsInput,
 	IdentifyLabelsOutput,
 	IdentifySource,
-	IdentifyEntitiesInput,
-	IdentifyEntitiesOutput,
-	isStorageSource,
-	isFileSource,
-	isBytesSource,
 	IdentifyTextInput,
 	IdentifyTextOutput,
+	isFileSource,
+	isIdentifyBytesSource,
 	isIdentifyCelebrities,
 	isIdentifyFromCollection,
-	IdentifyFromCollection,
-	FeatureTypes,
+	isIdentifyLabelsInput,
+	isIdentifyTextInput,
+	isStorageSource,
+	isValidIdentifyInput,
 } from '../types';
 import {
-	Image,
+	BlockList,
 	Document,
+	Image,
 	TextDetectionList,
-	BlockList,
 } from '../types/AWSTypes';
-import {
-	TextractClient,
-	DetectDocumentTextCommand,
-	DetectDocumentTextCommandInput,
-	AnalyzeDocumentCommand,
-	AnalyzeDocumentCommandInput,
-} from '@aws-sdk/client-textract';
-import { makeCamelCase, makeCamelCaseArray, blobToArrayBuffer } from './Utils';
 import {
 	categorizeRekognitionBlocks,
 	categorizeTextractBlocks,
 } from './IdentifyTextUtils';
+import { blobToArrayBuffer, makeCamelCase, makeCamelCaseArray } from './Utils';
 
-export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredictionsProvider {
-	private rekognitionClient: RekognitionClient;
-	private textractClient: TextractClient;
+const logger = new Logger('AmazonAIIdentifyPredictionsProvider');
 
-	constructor() {
-		super();
-	}
+export class AmazonAIIdentifyPredictionsProvider {
+	private rekognitionClient?: RekognitionClient;
+	private textractClient?: TextractClient;
 
 	getProviderName() {
 		return 'AmazonAIIdentifyPredictionsProvider';
 	}
 
+	identify(
+		input: IdentifyTextInput | IdentifyLabelsInput | IdentifyEntitiesInput
+	): Promise<
+		IdentifyTextOutput | IdentifyLabelsOutput | IdentifyEntitiesOutput
+	> {
+		assertValidationError(
+			isValidIdentifyInput(input),
+			PredictionsValidationErrorCode.InvalidInput
+		);
+
+		if (isIdentifyTextInput(input)) {
+			logger.debug('identifyText');
+			return this.identifyText(input);
+		} else if (isIdentifyLabelsInput(input)) {
+			logger.debug('identifyLabels');
+			return this.identifyLabels(input);
+		} else {
+			logger.debug('identifyEntities');
+			return this.identifyEntities(input);
+		}
+	}
+
 	/**
 	 * Verify user input source and converts it into source object readable by Rekognition and Textract.
 	 * Note that Rekognition and Textract use the same source interface, so we need not worry about types.
@@ -79,14 +109,15 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 		return new Promise((res, rej) => {
 			if (isStorageSource(source)) {
 				const storageConfig = {
-					level: source.level,
-					identityId: source.identityId,
+					accessLevel: source.level,
+					targetIdentityId: source.identityId,
 				};
-				Storage.get(source.key, storageConfig)
-					.then((url: string) => {
+
+				getUrl({ key: source.key, options: storageConfig })
+					.then(value => {
 						const parser =
 							/https:\/\/([a-zA-Z0-9%\-_.]+)\.s3\.[A-Za-z0-9%\-._~]+\/([a-zA-Z0-9%\-._~/]+)\?/;
-						const parsedURL = url.match(parser);
+						const parsedURL = value.url.toString().match(parser) ?? '';
 						if (parsedURL.length < 3) rej('Invalid S3 key was given.');
 						res({
 							S3Object: {
@@ -102,7 +133,7 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 						res({ Bytes: new Uint8Array(buffer) });
 					})
 					.catch(err => rej(err));
-			} else if (isBytesSource(source)) {
+			} else if (isIdentifyBytesSource(source)) {
 				const bytes = source.bytes;
 				if (bytes instanceof Blob) {
 					blobToArrayBuffer(bytes)
@@ -131,14 +162,17 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 	protected async identifyText(
 		input: IdentifyTextInput
 	): Promise<IdentifyTextOutput> {
-		const credentials = await Credentials.get();
-		if (!credentials) return Promise.reject('No credentials');
-		const {
-			identifyText: {
-				region = '',
-				defaults: { format: configFormat = 'PLAIN' } = {},
-			} = {},
-		} = this._config;
+		const { credentials } = await fetchAuthSession();
+		assertValidationError(
+			!!credentials,
+			PredictionsValidationErrorCode.NoCredentials
+		);
+
+		const { identifyText = {} } =
+			Amplify.getConfig().Predictions?.identify ?? {};
+		const { region = '', defaults = {} } = identifyText;
+		const { format: configFormat = 'PLAIN' } = defaults;
+
 		this.rekognitionClient = new RekognitionClient({
 			region,
 			credentials,
@@ -151,14 +185,10 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 		});
 		let inputDocument: Document;
 
-		try {
-			inputDocument = await this.configureSource(input.text.source);
-		} catch (err) {
-			return Promise.reject(err);
-		}
+		inputDocument = await this.configureSource(input.text?.source);
 
 		// get default value if format isn't specified in the input.
-		const format = input.text.format || configFormat;
+		const format = input.text?.format ?? configFormat;
 		const featureTypes: FeatureTypes = []; // structures we want to analyze (e.g. [TABLES, FORMS]).
 		if (format === 'FORM' || format === 'ALL') featureTypes.push('FORMS');
 		if (format === 'TABLE' || format === 'ALL') featureTypes.push('TABLES');
@@ -176,51 +206,43 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 				Image: inputDocument,
 			};
 
-			try {
-				const detectTextCommand = new DetectTextCommand(rekognitionParam);
-				const rekognitionData = await this.rekognitionClient.send(
-					detectTextCommand
-				);
-
-				const rekognitionResponse = categorizeRekognitionBlocks(
-					rekognitionData.TextDetections as TextDetectionList
-				);
-				if (rekognitionResponse.text.words.length < 50) {
-					// did not hit the word limit, return the data
-					return rekognitionResponse;
-				}
+			const detectTextCommand = new DetectTextCommand(rekognitionParam);
+			const rekognitionData = await this.rekognitionClient.send(
+				detectTextCommand
+			);
 
-				const detectDocumentTextCommand = new DetectDocumentTextCommand(
-					textractParam
-				);
+			const rekognitionResponse = categorizeRekognitionBlocks(
+				rekognitionData.TextDetections as TextDetectionList
+			);
+			if (rekognitionResponse.text.words.length < 50) {
+				// did not hit the word limit, return the data
+				return rekognitionResponse;
+			}
 
-				const { Blocks } = await this.textractClient.send(
-					detectDocumentTextCommand
-				);
+			const detectDocumentTextCommand = new DetectDocumentTextCommand(
+				textractParam
+			);
 
-				if (rekognitionData.TextDetections.length > Blocks.length) {
-					return rekognitionResponse;
-				}
+			const { Blocks } = await this.textractClient.send(
+				detectDocumentTextCommand
+			);
 
-				return categorizeTextractBlocks(Blocks as BlockList);
-			} catch (err) {
-				Promise.reject(err);
+			if (
+				(rekognitionData.TextDetections?.length ?? 0) > (Blocks?.length ?? 0)
+			) {
+				return rekognitionResponse;
 			}
+
+			return categorizeTextractBlocks(Blocks as BlockList);
 		} else {
 			const param: AnalyzeDocumentCommandInput = {
 				Document: inputDocument,
 				FeatureTypes: featureTypes,
 			};
 
-			try {
-				const analyzeDocumentCommand = new AnalyzeDocumentCommand(param);
-				const { Blocks } = await this.textractClient.send(
-					analyzeDocumentCommand
-				);
-				return categorizeTextractBlocks(Blocks as BlockList);
-			} catch (err) {
-				return Promise.reject(err);
-			}
+			const analyzeDocumentCommand = new AnalyzeDocumentCommand(param);
+			const { Blocks } = await this.textractClient.send(analyzeDocumentCommand);
+			return categorizeTextractBlocks(Blocks as BlockList);
 		}
 	}
 
@@ -232,53 +254,44 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 	protected async identifyLabels(
 		input: IdentifyLabelsInput
 	): Promise<IdentifyLabelsOutput> {
-		try {
-			const credentials = await Credentials.get();
-			if (!credentials) return Promise.reject('No credentials');
-			const {
-				identifyLabels: {
-					region = '',
-					defaults: { type = 'LABELS' } = {},
-				} = {},
-			} = this._config;
-			this.rekognitionClient = new RekognitionClient({
-				region,
-				credentials,
-				customUserAgent: _getPredictionsIdentifyAmplifyUserAgent(),
-			});
-			let inputImage: Image;
-			await this.configureSource(input.labels.source)
-				.then(data => {
-					inputImage = data;
-				})
-				.catch(err => {
-					return Promise.reject(err);
-				});
-			const param = { Image: inputImage };
-			const servicePromises = [];
-
-			// get default argument
-			const entityType = input.labels.type || type;
-			if (entityType === 'LABELS' || entityType === 'ALL') {
-				servicePromises.push(this.detectLabels(param));
-			}
-			if (entityType === 'UNSAFE' || entityType === 'ALL') {
-				servicePromises.push(this.detectModerationLabels(param));
-			}
+		const { credentials } = await fetchAuthSession();
+		assertValidationError(
+			!!credentials,
+			PredictionsValidationErrorCode.NoCredentials
+		);
+
+		const { identifyLabels = {} } =
+			Amplify.getConfig().Predictions?.identify ?? {};
+		const { region = '', defaults = {} } = identifyLabels;
+		const { type = 'LABELS' } = defaults;
 
-			return Promise.all(servicePromises)
-				.then(data => {
-					let identifyResult: IdentifyLabelsOutput = {};
-					// concatenate resolved promises to a single object
-					data.forEach(val => {
-						identifyResult = { ...identifyResult, ...val };
-					});
-					return identifyResult;
-				})
-				.catch(err => Promise.reject(err));
-		} catch (err) {
-			return Promise.reject(err);
+		this.rekognitionClient = new RekognitionClient({
+			region,
+			credentials,
+			customUserAgent: _getPredictionsIdentifyAmplifyUserAgent(),
+		});
+
+		const inputImage = await this.configureSource(input.labels?.source);
+		const param = { Image: inputImage };
+		const servicePromises: Promise<IdentifyLabelsOutput>[] = [];
+
+		// get default argument
+		const entityType = input.labels?.type ?? type;
+		if (entityType === 'LABELS' || entityType === 'ALL') {
+			servicePromises.push(this.detectLabels(param));
 		}
+		if (entityType === 'UNSAFE' || entityType === 'ALL') {
+			servicePromises.push(this.detectModerationLabels(param));
+		}
+
+		return Promise.all(servicePromises).then(data => {
+			let identifyResult: IdentifyLabelsOutput = {};
+			// concatenate resolved promises to a single object
+			data.forEach(val => {
+				identifyResult = { ...identifyResult, ...val };
+			});
+			return identifyResult;
+		});
 	}
 
 	/**
@@ -289,27 +302,25 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 	private async detectLabels(
 		param: DetectLabelsCommandInput
 	): Promise<IdentifyLabelsOutput> {
-		try {
-			const detectLabelsCommand = new DetectLabelsCommand(param);
-			const data = await this.rekognitionClient.send(detectLabelsCommand);
-			if (!data.Labels) return { labels: null }; // no image was detected
-			const detectLabelData = data.Labels.map(val => {
-				const boxes = val.Instances
-					? val.Instances.map(val => makeCamelCase(val.BoundingBox))
-					: undefined;
-				return {
-					name: val.Name,
-					boundingBoxes: boxes,
-					metadata: {
-						confidence: val.Confidence,
-						parents: makeCamelCaseArray(val.Parents),
-					},
-				};
-			});
-			return { labels: detectLabelData };
-		} catch (err) {
-			return Promise.reject(err);
-		}
+		const detectLabelsCommand = new DetectLabelsCommand(param);
+		const data = await this.rekognitionClient!.send(detectLabelsCommand);
+		if (!data.Labels) return {}; // no image was detected
+		const detectLabelData = data.Labels.map(label => {
+			const boxes =
+				label.Instances?.map(
+					instance =>
+						makeCamelCase(instance.BoundingBox) as BoundingBox | undefined
+				) || [];
+			return {
+				name: label.Name,
+				boundingBoxes: boxes,
+				metadata: {
+					confidence: label.Confidence,
+					parents: makeCamelCaseArray(label.Parents),
+				},
+			};
+		});
+		return { labels: detectLabelData };
 	}
 
 	/**
@@ -320,20 +331,16 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 	private async detectModerationLabels(
 		param: DetectModerationLabelsCommandInput
 	): Promise<IdentifyLabelsOutput> {
-		try {
-			const detectModerationLabelsCommand = new DetectModerationLabelsCommand(
-				param
-			);
-			const data = await this.rekognitionClient.send(
-				detectModerationLabelsCommand
-			);
-			if (data.ModerationLabels.length !== 0) {
-				return { unsafe: 'YES' };
-			} else {
-				return { unsafe: 'NO' };
-			}
-		} catch (err) {
-			return Promise.reject(err);
+		const detectModerationLabelsCommand = new DetectModerationLabelsCommand(
+			param
+		);
+		const data = await this.rekognitionClient!.send(
+			detectModerationLabelsCommand
+		);
+		if (data.ModerationLabels?.length !== 0) {
+			return { unsafe: 'YES' };
+		} else {
+			return { unsafe: 'NO' };
 		}
 	}
 
@@ -346,18 +353,23 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 	protected async identifyEntities(
 		input: IdentifyEntitiesInput
 	): Promise<IdentifyEntitiesOutput> {
-		const credentials = await Credentials.get();
-		if (!credentials) return Promise.reject('No credentials');
+		const { credentials } = await fetchAuthSession();
+		assertValidationError(
+			!!credentials,
+			PredictionsValidationErrorCode.NoCredentials
+		);
+
+		const { identifyEntities = {} } =
+			Amplify.getConfig().Predictions?.identify ?? {};
+		const {
+			region = '',
+			celebrityDetectionEnabled = false,
+			defaults = {},
+		} = identifyEntities;
 		const {
-			identifyEntities: {
-				region = '',
-				celebrityDetectionEnabled = false,
-				defaults: {
-					collectionId: collectionIdConfig = '',
-					maxEntities: maxFacesConfig = 50,
-				} = {},
-			} = {},
-		} = this._config;
+			collectionId: collectionIdConfig = '',
+			maxEntities: maxFacesConfig = 50,
+		} = defaults;
 		// default arguments
 
 		this.rekognitionClient = new RekognitionClient({
@@ -365,45 +377,36 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 			credentials,
 			customUserAgent: _getPredictionsIdentifyAmplifyUserAgent(),
 		});
-		let inputImage: Image;
-		await this.configureSource(input.entities.source)
-			.then(data => (inputImage = data))
-			.catch(err => {
-				return Promise.reject(err);
-			});
-
+		const inputImage = await this.configureSource(input.entities?.source);
 		const param = { Attributes: ['ALL'], Image: inputImage };
 
 		if (
 			isIdentifyCelebrities(input.entities) &&
 			input.entities.celebrityDetection
 		) {
-			if (!celebrityDetectionEnabled) {
-				return Promise.reject(
-					'Error: You have to enable celebrity detection first'
-				);
-			}
-			try {
-				const recognizeCelebritiesCommand = new RecognizeCelebritiesCommand(
-					param
-				);
-				const data = await this.rekognitionClient.send(
-					recognizeCelebritiesCommand
-				);
-				const faces = data.CelebrityFaces.map(celebrity => {
-					return {
-						boundingBox: makeCamelCase(celebrity.Face.BoundingBox),
-						landmarks: makeCamelCaseArray(celebrity.Face.Landmarks),
-						metadata: {
-							...makeCamelCase(celebrity, ['Id', 'Name', 'Urls']),
-							pose: makeCamelCase(celebrity.Face.Pose),
-						},
-					};
-				});
-				return { entities: faces };
-			} catch (err) {
-				return Promise.reject(err);
-			}
+			assertValidationError(
+				celebrityDetectionEnabled,
+				PredictionsValidationErrorCode.CelebrityDetectionNotEnabled
+			);
+			const recognizeCelebritiesCommand = new RecognizeCelebritiesCommand(
+				param
+			);
+			const data = await this.rekognitionClient.send(
+				recognizeCelebritiesCommand
+			);
+			const faces =
+				data.CelebrityFaces?.map(
+					celebrity =>
+						({
+							boundingBox: makeCamelCase(celebrity.Face?.BoundingBox),
+							landmarks: makeCamelCaseArray(celebrity.Face?.Landmarks),
+							metadata: {
+								...makeCamelCase(celebrity, ['Id', 'Name', 'Urls']),
+								pose: makeCamelCase(celebrity.Face?.Pose),
+							},
+						} as IdentifyEntity)
+				) ?? [];
+			return { entities: faces };
 		} else if (
 			isIdentifyFromCollection(input.entities) &&
 			input.entities.collection
@@ -418,33 +421,29 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 				CollectionId: collectionId,
 				MaxFaces: maxFaces,
 			};
-			try {
-				const searchFacesByImageCommand = new SearchFacesByImageCommand(
-					updatedParam
-				);
-				const data = await this.rekognitionClient.send(
-					searchFacesByImageCommand
-				);
-				const faces = data.FaceMatches.map(val => {
+			const searchFacesByImageCommand = new SearchFacesByImageCommand(
+				updatedParam
+			);
+			const data = await this.rekognitionClient.send(searchFacesByImageCommand);
+			const faces =
+				data.FaceMatches?.map(match => {
+					const externalImageId = match.Face?.ExternalImageId
+						? this.decodeExternalImageId(match.Face.ExternalImageId)
+						: undefined;
 					return {
-						boundingBox: makeCamelCase(val.Face.BoundingBox),
+						boundingBox: makeCamelCase(match.Face?.BoundingBox),
 						metadata: {
-							externalImageId: this.decodeExternalImageId(
-								val.Face.ExternalImageId
-							),
-							similarity: val.Similarity,
+							externalImageId,
+							similarity: match.Similarity,
 						},
-					};
-				});
-				return { entities: faces };
-			} catch (err) {
-				return Promise.reject(err);
-			}
+					} as IdentifyEntity;
+				}) ?? [];
+			return { entities: faces };
 		} else {
-			try {
-				const detectFacesCommand = new DetectFacesCommand(param);
-				const data = await this.rekognitionClient.send(detectFacesCommand);
-				const faces = data.FaceDetails.map(detail => {
+			const detectFacesCommand = new DetectFacesCommand(param);
+			const data = await this.rekognitionClient.send(detectFacesCommand);
+			const faces =
+				data.FaceDetails?.map(detail => {
 					// face attributes keys we want to extract from Rekognition's response
 					const attributeKeys = [
 						'Smile',
@@ -456,12 +455,14 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 						'EyesOpen',
 						'MouthOpen',
 					];
-					const faceAttributes = makeCamelCase(detail, attributeKeys);
-					if (detail.Emotions) {
-						faceAttributes['emotions'] = detail.Emotions.map(
-							emotion => emotion.Type
-						);
-					}
+					const faceAttributes = makeCamelCase(
+						detail,
+						attributeKeys
+					) as FaceAttributes;
+
+					faceAttributes.emotions = detail.Emotions?.map(
+						emotion => emotion.Type
+					);
 					return {
 						boundingBox: makeCamelCase(detail.BoundingBox),
 						landmarks: makeCamelCaseArray(detail.Landmarks),
@@ -471,12 +472,9 @@ export class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredict
 							confidence: detail.Confidence,
 							pose: makeCamelCase(detail.Pose),
 						},
-					};
-				});
-				return { entities: faces };
-			} catch (err) {
-				return Promise.reject(err);
-			}
+					} as IdentifyEntity;
+				}) ?? [];
+			return { entities: faces };
 		}
 	}