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

package/src/AwsClients/S3/abortMultipartUpload.ts

@@ -0,0 +1,62 @@
+// 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 { MetadataBearer } from '@aws-sdk/types';
+import type { AbortMultipartUploadCommandInput } from './types';
+
+import { defaultConfig } from './base';
+import {
+	parseXmlError,
+	s3TransferHandler,
+	serializePathnameObjectKey,
+} from './utils';
+
+export type AbortMultipartUploadInput = Pick<
+	AbortMultipartUploadCommandInput,
+	'Bucket' | 'Key' | 'UploadId'
+>;
+
+export type AbortMultipartUploadOutput = MetadataBearer;
+
+const abortMultipartUploadSerializer = (
+	input: AbortMultipartUploadInput,
+	endpoint: Endpoint
+): HttpRequest => {
+	const url = new URL(endpoint.url.toString());
+	url.pathname = serializePathnameObjectKey(url, input.Key);
+	url.search = new URLSearchParams({
+		uploadId: input.UploadId,
+	}).toString();
+	return {
+		method: 'DELETE',
+		headers: {},
+		url,
+	};
+};
+
+const abortMultipartUploadDeserializer = async (
+	response: HttpResponse
+): Promise<AbortMultipartUploadOutput> => {
+	if (response.statusCode >= 300) {
+		const error = await parseXmlError(response);
+		throw error;
+	} else {
+		return {
+			$metadata: parseMetadata(response),
+		};
+	}
+};
+
+export const abortMultipartUpload = composeServiceApi(
+	s3TransferHandler,
+	abortMultipartUploadSerializer,
+	abortMultipartUploadDeserializer,
+	{ ...defaultConfig, responseType: 'text' }
+);

package/src/AwsClients/S3/base.ts

@@ -0,0 +1,109 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { getAmplifyUserAgent } from '@aws-amplify/core';
+import {
+	getDnsSuffix,
+	jitteredBackoff,
+	getRetryDecider,
+	EndpointResolverOptions,
+} from '@aws-amplify/core/internals/aws-client-utils';
+import { parseXmlError } from './utils';
+
+const DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
+const IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
+const DOTS_PATTERN = /\.\./;
+
+/**
+ * The service name used to sign requests if the API requires authentication.
+ */
+export const SERVICE_NAME = 's3';
+
+/**
+ * Options for endpoint resolver.
+ *
+ * @internal
+ */
+export type S3EndpointResolverOptions = EndpointResolverOptions & {
+	/**
+	 * Whether to use the S3 Transfer Acceleration endpoint.
+	 */
+	useAccelerateEndpoint?: boolean;
+	/**
+	 * Fully qualified custom endpoint for S3. If this is set, this endpoint will be used regardless of region or
+	 * useAccelerateEndpoint config.
+	 * The path of this endpoint
+	 */
+	customEndpoint?: string;
+
+	/**
+	 * Whether to force path style URLs for S3 objects (e.g., https://s3.amazonaws.com/<bucketName>/<key> instead of
+	 * https://<bucketName>.s3.amazonaws.com/<key>
+	 * @default false
+	 */
+	forcePathStyle?: boolean;
+};
+
+/**
+ * The endpoint resolver function that returns the endpoint URL for a given region, and input parameters.
+ */
+const endpointResolver = (
+	options: S3EndpointResolverOptions,
+	apiInput?: { Bucket?: string }
+) => {
+	const { region, useAccelerateEndpoint, customEndpoint, forcePathStyle } =
+		options;
+	let endpoint: URL;
+	// 1. get base endpoint
+	if (customEndpoint) {
+		endpoint = new URL(customEndpoint);
+	} else if (useAccelerateEndpoint) {
+		if (forcePathStyle) {
+			throw new Error(
+				'Path style URLs are not supported with S3 Transfer Acceleration.'
+			);
+		}
+		endpoint = new URL(`https://s3-accelerate.${getDnsSuffix(region)}`);
+	} else {
+		endpoint = new URL(`https://s3.${region}.${getDnsSuffix(region)}`);
+	}
+	// 2. inject bucket name
+	if (apiInput?.Bucket) {
+		if (!isDnsCompatibleBucketName(apiInput.Bucket)) {
+			throw new Error(`Invalid bucket name: "${apiInput.Bucket}".`);
+		}
+		if (forcePathStyle || apiInput.Bucket.includes('.')) {
+			endpoint.pathname = `/${apiInput.Bucket}`;
+		} else {
+			endpoint.host = `${apiInput.Bucket}.${endpoint.host}`;
+		}
+	}
+	return { url: endpoint };
+};
+
+/**
+ * Determines whether a given string is DNS compliant per the rules outlined by
+ * S3. Length, capitaization, and leading dot restrictions are enforced by the
+ * DOMAIN_PATTERN regular expression.
+ * @internal
+ *
+ * @see https://github.com/aws/aws-sdk-js-v3/blob/f2da6182298d4d6b02e84fb723492c07c27469a8/packages/middleware-bucket-endpoint/src/bucketHostnameUtils.ts#L39-L48
+ * @see https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html
+ */
+export const isDnsCompatibleBucketName = (bucketName: string): boolean =>
+	DOMAIN_PATTERN.test(bucketName) &&
+	!IP_ADDRESS_PATTERN.test(bucketName) &&
+	!DOTS_PATTERN.test(bucketName);
+
+/**
+ * @internal
+ */
+export const defaultConfig = {
+	service: SERVICE_NAME,
+	endpointResolver,
+	retryDecider: getRetryDecider(parseXmlError),
+	computeDelay: jitteredBackoff,
+	userAgentValue: getAmplifyUserAgent(),
+	useAccelerateEndpoint: false,
+	uriEscapePath: false, // Required by S3. See https://github.com/aws/aws-sdk-js-v3/blob/9ba012dfa3a3429aa2db0f90b3b0b3a7a31f9bc3/packages/signature-v4/src/SignatureV4.ts#L76-L83
+};

package/src/AwsClients/S3/completeMultipartUpload.ts

@@ -0,0 +1,154 @@
+// 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 type {
+	CompleteMultipartUploadCommandInput,
+	CompleteMultipartUploadCommandOutput,
+	CompletedMultipartUpload,
+	CompletedPart,
+} from './types';
+import { defaultConfig } from './base';
+import {
+	map,
+	parseXmlBody,
+	parseXmlError,
+	s3TransferHandler,
+	serializePathnameObjectKey,
+	serializeObjectSsecOptionsToHeaders,
+} from './utils';
+
+const INVALID_PARAMETER_ERROR_MSG =
+	'Invalid parameter for ComplteMultipartUpload API';
+
+export type CompleteMultipartUploadInput = Pick<
+	CompleteMultipartUploadCommandInput,
+	| 'Bucket'
+	| 'Key'
+	| 'UploadId'
+	| 'MultipartUpload'
+	| 'SSECustomerAlgorithm'
+	| 'SSECustomerKey'
+	// TODO(AllanZhengYP): remove in V6.
+	| 'SSECustomerKeyMD5'
+>;
+
+export type CompleteMultipartUploadOutput = Pick<
+	CompleteMultipartUploadCommandOutput,
+	'$metadata' | 'Key' | 'ETag' | 'Location'
+>;
+
+const completeMultipartUploadSerializer = async (
+	input: CompleteMultipartUploadInput,
+	endpoint: Endpoint
+): Promise<HttpRequest> => {
+	const headers = await serializeObjectSsecOptionsToHeaders(input);
+	headers['content-type'] = 'application/xml';
+	const url = new URL(endpoint.url.toString());
+	url.pathname = serializePathnameObjectKey(url, input.Key);
+	url.search = new URLSearchParams({ uploadId: input.UploadId }).toString();
+	return {
+		method: 'POST',
+		headers,
+		url,
+		body:
+			'<?xml version="1.0" encoding="UTF-8"?>' +
+			serializeCompletedMultipartUpload(input.MultipartUpload),
+	};
+};
+
+const serializeCompletedMultipartUpload = (
+	input: CompletedMultipartUpload
+): string => {
+	if (!input.Parts?.length) {
+		throw new Error(`${INVALID_PARAMETER_ERROR_MSG}: ${input}`);
+	}
+	return `<CompleteMultipartUpload xmlns="http://s3.amazonaws.com/doc/2006-03-01/">${input.Parts.map(
+		serializeCompletedPartList
+	).join('')}</CompleteMultipartUpload>`;
+};
+
+const serializeCompletedPartList = (input: CompletedPart): string => {
+	if (!input.ETag || input.PartNumber == null) {
+		throw new Error(`${INVALID_PARAMETER_ERROR_MSG}: ${input}`);
+	}
+	return `<Part><ETag>${input.ETag}</ETag><PartNumber>${input.PartNumber}</PartNumber></Part>`;
+};
+
+/**
+ * Parse CompleteMultipartUpload API response payload, which may be empty or error indicating internal
+ * server error, even when the status code is 200.
+ *
+ * Ref: https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html#API_CompleteMultipartUpload_Example_4
+ */
+const parseXmlBodyOrThrow = async (response: HttpResponse): Promise<any> => {
+	const parsed = await parseXmlBody(response); // Handles empty body case
+	if (parsed.Code !== undefined && parsed.Message !== undefined) {
+		const error = await parseXmlError({
+			...response,
+			statusCode: 500, // To workaround the >=300 status code check common to other APIs.
+		});
+		error.$metadata.httpStatusCode = response.statusCode;
+		throw error;
+	}
+	return parsed;
+};
+
+const completeMultipartUploadDeserializer = async (
+	response: HttpResponse
+): Promise<CompleteMultipartUploadOutput> => {
+	if (response.statusCode >= 300) {
+		const error = await parseXmlError(response);
+		throw error;
+	} else {
+		const parsed = await parseXmlBodyOrThrow(response);
+		const contents = map(parsed, {
+			ETag: 'ETag',
+			Key: 'Key',
+			Location: 'Location',
+		});
+		return {
+			$metadata: parseMetadata(response),
+			...contents,
+		};
+	}
+};
+
+// CompleteMultiPartUpload API returns 200 status code with empty body or error message.
+// This indicates internal server error after the response has been sent to the client.
+// Ref: https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html#API_CompleteMultipartUpload_Example_4
+const retryWhenErrorWith200StatusCode = async (
+	response: HttpResponse,
+	error?: Error
+): Promise<boolean> => {
+	if (response.statusCode === 200) {
+		if (!response.body) {
+			return true;
+		}
+		const parsed = await parseXmlBody(response);
+		if (parsed.Code !== undefined && parsed.Message !== undefined) {
+			return true;
+		}
+		return false;
+	}
+
+	const defaultRetryDecider = defaultConfig.retryDecider;
+	return defaultRetryDecider(response, error);
+};
+
+export const completeMultipartUpload = composeServiceApi(
+	s3TransferHandler,
+	completeMultipartUploadSerializer,
+	completeMultipartUploadDeserializer,
+	{
+		...defaultConfig,
+		responseType: 'text',
+		retryDecider: retryWhenErrorWith200StatusCode,
+	}
+);

package/src/AwsClients/S3/copyObject.ts

@@ -0,0 +1,90 @@
+// 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 { MetadataBearer } from '@aws-sdk/types';
+import type { CopyObjectCommandInput } from './types';
+import { defaultConfig } from './base';
+import {
+	assignStringVariables,
+	parseXmlBody,
+	parseXmlError,
+	s3TransferHandler,
+	serializeObjectConfigsToHeaders,
+	serializePathnameObjectKey,
+} from './utils';
+import type { S3ProviderCopyConfig } from '../../types/AWSS3Provider';
+
+/**
+ * @see {@link S3ProviderCopyConfig}
+ */
+export type CopyObjectInput = Pick<
+	CopyObjectCommandInput,
+	| 'Bucket'
+	| 'CopySource'
+	| 'Key'
+	| 'MetadataDirective'
+	| 'CacheControl'
+	| 'ContentType'
+	| 'ContentDisposition'
+	| 'ContentLanguage'
+	| 'Expires'
+	| 'ACL'
+	| 'ServerSideEncryption'
+	| 'SSECustomerAlgorithm'
+	| 'SSECustomerKey'
+	// TODO(AllanZhengYP): remove in V6.
+	| 'SSECustomerKeyMD5'
+	| 'SSEKMSKeyId'
+	| 'Tagging'
+	| 'Metadata'
+>;
+
+export type CopyObjectOutput = MetadataBearer;
+
+const copyObjectSerializer = async (
+	input: CopyObjectInput,
+	endpoint: Endpoint
+): Promise<HttpRequest> => {
+	const headers = {
+		...(await serializeObjectConfigsToHeaders(input)),
+		...assignStringVariables({
+			'x-amz-copy-source': input.CopySource,
+			'x-amz-metadata-directive': input.MetadataDirective,
+		}),
+	};
+	const url = new URL(endpoint.url.toString());
+	url.pathname = serializePathnameObjectKey(url, input.Key);
+	return {
+		method: 'PUT',
+		headers,
+		url,
+	};
+};
+
+const copyObjectDeserializer = async (
+	response: HttpResponse
+): Promise<CopyObjectOutput> => {
+	if (response.statusCode >= 300) {
+		const error = await parseXmlError(response);
+		throw error;
+	} else {
+		await parseXmlBody(response);
+		return {
+			$metadata: parseMetadata(response),
+		};
+	}
+};
+
+export const copyObject = composeServiceApi(
+	s3TransferHandler,
+	copyObjectSerializer,
+	copyObjectDeserializer,
+	{ ...defaultConfig, responseType: 'text' }
+);

package/src/AwsClients/S3/createMultipartUpload.ts

@@ -0,0 +1,75 @@
+// 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 type {
+	CreateMultipartUploadCommandInput,
+	CreateMultipartUploadCommandOutput,
+} from './types';
+import type { PutObjectInput } from './putObject';
+
+import { defaultConfig } from './base';
+import {
+	map,
+	parseXmlBody,
+	parseXmlError,
+	s3TransferHandler,
+	serializeObjectConfigsToHeaders,
+	serializePathnameObjectKey,
+} from './utils';
+
+export type CreateMultipartUploadInput = Extract<
+	CreateMultipartUploadCommandInput,
+	PutObjectInput
+>;
+
+export type CreateMultipartUploadOutput = Pick<
+	CreateMultipartUploadCommandOutput,
+	'UploadId' | '$metadata'
+>;
+
+const createMultipartUploadSerializer = async (
+	input: CreateMultipartUploadInput,
+	endpoint: Endpoint
+): Promise<HttpRequest> => {
+	const headers = await serializeObjectConfigsToHeaders(input);
+	const url = new URL(endpoint.url.toString());
+	url.pathname = serializePathnameObjectKey(url, input.Key);
+	url.search = 'uploads';
+	return {
+		method: 'POST',
+		headers,
+		url,
+	};
+};
+
+const createMultipartUploadDeserializer = async (
+	response: HttpResponse
+): Promise<CreateMultipartUploadOutput> => {
+	if (response.statusCode >= 300) {
+		const error = await parseXmlError(response);
+		throw error;
+	} else {
+		const parsed = await parseXmlBody(response);
+		const contents = map(parsed, {
+			UploadId: 'UploadId',
+		});
+		return {
+			$metadata: parseMetadata(response),
+			...contents,
+		};
+	}
+};
+
+export const createMultipartUpload = composeServiceApi(
+	s3TransferHandler,
+	createMultipartUploadSerializer,
+	createMultipartUploadDeserializer,
+	{ ...defaultConfig, responseType: 'text' }
+);

package/src/AwsClients/S3/deleteObject.ts

@@ -0,0 +1,69 @@
+// 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 type {
+	DeleteObjectCommandInput,
+	DeleteObjectCommandOutput,
+} from './types';
+
+import { defaultConfig } from './base';
+import {
+	deserializeBoolean,
+	map,
+	parseXmlError,
+	s3TransferHandler,
+	serializePathnameObjectKey,
+} from './utils';
+
+export type DeleteObjectInput = Pick<
+	DeleteObjectCommandInput,
+	'Bucket' | 'Key'
+>;
+
+export type DeleteObjectOutput = DeleteObjectCommandOutput;
+
+const deleteObjectSerializer = (
+	input: DeleteObjectInput,
+	endpoint: Endpoint
+): HttpRequest => {
+	const url = new URL(endpoint.url.toString());
+	url.pathname = serializePathnameObjectKey(url, input.Key);
+	return {
+		method: 'DELETE',
+		headers: {},
+		url,
+	};
+};
+
+const deleteObjectDeserializer = async (
+	response: HttpResponse
+): Promise<DeleteObjectOutput> => {
+	if (response.statusCode >= 300) {
+		const error = await parseXmlError(response);
+		throw error;
+	} else {
+		const content = map(response.headers, {
+			DeleteMarker: ['x-amz-delete-marker', deserializeBoolean],
+			VersionId: 'x-amz-version-id',
+			RequestCharged: 'x-amz-request-charged',
+		});
+		return {
+			...content,
+			$metadata: parseMetadata(response),
+		};
+	}
+};
+
+export const deleteObject = composeServiceApi(
+	s3TransferHandler,
+	deleteObjectSerializer,
+	deleteObjectDeserializer,
+	{ ...defaultConfig, responseType: 'text' }
+);