@aws-amplify/storage 5.6.4-graphql-api-functional-options.1 → 5.6.4-unstable.28bc873.6

package/src/AwsClients/S3/uploadPart.ts

@@ -0,0 +1,83 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	Endpoint,
+	HttpRequest,
+	HttpResponse,
+	parseMetadata,
+} from '@aws-amplify/core/internals/aws-client-utils';
+import { composeServiceApi } from '@aws-amplify/core/internals/aws-client-utils/composers';
+
+import { defaultConfig } from './base';
+import type { UploadPartCommandInput, UploadPartCommandOutput } from './types';
+import {
+	map,
+	parseXmlError,
+	s3TransferHandler,
+	serializeObjectSsecOptionsToHeaders,
+	serializePathnameObjectKey,
+} from './utils';
+
+// Content-length is ignored here because it's forbidden header
+// and will be set by browser or fetch polyfill.
+export type UploadPartInput = Pick<
+	UploadPartCommandInput,
+	| 'PartNumber'
+	| 'Body'
+	| 'UploadId'
+	| 'Bucket'
+	| 'Key'
+	| 'SSECustomerAlgorithm'
+	| 'SSECustomerKey'
+	// TODO(AllanZhengYP): remove in V6.
+	| 'SSECustomerKeyMD5'
+>;
+
+export type UploadPartOutput = Pick<
+	UploadPartCommandOutput,
+	'$metadata' | 'ETag'
+>;
+
+const uploadPartSerializer = async (
+	input: UploadPartInput,
+	endpoint: Endpoint
+): Promise<HttpRequest> => {
+	const headers = await serializeObjectSsecOptionsToHeaders(input);
+	headers['content-type'] = 'application/octet-stream';
+	const url = new URL(endpoint.url.toString());
+	url.pathname = serializePathnameObjectKey(url, input.Key);
+	url.search = new URLSearchParams({
+		partNumber: input.PartNumber + '',
+		uploadId: input.UploadId,
+	}).toString();
+	return {
+		method: 'PUT',
+		headers,
+		url,
+		body: input.Body,
+	};
+};
+
+const uploadPartDeserializer = async (
+	response: HttpResponse
+): Promise<UploadPartOutput> => {
+	if (response.statusCode >= 300) {
+		const error = await parseXmlError(response);
+		throw error;
+	} else {
+		return {
+			...map(response.headers, {
+				ETag: 'etag',
+			}),
+			$metadata: parseMetadata(response),
+		};
+	}
+};
+
+export const uploadPart = composeServiceApi(
+	s3TransferHandler,
+	uploadPartSerializer,
+	uploadPartDeserializer,
+	{ ...defaultConfig, responseType: 'text' }
+);

package/src/AwsClients/S3/utils/deserializeHelpers.ts

@@ -0,0 +1,136 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Headers } from '@aws-amplify/core/internals/aws-client-utils';
+
+type PropertyNameWithStringValue = string;
+type PropertyNameWithSubsequentDeserializer<T> = [string, (any) => T];
+type Instruction<T> =
+	| PropertyNameWithStringValue
+	| PropertyNameWithSubsequentDeserializer<T>;
+
+type InferInstructionResultType<T extends Instruction<any>> =
+	| (T extends PropertyNameWithSubsequentDeserializer<infer R> ? R : string)
+	| undefined;
+
+/**
+ * Maps an object to a new object using the provided instructions.
+ * The instructions are a map of the returning mapped object's property names to a single instruction of how to map the
+ * value from the original object to the new object. There are two types of instructions:
+ *
+ * 1. A string representing the property name of the original object to map to the new object. The value mapped from
+ * the original object will be the same as the value in the new object, and it can ONLY be string.
+ *
+ * 2. An array of two elements. The first element is the property name of the original object to map to the new object.
+ * The second element is a function that takes the value from the original object and returns the value to be mapped to
+ * the new object. The function can return any type.
+ *
+ * Example:
+ * ```typescript
+ * const input = {
+ *   Foo: 'foo',
+ *   BarList: [{value: 'bar1'}, {value: 'bar2'}]
+ * }
+ * const output = map(input, {
+ *   someFoo: 'Foo',
+ *   bar: ['BarList', (barList) => barList.map(bar => bar.value)]
+ *   baz: 'Baz' // Baz does not exist in input, so it will not be in the output.
+ * });
+ * // output = { someFoo: 'foo', bar: ['bar1', 'bar2'] }
+ * ```
+ *
+ * @param obj The object containing the data to compose mapped object.
+ * @param instructions The instructions mapping the object values to the new object.
+ * @returns A new object with the mapped values.
+ *
+ * @internal
+ */
+export const map = <Instructions extends { [key: string]: Instruction<any> }>(
+	obj: Record<string, any>,
+	instructions: Instructions
+): {
+	[K in keyof Instructions]: InferInstructionResultType<Instructions[K]>;
+} => {
+	const result = {} as Record<keyof Instructions, any>;
+	for (const [key, instruction] of Object.entries(instructions)) {
+		const [accessor, deserializer] = Array.isArray(instruction)
+			? instruction
+			: [instruction];
+		if (obj.hasOwnProperty(accessor)) {
+			result[key as keyof Instructions] = deserializer
+				? deserializer(obj[accessor])
+				: String(obj[accessor]);
+		}
+	}
+	return result;
+};
+
+/**
+ * Deserializes a string to a number. Returns undefined if input is undefined.
+ *
+ * @internal
+ */
+export const deserializeNumber = (value?: string): number => {
+	return value ? Number(value) : undefined;
+};
+
+/**
+ * Deserializes a string to a boolean. Returns undefined if input is undefined. Returns true if input is 'true',
+ * otherwise false.
+ *
+ * @internal
+ */
+export const deserializeBoolean = (value?: string): boolean | undefined => {
+	return value ? value === 'true' : undefined;
+};
+
+/**
+ * Deserializes a string to a Date. Returns undefined if input is undefined.
+ * It supports epoch timestamp; rfc3339(cannot have a UTC, fractional precision supported); rfc7231(section 7.1.1.1)
+ *
+ * @see https://www.epoch101.com/
+ * @see https://datatracker.ietf.org/doc/html/rfc3339.html#section-5.6
+ * @see https://datatracker.ietf.org/doc/html/rfc7231.html#section-7.1.1.1
+ *
+ * @note For bundle size consideration, we use Date constructor to parse the timestamp string. There might be slight
+ * difference among browsers.
+ *
+ * @internal
+ */
+export const deserializeTimestamp = (value: string): Date | undefined => {
+	return value ? new Date(value) : undefined;
+};
+
+/**
+ * Function that makes sure the deserializer receives non-empty array.
+ *
+ * @internal
+ */
+export const emptyArrayGuard = <T extends Array<any>>(
+	value: any,
+	deserializer: (value: any[]) => T
+): T => {
+	if (value === '') {
+		return [] as T;
+	}
+	const valueArray = (Array.isArray(value) ? value : [value]).filter(
+		e => e != null
+	);
+	return deserializer(valueArray);
+};
+
+/**
+ * @internal
+ */
+export const deserializeMetadata = (
+	headers: Headers
+): Record<string, string> => {
+	const objectMetadataHeaderPrefix = 'x-amz-meta-';
+	const deserialized = Object.keys(headers)
+		.filter(header => header.startsWith(objectMetadataHeaderPrefix))
+		.reduce((acc, header) => {
+			acc[header.replace(objectMetadataHeaderPrefix, '')] = headers[header];
+			return acc;
+		}, {} as any);
+	return Object.keys(deserialized).length > 0 ? deserialized : undefined;
+};

package/src/AwsClients/S3/utils/index.ts

@@ -0,0 +1,27 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { parseXmlBody, parseXmlError } from './parsePayload';
+export {
+	SEND_DOWNLOAD_PROGRESS_EVENT,
+	SEND_UPLOAD_PROGRESS_EVENT,
+	s3TransferHandler,
+	CANCELED_ERROR_MESSAGE,
+	isCancelError,
+	CONTENT_SHA256_HEADER,
+} from '../runtime';
+export {
+	deserializeBoolean,
+	deserializeMetadata,
+	deserializeNumber,
+	deserializeTimestamp,
+	emptyArrayGuard,
+	map,
+} from './deserializeHelpers';
+export {
+	assignStringVariables,
+	serializeObjectConfigsToHeaders,
+	serializePathnameObjectKey,
+	serializeObjectSsecOptionsToHeaders,
+} from './serializeHelpers';
+export { toBase64, utf8Encode } from '../runtime';

package/src/AwsClients/S3/utils/parsePayload.ts

@@ -0,0 +1,45 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	ErrorParser,
+	HttpResponse,
+	parseMetadata,
+} from '@aws-amplify/core/internals/aws-client-utils';
+
+import { parser } from '../runtime';
+
+export const parseXmlError: ErrorParser = async (response?: HttpResponse) => {
+	if (!response || response.statusCode < 300) {
+		return;
+	}
+	const { statusCode } = response;
+	const body = await parseXmlBody(response);
+	const code = body?.['Code']
+		? (body.Code as string)
+		: statusCode === 404
+		? 'NotFound'
+		: statusCode.toString();
+	const message = body?.['message'] ?? body?.['Message'] ?? code;
+	const error = new Error(message);
+	return Object.assign(error, {
+		name: code,
+		$metadata: parseMetadata(response),
+	});
+};
+
+export const parseXmlBody = async (response: HttpResponse): Promise<any> => {
+	if (!response.body) {
+		// S3 can return 200 without a body indicating failure.
+		throw new Error('S3 aborted request.');
+	}
+	const data = await response.body.text();
+	if (data?.length > 0) {
+		try {
+			return parser.parse(data);
+		} catch (error) {
+			throw new Error('Failed to parse XML response.');
+		}
+	}
+	return {};
+};

package/src/AwsClients/S3/utils/serializeHelpers.ts

@@ -0,0 +1,112 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Md5 } from '@aws-sdk/md5-js';
+import { extendedEncodeURIComponent } from '@aws-amplify/core/internals/aws-client-utils';
+import { toBase64, utf8Encode } from '../utils';
+
+/**
+ * @internal
+ */
+export const assignStringVariables = (
+	values: Record<string, { toString: () => string } | undefined>
+): Record<string, string> => {
+	const queryParams = {};
+	for (const [key, value] of Object.entries(values)) {
+		if (value != null) {
+			queryParams[key] = value.toString();
+		}
+	}
+	return queryParams;
+};
+
+// Server-side encryption options
+interface ObjectSsecOptions {
+	SSECustomerAlgorithm?: string;
+	SSECustomerKey?: string;
+	SSECustomerKeyMD5?: string;
+}
+
+export const serializeObjectSsecOptionsToHeaders = async (
+	input: ObjectSsecOptions
+) => {
+	const getMd5Digest = async (content: any) => {
+		const md5Hasher = new Md5();
+		md5Hasher.update(utf8Encode(content));
+		return md5Hasher.digest();
+	};
+
+	return assignStringVariables({
+		'x-amz-server-side-encryption-customer-algorithm':
+			input.SSECustomerAlgorithm,
+		// base64 encoded is need
+		// see: https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html#specifying-s3-c-encryption
+		'x-amz-server-side-encryption-customer-key':
+			input.SSECustomerKey && toBase64(input.SSECustomerKey),
+		// Calculate the md5 digest of the the SSE-C key, for compatibility with AWS SDK
+		// see: https://github.com/aws/aws-sdk-js-v3/blob/91fc83307c38cc9cbe0b3acd919557d5b5b831d6/packages/middleware-ssec/src/index.ts#L36
+		'x-amz-server-side-encryption-customer-key-md5':
+			input.SSECustomerKey &&
+			toBase64(await getMd5Digest(input.SSECustomerKey)),
+	});
+};
+
+// Object configuration options when uploading an object.
+interface ObjectConfigs extends ObjectSsecOptions {
+	ServerSideEncryption?: string;
+	SSEKMSKeyId?: string;
+	ACL?: string;
+	CacheControl?: string;
+	ContentDisposition?: string;
+	ContentEncoding?: string;
+	ContentLanguage?: string;
+	ContentType?: string;
+	Expires?: Date;
+	Tagging?: string;
+	Metadata?: Record<string, string>;
+}
+
+/**
+ * Serailize the parameters for configuring the S3 object. Currently used by
+ * `putObject` and `createMultipartUpload` API.
+ *
+ * @internal
+ */
+export const serializeObjectConfigsToHeaders = async (
+	input: ObjectConfigs
+) => ({
+	...(await serializeObjectSsecOptionsToHeaders(input)),
+	...assignStringVariables({
+		'x-amz-server-side-encryption': input.ServerSideEncryption,
+		'x-amz-server-side-encryption-aws-kms-key-id': input.SSEKMSKeyId,
+		'x-amz-acl': input.ACL,
+		'cache-control': input.CacheControl,
+		'content-disposition': input.ContentDisposition,
+		'content-language': input.ContentLanguage,
+		'content-encoding': input.ContentEncoding,
+		'content-type': input.ContentType,
+		expires: input.Expires?.toUTCString(),
+		'x-amz-tagging': input.Tagging,
+		...serializeMetadata(input.Metadata),
+	}),
+});
+
+const serializeMetadata = (
+	metadata: Record<string, string> = {}
+): Record<string, string> =>
+	Object.keys(metadata).reduce((acc: any, suffix: string) => {
+		acc[`x-amz-meta-${suffix.toLowerCase()}`] = metadata[suffix];
+		return acc;
+	}, {});
+
+/**
+ * Serialize the object key to a URL pathname.
+ * @see https://github.com/aws/aws-sdk-js-v3/blob/7ed7101dcc4e81038b6c7f581162b959e6b33a04/clients/client-s3/src/protocols/Aws_restXml.ts#L1108
+ *
+ * @internal
+ */
+export const serializePathnameObjectKey = (url: URL, key: string) => {
+	return (
+		url.pathname.replace(/\/$/, '') +
+		`/${key.split('/').map(extendedEncodeURIComponent).join('/')}`
+	);
+};

package/src/Storage.ts

@@ -26,8 +26,8 @@ import {
 	StorageGetPropertiesConfig,
 	StorageGetPropertiesOutput,
 } from './types';
-import axios, { CancelTokenSource } from 'axios';
-import { PutObjectCommandInput } from '@aws-sdk/client-s3';
+import { PutObjectInput } from './AwsClients/S3';
+import { isCancelError } from './AwsClients/S3/utils';
 import { AWSS3UploadTask } from './providers/AWSS3UploadTask';
 
 const logger = new Logger('StorageClass');
@@ -46,11 +46,11 @@ export class Storage {
 
 	/**
 	 * Similar to the API module. This weak map allows users to cancel their in-flight request made using the Storage
-	 * module. For every get or put request, a unique cancel token will be generated and injected to it's underlying
-	 * AxiosHttpHandler. This map maintains a mapping of Request to CancelTokenSource. When .cancel is invoked, it will
-	 * attempt to retrieve it's corresponding cancelTokenSource and cancel the in-flight request.
+	 * module. For every get or put request, a unique AbortConttroller will be generated and injected to it's underlying
+	 * Xhr HTTP handler. This map maintains a mapping of Request to AbortController. When .cancel is invoked, it will
+	 * attempt to retrieve it's corresponding abortController and cancel the in-flight request.
 	 */
-	private _cancelTokenSourceMap: WeakMap<Promise<any>, CancelTokenSource>;
+	private _abortControllerMap: WeakMap<Promise<any>, AbortController>;
 
 	/**
 	 * @public
@@ -64,7 +64,7 @@ export class Storage {
 	constructor() {
 		this._config = {};
 		this._pluggables = [];
-		this._cancelTokenSourceMap = new WeakMap<Promise<any>, CancelTokenSource>();
+		this._abortControllerMap = new WeakMap<Promise<any>, AbortController>();
 		logger.debug('Storage Options', this._config);
 
 		this.get = this.get.bind(this);
@@ -139,6 +139,7 @@ export class Storage {
 			'serverSideEncryption',
 			'SSECustomerAlgorithm',
 			'SSECustomerKey',
+			// TODO(AllanZhengYP): remove in V6.
 			'SSECustomerKeyMD5',
 			'SSEKMSKeyId',
 		];
@@ -185,15 +186,15 @@ export class Storage {
 		return this._config;
 	}
 
-	private getCancellableTokenSource(): CancelTokenSource {
-		return axios.CancelToken.source();
+	private getAbortController(): AbortController {
+		return new AbortController();
 	}
 
 	private updateRequestToBeCancellable(
 		request: Promise<any>,
-		cancelTokenSource: CancelTokenSource
+		abortController: AbortController
 	) {
-		this._cancelTokenSourceMap.set(request, cancelTokenSource);
+		this._abortControllerMap.set(request, abortController);
 	}
 
 	private isUploadTask(x: unknown): x is UploadTask {
@@ -219,11 +220,13 @@ export class Storage {
 		if (request instanceof AWSS3UploadTask) {
 			return request._cancel();
 		}
-		const cancelTokenSource = this._cancelTokenSourceMap.get(
+		const abortController = this._abortControllerMap.get(
 			request as Promise<any>
 		);
-		if (cancelTokenSource) {
-			cancelTokenSource.cancel(message);
+		if (abortController) {
+			// TODO: [v6] clean up the aborted promise in the weak map.
+			// Not doing it yet to avoid breaking changes when users may abort a request twice.
+			abortController.abort(message);
 		} else {
 			logger.debug('The request does not map to any cancel token');
 		}
@@ -257,7 +260,7 @@ export class Storage {
 				'No plugin found in Storage for the provider'
 			) as StorageCopyOutput<T>;
 		}
-		const cancelTokenSource = this.getCancellableTokenSource();
+		const abortController = this.getAbortController();
 		if (typeof plugin.copy !== 'function') {
 			return Promise.reject(
 				`.copy is not implemented on provider ${plugin.getProviderName()}`
@@ -265,9 +268,9 @@ export class Storage {
 		}
 		const responsePromise = plugin.copy(src, dest, {
 			...config,
-			cancelTokenSource,
+			abortSignal: abortController.signal,
 		});
-		this.updateRequestToBeCancellable(responsePromise, cancelTokenSource);
+		this.updateRequestToBeCancellable(responsePromise, abortController);
 		return responsePromise as StorageCopyOutput<T>;
 	}
 
@@ -296,17 +299,17 @@ export class Storage {
 				'No plugin found in Storage for the provider'
 			) as StorageGetOutput<T>;
 		}
-		const cancelTokenSource = this.getCancellableTokenSource();
+		const abortController = this.getAbortController();
 		const responsePromise = plugin.get(key, {
 			...config,
-			cancelTokenSource,
+			abortSignal: abortController.signal,
 		});
-		this.updateRequestToBeCancellable(responsePromise, cancelTokenSource);
+		this.updateRequestToBeCancellable(responsePromise, abortController);
 		return responsePromise as StorageGetOutput<T>;
 	}
 
 	public isCancelError(error: any) {
-		return axios.isCancel(error);
+		return isCancelError(error);
 	}
 
 	public getProperties<T extends StorageProvider | { [key: string]: any }>(
@@ -321,7 +324,7 @@ export class Storage {
 			logger.debug('No plugin found with providerName', provider);
 			throw new Error('No plugin found with providerName');
 		}
-		const cancelTokenSource = this.getCancellableTokenSource();
+		const abortController = this.getAbortController();
 		if (typeof plugin.getProperties !== 'function') {
 			return Promise.reject(
 				`.getProperties is not implemented on provider ${plugin.getProviderName()}`
@@ -330,7 +333,7 @@ export class Storage {
 		const responsePromise = plugin?.getProperties(key, {
 			...config,
 		});
-		this.updateRequestToBeCancellable(responsePromise, cancelTokenSource);
+		this.updateRequestToBeCancellable(responsePromise, abortController);
 		return responsePromise as StorageGetPropertiesOutput<T>;
 	}
 	/**
@@ -348,7 +351,7 @@ export class Storage {
 	): StoragePutOutput<T>;
 	public put<T extends StorageProvider = AWSS3Provider>(
 		key: string,
-		object: Omit<PutObjectCommandInput['Body'], 'ReadableStream' | 'Readable'>,
+		object: Omit<PutObjectInput['Body'], 'ReadableStream' | 'Readable'>,
 		config?: StoragePutConfig<T>
 	): StoragePutOutput<T> {
 		const provider = config?.provider || DEFAULT_PROVIDER;
@@ -361,13 +364,13 @@ export class Storage {
 				'No plugin found in Storage for the provider'
 			) as StoragePutOutput<T>;
 		}
-		const cancelTokenSource = this.getCancellableTokenSource();
+		const abortController = this.getAbortController();
 		const response = plugin.put(key, object, {
 			...config,
-			cancelTokenSource,
+			abortSignal: abortController.signal,
 		});
 		if (!this.isUploadTask(response)) {
-			this.updateRequestToBeCancellable(response, cancelTokenSource);
+			this.updateRequestToBeCancellable(response, abortController);
 		}
 		return response as StoragePutOutput<T>;
 	}