@aws-amplify/storage 6.11.2-unstable.a361dd1.0 → 6.12.0

package/src/providers/s3/utils/client/s3data/deleteObjects.ts

@@ -0,0 +1,122 @@
+// 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 {
+	AmplifyUrl,
+	AmplifyUrlSearchParams,
+} from '@aws-amplify/core/internals/utils';
+import { composeServiceApi } from '@aws-amplify/core/internals/aws-client-utils/composers';
+
+import {
+	assignStringVariables,
+	buildStorageServiceError,
+	s3TransferHandler,
+	validateS3RequiredParameter,
+} from '../utils';
+import { generateDeleteObjectsXml } from '../../generateDeleteObjectsXml';
+import { calculateContentMd5 } from '../../md5';
+
+import type {
+	DeleteObjectsCommandInput,
+	DeleteObjectsCommandOutput,
+} from './types';
+import { defaultConfig, parseXmlError } from './base';
+
+export type DeleteObjectsInput = Pick<
+	DeleteObjectsCommandInput,
+	'Bucket' | 'Delete' | 'ExpectedBucketOwner'
+> & {
+	ContentMD5?: string;
+};
+
+export type DeleteObjectsOutput = DeleteObjectsCommandOutput;
+
+const deleteObjectsSerializer = async (
+	input: DeleteObjectsInput,
+	endpoint: Endpoint,
+): Promise<HttpRequest> => {
+	const url = new AmplifyUrl(endpoint.url.toString());
+	validateS3RequiredParameter(!!input.Delete, 'Delete');
+	url.pathname = '/';
+	url.search = new AmplifyUrlSearchParams({
+		delete: '',
+	}).toString();
+
+	const body = generateDeleteObjectsXml(
+		input.Delete!.Objects,
+		input.Delete!.Quiet ?? false,
+	);
+
+	const contentMd5 = input.ContentMD5 ?? (await calculateContentMd5(body));
+
+	const headers = assignStringVariables({
+		'x-amz-expected-bucket-owner': input.ExpectedBucketOwner,
+		'content-type': 'application/xml',
+		'content-md5': contentMd5,
+	});
+
+	const request = {
+		method: 'POST',
+		headers,
+		url,
+		body,
+	};
+
+	return request;
+};
+
+const deleteObjectsDeserializer = async (
+	response: HttpResponse,
+): Promise<DeleteObjectsOutput> => {
+	if (response.statusCode >= 300) {
+		const error = await parseXmlError(response);
+		throw buildStorageServiceError(error!);
+	}
+
+	const text = await response.body.text();
+
+	const deleted: { Key?: string }[] = [];
+	const errors: { Key?: string; Code?: string; Message?: string }[] = [];
+
+	const deletedMatches = text.matchAll(/<Deleted>[\s\S]*?<\/Deleted>/g);
+	for (const match of deletedMatches) {
+		const keyMatch = match[0].match(/<Key>(.*?)<\/Key>/);
+		if (keyMatch) {
+			deleted.push({ Key: keyMatch[1] });
+		}
+	}
+
+	const errorMatches = text.matchAll(/<Error>[\s\S]*?<\/Error>/g);
+	for (const match of errorMatches) {
+		const keyMatch = match[0].match(/<Key>(.*?)<\/Key>/);
+		const codeMatch = match[0].match(/<Code>(.*?)<\/Code>/);
+		const messageMatch = match[0].match(/<Message>(.*?)<\/Message>/);
+
+		errors.push({
+			Key: keyMatch?.[1],
+			Code: codeMatch?.[1],
+			Message: messageMatch?.[1],
+		});
+	}
+
+	const result = {
+		Deleted: deleted,
+		Errors: errors,
+		$metadata: parseMetadata(response),
+	};
+
+	return result;
+};
+
+export const deleteObjects = composeServiceApi(
+	s3TransferHandler,
+	deleteObjectsSerializer,
+	deleteObjectsDeserializer,
+	{ ...defaultConfig, responseType: 'text' },
+);

package/src/providers/s3/utils/client/s3data/index.ts

@@ -38,4 +38,9 @@ export {
 	DeleteObjectInput,
 	DeleteObjectOutput,
 } from './deleteObject';
+export {
+	deleteObjects,
+	DeleteObjectsInput,
+	DeleteObjectsOutput,
+} from './deleteObjects';
 export { CompletedPart, Part, _Object } from './types';

package/src/providers/s3/utils/client/s3data/types.ts

@@ -5452,4 +5452,24 @@ export type StorageClass = (typeof StorageClass)[keyof typeof StorageClass];
 export type TaggingDirective =
 	(typeof TaggingDirective)[keyof typeof TaggingDirective];
 
+/**
+ * @public
+ */
+export interface DeleteObjectsCommandInput {
+	Bucket: string;
+	Delete: {
+		Objects: Array<{ Key: string }>;
+		Quiet?: boolean;
+	};
+	ExpectedBucketOwner?: string;
+}
+
+/**
+ * @public
+ */
+export interface DeleteObjectsCommandOutput extends __MetadataBearer {
+	Deleted?: Array<{ Key?: string }>;
+	Errors?: Array<{ Key?: string; Code?: string; Message?: string }>;
+}
+
 export {};

package/src/providers/s3/utils/createAbortableTask.ts

@@ -0,0 +1,45 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { NonPausableTransferTask } from '../../../types/common';
+
+export function createAbortableTask<T>(
+	executor: (abortController: AbortController) => Promise<T>,
+): NonPausableTransferTask<T> & {
+	then: Promise<T>['then'];
+	catch: Promise<T>['catch'];
+	finally: Promise<T>['finally'];
+} {
+	const abortController = new AbortController();
+	let state: NonPausableTransferTask<T>['state'] = 'IN_PROGRESS';
+
+	const resultPromise = executor(abortController);
+
+	const wrappedPromise = resultPromise
+		.then(result => {
+			state = 'SUCCESS';
+
+			return result;
+		})
+		.catch(error => {
+			state = abortController.signal.aborted ? 'CANCELED' : 'ERROR';
+
+			throw error;
+		});
+
+	const operation = {
+		result: wrappedPromise,
+		cancel: () => {
+			abortController.abort();
+			state = 'CANCELED';
+		},
+		get state() {
+			return state;
+		},
+		then: wrappedPromise.then.bind(wrappedPromise),
+		catch: wrappedPromise.catch.bind(wrappedPromise),
+		finally: wrappedPromise.finally.bind(wrappedPromise),
+	};
+
+	return operation;
+}

package/src/providers/s3/utils/deleteFolderContents.ts

@@ -0,0 +1,118 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { StorageAction } from '@aws-amplify/core/internals/utils';
+
+import { CanceledError } from '../../../errors/CanceledError';
+import { ProgressInfo, RemoveWithPathOutput } from '../types';
+
+import { deleteObjects, listObjectsV2 } from './client/s3data';
+import { getStorageUserAgentValue } from './userAgent';
+
+const MAX_KEYS_PER_BATCH = 1000;
+
+export interface DeleteFolderContentsParams {
+	s3Config: any;
+	bucket: string;
+	folderKey: string;
+	expectedBucketOwner?: string;
+	onProgress?(progress: ProgressInfo): void;
+	abortSignal?: AbortSignal;
+}
+
+/**
+ * Deletes all contents of a folder in S3 using batch operations
+ *
+ * @param params - Configuration object for the delete operation
+ * @returns Promise that resolves to the removal result
+ */
+export const deleteFolderContents = async (
+	params: DeleteFolderContentsParams,
+): Promise<RemoveWithPathOutput> => {
+	const {
+		s3Config,
+		bucket,
+		folderKey,
+		expectedBucketOwner,
+		onProgress,
+		abortSignal,
+	} = params;
+
+	try {
+		const prefix = folderKey.endsWith('/') ? folderKey : `${folderKey}/`;
+		const progressCallback =
+			onProgress ??
+			(() => {
+				// no-op
+			});
+
+		let continuationToken: string | undefined;
+
+		do {
+			if (abortSignal?.aborted) {
+				throw new CanceledError({ message: 'Operation was canceled' });
+			}
+
+			const listResult = await listObjectsV2(
+				{
+					...s3Config,
+					userAgentValue: getStorageUserAgentValue(StorageAction.Remove),
+					abortSignal,
+				},
+				{
+					Bucket: bucket,
+					Prefix: prefix,
+					MaxKeys: MAX_KEYS_PER_BATCH,
+					ContinuationToken: continuationToken,
+					ExpectedBucketOwner: expectedBucketOwner,
+				},
+			);
+
+			if (!listResult.Contents || listResult.Contents.length === 0) {
+				break;
+			}
+
+			if (abortSignal?.aborted) {
+				throw new CanceledError({ message: 'Operation was canceled' });
+			}
+
+			const batch = listResult.Contents.map(obj => ({ Key: obj.Key! }));
+
+			const deleteResult = await deleteObjects(
+				{
+					...s3Config,
+					userAgentValue: getStorageUserAgentValue(StorageAction.Remove),
+					abortSignal,
+				},
+				{
+					Bucket: bucket,
+					Delete: {
+						Objects: batch,
+						Quiet: false,
+					},
+					ExpectedBucketOwner: expectedBucketOwner,
+				},
+			);
+
+			const deleted =
+				deleteResult.Deleted?.map(obj => ({ path: obj.Key! })) || [];
+			const failed =
+				deleteResult.Errors?.map(err => ({
+					path: err.Key!,
+					code: err.Code!,
+					message: err.Message!,
+				})) || [];
+
+			progressCallback({ deleted, failed });
+
+			continuationToken = listResult.NextContinuationToken;
+		} while (continuationToken);
+
+		return { path: folderKey };
+	} catch (error) {
+		if (abortSignal?.aborted) {
+			throw new CanceledError({ message: 'Operation was canceled' });
+		}
+		throw error;
+	}
+};

package/src/providers/s3/utils/generateDeleteObjectsXml.ts

@@ -0,0 +1,38 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Escapes special XML characters in a string
+ * @param str - String to escape
+ * @returns XML-escaped string
+ */
+const escapeXml = (str: string): string => {
+	return str
+		.replace(/&/g, '&')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;')
+		.replace(/'/g, '&apos;');
+};
+
+/**
+ * Generates XML for S3 batch delete operations
+ *
+ * @param objects - Array of objects to delete with their keys
+ * @param quiet - Whether to use quiet mode (default: true)
+ * @returns XML string for the delete request
+ */
+export const generateDeleteObjectsXml = (
+	objects: { Key: string }[],
+	quiet: boolean,
+): string => {
+	const objectsXml = objects
+		.map(obj => `<Object><Key>${escapeXml(obj.Key)}</Key></Object>`)
+		.join('');
+
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<Delete xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+	<Quiet>${quiet ? 'true' : 'false'}</Quiet>
+	${objectsXml}
+</Delete>`;
+};

package/src/providers/s3/utils/index.ts

@@ -2,10 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export { calculateContentMd5 } from './md5';
+export { deleteFolderContents } from './deleteFolderContents';
+export { generateDeleteObjectsXml } from './generateDeleteObjectsXml';
 export { resolveS3ConfigAndInput } from './resolveS3ConfigAndInput';
+export { resolveFinalKey } from './resolveFinalKey';
 export { createDownloadTask, createUploadTask } from './transferTask';
 export { validateBucketOwnerID } from './validateBucketOwnerID';
+export { validateRemovePath } from './validateRemovePath';
 export { validateStorageOperationInput } from './validateStorageOperationInput';
 export { validateStorageOperationInputWithPrefix } from './validateStorageOperationInputWithPrefix';
 export { isInputWithPath } from './isInputWithPath';
+export { isPathFolder } from './isPathFolder';
 export { urlDecode } from './urlDecoder';
+export { createAbortableTask } from './createAbortableTask';

package/src/providers/s3/utils/isPathFolder.ts

@@ -0,0 +1,50 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { StorageAction } from '@aws-amplify/core/internals/utils';
+
+import { listObjectsV2 } from './client/s3data';
+import { getStorageUserAgentValue } from './userAgent';
+
+export interface IsPathFolderParams {
+	s3Config: any;
+	bucket: string;
+	key: string;
+	expectedBucketOwner?: string;
+}
+
+/**
+ * Determines if a given S3 key represents a folder by checking if objects exist with that prefix.
+ *
+ * @param params - Configuration object for the folder check
+ * @returns Promise that resolves to true if the key represents a folder, false otherwise
+ */
+export const isPathFolder = async (
+	params: IsPathFolderParams,
+): Promise<boolean> => {
+	const { s3Config, bucket, key, expectedBucketOwner } = params;
+	try {
+		const prefix = key.endsWith('/') ? key : `${key}/`;
+
+		const result = await listObjectsV2(
+			{
+				...s3Config,
+				userAgentValue: getStorageUserAgentValue(StorageAction.Remove),
+			},
+			{
+				Bucket: bucket,
+				Prefix: prefix,
+				MaxKeys: 1,
+				ExpectedBucketOwner: expectedBucketOwner,
+			},
+		);
+
+		const isFolder =
+			!!(result.Contents && result.Contents.length > 0) ||
+			!!(result.CommonPrefixes && result.CommonPrefixes.length > 0);
+
+		return isFolder;
+	} catch (error) {
+		return false;
+	}
+};

package/src/providers/s3/utils/resolveFinalKey.ts

@@ -0,0 +1,22 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { STORAGE_INPUT_KEY } from './constants';
+
+/**
+ * Resolves the final S3 key based on input type and key prefix.
+ *
+ * @param inputType - The type of input (key-based or path-based)
+ * @param objectKey - The object key from the input
+ * @param keyPrefix - The key prefix to prepend for key-based inputs
+ * @returns The final S3 key to use for the operation
+ */
+export const resolveFinalKey = (
+	inputType: string,
+	objectKey: string,
+	keyPrefix: string,
+): string => {
+	return inputType === STORAGE_INPUT_KEY
+		? `${keyPrefix}${objectKey}`
+		: objectKey;
+};

package/src/providers/s3/utils/validateRemovePath.ts

@@ -0,0 +1,16 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validates that the path is safe for removal operations.
+ * Prevents deletion of dangerous paths that could affect entire buckets.
+ *
+ * @param path - The path to validate
+ * @throws Error if the path is considered dangerous
+ */
+export const validateRemovePath = (path: string): void => {
+	const DANGEROUS_PATHS = ['', '/', '*'];
+	if (DANGEROUS_PATHS.includes(path.trim())) {
+		throw new Error('Cannot delete root or bucket-wide paths');
+	}
+};

package/src/types/common.ts

@@ -49,6 +49,11 @@ export interface TransferTask<Result> {
 	result: Promise<Result>;
 }
 
+export interface NonPausableTransferTask<T>
+	extends Omit<TransferTask<T>, 'pause' | 'resume' | 'state'> {
+	state: Omit<TransferTask<T>['state'], 'PAUSED'>;
+}
+
 export type DownloadTask<Result> = Omit<
 	TransferTask<Result>,
 	'pause' | 'resume'