@aws-amplify/storage 4.4.12 → 4.4.13-custom-pk.86

package/src/providers/AWSS3ProviderManagedUpload.ts

@@ -58,8 +58,8 @@ export class AWSS3ProviderManagedUpload {
 	private params: PutObjectRequest = null;
 	private opts = null;
 	private completedParts: CompletedPart[] = [];
-	private cancel = false;
 	private s3client: S3Client;
+	private uploadId = null;
 
 	// Progress reporting
 	private bytesUploaded = 0;
@@ -74,79 +74,87 @@ export class AWSS3ProviderManagedUpload {
 	}
 
 	public async upload() {
-		this.body = await this.validateAndSanitizeBody(this.params.Body);
-		this.totalBytesToUpload = this.byteLength(this.body);
-		if (this.totalBytesToUpload <= this.minPartSize) {
-			// Multipart upload is not required. Upload the sanitized body as is
-			this.params.Body = this.body;
-			const putObjectCommand = new PutObjectCommand(this.params);
-			return this.s3client.send(putObjectCommand);
-		} else {
-			// Step 1: Initiate the multi part upload
-			const uploadId = await this.createMultiPartUpload();
-
-			// Step 2: Upload chunks in parallel as requested
-			const numberOfPartsToUpload = Math.ceil(
-				this.totalBytesToUpload / this.minPartSize
-			);
-
-			const parts: Part[] = this.createParts();
-			for (
-				let start = 0;
-				start < numberOfPartsToUpload;
-				start += this.queueSize
-			) {
-				/** This first block will try to cancel the upload if the cancel
-				 *	request came before any parts uploads have started.
-				 **/
-				await this.checkIfUploadCancelled(uploadId);
-
-				// Upload as many as `queueSize` parts simultaneously
-				await this.uploadParts(
-					uploadId,
-					parts.slice(start, start + this.queueSize)
+		try {
+			this.body = await this.validateAndSanitizeBody(this.params.Body);
+			this.totalBytesToUpload = this.byteLength(this.body);
+			if (this.totalBytesToUpload <= this.minPartSize) {
+				// Multipart upload is not required. Upload the sanitized body as is
+				this.params.Body = this.body;
+				const putObjectCommand = new PutObjectCommand(this.params);
+				return this.s3client.send(putObjectCommand);
+			} else {
+				// Step 1: Initiate the multi part upload
+				this.uploadId = await this.createMultiPartUpload();
+
+				// Step 2: Upload chunks in parallel as requested
+				const numberOfPartsToUpload = Math.ceil(
+					this.totalBytesToUpload / this.minPartSize
 				);
 
-				/** Call cleanup a second time in case there were part upload requests
-				 *  in flight. This is to ensure that all parts are cleaned up.
-				 */
-				await this.checkIfUploadCancelled(uploadId);
-			}
+				const parts: Part[] = this.createParts();
+				for (
+					let start = 0;
+					start < numberOfPartsToUpload;
+					start += this.queueSize
+				) {
+
+					// Upload as many as `queueSize` parts simultaneously
+					await this.uploadParts(
+						this.uploadId,
+						parts.slice(start, start + this.queueSize)
+					);
+				}
 
-			parts.map(part => {
-				this.removeEventListener(part);
-			});
+				parts.map(part => {
+					this.removeEventListener(part);
+				});
 
-			// Step 3: Finalize the upload such that S3 can recreate the file
-			return await this.finishMultiPartUpload(uploadId);
+				// Step 3: Finalize the upload such that S3 can recreate the file
+				return await this.finishMultiPartUpload(this.uploadId);
+			}
+		} catch (error) {
+			// if any error is thrown, call cleanup
+			await this.cleanup(this.uploadId);
+			logger.error('Error. Cancelling the multipart upload.');
+			throw error;
 		}
 	}
 
 	private createParts(): Part[] {
-		const parts: Part[] = [];
-		for (let bodyStart = 0; bodyStart < this.totalBytesToUpload; ) {
-			const bodyEnd = Math.min(
-				bodyStart + this.minPartSize,
-				this.totalBytesToUpload
-			);
-			parts.push({
-				bodyPart: this.body.slice(bodyStart, bodyEnd),
-				partNumber: parts.length + 1,
-				emitter: new events.EventEmitter(),
-				_lastUploadedBytes: 0,
-			});
-			bodyStart += this.minPartSize;
+		try {
+			const parts: Part[] = [];
+			for (let bodyStart = 0; bodyStart < this.totalBytesToUpload; ) {
+				const bodyEnd = Math.min(
+					bodyStart + this.minPartSize,
+					this.totalBytesToUpload
+				);
+				parts.push({
+					bodyPart: this.body.slice(bodyStart, bodyEnd),
+					partNumber: parts.length + 1,
+					emitter: new events.EventEmitter(),
+					_lastUploadedBytes: 0,
+				});
+				bodyStart += this.minPartSize;
+			}
+			return parts;
+		} catch (error) {
+			logger.error(error);
+			throw error;
 		}
-		return parts;
 	}
 
 	private async createMultiPartUpload() {
-		const createMultiPartUploadCommand = new CreateMultipartUploadCommand(
-			this.params
-		);
-		const response = await this.s3client.send(createMultiPartUploadCommand);
-		logger.debug(response.UploadId);
-		return response.UploadId;
+		try {
+			const createMultiPartUploadCommand = new CreateMultipartUploadCommand(
+				this.params
+			);
+			const response = await this.s3client.send(createMultiPartUploadCommand);
+			logger.debug(response.UploadId);
+			return response.UploadId;
+		} catch (error) {
+			logger.error(error);
+			throw error;
+		}
 	}
 
 	/**
@@ -191,11 +199,9 @@ export class AWSS3ProviderManagedUpload {
 			}
 		} catch (error) {
 			logger.error(
-				'error happened while uploading a part. Cancelling the multipart upload',
-				error
+				'Error happened while uploading a part. Cancelling the multipart upload'
 			);
-			this.cancelUpload();
-			return;
+			throw error;
 		}
 	}
 
@@ -211,31 +217,11 @@ export class AWSS3ProviderManagedUpload {
 			const data = await this.s3client.send(completeUploadCommand);
 			return data.Key;
 		} catch (error) {
-			logger.error(
-				'error happened while finishing the upload. Cancelling the multipart upload',
-				error
-			);
-			this.cancelUpload();
-			return;
+			logger.error('Error happened while finishing the upload.');
+			throw error;
 		}
 	}
 
-	private async checkIfUploadCancelled(uploadId: string) {
-		if (this.cancel) {
-			let errorMessage = 'Upload was cancelled.';
-			try {
-				await this.cleanup(uploadId);
-			} catch (error) {
-				errorMessage += ` ${error.message}`;
-			}
-			throw new Error(errorMessage);
-		}
-	}
-
-	public cancelUpload() {
-		this.cancel = true;
-	}
-
 	private async cleanup(uploadId: string) {
 		// Reset this's state
 		this.body = null;
@@ -255,7 +241,7 @@ export class AWSS3ProviderManagedUpload {
 		const data = await this.s3client.send(new ListPartsCommand(input));
 
 		if (data && data.Parts && data.Parts.length > 0) {
-			throw new Error('Multi Part upload clean up failed');
+			throw new Error('Multipart upload clean up failed.');
 		}
 	}
 

package/src/providers/axios-http-handler.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * 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
@@ -18,23 +18,48 @@ import axios, {
 	AxiosRequestConfig,
 	Method,
 	CancelTokenSource,
-	AxiosTransformer,
+	AxiosRequestHeaders,
+	AxiosRequestTransformer,
 } from 'axios';
 import { ConsoleLogger as Logger, Platform } from '@aws-amplify/core';
 import { FetchHttpHandlerOptions } from '@aws-sdk/fetch-http-handler';
 import * as events from 'events';
 import { AWSS3ProviderUploadErrorStrings } from '../common/StorageErrorStrings';
 
+/**
+Extending the axios interface here to make headers required, (previously, 
+they were not required on the type we were using, but our implementation
+does not currently account for missing headers. This worked previously, 
+because the previous `headers` type was `any`.
+*/
+interface AxiosTransformer extends Partial<AxiosRequestTransformer> {
+	(data: any, headers: AxiosRequestHeaders): any;
+}
+
 const logger = new Logger('axios-http-handler');
 export const SEND_UPLOAD_PROGRESS_EVENT = 'sendUploadProgress';
 export const SEND_DOWNLOAD_PROGRESS_EVENT = 'sendDownloadProgress';
 
+export type ErrorWithResponse = {
+	response: { status: number } & { [key: string]: any };
+};
+
 function isBlob(body: any): body is Blob {
 	return typeof Blob !== 'undefined' && body instanceof Blob;
 }
 
+function hasErrorResponse(error: any): error is ErrorWithResponse {
+	return (
+		typeof error !== 'undefined' &&
+		Object.prototype.hasOwnProperty.call(error, 'response') &&
+		typeof error.response !== 'undefined' &&
+		Object.prototype.hasOwnProperty.call(error.response, 'status') &&
+		typeof error.response.status === 'number'
+	);
+}
+
 const normalizeHeaders = (
-	headers: Record<string, string>,
+	headers: AxiosRequestHeaders,
 	normalizedName: string
 ) => {
 	for (const [k, v] of Object.entries(headers)) {
@@ -49,7 +74,7 @@ const normalizeHeaders = (
 };
 
 export const reactNativeRequestTransformer: AxiosTransformer[] = [
-	function(data, headers) {
+	(data: any, headers: AxiosRequestHeaders): any => {
 		if (isBlob(data)) {
 			normalizeHeaders(headers, 'Content-Type');
 			normalizeHeaders(headers, 'Accept');
@@ -137,10 +162,12 @@ export class AxiosHttpHandler implements HttpHandler {
 			}
 		}
 		if (emitter) {
+			// TODO: Unify linting rules across JS repo
 			axiosRequest.onUploadProgress = function(event) {
 				emitter.emit(SEND_UPLOAD_PROGRESS_EVENT, event);
 				logger.debug(event);
 			};
+			// TODO: Unify linting rules across JS repo
 			axiosRequest.onDownloadProgress = function(event) {
 				emitter.emit(SEND_DOWNLOAD_PROGRESS_EVENT, event);
 				logger.debug(event);
@@ -186,15 +213,19 @@ export class AxiosHttpHandler implements HttpHandler {
 						logger.error(error.message);
 					}
 					// for axios' cancel error, we should re-throw it back so it's not considered an s3client error
-					// if we return empty, or an abitrary error HttpResponse, it will be hard to debug down the line
-					if (axios.isCancel(error)) {
+					// if we return empty, or an abitrary error HttpResponse, it will be hard to debug down the line.
+					//
+					// for errors that does not have a 'response' object, it's very likely that it is an unexpected error for
+					// example a disconnect. Without it we cannot meaningfully reconstruct a HttpResponse, and the AWS SDK might
+					// consider the request successful by mistake. In this case we should also re-throw the error.
+					if (axios.isCancel(error) || !hasErrorResponse(error)) {
 						throw error;
 					}
 					// otherwise, we should re-construct an HttpResponse from the error, so that it can be passed down to other
 					// aws sdk middleware (e.g retry, clock skew correction, error message serializing)
 					return {
 						response: new HttpResponse({
-							statusCode: error.response?.status,
+							statusCode: error.response.status,
 							body: error.response?.data,
 							headers: error.response?.headers,
 						}),