@aws-amplify/storage 4.4.3 → 4.4.4-in-app-messaging.35

package/src/common/StorageUtils.ts

@@ -0,0 +1,51 @@
+import { Hub } from '@aws-amplify/core';
+import { AMPLIFY_SYMBOL } from './StorageConstants';
+
+export const byteLength = (x: unknown) => {
+	if (typeof x === 'string') {
+		return x.length;
+	} else if (isArrayBuffer(x)) {
+		return x.byteLength;
+	} else if (isBlob(x)) {
+		return x.size;
+	} else {
+		throw new Error('Cannot determine byte length of ' + x);
+	}
+};
+
+export const dispatchStorageEvent = (
+	track: boolean,
+	event: string,
+	attrs: any,
+	metrics: any,
+	message: string
+): void => {
+	if (track) {
+		const data = { attrs };
+		if (metrics) {
+			data['metrics'] = metrics;
+		}
+		Hub.dispatch(
+			'storage',
+			{
+				event,
+				data,
+				message,
+			},
+			'Storage',
+			AMPLIFY_SYMBOL
+		);
+	}
+};
+
+export const isFile = (x: unknown): x is File => {
+	return typeof x !== 'undefined' && x instanceof File;
+};
+
+export const isBlob = (x: unknown): x is Blob => {
+	return typeof x !== 'undefined' && x instanceof Blob;
+};
+
+const isArrayBuffer = (x: unknown): x is ArrayBuffer => {
+	return typeof x !== 'undefined' && x instanceof ArrayBuffer;
+};

package/src/providers/AWSS3Provider.ts

@@ -12,11 +12,11 @@
  */
 import {
 	ConsoleLogger as Logger,
-	Hub,
 	Credentials,
 	Parser,
-	getAmplifyUserAgent,
 	ICredentials,
+	StorageHelper,
+	Hub,
 } from '@aws-amplify/core';
 import {
 	S3Client,
@@ -33,7 +33,10 @@ import {
 import { formatUrl } from '@aws-sdk/util-format-url';
 import { createRequest } from '@aws-sdk/util-create-request';
 import { S3RequestPresigner } from '@aws-sdk/s3-request-presigner';
-import { AxiosHttpHandler, SEND_DOWNLOAD_PROGRESS_EVENT, SEND_UPLOAD_PROGRESS_EVENT } from './axios-http-handler';
+import {
+	SEND_DOWNLOAD_PROGRESS_EVENT,
+	SEND_UPLOAD_PROGRESS_EVENT,
+} from './axios-http-handler';
 import {
 	StorageOptions,
 	StorageProvider,
@@ -43,7 +46,6 @@ import {
 	S3ProviderRemoveConfig,
 	S3ProviderListOutput,
 	S3ProviderListConfig,
-	S3ProviderPutOutput,
 	S3ProviderCopyConfig,
 	S3ProviderCopyOutput,
 	S3CopySource,
@@ -51,41 +53,41 @@ import {
 	StorageAccessLevel,
 	CustomPrefix,
 	S3ProviderRemoveOutput,
+	S3ProviderPutOutput,
+	ResumableUploadConfig,
+	UploadTask,
 } from '../types';
 import { StorageErrorStrings } from '../common/StorageErrorStrings';
+import { dispatchStorageEvent } from '../common/StorageUtils';
+import {
+	createPrefixMiddleware,
+	prefixMiddlewareOptions,
+	getPrefix,
+	autoAdjustClockskewMiddleware,
+	autoAdjustClockskewMiddlewareOptions,
+	createS3Client,
+} from '../common/S3ClientUtils';
 import { AWSS3ProviderManagedUpload } from './AWSS3ProviderManagedUpload';
+import { AWSS3UploadTask, TaskEvents } from './AWSS3UploadTask';
+import { UPLOADS_STORAGE_KEY } from '../common/StorageConstants';
 import * as events from 'events';
 import { CancelTokenSource } from 'axios';
 
 const logger = new Logger('AWSS3Provider');
 
-const AMPLIFY_SYMBOL = (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function'
-	? Symbol.for('amplify_default')
-	: '@@amplify_default') as Symbol;
-const SET_CONTENT_LENGTH_HEADER = 'contentLengthMiddleware';
 const DEFAULT_STORAGE_LEVEL = 'public';
 const DEFAULT_PRESIGN_EXPIRATION = 900;
 
-const dispatchStorageEvent = (track: boolean, event: string, attrs: any, metrics: any, message: string): void => {
-	if (track) {
-		const data = { attrs };
-		if (metrics) {
-			data['metrics'] = metrics;
-		}
-		Hub.dispatch(
-			'storage',
-			{
-				event,
-				data,
-				message,
-			},
-			'Storage',
-			AMPLIFY_SYMBOL
-		);
-	}
-};
+interface AddTaskInput {
+	accessLevel: StorageAccessLevel;
+	file: Blob;
+	bucket: string;
+	emitter: events.EventEmitter;
+	key: string;
+	s3Client: S3Client;
+	params?: PutObjectCommandInput;
+}
 
-const localTestingStorageEndpoint = 'http://localhost:20005';
 /**
  * Provide storage methods to use AWS S3
  */
@@ -93,6 +95,7 @@ export class AWSS3Provider implements StorageProvider {
 	static readonly CATEGORY = 'Storage';
 	static readonly PROVIDER_NAME = 'AWSS3';
 	private _config: StorageOptions;
+	private _storage: Storage;
 
 	/**
 	 * Initialize Storage with AWS configurations
@@ -100,6 +103,13 @@ export class AWSS3Provider implements StorageProvider {
 	 */
 	constructor(config?: StorageOptions) {
 		this._config = config ? config : {};
+		this._storage = new StorageHelper().getStorage();
+		Hub.listen('auth', data => {
+			const { payload } = data;
+			if (payload.event === 'signOut' || payload.event === 'signIn') {
+				this._storage.removeItem(UPLOADS_STORAGE_KEY);
+			}
+		});
 		logger.debug('Storage Options', this._config);
 	}
 
@@ -133,6 +143,95 @@ export class AWSS3Provider implements StorageProvider {
 		return this._config;
 	}
 
+	private startResumableUpload(
+		addTaskInput: AddTaskInput,
+		config: S3ProviderPutConfig & ResumableUploadConfig
+	): UploadTask {
+		const { s3Client, emitter, key, file, params } = addTaskInput;
+		const {
+			progressCallback,
+			completeCallback,
+			errorCallback,
+			track = false,
+		} = config;
+		if (!(file instanceof Blob)) {
+			throw new Error(StorageErrorStrings.INVALID_BLOB);
+		}
+
+		emitter.on(TaskEvents.UPLOAD_PROGRESS, event => {
+			if (progressCallback) {
+				if (typeof progressCallback === 'function') {
+					progressCallback(event);
+				} else {
+					logger.warn(
+						'progressCallback should be a function, not a ' +
+							typeof progressCallback
+					);
+				}
+			}
+		});
+
+		emitter.on(TaskEvents.UPLOAD_COMPLETE, event => {
+			if (completeCallback) {
+				if (typeof completeCallback === 'function') {
+					completeCallback(event);
+				} else {
+					logger.warn(
+						'completeCallback should be a function, not a ' +
+							typeof completeCallback
+					);
+				}
+			}
+		});
+
+		emitter.on(TaskEvents.ERROR, err => {
+			if (errorCallback) {
+				if (typeof errorCallback === 'function') {
+					errorCallback(err);
+				} else {
+					logger.warn(
+						'errorCallback should be a function, not a ' + typeof errorCallback
+					);
+				}
+			}
+		});
+
+		// we want to keep this function sync so we defer this promise to AWSS3UploadTask to resolve when it's needed
+		// when its doing a final check with _listSingleFile function
+		const prefixPromise: Promise<string> = Credentials.get().then(
+			(credentials: any) => {
+				const cred = Credentials.shear(credentials);
+				return getPrefix({
+					...config,
+					credentials: cred,
+				});
+			}
+		);
+
+		const task = new AWSS3UploadTask({
+			s3Client,
+			file,
+			emitter,
+			level: config.level,
+			storage: this._storage,
+			params,
+			prefixPromise,
+		});
+
+		dispatchStorageEvent(
+			track,
+			'upload',
+			{ method: 'put', result: 'success' },
+			null,
+			`Upload Task created successfully for ${key}`
+		);
+
+		// automatically start the upload task
+		task.resume();
+
+		return task;
+	}
+
 	/**
 	 * Copy an object from a source object to a new object within the same bucket. Can optionally copy files across
 	 * different level or identityId (if source object's level is 'protected').
@@ -165,7 +264,11 @@ export class AWSS3Provider implements StorageProvider {
 			SSECustomerKeyMD5,
 			SSEKMSKeyId,
 		} = opt;
-		const { level: srcLevel = DEFAULT_STORAGE_LEVEL, identityId: srcIdentityId, key: srcKey } = src;
+		const {
+			level: srcLevel = DEFAULT_STORAGE_LEVEL,
+			identityId: srcIdentityId,
+			key: srcKey,
+		} = src;
 		const { level: destLevel = DEFAULT_STORAGE_LEVEL, key: destKey } = dest;
 		if (!srcKey || typeof srcKey !== 'string') {
 			throw new Error(StorageErrorStrings.NO_SRC_KEY);
@@ -216,7 +319,6 @@ export class AWSS3Provider implements StorageProvider {
 		if (acl) params.ACL = acl;
 
 		const s3 = this._createNewS3Client(opt);
-		s3.middlewareStack.remove(SET_CONTENT_LENGTH_HEADER);
 		try {
 			await s3.send(new CopyObjectCommand(params));
 			dispatchStorageEvent(
@@ -261,7 +363,7 @@ export class AWSS3Provider implements StorageProvider {
 	): Promise<S3ProviderGetOuput<T>>;
 	public async get(
 		key: string,
-		config?: S3ProviderGetConfig & StorageOptions
+		config?: S3ProviderGetConfig
 	): Promise<string | GetObjectCommandOutput> {
 		const credentialsOK = await this._ensureCredentials();
 		if (!credentialsOK || !this._isWithCredentials(this._config)) {
@@ -296,7 +398,8 @@ export class AWSS3Provider implements StorageProvider {
 
 		// See: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#getObject-property
 		if (cacheControl) params.ResponseCacheControl = cacheControl;
-		if (contentDisposition) params.ResponseContentDisposition = contentDisposition;
+		if (contentDisposition)
+			params.ResponseContentDisposition = contentDisposition;
 		if (contentEncoding) params.ResponseContentEncoding = contentEncoding;
 		if (contentLanguage) params.ResponseContentLanguage = contentLanguage;
 		if (contentType) params.ResponseContentType = contentType;
@@ -319,7 +422,10 @@ export class AWSS3Provider implements StorageProvider {
 							progressCallback(progress);
 						});
 					} else {
-						logger.warn('progressCallback should be a function, not a ' + typeof progressCallback);
+						logger.warn(
+							'progressCallback should be a function, not a ' +
+								typeof progressCallback
+						);
 					}
 				}
 				const response = await s3.send(getObjectCommand);
@@ -353,8 +459,18 @@ export class AWSS3Provider implements StorageProvider {
 			const signer = new S3RequestPresigner({ ...s3.config });
 			const request = await createRequest(s3, new GetObjectCommand(params));
 			// Default is 15 mins as defined in V2 AWS SDK
-			const url = formatUrl(await signer.presign(request, { expiresIn: expires || DEFAULT_PRESIGN_EXPIRATION }));
-			dispatchStorageEvent(track, 'getSignedUrl', { method: 'get', result: 'success' }, null, `Signed URL: ${url}`);
+			const url = formatUrl(
+				await signer.presign(request, {
+					expiresIn: expires || DEFAULT_PRESIGN_EXPIRATION,
+				})
+			);
+			dispatchStorageEvent(
+				track,
+				'getSignedUrl',
+				{ method: 'get', result: 'success' },
+				null,
+				`Signed URL: ${url}`
+			);
 			return url;
 		} catch (error) {
 			logger.warn('get signed url error', error);
@@ -371,33 +487,41 @@ export class AWSS3Provider implements StorageProvider {
 
 	/**
 	 * Put a file in S3 bucket specified to configure method
-	 * @param {string} key - key of the object
-	 * @param {PutObjectCommandInput["Body"]} object - File to be put in Amazon S3 bucket
-	 * @param {S3ProviderPutConfig} [config] - Optional configuration for the underlying S3 command
-	 * @return {Promise<S3ProviderPutOutput>} - promise resolves to an object with the new object's key on success
+	 * @param key - key of the object
+	 * @param object - File to be put in Amazon S3 bucket
+	 * @param [config] - Optional configuration for the underlying S3 command
+	 * @return an instance of AWSS3UploadTask or a promise that resolves to an object with the new object's key on
+	 * success.
 	 */
-	public async put(
+	public put<T extends S3ProviderPutConfig>(
 		key: string,
 		object: PutObjectCommandInput['Body'],
-		config?: S3ProviderPutConfig
-	): Promise<S3ProviderPutOutput> {
-		const credentialsOK = await this._ensureCredentials();
-		if (!credentialsOK || !this._isWithCredentials(this._config)) {
-			throw new Error(StorageErrorStrings.NO_CREDENTIALS);
-		}
+		config?: T
+	): S3ProviderPutOutput<T> {
 		const opt = Object.assign({}, this._config, config);
-		const { bucket, track, progressCallback } = opt;
-		const { contentType, contentDisposition, contentEncoding, cacheControl, expires, metadata, tagging, acl } = opt;
-		const { serverSideEncryption, SSECustomerAlgorithm, SSECustomerKey, SSECustomerKeyMD5, SSEKMSKeyId } = opt;
+		const { bucket, track, progressCallback, level, resumable } = opt;
+		const {
+			contentType,
+			contentDisposition,
+			contentEncoding,
+			cacheControl,
+			expires,
+			metadata,
+			tagging,
+			acl,
+		} = opt;
+		const {
+			serverSideEncryption,
+			SSECustomerAlgorithm,
+			SSECustomerKey,
+			SSECustomerKeyMD5,
+			SSEKMSKeyId,
+		} = opt;
 		const type = contentType ? contentType : 'binary/octet-stream';
 
-		const prefix = this._prefix(opt);
-		const final_key = prefix + key;
-		logger.debug('put ' + key + ' to ' + final_key);
-
 		const params: PutObjectCommandInput = {
 			Bucket: bucket,
-			Key: final_key,
+			Key: key,
 			Body: object,
 			ContentType: type,
 		};
@@ -442,6 +566,30 @@ export class AWSS3Provider implements StorageProvider {
 			params.ACL = acl;
 		}
 
+		if (resumable === true) {
+			const s3Client = this._createNewS3Client(opt);
+			// we are using aws sdk middleware to inject the prefix to key, this way we don't have to call
+			// this._ensureCredentials() which allows us to make this function sync so we can return non-Promise like UploadTask
+			s3Client.middlewareStack.add(
+				createPrefixMiddleware(opt, key),
+				prefixMiddlewareOptions
+			);
+			const addTaskInput: AddTaskInput = {
+				bucket,
+				key,
+				s3Client,
+				file: object as Blob,
+				emitter,
+				accessLevel: level,
+				params,
+			};
+			// explicitly asserting the type here as Typescript could not infer that resumable is of type true
+			return this.startResumableUpload(
+				addTaskInput,
+				config as typeof config & { resumable: true }
+			) as S3ProviderPutOutput<T>;
+		}
+
 		try {
 			if (progressCallback) {
 				if (typeof progressCallback === 'function') {
@@ -449,20 +597,33 @@ export class AWSS3Provider implements StorageProvider {
 						progressCallback(progress);
 					});
 				} else {
-					logger.warn('progressCallback should be a function, not a ' + typeof progressCallback);
+					logger.warn(
+						'progressCallback should be a function, not a ' +
+							typeof progressCallback
+					);
 				}
 			}
 
-			const response = await uploader.upload();
-
-			logger.debug('upload result', response);
-			dispatchStorageEvent(track, 'upload', { method: 'put', result: 'success' }, null, `Upload success for ${key}`);
-			return {
-				key,
-			};
+			return uploader.upload().then(response => {
+				logger.debug('upload result', response);
+				dispatchStorageEvent(
+					track,
+					'upload',
+					{ method: 'put', result: 'success' },
+					null,
+					`Upload success for ${key}`
+				);
+				return { key };
+			}) as S3ProviderPutOutput<T>;
 		} catch (error) {
 			logger.warn('error uploading', error);
-			dispatchStorageEvent(track, 'upload', { method: 'put', result: 'failed' }, null, `Error uploading ${key}`);
+			dispatchStorageEvent(
+				track,
+				'upload',
+				{ method: 'put', result: 'failed' },
+				null,
+				`Error uploading ${key}`
+			);
 			throw error;
 		}
 	}
@@ -473,7 +634,10 @@ export class AWSS3Provider implements StorageProvider {
 	 * @param {S3ProviderRemoveConfig} [config] - Optional configuration for the underlying S3 command
 	 * @return {Promise<S3ProviderRemoveOutput>} - Promise resolves upon successful removal of the object
 	 */
-	public async remove(key: string, config?: S3ProviderRemoveConfig): Promise<S3ProviderRemoveOutput> {
+	public async remove(
+		key: string,
+		config?: S3ProviderRemoveConfig
+	): Promise<S3ProviderRemoveOutput> {
 		const credentialsOK = await this._ensureCredentials();
 		if (!credentialsOK || !this._isWithCredentials(this._config)) {
 			throw new Error(StorageErrorStrings.NO_CREDENTIALS);
@@ -522,7 +686,10 @@ export class AWSS3Provider implements StorageProvider {
 	 * @return {Promise<S3ProviderListOutput>} - Promise resolves to list of keys, eTags, lastModified and file size for
 	 * all objects in path
 	 */
-	public async list(path: string, config?: S3ProviderListConfig): Promise<S3ProviderListOutput> {
+	public async list(
+		path: string,
+		config?: S3ProviderListConfig
+	): Promise<S3ProviderListOutput> {
 		const credentialsOK = await this._ensureCredentials();
 		if (!credentialsOK || !this._isWithCredentials(this._config)) {
 			throw new Error(StorageErrorStrings.NO_CREDENTIALS);
@@ -593,7 +760,9 @@ export class AWSS3Provider implements StorageProvider {
 		}
 	}
 
-	private _isWithCredentials(config: StorageOptions): config is StorageOptions & { credentials: ICredentials } {
+	private _isWithCredentials(
+		config: StorageOptions
+	): config is StorageOptions & { credentials: ICredentials } {
 		return typeof config === 'object' && config.hasOwnProperty('credentials');
 	}
 
@@ -607,10 +776,18 @@ export class AWSS3Provider implements StorageProvider {
 
 		const customPrefix = config.customPrefix || {};
 		const identityId = config.identityId || credentials.identityId;
-		const privatePath = (customPrefix.private !== undefined ? customPrefix.private : 'private/') + identityId + '/';
+		const privatePath =
+			(customPrefix.private !== undefined ? customPrefix.private : 'private/') +
+			identityId +
+			'/';
 		const protectedPath =
-			(customPrefix.protected !== undefined ? customPrefix.protected : 'protected/') + identityId + '/';
-		const publicPath = customPrefix.public !== undefined ? customPrefix.public : 'public/';
+			(customPrefix.protected !== undefined
+				? customPrefix.protected
+				: 'protected/') +
+			identityId +
+			'/';
+		const publicPath =
+			customPrefix.public !== undefined ? customPrefix.public : 'public/';
 
 		switch (level) {
 			case 'private':
@@ -627,32 +804,18 @@ export class AWSS3Provider implements StorageProvider {
 	 */
 	private _createNewS3Client(
 		config: {
-			credentials: ICredentials;
 			region?: string;
 			cancelTokenSource?: CancelTokenSource;
 			dangerouslyConnectToHttpEndpointForTesting?: boolean;
+			useAccelerateEndpoint?: boolean;
 		},
 		emitter?: events.EventEmitter
 	): S3Client {
-		const { region, credentials, cancelTokenSource, dangerouslyConnectToHttpEndpointForTesting } = config;
-		let localTestingConfig = {};
-
-		if (dangerouslyConnectToHttpEndpointForTesting) {
-			localTestingConfig = {
-				endpoint: localTestingStorageEndpoint,
-				tls: false,
-				bucketEndpoint: false,
-				forcePathStyle: true,
-			};
-		}
-
-		const s3client = new S3Client({
-			region,
-			credentials,
-			customUserAgent: getAmplifyUserAgent(),
-			...localTestingConfig,
-			requestHandler: new AxiosHttpHandler({}, emitter, cancelTokenSource),
-		});
+		const s3client = createS3Client(config, emitter);
+		s3client.middlewareStack.add(
+			autoAdjustClockskewMiddleware(s3client.config),
+			autoAdjustClockskewMiddlewareOptions
+		);
 		return s3client;
 	}
 }