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

package/src/AwsClients/S3/runtime/base64/index.native.ts

@@ -0,0 +1,16 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Buffer } from 'buffer';
+
+export function utf8Encode(input: string): Uint8Array {
+	return Buffer.from(input, 'utf-8');
+}
+
+export function toBase64(input: string | ArrayBufferView): string {
+	if (typeof input === 'string') {
+		return Buffer.from(input, 'utf-8').toString('base64');
+	}
+
+	return new Buffer(input.buffer).toString('base64');
+}

package/src/AwsClients/S3/runtime/constants.ts

@@ -0,0 +1,16 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export const SEND_UPLOAD_PROGRESS_EVENT = 'sendUploadProgress';
+export const SEND_DOWNLOAD_PROGRESS_EVENT = 'sendDownloadProgress';
+
+export const NETWORK_ERROR_MESSAGE = 'Network Error';
+export const NETWORK_ERROR_CODE = 'ECONNABORTED';
+
+export const ABORT_ERROR_MESSAGE = 'Request aborted';
+export const ABORT_ERROR_CODE = 'ERR_ABORTED';
+
+export const CANCELED_ERROR_MESSAGE = 'canceled';
+export const CANCELED_ERROR_CODE = 'ERR_CANCELED';
+
+export const CONTENT_SHA256_HEADER = 'x-amz-content-sha256';

package/src/AwsClients/S3/runtime/contentSha256middleware.ts

@@ -0,0 +1,29 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	HttpRequest,
+	getHashedPayload,
+	MiddlewareHandler,
+	HttpResponse,
+} from '@aws-amplify/core/internals/aws-client-utils';
+import { CONTENT_SHA256_HEADER } from './constants';
+
+/**
+ * A middleware that adds the x-amz-content-sha256 header to the request if it is not already present.
+ * It's required for S3 requests in browsers where the request body is sent in 1 chunk.
+ * @see https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-header-based-auth.html
+ *
+ * @internal
+ */
+export const contentSha256Middleware =
+	(options: {}) => (next: MiddlewareHandler<HttpRequest, HttpResponse>) =>
+		async function contentSha256Middleware(request: HttpRequest) {
+			if (request.headers[CONTENT_SHA256_HEADER]) {
+				return next(request);
+			} else {
+				const hash = await getHashedPayload(request.body);
+				request.headers[CONTENT_SHA256_HEADER] = hash;
+				return next(request);
+			}
+		};

package/src/AwsClients/S3/runtime/index.browser.ts

@@ -0,0 +1,14 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+// Entry point for browser-specific S3 client utilities. It's used where DOMParser is available.
+export {
+	SEND_DOWNLOAD_PROGRESS_EVENT,
+	SEND_UPLOAD_PROGRESS_EVENT,
+	CANCELED_ERROR_MESSAGE,
+	CONTENT_SHA256_HEADER,
+} from './constants';
+export { s3TransferHandler } from './s3TransferHandler/xhr';
+export { parser } from './xmlParser/dom';
+export { isCancelError } from './xhrTransferHandler';
+export { toBase64, utf8Encode } from './base64/index.browser';

package/src/AwsClients/S3/runtime/index.native.ts

@@ -0,0 +1,14 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+// Entry point for ReactNative-specific S3 client utilities
+export {
+	SEND_DOWNLOAD_PROGRESS_EVENT,
+	SEND_UPLOAD_PROGRESS_EVENT,
+	CANCELED_ERROR_MESSAGE,
+	CONTENT_SHA256_HEADER,
+} from './constants';
+export { s3TransferHandler } from './s3TransferHandler/xhr';
+export { parser } from './xmlParser/pureJs';
+export { isCancelError } from './xhrTransferHandler';
+export { toBase64, utf8Encode } from './base64/index.native';

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

@@ -0,0 +1,15 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+// Entry point for Node.js-specific S3 client utilities
+// This behavior is not guaranteed in v5.
+export {
+	SEND_DOWNLOAD_PROGRESS_EVENT,
+	SEND_UPLOAD_PROGRESS_EVENT,
+	CANCELED_ERROR_MESSAGE,
+	CONTENT_SHA256_HEADER,
+} from './constants';
+export { s3TransferHandler } from './s3TransferHandler/fetch';
+export { parser } from './xmlParser/pureJs';
+export { isCancelError } from './xhrTransferHandler';
+export { toBase64, utf8Encode } from './index.native';

package/src/AwsClients/S3/runtime/s3TransferHandler/fetch.ts

@@ -0,0 +1,23 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	HttpRequest,
+	HttpResponse,
+	authenticatedHandler,
+} from '@aws-amplify/core/internals/aws-client-utils';
+import type { s3TransferHandler as s3BrowserTransferhandler } from './xhr';
+import { composeTransferHandler } from '@aws-amplify/core/internals/aws-client-utils/composers';
+import { contentSha256Middleware } from '../contentSha256middleware';
+
+/**
+ * S3 transfer handler for node based on Node-fetch. On top of basic transfer handler, it also supports
+ * x-amz-content-sha256 header. However, it does not support request&response process tracking like browser.
+ *
+ * @internal
+ */
+export const s3TransferHandler: typeof s3BrowserTransferhandler =
+	composeTransferHandler<[{}], HttpRequest, HttpResponse>(
+		authenticatedHandler,
+		[contentSha256Middleware]
+	);

package/src/AwsClients/S3/runtime/s3TransferHandler/xhr.ts

@@ -0,0 +1,35 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	retryMiddleware,
+	RetryOptions,
+	signingMiddleware,
+	SigningOptions,
+	userAgentMiddleware,
+	UserAgentOptions,
+	HttpRequest,
+	HttpResponse,
+} from '@aws-amplify/core/internals/aws-client-utils';
+import { composeTransferHandler } from '@aws-amplify/core/internals/aws-client-utils/composers';
+
+import { contentSha256Middleware } from '../contentSha256middleware';
+import { xhrTransferHandler } from '../xhrTransferHandler';
+
+/**
+ * S3 transfer handler for browser and React Native based on XHR. On top of basic transfer handler, it also supports
+ * x-amz-content-sha256 header, and request&response process tracking.
+ *
+ * @internal
+ */
+export const s3TransferHandler = composeTransferHandler<
+	[{}, UserAgentOptions, RetryOptions<HttpResponse>, SigningOptions],
+	HttpRequest,
+	HttpResponse,
+	typeof xhrTransferHandler
+>(xhrTransferHandler, [
+	contentSha256Middleware,
+	userAgentMiddleware,
+	retryMiddleware,
+	signingMiddleware,
+]);

package/src/AwsClients/S3/runtime/xhrTransferHandler.ts

@@ -0,0 +1,254 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	HttpRequest,
+	HttpResponse,
+	TransferHandler,
+	ResponseBodyMixin,
+	withMemoization,
+} from '@aws-amplify/core/internals/aws-client-utils';
+import { ConsoleLogger as Logger } from '@aws-amplify/core';
+import type { EventEmitter } from 'events';
+import {
+	SEND_DOWNLOAD_PROGRESS_EVENT,
+	SEND_UPLOAD_PROGRESS_EVENT,
+	ABORT_ERROR_CODE,
+	ABORT_ERROR_MESSAGE,
+	CANCELED_ERROR_CODE,
+	CANCELED_ERROR_MESSAGE,
+	NETWORK_ERROR_CODE,
+	NETWORK_ERROR_MESSAGE,
+} from './constants';
+
+const logger = new Logger('xhr-http-handler');
+
+/**
+ * @internal
+ */
+export interface XhrTransferHandlerOptions {
+	// Expected response body type. If `blob`, the response will be returned as a Blob object. It's mainly used to
+	// download binary data. Otherwise, use `text` to return the response as a string.
+	responseType: 'text' | 'blob';
+	abortSignal?: AbortSignal;
+	emitter?: EventEmitter;
+}
+
+/**
+ * Base transfer handler implementation using XMLHttpRequest to support upload and download progress events.
+ *
+ * @param request - The request object.
+ * @param options - The request options.
+ * @returns A promise that will be resolved with the response object.
+ *
+ * @internal
+ */
+export const xhrTransferHandler: TransferHandler<
+	HttpRequest,
+	HttpResponse,
+	XhrTransferHandlerOptions
+> = (request, options): Promise<HttpResponse> => {
+	const { url, method, headers, body } = request;
+	const { emitter, responseType, abortSignal } = options;
+
+	return new Promise((resolve, reject) => {
+		let xhr: XMLHttpRequest | null = new XMLHttpRequest();
+		xhr.open(method.toUpperCase(), url.toString());
+
+		Object.entries(headers)
+			.filter(([header]) => !FORBIDDEN_HEADERS.includes(header))
+			.forEach(([header, value]) => {
+				xhr!.setRequestHeader(header, value);
+			});
+
+		xhr.responseType = responseType;
+
+		if (emitter) {
+			xhr.upload.addEventListener('progress', event => {
+				emitter.emit(SEND_UPLOAD_PROGRESS_EVENT, event);
+				logger.debug(event);
+			});
+			xhr.addEventListener('progress', event => {
+				emitter.emit(SEND_DOWNLOAD_PROGRESS_EVENT, event);
+				logger.debug(event);
+			});
+		}
+
+		xhr.addEventListener('error', () => {
+			const error = simulateAxiosError(
+				NETWORK_ERROR_MESSAGE,
+				NETWORK_ERROR_CODE,
+				xhr!,
+				options
+			);
+			logger.error(NETWORK_ERROR_MESSAGE);
+			reject(error);
+			xhr = null; // clean up request
+		});
+
+		// Handle browser request cancellation (as opposed to a manual cancellation)
+		xhr.addEventListener('abort', () => {
+			// The abort event can be triggered after the error or load event. So we need to check if the xhr is null.
+			if (!xhr || abortSignal?.aborted) return;
+			const error = simulateAxiosError(
+				ABORT_ERROR_MESSAGE,
+				ABORT_ERROR_CODE,
+				xhr,
+				options
+			);
+			logger.error(ABORT_ERROR_MESSAGE);
+			reject(error);
+			xhr = null; // clean up request
+		});
+
+		// Skip handling timeout error since we don't have a timeout
+
+		xhr.addEventListener('readystatechange', () => {
+			if (!xhr || xhr.readyState !== xhr.DONE) {
+				return;
+			}
+
+			const onloadend = () => {
+				// The load event is triggered after the error/abort/load event. So we need to check if the xhr is null.
+				if (!xhr) return;
+				const responseHeaders = convertResponseHeaders(
+					xhr.getAllResponseHeaders()
+				);
+				const responseType = xhr.responseType;
+				const responseBlob = xhr.response as Blob;
+				const responseText = responseType === 'text' ? xhr.responseText : '';
+				const bodyMixIn: ResponseBodyMixin = {
+					blob: () => Promise.resolve(responseBlob),
+					text: withMemoization(() =>
+						responseType === 'blob'
+							? readBlobAsText(responseBlob)
+							: Promise.resolve(responseText)
+					),
+					json: () =>
+						Promise.reject(
+							// S3 does not support JSON response. So fail-fast here with nicer error message.
+							new Error(
+								'Parsing response to JSON is not implemented. Please use response.text() instead.'
+							)
+						),
+				};
+				const response: HttpResponse = {
+					statusCode: xhr.status,
+					headers: responseHeaders,
+					// The xhr.responseType is only set to 'blob' for streaming binary S3 object data. The streaming data is
+					// exposed via public interface of Storage.get(). So we need to return the response as a Blob object for
+					// backward compatibility. In other cases, the response payload is only used internally, we return it is
+					// {@link ResponseBodyMixin}
+					body: (xhr.responseType === 'blob'
+						? Object.assign(responseBlob, bodyMixIn)
+						: bodyMixIn) as HttpResponse['body'],
+				};
+				resolve(response);
+				xhr = null; // clean up request
+			};
+
+			// readystate handler is calling before onerror or ontimeout handlers,
+			// so we should call onloadend on the next 'tick'
+			// @see https://github.com/axios/axios/blob/9588fcdec8aca45c3ba2f7968988a5d03f23168c/lib/adapters/xhr.js#L98-L99
+			setTimeout(onloadend);
+		});
+
+		if (abortSignal) {
+			const onCancelled = () => {
+				// The abort event is triggered after the error or load event. So we need to check if the xhr is null.
+				if (!xhr) {
+					return;
+				}
+				const canceledError = simulateAxiosCanceledError(
+					CANCELED_ERROR_MESSAGE ?? abortSignal.reason,
+					CANCELED_ERROR_CODE,
+					xhr,
+					options
+				);
+				xhr.abort();
+				reject(canceledError);
+				xhr = null;
+			};
+			abortSignal.aborted
+				? onCancelled()
+				: abortSignal.addEventListener('abort', onCancelled);
+		}
+
+		if (
+			typeof ReadableStream === 'function' &&
+			body instanceof ReadableStream
+		) {
+			// This does not matter as previous implementation uses Axios which does not support ReadableStream anyway.
+			throw new Error('ReadableStream request payload is not supported.');
+		}
+
+		xhr.send((body as Exclude<BodyInit, ReadableStream>) ?? null);
+	});
+};
+
+// TODO: V6 remove this
+const simulateAxiosError = (
+	message: string,
+	code: string,
+	request: XMLHttpRequest,
+	config: XhrTransferHandlerOptions
+) =>
+	Object.assign(new Error(message), {
+		code,
+		config,
+		request,
+	});
+
+const simulateAxiosCanceledError = (
+	message: string,
+	code: string,
+	request: XMLHttpRequest,
+	config: XhrTransferHandlerOptions
+) => {
+	const error = simulateAxiosError(message, code, request, config);
+	error.name = 'CanceledError';
+	error['__CANCEL__'] = true;
+	return error;
+};
+
+export const isCancelError = (error: unknown): boolean =>
+	!!error?.['__CANCEL__'];
+/**
+ * Convert xhr.getAllResponseHeaders() string to a Record<string, string>. Note that modern browser already returns
+ * header names in lowercase.
+ * @param xhrHeaders - string of headers returned from xhr.getAllResponseHeaders()
+ */
+const convertResponseHeaders = (xhrHeaders: string): Record<string, string> => {
+	if (!xhrHeaders) {
+		return {};
+	}
+	return xhrHeaders
+		.split('\r\n')
+		.reduce((headerMap: Record<string, string>, line: string) => {
+			const parts = line.split(': ');
+			const header = parts.shift()!;
+			const value = parts.join(': ');
+			headerMap[header.toLowerCase()] = value;
+			return headerMap;
+		}, {});
+};
+
+const readBlobAsText = (blob: Blob) => {
+	const reader = new FileReader();
+	return new Promise<string>((resolve, reject) => {
+		reader.onloadend = () => {
+			if (reader.readyState !== FileReader.DONE) {
+				return;
+			}
+			resolve(reader.result as string);
+		};
+		reader.onerror = () => {
+			reject(reader.error);
+		};
+		reader.readAsText(blob);
+	});
+};
+
+// To add more forbidden headers as found set by S3. Intentionally NOT list all of them here to save bundle size.
+// https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name
+const FORBIDDEN_HEADERS = ['host'];

package/src/AwsClients/S3/runtime/xmlParser/dom.ts

@@ -0,0 +1,92 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Drop-in replacement for fast-xml-parser's XmlParser class used in the AWS SDK S3 client XML deserializer. This
+ * implementation is not tested against the full xml conformance test suite. It is only tested against the XML responses
+ * from S3. This implementation requires the `DOMParser` class in the runtime.
+ */
+export const parser = {
+	parse: (xmlStr: string): any => {
+		const domParser = new DOMParser();
+		const xml = domParser.parseFromString(xmlStr, 'text/xml');
+		const parsedObj = parseXmlNode(xml);
+		const rootKey = Object.keys(parsedObj)[0];
+		return parsedObj[rootKey];
+	},
+};
+
+const parseXmlNode = (node: Node): any => {
+	if (isDocumentNode(node)) {
+		return {
+			[node.documentElement.nodeName]: parseXmlNode(node.documentElement),
+		};
+	}
+
+	if (node.nodeType === Node.TEXT_NODE) {
+		return node.nodeValue?.trim();
+	}
+
+	if (isElementNode(node)) {
+		// Node like <Location>foo</Location> will be converted to { Location: 'foo' }
+		// instead of { Location: { '#text': 'foo' } }.
+		if (isTextOnlyElementNode(node)) {
+			return node.childNodes[0]?.nodeValue!;
+		}
+
+		const nodeValue = {};
+		// convert attributes
+		for (let i = 0; i < node.attributes.length; i++) {
+			const attr = node.attributes[i];
+			if (!isNamespaceAttributeName(attr.nodeName)) {
+				nodeValue[attr.nodeName] = attr.nodeValue!;
+			}
+		}
+
+		// convert child nodes
+		if (node.children.length > 0) {
+			for (let i = 0; i < node.children.length; i++) {
+				const child = node.children[i];
+				const childValue = parseXmlNode(child);
+				if (childValue === undefined) {
+					continue;
+				}
+				const childName = child.nodeName;
+				if (nodeValue[childName] === undefined) {
+					nodeValue[childName] = childValue;
+				} else if (Array.isArray(nodeValue[childName])) {
+					nodeValue[childName].push(childValue);
+				} else {
+					nodeValue[childName] = [nodeValue[childName], childValue];
+				}
+			}
+		}
+
+		// Return empty element node as empty string instead of `{}`, which is the default behavior of fast-xml-parser.
+		return Object.keys(nodeValue).length === 0 ? '' : nodeValue;
+	}
+};
+
+const isElementNode = (node: Node): node is Element =>
+	node.nodeType === Node.ELEMENT_NODE;
+
+const isDocumentNode = (node: Node): node is Document =>
+	node.nodeType === Node.DOCUMENT_NODE;
+
+const isTextOnlyElementNode = (node: Element): boolean =>
+	hasOnlyNamespaceAttributes(node) &&
+	node.children.length === 0 &&
+	node.firstChild?.nodeType === Node.TEXT_NODE;
+
+const hasOnlyNamespaceAttributes = (node: Element): boolean => {
+	for (let i = 0; i < node.attributes.length; i++) {
+		const attr = node.attributes[i];
+		if (!isNamespaceAttributeName(attr.nodeName)) {
+			return false;
+		}
+	}
+	return true;
+};
+
+const isNamespaceAttributeName = (name: string): boolean =>
+	name === 'xmlns' || name.startsWith('xmlns:');

package/src/AwsClients/S3/runtime/xmlParser/pureJs.ts

@@ -0,0 +1,55 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { XMLParser } from 'fast-xml-parser';
+
+/**
+ * Pure JS XML parser that can be used in Non-browser environments, like React Native and Node.js. This is the same
+ * XML parser implementation as used in AWS SDK S3 client. It depends on pure JavaScript XML parser library
+ * `fast-xml-parser`.
+ *
+ * Ref: https://github.com/aws/aws-sdk-js-v3/blob/1e806ba3f4a83c9e3eb0b41a3a7092da93826b8f/clients/client-s3/src/protocols/Aws_restXml.ts#L12938-L12959
+ */
+export const parser = {
+	parse: (xmlStr: string): any => {
+		const parser = new XMLParser({
+			attributeNamePrefix: '',
+			htmlEntities: true,
+			ignoreAttributes: false,
+			ignoreDeclaration: true,
+			parseTagValue: false,
+			trimValues: false,
+			removeNSPrefix: true,
+			tagValueProcessor: (_, val) =>
+				val.trim() === '' && val.includes('\n') ? '' : undefined,
+		});
+		parser.addEntity('#xD', '\r');
+		parser.addEntity('#10', '\n');
+		const parsedObj = parser.parse(xmlStr);
+		const textNodeName = '#text';
+		const key = Object.keys(parsedObj)[0];
+		const parsedObjToReturn = parsedObj[key];
+		if (parsedObjToReturn[textNodeName]) {
+			parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
+			delete parsedObjToReturn[textNodeName];
+		}
+		return getValueFromTextNode(parsedObjToReturn);
+	},
+};
+
+/**
+ * Recursively parses object and populates value is node from "#text" key if it's available
+ *
+ * Ref: https://github.com/aws/aws-sdk-js-v3/blob/6b4bde6f338720abf28b931f8a4506613bd64d3f/packages/smithy-client/src/get-value-from-text-node.ts#L1
+ */
+const getValueFromTextNode = (obj: any) => {
+	const textNodeName = '#text';
+	for (const key in obj) {
+		if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== undefined) {
+			obj[key] = obj[key][textNodeName];
+		} else if (typeof obj[key] === 'object' && obj[key] !== null) {
+			obj[key] = getValueFromTextNode(obj[key]);
+		}
+	}
+	return obj;
+};