feat(storage): multi bucket remove

packages/amplify_core/lib/src/types/storage/remove_options.dart

@@ -1,7 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import 'package:aws_common/aws_common.dart';
+import 'package:amplify_core/amplify_core.dart';
 
 /// {@template amplify_core.storage.remove_options}
 /// Configurable options for `Amplify.Storage.remove`.
@@ -14,20 +14,25 @@ class StorageRemoveOptions
   /// {@macro amplify_core.storage.remove_options}
   const StorageRemoveOptions({
     this.pluginOptions,
+    this.bucket,
   });
 
   /// {@macro amplify_core.storage.remove_plugin_options}
   final StorageRemovePluginOptions? pluginOptions;
 
+  /// Optionally specify which bucket to target
+  final StorageBucket? bucket;
+
   @override
-  List<Object?> get props => [pluginOptions];
+  List<Object?> get props => [pluginOptions, bucket];
 
   @override
   String get runtimeTypeName => 'StorageRemoveOptions';
 
   @override
   Map<String, Object?> toJson() => {
         'pluginOptions': pluginOptions?.toJson(),
+        'bucket': bucket,
       };
 }
 

packages/storage/amplify_storage_s3/example/integration_test/remove_test.dart

@@ -64,6 +64,91 @@ void main() {
         });
       });
 
+      group('Multi-bucket', () {
+        final mainBucket = StorageBucket.fromOutputs(
+          'Storage Integ Test main bucket',
+        );
+        final secondaryBucket = StorageBucket.fromOutputs(
+          'Storage Integ Test secondary bucket',
+        );
+        final path = 'public/multi-bucket-remove-${uuid()}';
+        final storagePath = StoragePath.fromString(path);
+        setUp(() async {
+          // upload to main bucket
+          await Amplify.Storage.uploadData(
+            data: StorageDataPayload.bytes('data'.codeUnits),
+            path: storagePath,
+            bucket: mainBucket,
+          ).result;
+        });
+
+        testWidgets('removes from multiple buckets', (_) async {
+          // upload to secondary bucket
+          await Amplify.Storage.uploadData(
+            data: StorageDataPayload.bytes('data'.codeUnits),
+            path: storagePath,
+            bucket: secondaryBucket,
+          ).result;
+          expect(
+            await objectExistsInBuckets(
+              storagePath,
+              [mainBucket, secondaryBucket],
+            ),
+            true,
+          );
+
+          final mainResult = await Amplify.Storage.remove(
+            path: storagePath,
+            options: StorageRemoveOptions(bucket: mainBucket),
+          ).result;
+          expect(mainResult.removedItem.path, path);
+
+          final secondaryResult = await Amplify.Storage.remove(
+            path: storagePath,
+            options: StorageRemoveOptions(bucket: mainBucket),
+          ).result;
+          expect(secondaryResult.removedItem.path, path);
+
+          expect(
+            await objectExistsInBuckets(
+              storagePath,
+              [mainBucket, secondaryBucket],
+            ),
+            false,
+          );
+        });
+
+        testWidgets('removes when present in bucket', (_) async {
+          expect(
+            await objectExistsInBuckets(
+              storagePath,
+              [mainBucket],
+            ),
+            true,
+          );
+          final mainResult = await Amplify.Storage.remove(
+            path: storagePath,
+            options: StorageRemoveOptions(bucket: mainBucket),
+          ).result;
+          expect(mainResult.removedItem.path, path);
+          expect(
+            await objectExistsInBuckets(
+              storagePath,
+              [mainBucket],
+            ),
+            false,
+          );
+
+          await expectLater(
+            Amplify.Storage.remove(
+              path: storagePath,
+              options: StorageRemoveOptions(bucket: secondaryBucket),
+            ).result,
+            completes,
+          );
+        });
+      });
+
       testWidgets('unauthorized path', (_) async {
         await expectLater(
           () => Amplify.Storage.remove(

packages/storage/amplify_storage_s3/example/integration_test/utils/object_exists.dart

@@ -3,7 +3,29 @@ import 'package:amplify_core/amplify_core.dart';
 /// Returns true if an object exists at the given [path].
 Future<bool> objectExists(StoragePath path) async {
   try {
-    await Amplify.Storage.getProperties(path: path).result;
+    await Amplify.Storage.getProperties(
+      path: path,
+    ).result;
+    return true;
+  } on StorageNotFoundException {
+    return false;
+  }
+}
+
+/// Returns true if an object exists in multiple [buckets] at [path].
+Future<bool> objectExistsInBuckets(
+  StoragePath path,
+  List<StorageBucket> buckets,
+) async {
+  try {
+    await Future.wait(
+      buckets.map(
+        (bucket) => Amplify.Storage.getProperties(
+          path: path,
+          options: StorageGetPropertiesOptions(bucket: bucket),
+        ).result,
+      ),
+    );
     return true;
   } on StorageNotFoundException {
     return false;

packages/storage/amplify_storage_s3/example/integration_test/utils/tear_down.dart

@@ -36,6 +36,27 @@ void addTearDownPaths(List<StoragePath> paths) {
   );
 }
 
+/// Adds a tear down to remove the same object in multiple [buckets].
+void addTearDownMultiBucket(StoragePath path, List<StorageBucket> buckets) {
+  addTearDown(
+    () {
+      try {
+        return Future.wait(
+          buckets.map(
+            (bucket) => Amplify.Storage.remove(
+              path: path,
+              options: StorageRemoveOptions(bucket: bucket),
+            ).result,
+          ),
+        );
+      } on Exception catch (e) {
+        _logger.warn('Failed to remove files after test', e);
+        rethrow;
+      }
+    },
+  );
+}
+
 /// Adds a tear down to delete the current user.
 void addTearDownCurrentUser() {
   addTearDown(() {

packages/storage/amplify_storage_s3_dart/lib/src/storage_s3_service/service/storage_s3_service_impl.dart

@@ -456,11 +456,12 @@ class StorageS3Service {
     required StoragePath path,
     required StorageRemoveOptions options,
   }) async {
+    final s3ClientInfo = getS3ClientInfo(storageBucket: options.bucket);
     final resolvedPath = await _pathResolver.resolvePath(path: path);
 
     await _deleteObject(
-      s3client: _defaultS3Client,
-      bucket: _storageOutputs.bucketName,
+      s3client: s3ClientInfo.client,
+      bucket: s3ClientInfo.bucketName,
       key: resolvedPath,
     );