@scality/data-browser-library 1.1.9 → 1.1.11

package/dist/components/objects/GetPresignedUrlButton.js

@@ -62,7 +62,7 @@ const GetPresignedUrlButton = ({ bucketName, objectKey, versionId })=>{
         } catch (error) {
             showToast({
                 open: true,
-                message: error instanceof Error ? error.message : 'Failed to generate presigned URL',
+                message: error instanceof Error ? error.message : 'Unknown error',
                 status: 'error'
             });
         }

package/dist/components/objects/ObjectDetails/ObjectMetadata.js

@@ -160,7 +160,7 @@ const ObjectMetadata = ({ bucketName, objectKey, versionId })=>{
                 status: 'success'
             });
         } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Failed to save metadata';
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
             showToast({
                 open: true,
                 message: errorMessage,

package/dist/components/objects/ObjectDetails/ObjectSummary.js

@@ -106,7 +106,7 @@ const ObjectSummary = ({ bucketName, objectKey, versionId })=>{
             onError: (error)=>{
                 showToast({
                     open: true,
-                    message: error instanceof Error ? error.message : 'Failed to update legal hold',
+                    message: error.message,
                     status: 'error'
                 });
             }
@@ -138,7 +138,7 @@ const ObjectSummary = ({ bucketName, objectKey, versionId })=>{
             onError: (error)=>{
                 showToast({
                     open: true,
-                    message: error instanceof Error ? error.message : 'Failed to update object visibility',
+                    message: error.message,
                     status: 'error'
                 });
             }

package/dist/components/objects/ObjectDetails/ObjectTags.js

@@ -108,7 +108,7 @@ const ObjectTags = ({ bucketName, objectKey, versionId })=>{
                 status: 'success'
             });
         } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Failed to save tags';
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
             showToast({
                 open: true,
                 message: errorMessage,

package/dist/components/objects/ObjectDetails/__tests__/ObjectSummary.test.js

@@ -6,6 +6,7 @@ import user_event from "@testing-library/user-event";
 import { DataBrowserUICustomizationProvider } from "../../../../contexts/DataBrowserUICustomizationContext.js";
 import { useGetPresignedDownload, useGetPublicAccessBlock, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useSetObjectAcl, useSetObjectLegalHold } from "../../../../hooks/index.js";
 import { findToggleByLabel } from "../../../../test/testUtils.js";
+import { EnhancedS3Error, ErrorCategory } from "../../../../utils/errorHandling.js";
 import { ObjectSummary } from "../ObjectSummary.js";
 jest.mock('../../../../hooks');
 jest.mock('@scality/core-ui', ()=>{
@@ -663,6 +664,41 @@ describe('ObjectSummary', ()=>{
                 });
             });
         });
+        it('should show permission message when mutation fails with 403 error', async ()=>{
+            const user = user_event.setup();
+            const mockShowToast = jest.fn();
+            const authError = new EnhancedS3Error("You don't have permission to update legal hold. Contact your administrator.", 'AccessDenied', ErrorCategory.AUTHORIZATION, new Error('Access Denied'), 403);
+            const mockMutate = jest.fn((_params, callbacks)=>{
+                callbacks.onError(authError);
+            });
+            mockUseToast.mockReturnValue({
+                showToast: mockShowToast
+            });
+            mockUseObjectRetention.mockReturnValueOnce({
+                data: mockRetentionData,
+                status: 'success'
+            });
+            mockUseObjectLegalHold.mockReturnValueOnce({
+                data: mockLegalHoldData,
+                status: 'success'
+            });
+            mockUseSetObjectLegalHold.mockReturnValueOnce({
+                mutate: mockMutate,
+                isPending: false
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = getLegalHoldToggle();
+            await user.click(toggle);
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: "You don't have permission to update legal hold. Contact your administrator.",
+                    status: 'error'
+                });
+            });
+        });
         it('should show generic error message when mutation fails with non-Error object', async ()=>{
             const user = user_event.setup();
             const mockShowToast = jest.fn();
@@ -694,7 +730,7 @@ describe('ObjectSummary', ()=>{
             await waitFor(()=>{
                 expect(mockShowToast).toHaveBeenCalledWith({
                     open: true,
-                    message: 'Failed to update legal hold',
+                    message: 'Custom error',
                     status: 'error'
                 });
             });

package/dist/components/objects/ObjectLock/ObjectLockSettings.js

@@ -102,7 +102,7 @@ function ObjectLockSettings() {
                 navigate(`/buckets/${bucketName}`);
             },
             onError: (error)=>{
-                const errorMessage = error instanceof Error ? error.message : 'Failed to save Object Lock settings';
+                const errorMessage = error.message;
                 showToast({
                     open: true,
                     message: errorMessage,

package/dist/components/objects/__tests__/GetPresignedUrlButton.test.js

@@ -4,6 +4,7 @@ import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { cleanup, render, screen, waitFor } from "@testing-library/react";
 import user_event from "@testing-library/user-event";
 import { useGetPresignedDownload } from "../../../hooks/index.js";
+import { EnhancedS3Error, ErrorCategory } from "../../../utils/errorHandling.js";
 import { GetPresignedUrlButton } from "../GetPresignedUrlButton.js";
 jest.mock('../../../hooks');
 jest.mock('@scality/core-ui', ()=>{
@@ -462,6 +463,34 @@ describe('GetPresignedUrlButton', ()=>{
                 });
             });
         });
+        it('should show permission message for 403 errors', async ()=>{
+            const mockShowToast = jest.fn();
+            mockUseToast.mockReturnValue({
+                showToast: mockShowToast
+            });
+            const authError = new EnhancedS3Error("You don't have permission to generate the presigned URL. Contact your administrator.", 'AccessDenied', ErrorCategory.AUTHORIZATION, new Error('Access Denied'), 403);
+            mockUseGetPresignedDownload.mockReturnValue({
+                mutateAsync: jest.fn().mockRejectedValue(authError),
+                isPending: false
+            });
+            const user = user_event.setup();
+            renderWithProviders(/*#__PURE__*/ jsx(GetPresignedUrlButton, {
+                ...defaultProps
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /get pre-signed url/i
+            }));
+            await user.click(screen.getByRole('button', {
+                name: /generate a pre-signed url/i
+            }));
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: "You don't have permission to generate the presigned URL. Contact your administrator.",
+                    status: 'error'
+                });
+            });
+        });
         it('should show generic toast for non-Error failures', async ()=>{
             const mockShowToast = jest.fn();
             mockUseToast.mockReturnValue({
@@ -484,7 +513,7 @@ describe('GetPresignedUrlButton', ()=>{
             await waitFor(()=>{
                 expect(mockShowToast).toHaveBeenCalledWith({
                     open: true,
-                    message: 'Failed to generate presigned URL',
+                    message: 'Unknown error',
                     status: 'error'
                 });
             });

package/dist/components/providers/QueryProvider.js

@@ -1,11 +1,12 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { ReactQueryDevtools } from "@tanstack/react-query-devtools";
+import { shouldRetryError } from "../../utils/errorHandling.js";
 const defaultQueryClient = new QueryClient({
     defaultOptions: {
         queries: {
             staleTime: 300000,
-            retry: 2
+            retry: (failureCount, error)=>shouldRetryError(error, failureCount, 2)
         }
     }
 });

package/dist/hooks/bucketConfiguration.js

@@ -5,40 +5,40 @@ const useGetBucketAcl = useCreateS3QueryHook(GetBucketAclCommand, 'GetBucketAcl'
 const useSetBucketAcl = useCreateS3MutationHook(PutBucketAclCommand, 'PutBucketAcl', [
     'GetBucketAcl',
     'ListBuckets'
-]);
-const useGetBucketPolicy = useCreateS3QueryHook(GetBucketPolicyCommand, 'GetBucketPolicy');
+], 'update bucket visibility');
+const useGetBucketPolicy = useCreateS3QueryHook(GetBucketPolicyCommand, 'GetBucketPolicy', 'load the bucket policy');
 const useSetBucketPolicy = useCreateS3MutationHook(PutBucketPolicyCommand, 'PutBucketPolicy', [
     'GetBucketPolicy',
     'ListBuckets'
-]);
+], 'save the bucket policy');
 const useDeleteBucketPolicy = useCreateS3MutationHook(DeleteBucketPolicyCommand, 'DeleteBucketPolicy', [
     'GetBucketPolicy'
-]);
+], 'delete the bucket policy');
 const useGetBucketVersioning = useCreateS3QueryHook(GetBucketVersioningCommand, 'GetBucketVersioning');
 const useSetBucketVersioning = useCreateS3MutationHook(PutBucketVersioningCommand, 'PutBucketVersioning', [
     'GetBucketVersioning'
-]);
-const useGetBucketCors = useCreateS3QueryHook(GetBucketCorsCommand, 'GetBucketCors');
+], 'update bucket versioning');
+const useGetBucketCors = useCreateS3QueryHook(GetBucketCorsCommand, 'GetBucketCors', 'load CORS configuration');
 const useSetBucketCors = useCreateS3MutationHook(PutBucketCorsCommand, 'PutBucketCors', [
     'GetBucketCors',
     'ListBuckets'
-]);
+], 'save the CORS configuration');
 const useDeleteBucketCors = useCreateS3MutationHook(DeleteBucketCorsCommand, 'DeleteBucketCors', [
     'GetBucketCors'
-]);
+], 'delete the CORS rule');
 const useGetBucketLifecycle = useCreateS3QueryHook(GetBucketLifecycleConfigurationCommand, 'GetBucketLifecycleConfiguration');
 const useSetBucketLifecycle = useCreateS3MutationHook(PutBucketLifecycleConfigurationCommand, 'PutBucketLifecycleConfiguration', [
     'GetBucketLifecycleConfiguration',
     'ListBuckets'
-]);
+], 'save the lifecycle rule');
 const useDeleteBucketLifecycle = useCreateS3MutationHook(DeleteBucketLifecycleCommand, 'DeleteBucketLifecycle', [
     'GetBucketLifecycleConfiguration'
-]);
-const useGetBucketNotification = useCreateS3QueryHook(GetBucketNotificationConfigurationCommand, 'GetBucketNotificationConfiguration');
+], 'delete the lifecycle rule');
+const useGetBucketNotification = useCreateS3QueryHook(GetBucketNotificationConfigurationCommand, 'GetBucketNotificationConfiguration', 'load the notification configuration');
 const useSetBucketNotification = useCreateS3MutationHook(PutBucketNotificationConfigurationCommand, 'PutBucketNotificationConfiguration', [
     'GetBucketNotificationConfiguration',
     'ListBuckets'
-]);
+], 'save the notification configuration');
 const useGetBucketEncryption = useCreateS3QueryHook(GetBucketEncryptionCommand, 'GetBucketEncryption');
 const useSetBucketEncryption = useCreateS3MutationHook(PutBucketEncryptionCommand, 'PutBucketEncryption', [
     'GetBucketEncryption',
@@ -55,15 +55,15 @@ const useDeleteBucketTagging = useCreateS3MutationHook(DeleteBucketTaggingComman
 const useGetBucketObjectLockConfiguration = useCreateS3QueryHook(GetObjectLockConfigurationCommand, 'GetObjectLockConfiguration');
 const useSetBucketObjectLockConfiguration = useCreateS3MutationHook(PutObjectLockConfigurationCommand, 'PutObjectLockConfiguration', [
     'GetObjectLockConfiguration'
-]);
+], 'save Object Lock settings');
 const useGetBucketReplication = useCreateS3QueryHook(GetBucketReplicationCommand, 'GetBucketReplication');
 const useSetBucketReplication = useCreateS3MutationHook(PutBucketReplicationCommand, 'PutBucketReplication', [
     'GetBucketReplication',
     'ListBuckets'
-]);
+], 'save the replication rule');
 const useDeleteBucketReplication = useCreateS3MutationHook(DeleteBucketReplicationCommand, 'DeleteBucketReplication', [
     'GetBucketReplication'
-]);
+], 'delete the replication rule');
 const useGetPublicAccessBlock = useCreateS3QueryHook(GetPublicAccessBlockCommand, 'GetPublicAccessBlock');
 const usePutPublicAccessBlock = useCreateS3MutationHook(PutPublicAccessBlockCommand, 'PutPublicAccessBlock', [
     'GetPublicAccessBlock',

package/dist/hooks/bucketOperations.js

@@ -5,7 +5,7 @@ const useBuckets = useCreateS3QueryHook(ListBucketsCommand, 'ListBuckets');
 const useGetBucketLocation = useCreateS3QueryHook(GetBucketLocationCommand, 'GetBucketLocation');
 const useCreateBucket = useCreateS3MutationHook(CreateBucketCommand, 'CreateBucket', [
     'ListBuckets'
-]);
+], 'create the bucket');
 const useDeleteBucket = useCreateS3MutationHook(DeleteBucketCommand, 'DeleteBucket', [
     'ListBuckets'
 ]);

package/dist/hooks/factories/__tests__/useCreateS3FunctionMutationHook.test.js

@@ -61,9 +61,13 @@ describe('useCreateS3FunctionMutationHook - Factory Specific', ()=>{
         expect(mockOperation).toHaveBeenCalledWith(mockS3Client, inputParams);
         expect(mockOperation).toHaveBeenCalledTimes(1);
     });
-    it('should handle function operation errors', async ()=>{
+    it('should handle function operation errors by wrapping with createS3OperationError', async ()=>{
         const mockError = new Error('Presigned URL generation failed');
+        const enhancedError = {
+            message: 'Enhanced error'
+        };
         mockOperation.mockRejectedValue(mockError);
+        mockCreateS3OperationError.mockReturnValue(enhancedError);
         const useMutation = useCreateS3FunctionMutationHook(mockOperation);
         const { result } = renderHook(()=>useMutation(), {
             wrapper: createTestWrapper()
@@ -75,40 +79,8 @@ describe('useCreateS3FunctionMutationHook - Factory Specific', ()=>{
         await waitFor(()=>{
             expect(result.current.isError).toBe(true);
         });
-        expect(result.current.error).toBe(mockError);
-        expect(mockOperation).toHaveBeenCalledWith(mockS3Client, {
-            Bucket: 'test-bucket',
-            Key: 'test-key'
-        });
-        expect(mockCreateS3OperationError).not.toHaveBeenCalled();
-    });
-    it('should handle function operation with internal error wrapping', async ()=>{
-        const mockInternalError = new Error('Internal operation error');
-        const mockWrappedError = new Error('Wrapped operation error');
-        const mockOperationWithErrorHandling = jest.fn().mockImplementation(async ()=>{
-            try {
-                throw mockInternalError;
-            } catch (error) {
-                const wrappedError = mockWrappedError;
-                throw wrappedError;
-            }
-        });
-        const useMutation = useCreateS3FunctionMutationHook(mockOperationWithErrorHandling);
-        const { result } = renderHook(()=>useMutation(), {
-            wrapper: createTestWrapper()
-        });
-        result.current.mutate({
-            Bucket: 'test-bucket',
-            Key: 'test-key'
-        });
-        await waitFor(()=>{
-            expect(result.current.isError).toBe(true);
-        });
-        expect(result.current.error).toBe(mockWrappedError);
-        expect(mockOperationWithErrorHandling).toHaveBeenCalledWith(mockS3Client, {
-            Bucket: 'test-bucket',
-            Key: 'test-key'
-        });
+        expect(result.current.error).toBe(enhancedError);
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'FunctionMutation', void 0, void 0, void 0);
     });
     it('should handle mutation callbacks correctly', async ()=>{
         const mockResponse = {

package/dist/hooks/factories/__tests__/useCreateS3InfiniteQueryHook.test.js

@@ -173,7 +173,7 @@ describe('useCreateS3InfiniteQueryHook - Pagination Logic', ()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(enhancedError);
-        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'ListObjects', 'test-bucket');
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'ListObjects', 'test-bucket', void 0, void 0);
     });
     it('should handle fetchNextPage correctly', async ()=>{
         const mockFirstPage = {

package/dist/hooks/factories/__tests__/useCreateS3MutationHook.test.js

@@ -84,7 +84,7 @@ describe('useCreateS3MutationHook - Factory Specific', ()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(enhancedError);
-        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'PutObject', 'test-bucket');
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'PutObject', 'test-bucket', void 0, void 0);
     });
     it('should handle mutation callbacks correctly', async ()=>{
         const mockResponse = {

package/dist/hooks/factories/__tests__/useCreateS3QueryHook.test.js

@@ -84,7 +84,7 @@ describe('useCreateS3QueryHook - Factory Specific', ()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(enhancedError);
-        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'testOperation', 'test-bucket');
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'testOperation', 'test-bucket', void 0, void 0);
     });
     it('should handle parameter validation correctly', ()=>{
         const useTestQuery = useCreateS3QueryHook(MockCommand, 'testOperation');

package/dist/hooks/factories/useCreateS3InfiniteQueryHook.d.ts

@@ -10,4 +10,4 @@ import { type EnhancedS3Error } from '../../utils/errorHandling';
  * - AbortSignal support for cancellation
  * - Pagination parameters and logic
  */
-export declare function useCreateS3InfiniteQueryHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string): (params: TInput, options?: Partial<UseInfiniteQueryOptions<TOutput, EnhancedS3Error, TOutput, (string | TInput)[], string | undefined>>) => UseInfiniteQueryResult<TOutput, EnhancedS3Error>;
+export declare function useCreateS3InfiniteQueryHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string, operationLabel?: string): (params: TInput, options?: Partial<UseInfiniteQueryOptions<TOutput, EnhancedS3Error, TOutput, (string | TInput)[], string | undefined>>) => UseInfiniteQueryResult<TOutput, EnhancedS3Error>;

package/dist/hooks/factories/useCreateS3InfiniteQueryHook.js

@@ -2,7 +2,7 @@ import { useInfiniteQuery } from "@tanstack/react-query";
 import { useDataBrowserContext } from "../../components/providers/DataBrowserProvider.js";
 import { createS3OperationError, shouldRetryError } from "../../utils/errorHandling.js";
 import { useS3Client } from "../useS3Client.js";
-function useCreateS3InfiniteQueryHook(Command, operationName) {
+function useCreateS3InfiniteQueryHook(Command, operationName, operationLabel) {
     return (params, options)=>{
         const { s3ConfigIdentifier } = useDataBrowserContext();
         const s3Client = useS3Client();
@@ -24,7 +24,7 @@ function useCreateS3InfiniteQueryHook(Command, operationName) {
                     return response;
                 } catch (error) {
                     const bucketName = 'Bucket' in params ? params.Bucket : void 0;
-                    throw createS3OperationError(error, operationName, bucketName);
+                    throw createS3OperationError(error, operationName, bucketName, void 0, operationLabel);
                 }
             },
             retry: options?.retry ?? ((failureCount, error)=>shouldRetryError(error, failureCount)),

package/dist/hooks/factories/useCreateS3MutationHook.d.ts

@@ -1,7 +1,7 @@
 import type { S3Client } from '@aws-sdk/client-s3';
 import { type UseMutationOptions, type UseMutationResult } from '@tanstack/react-query';
 import { type EnhancedS3Error } from '../../utils/errorHandling';
-export declare function useCreateS3MutationHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string, invalidationKeys?: string[]): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;
-export declare function useCreateS3FunctionMutationHook<TInput, TOutput>(operation: (s3Client: S3Client, input: TInput) => Promise<TOutput>, invalidationKeys?: string[]): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput, unknown>, "mutationFn"> | undefined) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;
+export declare function useCreateS3MutationHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string, invalidationKeys?: string[], operationLabel?: string): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;
+export declare function useCreateS3FunctionMutationHook<TInput, TOutput>(operation: (s3Client: S3Client, input: TInput) => Promise<TOutput>, invalidationKeys?: string[], operationLabel?: string): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput, unknown>, "mutationFn"> | undefined) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;
 export type UrlRewriter = (url: string) => string;
-export declare function useCreatePresigningMutationHook<TInput, TOutput>(operation: (s3Client: S3Client, input: TInput, rewriteUrl: UrlRewriter) => Promise<TOutput>, invalidationKeys?: string[]): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;
+export declare function useCreatePresigningMutationHook<TInput, TOutput>(operation: (s3Client: S3Client, input: TInput, rewriteUrl: UrlRewriter) => Promise<TOutput>, invalidationKeys?: string[], operationLabel?: string): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;

package/dist/hooks/factories/useCreateS3MutationHook.js

@@ -3,7 +3,7 @@ import { useDataBrowserContext } from "../../components/providers/DataBrowserPro
 import { createS3OperationError } from "../../utils/errorHandling.js";
 import { usePresigningS3Client } from "../usePresigningS3Client.js";
 import { useS3Client } from "../useS3Client.js";
-function useCreateS3MutationHook(Command, operationName, invalidationKeys) {
+function useCreateS3MutationHook(Command, operationName, invalidationKeys, operationLabel) {
     return (options)=>{
         const { s3ConfigIdentifier } = useDataBrowserContext();
         const s3Client = useS3Client();
@@ -15,7 +15,7 @@ function useCreateS3MutationHook(Command, operationName, invalidationKeys) {
                     return await s3Client.send(command);
                 } catch (error) {
                     const bucketName = 'Bucket' in params ? params.Bucket : void 0;
-                    throw createS3OperationError(error, operationName, bucketName);
+                    throw createS3OperationError(error, operationName, bucketName, void 0, operationLabel);
                 }
             },
             onSuccess: (_data, _variables)=>{
@@ -32,13 +32,19 @@ function useCreateS3MutationHook(Command, operationName, invalidationKeys) {
         });
     };
 }
-function createFunctionMutationHook(operation, useClient, invalidationKeys) {
+function createFunctionMutationHook(operation, useClient, invalidationKeys, operationLabel) {
     return (options)=>{
         const { s3ConfigIdentifier } = useDataBrowserContext();
         const s3Client = useClient();
         const queryClient = useQueryClient();
         return useMutation({
-            mutationFn: async (params)=>operation(s3Client, params),
+            mutationFn: async (params)=>{
+                try {
+                    return await operation(s3Client, params);
+                } catch (error) {
+                    throw createS3OperationError(error, 'FunctionMutation', void 0, void 0, operationLabel);
+                }
+            },
             onSuccess: (_data, _variables)=>{
                 if (invalidationKeys) invalidationKeys.forEach((key)=>{
                     queryClient.invalidateQueries({
@@ -53,16 +59,22 @@ function createFunctionMutationHook(operation, useClient, invalidationKeys) {
         });
     };
 }
-function useCreateS3FunctionMutationHook(operation, invalidationKeys) {
-    return createFunctionMutationHook(operation, useS3Client, invalidationKeys);
+function useCreateS3FunctionMutationHook(operation, invalidationKeys, operationLabel) {
+    return createFunctionMutationHook(operation, useS3Client, invalidationKeys, operationLabel);
 }
-function useCreatePresigningMutationHook(operation, invalidationKeys) {
+function useCreatePresigningMutationHook(operation, invalidationKeys, operationLabel) {
     return (options)=>{
         const { s3ConfigIdentifier } = useDataBrowserContext();
         const { client, rewriteUrl } = usePresigningS3Client();
         const queryClient = useQueryClient();
         return useMutation({
-            mutationFn: async (params)=>operation(client, params, rewriteUrl),
+            mutationFn: async (params)=>{
+                try {
+                    return await operation(client, params, rewriteUrl);
+                } catch (error) {
+                    throw createS3OperationError(error, 'PresigningMutation', void 0, void 0, operationLabel);
+                }
+            },
             onSuccess: (_data, _variables)=>{
                 if (invalidationKeys) invalidationKeys.forEach((key)=>{
                     queryClient.invalidateQueries({

package/dist/hooks/factories/useCreateS3QueryHook.d.ts

@@ -1,4 +1,4 @@
 import { type QueryKey, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import { type EnhancedS3Error } from '../../utils/errorHandling';
 export declare function createS3QueryKey(s3ConfigIdentifier: string, operationName: string, params?: object): QueryKey;
-export declare function useCreateS3QueryHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string): (params?: TInput, options?: Omit<UseQueryOptions<TOutput, EnhancedS3Error, TOutput, QueryKey>, "queryKey" | "queryFn">) => UseQueryResult<TOutput, EnhancedS3Error>;
+export declare function useCreateS3QueryHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string, operationLabel?: string): (params?: TInput, options?: Omit<UseQueryOptions<TOutput, EnhancedS3Error, TOutput, QueryKey>, "queryKey" | "queryFn">) => UseQueryResult<TOutput, EnhancedS3Error>;

package/dist/hooks/factories/useCreateS3QueryHook.js

@@ -28,7 +28,7 @@ function createS3QueryKey(s3ConfigIdentifier, operationName, params) {
         params
     ];
 }
-function useCreateS3QueryHook(Command, operationName) {
+function useCreateS3QueryHook(Command, operationName, operationLabel) {
     return (params, options)=>{
         const { s3ConfigIdentifier } = useDataBrowserContext();
         const s3Client = useS3Client();
@@ -47,7 +47,7 @@ function useCreateS3QueryHook(Command, operationName) {
                         const emptyConfig = getEmptyConfigForOperation(operationName);
                         if (null !== emptyConfig) return emptyConfig;
                     }
-                    throw createS3OperationError(error, operationName, bucketName);
+                    throw createS3OperationError(error, operationName, bucketName, void 0, operationLabel);
                 }
             },
             retry: options?.retry ?? ((failureCount, error)=>shouldRetryError(error, failureCount)),

package/dist/hooks/objectOperations.js

@@ -30,12 +30,12 @@ const useDeleteObjects = useCreateS3MutationHook(DeleteObjectsCommand, 'DeleteOb
     'ListObjectVersions',
     'SearchObjects',
     'SearchObjectsVersions'
-]);
+], 'delete objects');
 const useCopyObject = useCreateS3MutationHook(CopyObjectCommand, 'CopyObject', [
     'ListObjects',
     'SearchObjects',
     'HeadObject'
-]);
+], 'save metadata');
 const useObjectRetention = useCreateS3QueryHook(GetObjectRetentionCommand, 'GetObjectRetention');
 const useSetObjectRetention = useCreateS3MutationHook(PutObjectRetentionCommand, 'PutObjectRetention', [
     'GetObjectRetention'
@@ -44,18 +44,18 @@ const useObjectLegalHold = useCreateS3QueryHook(GetObjectLegalHoldCommand, 'GetO
 const useSetObjectLegalHold = useCreateS3MutationHook(PutObjectLegalHoldCommand, 'PutObjectLegalHold', [
     'GetObjectLegalHold',
     'BatchObjectLegalHold'
-]);
+], 'update legal hold');
 const useObjectTagging = useCreateS3QueryHook(GetObjectTaggingCommand, 'GetObjectTagging');
 const useSetObjectTagging = useCreateS3MutationHook(PutObjectTaggingCommand, 'PutObjectTagging', [
     'GetObjectTagging'
-]);
+], 'save tags');
 const useDeleteObjectTagging = useCreateS3MutationHook(DeleteObjectTaggingCommand, 'DeleteObjectTagging', [
     'GetObjectTagging'
-]);
+], 'save tags');
 const useObjectAcl = useCreateS3QueryHook(GetObjectAclCommand, 'GetObjectAcl');
 const useSetObjectAcl = useCreateS3MutationHook(PutObjectAclCommand, 'PutObjectAcl', [
     'GetObjectAcl'
-]);
+], 'update object visibility');
 const useGetObjectAttributes = useCreateS3QueryHook(GetObjectAttributesCommand, 'GetObjectAttributes');
 const useGetObjectTorrent = useCreateS3QueryHook(GetObjectTorrentCommand, 'GetObjectTorrent');
 const useRestoreObject = useCreateS3MutationHook(RestoreObjectCommand, 'RestoreObject', [

package/dist/hooks/presignedOperations.js

@@ -67,7 +67,7 @@ const generatePresignedPost = async (client, config, rewriteUrl)=>{
         throw createS3OperationError(error, 'GeneratePresignedPost', config.Bucket, config.Key);
     }
 };
-const useGetPresignedDownload = useCreatePresigningMutationHook(generatePresignedDownloadUrl);
+const useGetPresignedDownload = useCreatePresigningMutationHook(generatePresignedDownloadUrl, void 0, 'generate the presigned URL');
 const useGetPresignedUpload = useCreatePresigningMutationHook(generatePresignedUploadUrl);
 const useGetPresignedPost = useCreatePresigningMutationHook(generatePresignedPost);
 export { useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload };

package/dist/hooks/useDeleteFolder.js

@@ -36,5 +36,5 @@ async function deleteFolder(s3Client, input) {
         }
     }
 }
-const useDeleteFolder = useCreateS3FunctionMutationHook(deleteFolder);
+const useDeleteFolder = useCreateS3FunctionMutationHook(deleteFolder, void 0, 'delete the folder');
 export { useDeleteFolder };