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

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'