@aws-amplify/storage 5.6.4-api-v6.2 → 5.6.4-api-v6.13

package/src/providers/AWSS3ProviderManagedUpload.ts

@@ -3,33 +3,30 @@
 
 import { ConsoleLogger as Logger, StorageAction } from '@aws-amplify/core';
 import {
-	PutObjectCommandInput,
-	PutObjectCommand,
-	CreateMultipartUploadCommand,
-	UploadPartCommand,
-	CompleteMultipartUploadCommand,
-	CompleteMultipartUploadCommandInput,
-	ListPartsCommand,
-	AbortMultipartUploadCommand,
+	PutObjectInput,
+	putObject,
+	createMultipartUpload,
 	CompletedPart,
-	S3Client,
-} from '@aws-sdk/client-s3';
+	uploadPart,
+	CompleteMultipartUploadInput,
+	completeMultipartUpload,
+	abortMultipartUpload,
+	listParts,
+} from '../AwsClients/S3';
 import {
-	SEND_UPLOAD_PROGRESS_EVENT,
 	SEND_DOWNLOAD_PROGRESS_EVENT,
-	AxiosHttpHandlerOptions,
-} from './axios-http-handler';
-import * as events from 'events';
+	SEND_UPLOAD_PROGRESS_EVENT,
+} from '../AwsClients/S3/utils';
+import { EventEmitter } from 'events';
 import {
-	autoAdjustClockskewMiddleware,
-	autoAdjustClockskewMiddlewareOptions,
 	calculatePartSize,
-	createPrefixMiddleware,
-	createS3Client,
-	prefixMiddlewareOptions,
 	DEFAULT_PART_SIZE,
 	DEFAULT_QUEUE_SIZE,
 	MAX_OBJECT_SIZE,
+	S3ResolvedConfig,
+	loadS3Config,
+	getPrefix,
+	credentialsProvider,
 } from '../common/S3ClientUtils';
 
 const logger = new Logger('AWSS3ProviderManagedUpload');
@@ -37,7 +34,7 @@ const logger = new Logger('AWSS3ProviderManagedUpload');
 export declare interface Part {
 	bodyPart: any;
 	partNumber: number;
-	emitter: events.EventEmitter;
+	emitter: EventEmitter;
 	etag?: string;
 	_lastUploadedBytes: number;
 }
@@ -45,27 +42,27 @@ export declare interface Part {
 export class AWSS3ProviderManagedUpload {
 	// Data for current upload
 	private body;
-	private params: PutObjectCommandInput;
+	private params: PutObjectInput;
 	private opts = null;
 	private completedParts: CompletedPart[] = [];
-	private s3client: S3Client;
+	private s3Config: S3ResolvedConfig;
 	private uploadId: string | undefined;
 	private partSize = DEFAULT_PART_SIZE;
 
 	// Progress reporting
 	private bytesUploaded = 0;
 	private totalBytesToUpload = 0;
-	private emitter: events.EventEmitter | null = null;
+	private emitter: EventEmitter | null = null;
 
-	constructor(
-		params: PutObjectCommandInput,
-		opts,
-		emitter: events.EventEmitter
-	) {
+	constructor(params: PutObjectInput, opts, emitter: EventEmitter) {
 		this.params = params;
 		this.opts = opts;
 		this.emitter = emitter;
-		this.s3client = this._createNewS3Client(opts, emitter);
+		this.s3Config = loadS3Config({
+			...opts,
+			emitter,
+			storageAction: StorageAction.Put,
+		});
 	}
 
 	public async upload() {
@@ -75,8 +72,10 @@ export class AWSS3ProviderManagedUpload {
 			if (this.totalBytesToUpload <= DEFAULT_PART_SIZE) {
 				// 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);
+				return putObject(this.s3Config, {
+					...this.params,
+					Key: await this.getObjectKeyWithPrefix(this.params.Key),
+				});
 			} else {
 				// Step 1: Determine appropriate part size.
 				this.partSize = calculatePartSize(this.totalBytesToUpload);
@@ -127,7 +126,7 @@ export class AWSS3ProviderManagedUpload {
 				parts.push({
 					bodyPart: this.body.slice(bodyStart, bodyEnd),
 					partNumber: parts.length + 1,
-					emitter: new events.EventEmitter(),
+					emitter: new EventEmitter(),
 					_lastUploadedBytes: 0,
 				});
 				bodyStart += this.partSize;
@@ -141,10 +140,10 @@ export class AWSS3ProviderManagedUpload {
 
 	private async createMultiPartUpload() {
 		try {
-			const createMultiPartUploadCommand = new CreateMultipartUploadCommand(
-				this.params
-			);
-			const response = await this.s3client.send(createMultiPartUploadCommand);
+			const response = await createMultipartUpload(this.s3Config, {
+				...this.params,
+				Key: await this.getObjectKeyWithPrefix(this.params.Key),
+			});
 			logger.debug(response.UploadId);
 			return response.UploadId;
 		} catch (error) {
@@ -162,7 +161,6 @@ export class AWSS3ProviderManagedUpload {
 			const allResults = await Promise.all(
 				parts.map(async part => {
 					this.setupEventListener(part);
-					const options: AxiosHttpHandlerOptions = { emitter: part.emitter };
 					const {
 						Key,
 						Bucket,
@@ -170,18 +168,18 @@ export class AWSS3ProviderManagedUpload {
 						SSECustomerKey,
 						SSECustomerKeyMD5,
 					} = this.params;
-					const res = await this.s3client.send(
-						new UploadPartCommand({
+					const res = await uploadPart(
+						{ ...this.s3Config, emitter: part.emitter },
+						{
 							PartNumber: part.partNumber,
 							Body: part.bodyPart,
 							UploadId: uploadId,
-							Key,
+							Key: await this.getObjectKeyWithPrefix(this.params.Key),
 							Bucket,
-							...(SSECustomerAlgorithm && { SSECustomerAlgorithm }),
-							...(SSECustomerKey && { SSECustomerKey }),
-							...(SSECustomerKeyMD5 && { SSECustomerKeyMD5 }),
-						}),
-						options
+							SSECustomerAlgorithm,
+							SSECustomerKey,
+							SSECustomerKeyMD5,
+						}
 					);
 					return res;
 				})
@@ -202,16 +200,15 @@ export class AWSS3ProviderManagedUpload {
 	}
 
 	private async finishMultiPartUpload(uploadId: string) {
-		const input: CompleteMultipartUploadCommandInput = {
+		const input: CompleteMultipartUploadInput = {
 			Bucket: this.params.Bucket,
-			Key: this.params.Key,
+			Key: await this.getObjectKeyWithPrefix(this.params.Key),
 			UploadId: uploadId,
 			MultipartUpload: { Parts: this.completedParts },
 		};
-		const completeUploadCommand = new CompleteMultipartUploadCommand(input);
 		try {
-			const data = await this.s3client.send(completeUploadCommand);
-			return data.Key;
+			const { Key } = await completeMultipartUpload(this.s3Config, input);
+			return Key;
 		} catch (error) {
 			logger.error('Error happened while finishing the upload.');
 			throw error;
@@ -232,14 +229,14 @@ export class AWSS3ProviderManagedUpload {
 
 		const input = {
 			Bucket: this.params.Bucket,
-			Key: this.params.Key,
+			Key: await this.getObjectKeyWithPrefix(this.params.Key),
 			UploadId: uploadId,
 		};
 
-		await this.s3client.send(new AbortMultipartUploadCommand(input));
+		await abortMultipartUpload(this.s3Config, input);
 
 		// verify that all parts are removed.
-		const data = await this.s3client.send(new ListPartsCommand(input));
+		const data = await listParts(this.s3Config, input);
 
 		if (data && data.Parts && data.Parts.length > 0) {
 			throw new Error('Multipart upload clean up failed.');
@@ -320,16 +317,12 @@ export class AWSS3ProviderManagedUpload {
 		return false;
 	}
 
-	protected _createNewS3Client(config, emitter?: events.EventEmitter) {
-		const s3client = createS3Client(config, StorageAction.Put, emitter);
-		s3client.middlewareStack.add(
-			createPrefixMiddleware(this.opts, this.params.Key),
-			prefixMiddlewareOptions
-		);
-		s3client.middlewareStack.add(
-			autoAdjustClockskewMiddleware(s3client.config),
-			autoAdjustClockskewMiddlewareOptions
+	private async getObjectKeyWithPrefix(keyWithoutPrefix: string) {
+		return (
+			(await getPrefix({
+				...this.opts,
+				credentials: await credentialsProvider(),
+			})) + keyWithoutPrefix
 		);
-		return s3client;
 	}
 }

package/src/providers/AWSS3UploadTask.ts

@@ -1,33 +1,30 @@
-import {
-	UploadPartCommandInput,
-	CompletedPart,
-	S3Client,
-	UploadPartCommand,
-	CompleteMultipartUploadCommand,
-	Part,
-	AbortMultipartUploadCommand,
-	ListPartsCommand,
-	CreateMultipartUploadCommand,
-	PutObjectCommandInput,
-	ListObjectsV2Command,
-} from '@aws-sdk/client-s3';
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
 import * as events from 'events';
-import axios, { Canceler, CancelTokenSource } from 'axios';
-import { HttpHandlerOptions } from '@aws-sdk/types';
 import { Logger } from '@aws-amplify/core';
 import { UploadTask } from '../types/Provider';
+import {
+	PutObjectInput,
+	createMultipartUpload,
+	uploadPart,
+	UploadPartInput,
+	listObjectsV2,
+	CompletedPart,
+	Part,
+	listParts,
+	completeMultipartUpload,
+	abortMultipartUpload,
+} from '../AwsClients/S3';
+import { isCancelError, CANCELED_ERROR_MESSAGE } from '../AwsClients/S3/utils';
 import {
 	calculatePartSize,
 	DEFAULT_PART_SIZE,
 	DEFAULT_QUEUE_SIZE,
 	MAX_OBJECT_SIZE,
+	S3ResolvedConfig,
 } from '../common/S3ClientUtils';
 import { byteLength, isFile } from '../common/StorageUtils';
-import { AWSS3ProviderUploadErrorStrings } from '../common/StorageErrorStrings';
-import {
-	SET_CONTENT_LENGTH_HEADER,
-	UPLOADS_STORAGE_KEY,
-} from '../common/StorageConstants';
+import { UPLOADS_STORAGE_KEY } from '../common/StorageConstants';
 import { StorageAccessLevel } from '..';
 
 const logger = new Logger('AWSS3UploadTask');
@@ -47,19 +44,19 @@ export enum TaskEvents {
 }
 
 export interface AWSS3UploadTaskParams {
-	s3Client: S3Client;
+	s3Config: S3ResolvedConfig;
 	file: Blob;
 	storage: Storage;
 	level: StorageAccessLevel;
-	params: PutObjectCommandInput;
+	params: PutObjectInput;
 	prefixPromise: Promise<string>;
 	emitter?: events.EventEmitter;
 }
 
 export interface InProgressRequest {
-	uploadPartInput: UploadPartCommandInput;
+	uploadPartInput: UploadPartInput;
 	s3Request: Promise<any>;
-	cancel: Canceler;
+	abortController: AbortController;
 }
 
 export interface UploadTaskCompleteEvent {
@@ -94,16 +91,16 @@ export class AWSS3UploadTask implements UploadTask {
 	private readonly emitter: events.EventEmitter;
 	private readonly file: Blob;
 	private readonly queueSize = DEFAULT_QUEUE_SIZE;
-	private readonly s3client: S3Client;
+	private readonly s3Config: S3ResolvedConfig;
 	private readonly storage: Storage;
 	private readonly storageSync: Promise<any>;
 	private readonly fileId: string;
-	private readonly params: PutObjectCommandInput;
+	private readonly params: PutObjectInput;
 	private readonly prefixPromise: Promise<string>;
 	private partSize: number = DEFAULT_PART_SIZE;
 	private inProgress: InProgressRequest[] = [];
 	private completedParts: CompletedPart[] = [];
-	private queued: UploadPartCommandInput[] = [];
+	private queued: UploadPartInput[] = [];
 	private bytesUploaded: number = 0;
 	private totalBytes: number = 0;
 	private uploadId: string;
@@ -111,7 +108,7 @@ export class AWSS3UploadTask implements UploadTask {
 	public state: AWSS3UploadTaskState = AWSS3UploadTaskState.INIT;
 
 	constructor({
-		s3Client,
+		s3Config,
 		file,
 		emitter,
 		storage,
@@ -120,8 +117,7 @@ export class AWSS3UploadTask implements UploadTask {
 		prefixPromise,
 	}: AWSS3UploadTaskParams) {
 		this.prefixPromise = prefixPromise;
-		this.s3client = s3Client;
-		this.s3client.middlewareStack.remove(SET_CONTENT_LENGTH_HEADER);
+		this.s3Config = s3Config;
 		this.storage = storage;
 		this.storageSync = Promise.resolve();
 		if (typeof this.storage['sync'] === 'function') {
@@ -155,15 +151,12 @@ export class AWSS3UploadTask implements UploadTask {
 		key: string;
 		bucket: string;
 	}) {
-		const listObjectRes = await this.s3client.send(
-			new ListObjectsV2Command({
-				Bucket: bucket,
-				Prefix: key,
-			})
-		);
-		const { Contents = [] } = listObjectRes;
-		const prefix = await this.prefixPromise;
-		const obj = Contents.find(o => o.Key === `${prefix}${key}`);
+		const objectKeyPrefix = await this.prefixPromise;
+		const { Contents = [] } = await listObjectsV2(this.s3Config, {
+			Bucket: bucket,
+			Prefix: objectKeyPrefix + key,
+		});
+		const obj = Contents.find(o => o.Key === `${objectKeyPrefix}${key}`);
 		return obj;
 	}
 
@@ -207,16 +200,14 @@ export class AWSS3UploadTask implements UploadTask {
 		cachedUploadFileData.lastTouched = Date.now();
 		this.storage.setItem(UPLOADS_STORAGE_KEY, JSON.stringify(uploadRequests));
 
-		const listPartsOutput = await this.s3client.send(
-			new ListPartsCommand({
-				Bucket: this.params.Bucket,
-				Key: this.params.Key,
-				UploadId: cachedUploadFileData.uploadId,
-			})
-		);
+		const { Parts = [] } = await listParts(this.s3Config, {
+			Bucket: this.params.Bucket,
+			Key: (await this.prefixPromise) + this.params.Key,
+			UploadId: cachedUploadFileData.uploadId,
+		});
 
 		return {
-			parts: listPartsOutput.Parts || [],
+			parts: Parts,
 			uploadId: cachedUploadFileData.uploadId,
 		};
 	}
@@ -267,7 +258,7 @@ export class AWSS3UploadTask implements UploadTask {
 	}: {
 		eTag: string;
 		partNumber: number;
-		chunk: UploadPartCommandInput['Body'];
+		chunk: UploadPartInput['Body'];
 	}) {
 		this.completedParts.push({
 			ETag: eTag,
@@ -289,17 +280,15 @@ export class AWSS3UploadTask implements UploadTask {
 
 	private async _completeUpload() {
 		try {
-			await this.s3client.send(
-				new CompleteMultipartUploadCommand({
-					Bucket: this.params.Bucket,
-					Key: this.params.Key,
-					UploadId: this.uploadId,
-					MultipartUpload: {
-						// Parts are not always completed in order, we need to manually sort them
-						Parts: this.completedParts.sort(comparePartNumber),
-					},
-				})
-			);
+			await completeMultipartUpload(this.s3Config, {
+				Bucket: this.params.Bucket,
+				Key: (await this.prefixPromise) + this.params.Key,
+				UploadId: this.uploadId,
+				MultipartUpload: {
+					// Parts are not always completed in order, we need to manually sort them
+					Parts: [...this.completedParts].sort(comparePartNumber),
+				},
+			});
 			await this._verifyFileSize();
 			this._emitEvent<UploadTaskCompleteEvent>(TaskEvents.UPLOAD_COMPLETE, {
 				key: this.params.Key,
@@ -313,13 +302,20 @@ export class AWSS3UploadTask implements UploadTask {
 	}
 
 	private async _makeUploadPartRequest(
-		input: UploadPartCommandInput,
-		cancelTokenSource: CancelTokenSource
+		input: UploadPartInput,
+		abortSignal: AbortSignal
 	) {
 		try {
-			const res = await this.s3client.send(new UploadPartCommand(input), {
-				cancelTokenSource,
-			} as HttpHandlerOptions);
+			const res = await uploadPart(
+				{
+					...this.s3Config,
+					abortSignal,
+				},
+				{
+					...input,
+					Key: (await this.prefixPromise) + this.params.Key,
+				}
+			);
 			await this._onPartUploadCompletion({
 				eTag: res.ETag,
 				partNumber: input.PartNumber,
@@ -333,12 +329,9 @@ export class AWSS3UploadTask implements UploadTask {
 			} else {
 				logger.error('error starting next part of upload: ', err);
 			}
-			// axios' cancel will also throw an error, however we don't need to emit an event in that case as it's an
+			// xhr transfer handlers' cancel will also throw an error, however we don't need to emit an event in that case as it's an
 			// expected behavior
-			if (
-				!axios.isCancel(err) &&
-				err.message !== AWSS3ProviderUploadErrorStrings.UPLOAD_PAUSED_MESSAGE
-			) {
+			if (!isCancelError(err) && err.message !== CANCELED_ERROR_MESSAGE) {
 				this._emitEvent(TaskEvents.ERROR, err);
 				this.pause();
 			}
@@ -347,12 +340,15 @@ export class AWSS3UploadTask implements UploadTask {
 
 	private _startNextPart() {
 		if (this.queued.length > 0 && this.state !== AWSS3UploadTaskState.PAUSED) {
-			const cancelTokenSource = axios.CancelToken.source();
+			const abortController = new AbortController();
 			const nextPart = this.queued.shift();
 			this.inProgress.push({
 				uploadPartInput: nextPart,
-				s3Request: this._makeUploadPartRequest(nextPart, cancelTokenSource),
-				cancel: cancelTokenSource.cancel,
+				s3Request: this._makeUploadPartRequest(
+					nextPart,
+					abortController.signal
+				),
+				abortController,
 			});
 		}
 	}
@@ -395,7 +391,7 @@ export class AWSS3UploadTask implements UploadTask {
 
 	private _createParts() {
 		const size = this.file.size;
-		const parts: UploadPartCommandInput[] = [];
+		const parts: UploadPartInput[] = [];
 		for (let bodyStart = 0; bodyStart < size; ) {
 			const bodyEnd = Math.min(bodyStart + this.partSize, size);
 			parts.push({
@@ -430,9 +426,10 @@ export class AWSS3UploadTask implements UploadTask {
 	}
 
 	private async _initMultipartUpload() {
-		const res = await this.s3client.send(
-			new CreateMultipartUploadCommand(this.params)
-		);
+		const res = await createMultipartUpload(this.s3Config, {
+			...this.params,
+			Key: (await this.prefixPromise) + this.params.Key,
+		});
 		this._cache({
 			uploadId: res.UploadId,
 			lastTouched: Date.now(),
@@ -452,7 +449,11 @@ export class AWSS3UploadTask implements UploadTask {
 				this.uploadId = uploadId;
 				this.queued = this._createParts();
 				this._initCachedUploadParts(parts);
-				this._startUpload();
+				if (this._isDone()) {
+					this._completeUpload();
+				} else {
+					this._startUpload();
+				}
 			} else {
 				if (!this.uploadId) {
 					const uploadId = await this._initMultipartUpload();
@@ -462,7 +463,7 @@ export class AWSS3UploadTask implements UploadTask {
 				}
 			}
 		} catch (err) {
-			if (!axios.isCancel(err)) {
+			if (!isCancelError(err)) {
 				logger.error('Error initializing the upload task', err);
 				this._emitEvent(TaskEvents.ERROR, err);
 			}
@@ -506,13 +507,11 @@ export class AWSS3UploadTask implements UploadTask {
 			this.bytesUploaded = 0;
 			this.state = AWSS3UploadTaskState.CANCELLED;
 			try {
-				await this.s3client.send(
-					new AbortMultipartUploadCommand({
-						Bucket: this.params.Bucket,
-						Key: this.params.Key,
-						UploadId: this.uploadId,
-					})
-				);
+				await abortMultipartUpload(this.s3Config, {
+					Bucket: this.params.Bucket,
+					Key: (await this.prefixPromise) + this.params.Key,
+					UploadId: this.uploadId,
+				});
 				await this._removeFromCache();
 				return true;
 			} catch (err) {
@@ -534,14 +533,14 @@ export class AWSS3UploadTask implements UploadTask {
 			logger.warn('This task is already paused');
 		}
 		this.state = AWSS3UploadTaskState.PAUSED;
-		// Use axios cancel token to abort the part request immediately
+		// Abort the part request immediately
 		// Add the inProgress parts back to pending
 		const removedInProgressReq = this.inProgress.splice(
 			0,
 			this.inProgress.length
 		);
 		removedInProgressReq.forEach(req => {
-			req.cancel(AWSS3ProviderUploadErrorStrings.UPLOAD_PAUSED_MESSAGE);
+			req.abortController.abort();
 		});
 		// Put all removed in progress parts back into the queue
 		this.queued.unshift(

package/src/providers/index.ts

@@ -1 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
 export { AWSS3Provider } from './AWSS3Provider';