@scality/data-browser-library 1.1.5 → 1.1.7

package/dist/hooks/__tests__/useDeleteFolder.test.js

@@ -0,0 +1,203 @@
+import { act } from "@testing-library/react";
+import { renderHookWithWrapper } from "../../test/testUtils.js";
+import { useS3Client } from "../useS3Client.js";
+import { useDeleteFolder } from "../useDeleteFolder.js";
+jest.mock('../useS3Client');
+const mockSend = jest.fn();
+const mockUseS3Client = jest.mocked(useS3Client);
+describe('useDeleteFolder', ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockUseS3Client.mockReturnValue({
+            send: mockSend
+        });
+    });
+    it('deletes an empty folder with a single version', async ()=>{
+        mockSend.mockResolvedValueOnce({
+            Versions: [
+                {
+                    Key: 'folder/',
+                    VersionId: 'v1'
+                }
+            ],
+            DeleteMarkers: [],
+            CommonPrefixes: [],
+            IsTruncated: false
+        });
+        mockSend.mockResolvedValueOnce({
+            Deleted: [
+                {
+                    Key: 'folder/'
+                }
+            ],
+            Errors: []
+        });
+        const { result } = renderHookWithWrapper(()=>useDeleteFolder());
+        await act(()=>result.current.mutateAsync({
+                Bucket: 'my-bucket',
+                FolderKey: 'folder/'
+            }));
+        expect(mockSend).toHaveBeenCalledTimes(2);
+        const deleteCommand = mockSend.mock.calls[1][0];
+        expect(deleteCommand.input).toEqual({
+            Bucket: 'my-bucket',
+            Delete: {
+                Objects: [
+                    {
+                        Key: 'folder/',
+                        VersionId: 'v1'
+                    }
+                ]
+            }
+        });
+    });
+    it('deletes folder with multiple versions and delete markers', async ()=>{
+        mockSend.mockResolvedValueOnce({
+            Versions: [
+                {
+                    Key: 'folder/',
+                    VersionId: 'v1'
+                },
+                {
+                    Key: 'folder/',
+                    VersionId: 'v2'
+                }
+            ],
+            DeleteMarkers: [
+                {
+                    Key: 'folder/',
+                    VersionId: 'dm1'
+                }
+            ],
+            CommonPrefixes: [],
+            IsTruncated: false
+        });
+        mockSend.mockResolvedValueOnce({
+            Deleted: [],
+            Errors: []
+        });
+        const { result } = renderHookWithWrapper(()=>useDeleteFolder());
+        await act(()=>result.current.mutateAsync({
+                Bucket: 'my-bucket',
+                FolderKey: 'folder/'
+            }));
+        const deleteCommand = mockSend.mock.calls[1][0];
+        expect(deleteCommand.input.Delete.Objects).toEqual([
+            {
+                Key: 'folder/',
+                VersionId: 'v1'
+            },
+            {
+                Key: 'folder/',
+                VersionId: 'v2'
+            },
+            {
+                Key: 'folder/',
+                VersionId: 'dm1'
+            }
+        ]);
+    });
+    it('throws when folder has sub-folders (CommonPrefixes)', async ()=>{
+        mockSend.mockResolvedValueOnce({
+            Versions: [
+                {
+                    Key: 'folder/',
+                    VersionId: 'v1'
+                }
+            ],
+            DeleteMarkers: [],
+            CommonPrefixes: [
+                {
+                    Prefix: 'folder/sub/'
+                }
+            ],
+            IsTruncated: false
+        });
+        const { result } = renderHookWithWrapper(()=>useDeleteFolder());
+        await expect(act(()=>result.current.mutateAsync({
+                Bucket: 'my-bucket',
+                FolderKey: 'folder/'
+            }))).rejects.toThrow('Cannot delete folder: The folder is not empty');
+    });
+    it('throws when folder contains other objects', async ()=>{
+        mockSend.mockResolvedValueOnce({
+            Versions: [
+                {
+                    Key: 'folder/',
+                    VersionId: 'v1'
+                },
+                {
+                    Key: 'folder/file.txt',
+                    VersionId: 'v2'
+                }
+            ],
+            DeleteMarkers: [],
+            CommonPrefixes: [],
+            IsTruncated: false
+        });
+        const { result } = renderHookWithWrapper(()=>useDeleteFolder());
+        await expect(act(()=>result.current.mutateAsync({
+                Bucket: 'my-bucket',
+                FolderKey: 'folder/'
+            }))).rejects.toThrow('Cannot delete folder: The folder is not empty');
+    });
+    it('throws when ListObjectVersions response is truncated', async ()=>{
+        mockSend.mockResolvedValueOnce({
+            Versions: [
+                {
+                    Key: 'folder/',
+                    VersionId: 'v1'
+                }
+            ],
+            DeleteMarkers: [],
+            CommonPrefixes: [],
+            IsTruncated: true
+        });
+        const { result } = renderHookWithWrapper(()=>useDeleteFolder());
+        await expect(act(()=>result.current.mutateAsync({
+                Bucket: 'my-bucket',
+                FolderKey: 'folder/'
+            }))).rejects.toThrow('Cannot delete folder: The folder is not empty');
+    });
+    it('throws when DeleteObjects returns Errors', async ()=>{
+        mockSend.mockResolvedValueOnce({
+            Versions: [
+                {
+                    Key: 'folder/',
+                    VersionId: 'v1'
+                }
+            ],
+            DeleteMarkers: [],
+            CommonPrefixes: [],
+            IsTruncated: false
+        });
+        mockSend.mockResolvedValueOnce({
+            Errors: [
+                {
+                    Key: 'folder/',
+                    Code: 'AccessDenied',
+                    Message: 'Access Denied because object protected by object lock.'
+                }
+            ]
+        });
+        const { result } = renderHookWithWrapper(()=>useDeleteFolder());
+        await expect(act(()=>result.current.mutateAsync({
+                Bucket: 'my-bucket',
+                FolderKey: 'folder/'
+            }))).rejects.toThrow('Access Denied because object protected by object lock.');
+    });
+    it('does not call DeleteObjects when folder has no versions', async ()=>{
+        mockSend.mockResolvedValueOnce({
+            Versions: [],
+            DeleteMarkers: [],
+            CommonPrefixes: [],
+            IsTruncated: false
+        });
+        const { result } = renderHookWithWrapper(()=>useDeleteFolder());
+        await act(()=>result.current.mutateAsync({
+                Bucket: 'my-bucket',
+                FolderKey: 'folder/'
+            }));
+        expect(mockSend).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/hooks/index.d.ts

@@ -9,6 +9,7 @@ export { useBatchObjectLegalHold } from './useBatchObjectLegalHold';
 export { type BucketConfigEditorConfig, type BucketConfigEditorResult, useBucketConfigEditor } from './useBucketConfigEditor';
 export { useBucketLocations } from './useBucketLocations';
 export { useDeleteBucketConfigRule } from './useDeleteBucketConfigRule';
+export { useDeleteFolder } from './useDeleteFolder';
 export { useEmptyBucket } from './useEmptyBucket';
 export { useFeatures } from './useFeatures';
 export { useISVBucketStatus } from './useISVBucketDetection';

package/dist/hooks/index.js

@@ -8,6 +8,7 @@ import { useBatchObjectLegalHold } from "./useBatchObjectLegalHold.js";
 import { useBucketConfigEditor } from "./useBucketConfigEditor.js";
 import { useBucketLocations } from "./useBucketLocations.js";
 import { useDeleteBucketConfigRule } from "./useDeleteBucketConfigRule.js";
+import { useDeleteFolder } from "./useDeleteFolder.js";
 import { useEmptyBucket } from "./useEmptyBucket.js";
 import { useFeatures } from "./useFeatures.js";
 import { useISVBucketStatus } from "./useISVBucketDetection.js";
@@ -17,4 +18,4 @@ import { useS3Client } from "./useS3Client.js";
 import { useS3ConfigSwitch } from "./useS3ConfigSwitch.js";
 import { useSupportedNotificationEvents } from "./useSupportedNotificationEvents.js";
 import { useTableRowSelection } from "./useTableRowSelection.js";
-export { getAccessibleBucketsStorageKey, getLimitedAccessFlagKey, setLimitedAccessFlag, useAccessibleBuckets, useBatchObjectLegalHold, useBucketConfigEditor, useBucketLocations, useBuckets, useCopyObject, useCreateBucket, useCreateFolder, useDeleteBucket, useDeleteBucketConfigRule, useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useDeletePublicAccessBlock, useEmptyBucket, useFeatures, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketLocation, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload, useGetPublicAccessBlock, useISVBucketStatus, useIsBucketEmpty, useLimitedAccessFlow, useListMultipartUploads, useListObjectVersions, useListObjects, useLoginMutation, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, usePutPublicAccessBlock, useRestoreObject, useS3Client, useS3ConfigSwitch, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useSupportedNotificationEvents, useTableRowSelection, useUploadObjects, useValidateBucketAccess };
+export { getAccessibleBucketsStorageKey, getLimitedAccessFlagKey, setLimitedAccessFlag, useAccessibleBuckets, useBatchObjectLegalHold, useBucketConfigEditor, useBucketLocations, useBuckets, useCopyObject, useCreateBucket, useCreateFolder, useDeleteBucket, useDeleteBucketConfigRule, useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useDeleteFolder, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useDeletePublicAccessBlock, useEmptyBucket, useFeatures, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketLocation, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload, useGetPublicAccessBlock, useISVBucketStatus, useIsBucketEmpty, useLimitedAccessFlow, useListMultipartUploads, useListObjectVersions, useListObjects, useLoginMutation, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, usePutPublicAccessBlock, useRestoreObject, useS3Client, useS3ConfigSwitch, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useSupportedNotificationEvents, useTableRowSelection, useUploadObjects, useValidateBucketAccess };

package/dist/hooks/useDeleteFolder.d.ts

@@ -0,0 +1,6 @@
+interface DeleteFolderInput {
+    Bucket: string;
+    FolderKey: string;
+}
+export declare const useDeleteFolder: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<void, import("..").EnhancedS3Error, DeleteFolderInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<void, import("..").EnhancedS3Error, DeleteFolderInput>;
+export {};

package/dist/hooks/useDeleteFolder.js

@@ -0,0 +1,40 @@
+import { DeleteObjectsCommand, ListObjectVersionsCommand } from "@aws-sdk/client-s3";
+import { useCreateS3FunctionMutationHook } from "./factories/useCreateS3MutationHook.js";
+async function deleteFolder(s3Client, input) {
+    const { Bucket, FolderKey } = input;
+    const listResponse = await s3Client.send(new ListObjectVersionsCommand({
+        Bucket,
+        Prefix: FolderKey,
+        Delimiter: '/'
+    }));
+    const versions = listResponse.Versions ?? [];
+    const deleteMarkers = listResponse.DeleteMarkers ?? [];
+    const commonPrefixes = listResponse.CommonPrefixes ?? [];
+    const filteredVersions = versions.filter((v)=>v.Key === FolderKey);
+    const filteredDeleteMarkers = deleteMarkers.filter((v)=>v.Key === FolderKey);
+    if (listResponse.IsTruncated || commonPrefixes.length > 0 || filteredVersions.length + filteredDeleteMarkers.length < versions.length + deleteMarkers.length) throw new Error('Cannot delete folder: The folder is not empty');
+    const objects = [
+        ...filteredVersions.map((v)=>({
+                Key: v.Key,
+                VersionId: v.VersionId
+            })),
+        ...filteredDeleteMarkers.map((v)=>({
+                Key: v.Key,
+                VersionId: v.VersionId
+            }))
+    ];
+    if (objects.length > 0) {
+        const deleteResponse = await s3Client.send(new DeleteObjectsCommand({
+            Bucket,
+            Delete: {
+                Objects: objects
+            }
+        }));
+        if (deleteResponse.Errors && deleteResponse.Errors.length > 0) {
+            const firstError = deleteResponse.Errors[0];
+            throw new Error(firstError.Message ?? 'Failed to delete folder');
+        }
+    }
+}
+const useDeleteFolder = useCreateS3FunctionMutationHook(deleteFolder);
+export { useDeleteFolder };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scality/data-browser-library",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "A modular React component library for browsing S3 buckets and objects",
   "type": "module",
   "types": "./dist/index.d.ts",