@scality/data-browser-library 1.1.10 → 1.1.12

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 };

package/dist/test/utils/errorHandling.test.js

@@ -117,6 +117,18 @@ describe('EnhancedS3Error', ()=>{
             expect(TestEnhancedErrors.unknown().shouldRetry()).toBe(false);
         });
     });
+    describe('getUserMessage', ()=>{
+        test('returns permission message for AUTHORIZATION errors', ()=>{
+            expect(TestEnhancedErrors.auth().getUserMessage('save the bucket policy')).toBe("You don't have permission to save the bucket policy. Contact your administrator.");
+        });
+        test('returns original message for non-authorization errors', ()=>{
+            expect(TestEnhancedErrors.server().getUserMessage('save tags')).toBe('Server error');
+        });
+        test('returns fallback when message is empty', ()=>{
+            const error = new EnhancedS3Error('', 'EmptyError', ErrorCategory.SERVER_ERROR, new Error());
+            expect(error.getUserMessage('save tags')).toBe('Failed to save tags');
+        });
+    });
 });
 describe('Type Guards', ()=>{
     describe('isS3ServiceException', ()=>{
@@ -272,39 +284,15 @@ describe('createS3Error', ()=>{
     });
 });
 describe('createS3OperationError', ()=>{
-    test('message modification scenarios', ()=>{
-        const testCases = [
-            {
-                name: 'preserves existing operation in message',
-                error: new Error('ListObjectsV2 failed: Access denied'),
-                operation: 'ListObjectsV2',
-                bucket: TEST_CONSTANTS.BUCKET,
-                expectedMessage: 'ListObjectsV2 failed: Access denied'
-            },
-            {
-                name: 'enhances message with operation context',
-                error: new Error(TEST_CONSTANTS.MESSAGES.ACCESS_DENIED),
-                operation: 'GetObject',
-                bucket: TEST_CONSTANTS.BUCKET,
-                key: TEST_CONSTANTS.KEY,
-                expectedMessage: `GetObject failed for bucket '${TEST_CONSTANTS.BUCKET}', key '${TEST_CONSTANTS.KEY}': ${TEST_CONSTANTS.MESSAGES.ACCESS_DENIED}`
-            },
-            {
-                name: 'handles operation without bucket',
-                error: new Error(TEST_CONSTANTS.MESSAGES.SERVICE_UNAVAILABLE),
-                operation: 'ListBuckets',
-                expectedMessage: `ListBuckets failed: ${TEST_CONSTANTS.MESSAGES.SERVICE_UNAVAILABLE}`
-            }
-        ];
-        testCases.forEach(({ error, operation, bucket, key, expectedMessage })=>{
-            const result = createS3OperationError(error, operation, bucket, key);
-            expect(result.message).toBe(expectedMessage);
-            expect(result.context).toEqual({
-                operation,
-                bucketName: bucket || void 0,
-                objectKey: key || void 0,
-                timestamp: expect.any(String)
-            });
+    test('preserves original error message without operationLabel', ()=>{
+        const error = new Error(TEST_CONSTANTS.MESSAGES.ACCESS_DENIED);
+        const result = createS3OperationError(error, 'GetObject', TEST_CONSTANTS.BUCKET, TEST_CONSTANTS.KEY);
+        expect(result.message).toBe(TEST_CONSTANTS.MESSAGES.ACCESS_DENIED);
+        expect(result.context).toEqual({
+            operation: 'GetObject',
+            bucketName: TEST_CONSTANTS.BUCKET,
+            objectKey: TEST_CONSTANTS.KEY,
+            timestamp: expect.any(String)
         });
     });
     test('preserves all error properties', ()=>{
@@ -411,6 +399,30 @@ describe('isNotFoundError', ()=>{
         expect(result).toBe(false);
     });
 });
+describe('createS3OperationError with operationLabel', ()=>{
+    test('embeds permission message for 403 errors', ()=>{
+        const error = TestErrors.accessDenied();
+        const result = createS3OperationError(error, 'PutBucketPolicy', 'my-bucket', void 0, 'save the bucket policy');
+        expect(result.message).toBe("You don't have permission to save the bucket policy. Contact your administrator.");
+    });
+    test('preserves original message for non-403 errors', ()=>{
+        const error = TestErrors.internalError();
+        const result = createS3OperationError(error, 'PutBucketPolicy', 'my-bucket', void 0, 'save the bucket policy');
+        expect(result.message).toBe('Internal error');
+    });
+    test('uses fallback when error has no message', ()=>{
+        const error = new Error('');
+        const result = createS3OperationError(error, 'PutBucketPolicy', 'my-bucket', void 0, 'save the bucket policy');
+        expect(result.message).toBe('Failed to save the bucket policy');
+    });
+    test('preserves category when double-wrapping an EnhancedS3Error', ()=>{
+        const inner = createS3OperationError(TestErrors.accessDenied(), 'GeneratePresignedDownload', 'my-bucket');
+        expect(inner.category).toBe(ErrorCategory.AUTHORIZATION);
+        const outer = createS3OperationError(inner, 'PresigningMutation', void 0, void 0, 'generate the presigned URL');
+        expect(outer.category).toBe(ErrorCategory.AUTHORIZATION);
+        expect(outer.message).toBe("You don't have permission to generate the presigned URL. Contact your administrator.");
+    });
+});
 describe('Integration Tests', ()=>{
     test('complete error processing workflow', ()=>{
         const testCases = [

package/dist/utils/__tests__/coldStorage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__tests__/coldStorage.test.js

@@ -0,0 +1,24 @@
+import { parseRestoreStatus } from "../coldStorage.js";
+describe('parseRestoreStatus', ()=>{
+    it('returns "cold" when restore header is undefined', ()=>{
+        expect(parseRestoreStatus(void 0)).toEqual({
+            status: 'cold'
+        });
+    });
+    it('returns "restoring" when ongoing-request="true"', ()=>{
+        expect(parseRestoreStatus('ongoing-request="true"')).toEqual({
+            status: 'restoring'
+        });
+    });
+    it('returns "restored" with expiry date when ongoing-request="false"', ()=>{
+        const header = 'ongoing-request="false", expiry-date="Fri, 02 May 2026 00:00:00 GMT"';
+        const result = parseRestoreStatus(header);
+        expect(result.status).toBe('restored');
+        if ('restored' === result.status) expect(result.expiryDate).toEqual(new Date('Fri, 02 May 2026 00:00:00 GMT'));
+    });
+    it('returns "restored" without expiry if date is missing', ()=>{
+        expect(parseRestoreStatus('ongoing-request="false"')).toEqual({
+            status: 'restored'
+        });
+    });
+});

package/dist/utils/coldStorage.d.ts

@@ -0,0 +1,12 @@
+import type React from 'react';
+export declare const COLD_STORAGE_TOOLTIP = "The Temperature of this Location is Cold.\n\nYou can move your data in this Location through a Transition rule.\n\nOnce your data are in this Location, you can only trigger a request for restoration to get a temporary access to the object.";
+export declare const COLD_STORAGE_TOOLTIP_STYLE: React.CSSProperties;
+export type ColdStorageStatus = {
+    status: 'cold';
+} | {
+    status: 'restoring';
+} | {
+    status: 'restored';
+    expiryDate?: Date;
+};
+export declare function parseRestoreStatus(restoreHeader: string | undefined): ColdStorageStatus;

package/dist/utils/coldStorage.js

@@ -0,0 +1,23 @@
+const COLD_STORAGE_TOOLTIP = 'The Temperature of this Location is Cold.\n\nYou can move your data in this Location through a Transition rule.\n\nOnce your data are in this Location, you can only trigger a request for restoration to get a temporary access to the object.';
+const COLD_STORAGE_TOOLTIP_STYLE = {
+    textWrap: 'wrap',
+    width: '24rem',
+    textAlign: 'left'
+};
+function parseRestoreStatus(restoreHeader) {
+    if (!restoreHeader) return {
+        status: 'cold'
+    };
+    if (restoreHeader.includes('ongoing-request="true"')) return {
+        status: 'restoring'
+    };
+    const expiryMatch = restoreHeader.match(/expiry-date="([^"]+)"/);
+    if (expiryMatch) return {
+        status: 'restored',
+        expiryDate: new Date(expiryMatch[1])
+    };
+    return {
+        status: 'restored'
+    };
+}
+export { COLD_STORAGE_TOOLTIP, COLD_STORAGE_TOOLTIP_STYLE, parseRestoreStatus };

package/dist/utils/errorHandling.d.ts

@@ -29,6 +29,7 @@ export declare class EnhancedS3Error extends Error {
      * Server errors, network issues, and expired credentials are retryable.
      */
     shouldRetry(): boolean;
+    getUserMessage(operationLabel: string): string;
 }
 /**
  * Type guard to check if an error is an AWS S3 service exception.
@@ -47,7 +48,7 @@ export declare function createS3Error(error: unknown, context?: Record<string, u
  * Creates an enhanced S3 error with operation context and enriched error messages.
  * Automatically adds operation details to error messages for better debugging.
  */
-export declare function createS3OperationError(error: unknown, operation: string, bucketName?: string, objectKey?: string): EnhancedS3Error;
+export declare function createS3OperationError(error: unknown, operation: string, bucketName?: string, objectKey?: string, operationLabel?: string): EnhancedS3Error;
 /**
  * Determines whether an error should be retried based on its classification.
  * Implements unified retry policy for all S3 operations.

package/dist/utils/errorHandling.js

@@ -29,6 +29,10 @@ class EnhancedS3Error extends Error {
     shouldRetry() {
         return "SERVER_ERROR" === this.category || "NETWORK_ERROR" === this.category || "EXPIRED_CREDENTIALS" === this.category;
     }
+    getUserMessage(operationLabel) {
+        if ("AUTHORIZATION" === this.category) return `You don't have permission to ${operationLabel}. Contact your administrator.`;
+        return this.message || `Failed to ${operationLabel}`;
+    }
 }
 const EXPIRED_CREDENTIAL_ERROR_NAMES = new Set([
     'ExpiredToken',
@@ -68,19 +72,16 @@ function createS3Error(error, context) {
     const message = 'string' == typeof error ? error : 'Unknown error occurred';
     return new EnhancedS3Error(message, 'UnknownError', "UNKNOWN", new Error(message), void 0, void 0, context);
 }
-function createS3OperationError(error, operation, bucketName, objectKey) {
+function createS3OperationError(error, operation, bucketName, objectKey, operationLabel) {
     const context = {
         operation,
         bucketName,
         objectKey,
         timestamp: new Date().toISOString()
     };
-    const enhancedError = createS3Error(error, context);
-    if (!enhancedError.message.includes(operation)) {
-        const prefix = bucketName ? `${operation} failed for bucket '${bucketName}'${objectKey ? `, key '${objectKey}'` : ''}` : `${operation} failed`;
-        return new EnhancedS3Error(`${prefix}: ${enhancedError.message}`, enhancedError.name, enhancedError.category, enhancedError.originalError, enhancedError.statusCode, enhancedError.metadata, context);
-    }
-    return enhancedError;
+    const enhancedError = isEnhancedS3Error(error) ? error : createS3Error(error, context);
+    const message = operationLabel ? enhancedError.getUserMessage(operationLabel) : enhancedError.message;
+    return new EnhancedS3Error(message, enhancedError.name, enhancedError.category, enhancedError.originalError, enhancedError.statusCode, enhancedError.metadata, context);
 }
 function shouldRetryError(error, failureCount, maxRetries = 3) {
     if (failureCount >= maxRetries) return false;

package/package.json

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