@scality/data-browser-library 1.0.0-preview.9 → 1.0.1

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

@@ -1,23 +1,23 @@
 import { EnhancedS3Error, ErrorCategory, createS3Error, createS3OperationError, isEnhancedS3Error, isNotFoundError, isS3ServiceException, shouldRetryError } from "../../utils/errorHandling.js";
 const TEST_CONSTANTS = {
-    REQUEST_ID: "test-request-id",
+    REQUEST_ID: 'test-request-id',
     ATTEMPTS: 1,
     RETRY_DELAY: 0,
-    BUCKET: "test-bucket",
-    KEY: "test-key",
+    BUCKET: 'test-bucket',
+    KEY: 'test-key',
     MESSAGES: {
-        NO_SUCH_BUCKET: "The specified bucket does not exist",
-        NO_SUCH_KEY: "The specified key does not exist",
-        INVALID_REQUEST: "Invalid request",
-        ACCESS_DENIED: "Access denied",
-        INTERNAL_ERROR: "Internal error",
-        NETWORK_FAILED: "Network connection failed",
-        SERVICE_UNAVAILABLE: "Service temporarily unavailable"
+        NO_SUCH_BUCKET: 'The specified bucket does not exist',
+        NO_SUCH_KEY: 'The specified key does not exist',
+        INVALID_REQUEST: 'Invalid request',
+        ACCESS_DENIED: 'Access denied',
+        INTERNAL_ERROR: 'Internal error',
+        NETWORK_FAILED: 'Network connection failed',
+        SERVICE_UNAVAILABLE: 'Service temporarily unavailable'
     }
 };
 const createMockAWSError = (errorType, message, statusCode = 500)=>{
     const error = new Error(message);
-    Object.defineProperty(error, "name", {
+    Object.defineProperty(error, 'name', {
         value: errorType,
         writable: true
     });
@@ -30,53 +30,53 @@ const createMockAWSError = (errorType, message, statusCode = 500)=>{
     return error;
 };
 const TestErrors = {
-    noSuchBucket: ()=>createMockAWSError("NoSuchBucket", TEST_CONSTANTS.MESSAGES.NO_SUCH_BUCKET, 404),
-    noSuchKey: ()=>createMockAWSError("NoSuchKey", TEST_CONSTANTS.MESSAGES.NO_SUCH_KEY, 404),
-    invalidRequest: ()=>createMockAWSError("InvalidRequest", TEST_CONSTANTS.MESSAGES.INVALID_REQUEST, 400),
-    accessDenied: ()=>createMockAWSError("AccessDenied", TEST_CONSTANTS.MESSAGES.ACCESS_DENIED, 403),
-    internalError: ()=>createMockAWSError("InternalError", TEST_CONSTANTS.MESSAGES.INTERNAL_ERROR, 500),
-    serviceUnavailable: ()=>createMockAWSError("ServiceUnavailable", TEST_CONSTANTS.MESSAGES.SERVICE_UNAVAILABLE, 503),
+    noSuchBucket: ()=>createMockAWSError('NoSuchBucket', TEST_CONSTANTS.MESSAGES.NO_SUCH_BUCKET, 404),
+    noSuchKey: ()=>createMockAWSError('NoSuchKey', TEST_CONSTANTS.MESSAGES.NO_SUCH_KEY, 404),
+    invalidRequest: ()=>createMockAWSError('InvalidRequest', TEST_CONSTANTS.MESSAGES.INVALID_REQUEST, 400),
+    accessDenied: ()=>createMockAWSError('AccessDenied', TEST_CONSTANTS.MESSAGES.ACCESS_DENIED, 403),
+    internalError: ()=>createMockAWSError('InternalError', TEST_CONSTANTS.MESSAGES.INTERNAL_ERROR, 500),
+    serviceUnavailable: ()=>createMockAWSError('ServiceUnavailable', TEST_CONSTANTS.MESSAGES.SERVICE_UNAVAILABLE, 503),
     abortError: ()=>{
-        const error = new Error("Operation aborted");
-        Object.defineProperty(error, "name", {
-            value: "AbortError",
+        const error = new Error('Operation aborted');
+        Object.defineProperty(error, 'name', {
+            value: 'AbortError',
             writable: true
         });
         return error;
     },
     networkError: ()=>new Error(TEST_CONSTANTS.MESSAGES.NETWORK_FAILED),
     timeoutError: ()=>{
-        const error = new Error("Request timeout");
-        Object.defineProperty(error, "name", {
-            value: "TimeoutError",
+        const error = new Error('Request timeout');
+        Object.defineProperty(error, 'name', {
+            value: 'TimeoutError',
             writable: true
         });
         return error;
     }
 };
 const TestEnhancedErrors = {
-    server: ()=>new EnhancedS3Error("Server error", "ServerError", ErrorCategory.SERVER_ERROR, new Error()),
-    network: ()=>new EnhancedS3Error("Network error", "NetworkError", ErrorCategory.NETWORK_ERROR, new Error()),
-    client: ()=>new EnhancedS3Error("Client error", "ClientError", ErrorCategory.CLIENT_ERROR, new Error()),
-    auth: ()=>new EnhancedS3Error("Auth error", "AuthError", ErrorCategory.AUTHORIZATION, new Error()),
-    notFound: ()=>new EnhancedS3Error("Not found", "NotFoundError", ErrorCategory.NOT_FOUND, new Error()),
-    cancelled: ()=>new EnhancedS3Error("Cancelled", "CancelError", ErrorCategory.CANCELLATION, new Error()),
-    unknown: ()=>new EnhancedS3Error("Unknown", "UnknownError", ErrorCategory.UNKNOWN, new Error())
+    server: ()=>new EnhancedS3Error('Server error', 'ServerError', ErrorCategory.SERVER_ERROR, new Error()),
+    network: ()=>new EnhancedS3Error('Network error', 'NetworkError', ErrorCategory.NETWORK_ERROR, new Error()),
+    client: ()=>new EnhancedS3Error('Client error', 'ClientError', ErrorCategory.CLIENT_ERROR, new Error()),
+    auth: ()=>new EnhancedS3Error('Auth error', 'AuthError', ErrorCategory.AUTHORIZATION, new Error()),
+    notFound: ()=>new EnhancedS3Error('Not found', 'NotFoundError', ErrorCategory.NOT_FOUND, new Error()),
+    cancelled: ()=>new EnhancedS3Error('Cancelled', 'CancelError', ErrorCategory.CANCELLATION, new Error()),
+    unknown: ()=>new EnhancedS3Error('Unknown', 'UnknownError', ErrorCategory.UNKNOWN, new Error())
 };
-describe("ErrorCategory", ()=>{
-    test("contains all expected categories", ()=>{
-        expect(ErrorCategory.CLIENT_ERROR).toBe("CLIENT_ERROR");
-        expect(ErrorCategory.SERVER_ERROR).toBe("SERVER_ERROR");
-        expect(ErrorCategory.NETWORK_ERROR).toBe("NETWORK_ERROR");
-        expect(ErrorCategory.CANCELLATION).toBe("CANCELLATION");
-        expect(ErrorCategory.AUTHORIZATION).toBe("AUTHORIZATION");
-        expect(ErrorCategory.NOT_FOUND).toBe("NOT_FOUND");
-        expect(ErrorCategory.UNKNOWN).toBe("UNKNOWN");
+describe('ErrorCategory', ()=>{
+    test('contains all expected categories', ()=>{
+        expect(ErrorCategory.CLIENT_ERROR).toBe('CLIENT_ERROR');
+        expect(ErrorCategory.SERVER_ERROR).toBe('SERVER_ERROR');
+        expect(ErrorCategory.NETWORK_ERROR).toBe('NETWORK_ERROR');
+        expect(ErrorCategory.CANCELLATION).toBe('CANCELLATION');
+        expect(ErrorCategory.AUTHORIZATION).toBe('AUTHORIZATION');
+        expect(ErrorCategory.NOT_FOUND).toBe('NOT_FOUND');
+        expect(ErrorCategory.UNKNOWN).toBe('UNKNOWN');
     });
 });
-describe("EnhancedS3Error", ()=>{
-    test("creates error with all properties", ()=>{
-        const originalError = new Error("Original error");
+describe('EnhancedS3Error', ()=>{
+    test('creates error with all properties', ()=>{
+        const originalError = new Error('Original error');
         const metadata = {
             httpStatusCode: 400,
             requestId: TEST_CONSTANTS.REQUEST_ID,
@@ -84,12 +84,12 @@ describe("EnhancedS3Error", ()=>{
             totalRetryDelay: TEST_CONSTANTS.RETRY_DELAY
         };
         const context = {
-            operation: "test",
+            operation: 'test',
             bucket: TEST_CONSTANTS.BUCKET
         };
-        const error = new EnhancedS3Error("Test error", "TestError", ErrorCategory.CLIENT_ERROR, originalError, 400, metadata, context);
-        expect(error.message).toBe("Test error");
-        expect(error.name).toBe("TestError");
+        const error = new EnhancedS3Error('Test error', 'TestError', ErrorCategory.CLIENT_ERROR, originalError, 400, metadata, context);
+        expect(error.message).toBe('Test error');
+        expect(error.name).toBe('TestError');
         expect(error.category).toBe(ErrorCategory.CLIENT_ERROR);
         expect(error.statusCode).toBe(400);
         expect(error.metadata).toBe(metadata);
@@ -98,12 +98,12 @@ describe("EnhancedS3Error", ()=>{
         expect(error instanceof Error).toBe(true);
         expect(error instanceof EnhancedS3Error).toBe(true);
     });
-    describe("shouldRetry", ()=>{
-        test("returns true for retryable categories", ()=>{
+    describe('shouldRetry', ()=>{
+        test('returns true for retryable categories', ()=>{
             expect(TestEnhancedErrors.server().shouldRetry()).toBe(true);
             expect(TestEnhancedErrors.network().shouldRetry()).toBe(true);
         });
-        test("returns false for non-retryable categories", ()=>{
+        test('returns false for non-retryable categories', ()=>{
             expect(TestEnhancedErrors.client().shouldRetry()).toBe(false);
             expect(TestEnhancedErrors.auth().shouldRetry()).toBe(false);
             expect(TestEnhancedErrors.notFound().shouldRetry()).toBe(false);
@@ -112,59 +112,59 @@ describe("EnhancedS3Error", ()=>{
         });
     });
 });
-describe("Type Guards", ()=>{
-    describe("isS3ServiceException", ()=>{
-        test("returns true for S3ServiceException", ()=>{
+describe('Type Guards', ()=>{
+    describe('isS3ServiceException', ()=>{
+        test('returns true for S3ServiceException', ()=>{
             expect(isS3ServiceException(TestErrors.invalidRequest())).toBe(true);
         });
-        test("returns false for regular Error", ()=>{
-            expect(isS3ServiceException(new Error("Regular error"))).toBe(false);
+        test('returns false for regular Error', ()=>{
+            expect(isS3ServiceException(new Error('Regular error'))).toBe(false);
         });
-        test("returns false for non-Error objects", ()=>{
-            expect(isS3ServiceException("string")).toBe(false);
+        test('returns false for non-Error objects', ()=>{
+            expect(isS3ServiceException('string')).toBe(false);
             expect(isS3ServiceException(null)).toBe(false);
             expect(isS3ServiceException(void 0)).toBe(false);
             expect(isS3ServiceException({})).toBe(false);
         });
     });
-    describe("isEnhancedS3Error", ()=>{
-        test("returns true for EnhancedS3Error", ()=>{
+    describe('isEnhancedS3Error', ()=>{
+        test('returns true for EnhancedS3Error', ()=>{
             expect(isEnhancedS3Error(TestEnhancedErrors.unknown())).toBe(true);
         });
-        test("returns false for other error types", ()=>{
-            expect(isEnhancedS3Error(new Error("Regular error"))).toBe(false);
+        test('returns false for other error types', ()=>{
+            expect(isEnhancedS3Error(new Error('Regular error'))).toBe(false);
             expect(isEnhancedS3Error(TestErrors.invalidRequest())).toBe(false);
-            expect(isEnhancedS3Error("string")).toBe(false);
+            expect(isEnhancedS3Error('string')).toBe(false);
         });
     });
 });
-describe("createS3Error", ()=>{
-    test("handles AbortError", ()=>{
+describe('createS3Error', ()=>{
+    test('handles AbortError', ()=>{
         const abortError = TestErrors.abortError();
         const result = createS3Error(abortError);
-        expect(result.message).toBe("Operation was cancelled");
-        expect(result.name).toBe("AbortError");
+        expect(result.message).toBe('Operation was cancelled');
+        expect(result.name).toBe('AbortError');
         expect(result.category).toBe(ErrorCategory.CANCELLATION);
         expect(result.originalError).toBe(abortError);
     });
-    test("handles specific AWS errors", ()=>{
+    test('handles specific AWS errors', ()=>{
         const testCases = [
             {
                 error: TestErrors.noSuchBucket(),
                 expectedCategory: ErrorCategory.NOT_FOUND,
-                expectedName: "NoSuchBucket",
+                expectedName: 'NoSuchBucket',
                 expectedStatus: 404
             },
             {
                 error: TestErrors.noSuchKey(),
                 expectedCategory: ErrorCategory.NOT_FOUND,
-                expectedName: "NoSuchKey",
+                expectedName: 'NoSuchKey',
                 expectedStatus: 404
             },
             {
                 error: TestErrors.invalidRequest(),
                 expectedCategory: ErrorCategory.CLIENT_ERROR,
-                expectedName: "InvalidRequest",
+                expectedName: 'InvalidRequest',
                 expectedStatus: 400
             }
         ];
@@ -176,7 +176,7 @@ describe("createS3Error", ()=>{
             expect(result.metadata).toBe(error.$metadata);
         });
     });
-    test("handles status code classification", ()=>{
+    test('handles status code classification', ()=>{
         const testCases = [
             {
                 error: TestErrors.accessDenied(),
@@ -192,7 +192,7 @@ describe("createS3Error", ()=>{
             expect(result.category).toBe(expectedCategory);
         });
     });
-    test("handles network errors", ()=>{
+    test('handles network errors', ()=>{
         const testCases = [
             TestErrors.networkError(),
             TestErrors.timeoutError()
@@ -202,28 +202,28 @@ describe("createS3Error", ()=>{
             expect(result.category).toBe(ErrorCategory.NETWORK_ERROR);
         });
     });
-    test("handles edge cases", ()=>{
+    test('handles edge cases', ()=>{
         const testCases = [
             {
-                input: new Error("Some error"),
+                input: new Error('Some error'),
                 expectedCategory: ErrorCategory.UNKNOWN,
-                expectedMessage: "Some error"
+                expectedMessage: 'Some error'
             },
             {
-                input: "String error",
+                input: 'String error',
                 expectedCategory: ErrorCategory.UNKNOWN,
-                expectedMessage: "String error",
-                expectedName: "UnknownError"
+                expectedMessage: 'String error',
+                expectedName: 'UnknownError'
             },
             {
                 input: null,
                 expectedCategory: ErrorCategory.UNKNOWN,
-                expectedMessage: "Unknown error occurred"
+                expectedMessage: 'Unknown error occurred'
             },
             {
                 input: void 0,
                 expectedCategory: ErrorCategory.UNKNOWN,
-                expectedMessage: "Unknown error occurred"
+                expectedMessage: 'Unknown error occurred'
             }
         ];
         testCases.forEach(({ input, expectedCategory, expectedMessage, expectedName })=>{
@@ -233,37 +233,37 @@ describe("createS3Error", ()=>{
             if (expectedName) expect(result.name).toBe(expectedName);
         });
     });
-    test("preserves context", ()=>{
+    test('preserves context', ()=>{
         const context = {
-            operation: "test",
+            operation: 'test',
             bucket: TEST_CONSTANTS.BUCKET
         };
-        const result = createS3Error(new Error("Test error"), context);
+        const result = createS3Error(new Error('Test error'), context);
         expect(result.context).toBe(context);
     });
 });
-describe("createS3OperationError", ()=>{
-    test("message modification scenarios", ()=>{
+describe('createS3OperationError', ()=>{
+    test('message modification scenarios', ()=>{
         const testCases = [
             {
-                name: "preserves existing operation in message",
-                error: new Error("ListObjectsV2 failed: Access denied"),
-                operation: "ListObjectsV2",
+                name: 'preserves existing operation in message',
+                error: new Error('ListObjectsV2 failed: Access denied'),
+                operation: 'ListObjectsV2',
                 bucket: TEST_CONSTANTS.BUCKET,
-                expectedMessage: "ListObjectsV2 failed: Access denied"
+                expectedMessage: 'ListObjectsV2 failed: Access denied'
             },
             {
-                name: "enhances message with operation context",
+                name: 'enhances message with operation context',
                 error: new Error(TEST_CONSTANTS.MESSAGES.ACCESS_DENIED),
-                operation: "GetObject",
+                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",
+                name: 'handles operation without bucket',
                 error: new Error(TEST_CONSTANTS.MESSAGES.SERVICE_UNAVAILABLE),
-                operation: "ListBuckets",
+                operation: 'ListBuckets',
                 expectedMessage: `ListBuckets failed: ${TEST_CONSTANTS.MESSAGES.SERVICE_UNAVAILABLE}`
             }
         ];
@@ -278,17 +278,17 @@ describe("createS3OperationError", ()=>{
             });
         });
     });
-    test("preserves all error properties", ()=>{
+    test('preserves all error properties', ()=>{
         const originalError = TestErrors.noSuchBucket();
-        const result = createS3OperationError(originalError, "HeadObject", TEST_CONSTANTS.BUCKET, TEST_CONSTANTS.KEY);
+        const result = createS3OperationError(originalError, 'HeadObject', TEST_CONSTANTS.BUCKET, TEST_CONSTANTS.KEY);
         expect(result.category).toBe(ErrorCategory.NOT_FOUND);
         expect(result.statusCode).toBe(404);
         expect(result.metadata).toBe(originalError.$metadata);
         expect(result.originalError).toBe(originalError);
     });
 });
-describe("shouldRetryError", ()=>{
-    test("respects maxRetries limit", ()=>{
+describe('shouldRetryError', ()=>{
+    test('respects maxRetries limit', ()=>{
         const retryableError = TestEnhancedErrors.server();
         const maxRetries = 3;
         expect(shouldRetryError(retryableError, 0, maxRetries)).toBe(true);
@@ -296,7 +296,7 @@ describe("shouldRetryError", ()=>{
         expect(shouldRetryError(retryableError, 3, maxRetries)).toBe(false);
         expect(shouldRetryError(retryableError, 5, maxRetries)).toBe(false);
     });
-    test("uses error category for retry decision", ()=>{
+    test('uses error category for retry decision', ()=>{
         const testCases = [
             {
                 error: TestEnhancedErrors.server(),
@@ -319,7 +319,7 @@ describe("shouldRetryError", ()=>{
             expect(shouldRetryError(error, 0)).toBe(shouldRetry);
         });
     });
-    test("converts and retries AWS errors", ()=>{
+    test('converts and retries AWS errors', ()=>{
         const testCases = [
             {
                 error: TestErrors.internalError(),
@@ -334,25 +334,25 @@ describe("shouldRetryError", ()=>{
             expect(shouldRetryError(error, 0)).toBe(shouldRetry);
         });
     });
-    test("uses default maxRetries of 3", ()=>{
+    test('uses default maxRetries of 3', ()=>{
         const retryableError = TestEnhancedErrors.server();
         expect(shouldRetryError(retryableError, 0)).toBe(true);
         expect(shouldRetryError(retryableError, 3)).toBe(false);
     });
 });
-describe("isNotFoundError", ()=>{
-    test("returns true for NOT_FOUND category errors", ()=>{
+describe('isNotFoundError', ()=>{
+    test('returns true for NOT_FOUND category errors', ()=>{
         expect(isNotFoundError(TestEnhancedErrors.notFound())).toBe(true);
     });
-    test("returns true for AWS NOT_FOUND errors", ()=>{
+    test('returns true for AWS NOT_FOUND errors', ()=>{
         expect(isNotFoundError(TestErrors.noSuchBucket())).toBe(true);
         expect(isNotFoundError(TestErrors.noSuchKey())).toBe(true);
     });
-    test("returns true for 404 status code errors", ()=>{
-        const error404 = createMockAWSError("NoSuchLifecycleConfiguration", "The lifecycle configuration does not exist", 404);
+    test('returns true for 404 status code errors', ()=>{
+        const error404 = createMockAWSError('NoSuchLifecycleConfiguration', 'The lifecycle configuration does not exist', 404);
         expect(isNotFoundError(error404)).toBe(true);
     });
-    test("returns false for other error categories", ()=>{
+    test('returns false for other error categories', ()=>{
         expect(isNotFoundError(TestEnhancedErrors.server())).toBe(false);
         expect(isNotFoundError(TestEnhancedErrors.network())).toBe(false);
         expect(isNotFoundError(TestEnhancedErrors.client())).toBe(false);
@@ -360,39 +360,39 @@ describe("isNotFoundError", ()=>{
         expect(isNotFoundError(TestEnhancedErrors.cancelled())).toBe(false);
         expect(isNotFoundError(TestEnhancedErrors.unknown())).toBe(false);
     });
-    test("returns false for non-404 AWS errors", ()=>{
+    test('returns false for non-404 AWS errors', ()=>{
         expect(isNotFoundError(TestErrors.invalidRequest())).toBe(false);
         expect(isNotFoundError(TestErrors.accessDenied())).toBe(false);
         expect(isNotFoundError(TestErrors.internalError())).toBe(false);
     });
-    test("handles edge cases", ()=>{
+    test('handles edge cases', ()=>{
         expect(isNotFoundError(null)).toBe(false);
         expect(isNotFoundError(void 0)).toBe(false);
-        expect(isNotFoundError("string")).toBe(false);
+        expect(isNotFoundError('string')).toBe(false);
         expect(isNotFoundError({})).toBe(false);
-        expect(isNotFoundError(new Error("Regular error"))).toBe(false);
+        expect(isNotFoundError(new Error('Regular error'))).toBe(false);
     });
-    test("works with any error type by converting to EnhancedS3Error", ()=>{
-        const regularError = new Error("Some error");
+    test('works with any error type by converting to EnhancedS3Error', ()=>{
+        const regularError = new Error('Some error');
         const result = isNotFoundError(regularError);
         expect(result).toBe(false);
     });
 });
-describe("Integration Tests", ()=>{
-    test("complete error processing workflow", ()=>{
+describe('Integration Tests', ()=>{
+    test('complete error processing workflow', ()=>{
         const testCases = [
             {
-                name: "NoSuchBucket - non-retryable",
+                name: 'NoSuchBucket - non-retryable',
                 originalError: TestErrors.noSuchBucket(),
-                operation: "ListObjectsV2",
+                operation: 'ListObjectsV2',
                 bucket: TEST_CONSTANTS.BUCKET,
                 expectedCategory: ErrorCategory.NOT_FOUND,
                 shouldRetry: false
             },
             {
-                name: "Server error - retryable",
+                name: 'Server error - retryable',
                 originalError: TestErrors.serviceUnavailable(),
-                operation: "PutObject",
+                operation: 'PutObject',
                 bucket: TEST_CONSTANTS.BUCKET,
                 key: TEST_CONSTANTS.KEY,
                 expectedCategory: ErrorCategory.SERVER_ERROR,
@@ -408,9 +408,9 @@ describe("Integration Tests", ()=>{
             expect(shouldRetryError(operationError, 3)).toBe(false);
         });
     });
-    test("retry attempt progression", ()=>{
+    test('retry attempt progression', ()=>{
         const serverError = TestErrors.serviceUnavailable();
-        const operationError = createS3OperationError(serverError, "PutObject", TEST_CONSTANTS.BUCKET, TEST_CONSTANTS.KEY);
+        const operationError = createS3OperationError(serverError, 'PutObject', TEST_CONSTANTS.BUCKET, TEST_CONSTANTS.KEY);
         [
             0,
             1,

package/dist/types/index.d.ts

@@ -1,50 +1,63 @@
-import { S3ClientConfig } from "@aws-sdk/client-s3";
+import type { S3ClientConfig } from "@aws-sdk/client-s3";
 import type { AwsCredentialIdentity } from "@aws-sdk/types";
-export type { CreateBucketCommandInput, CreateBucketCommandOutput, DeleteBucketCommandInput, DeleteBucketCommandOutput, ListBucketsCommandOutput, GetBucketLocationCommandInput, GetBucketLocationCommandOutput, PutBucketTaggingCommandInput, PutBucketTaggingCommandOutput, GetBucketTaggingCommandOutput, DeleteBucketTaggingCommandOutput, PutBucketPolicyCommandInput, GetBucketPolicyCommandOutput, DeleteBucketPolicyCommandOutput, PutBucketVersioningCommandInput, GetBucketVersioningCommandOutput, PutBucketCorsCommandInput, GetBucketCorsCommandOutput, DeleteBucketCorsCommandOutput, PutBucketLifecycleConfigurationCommandInput, GetBucketLifecycleConfigurationCommandOutput, DeleteBucketLifecycleCommandOutput, PutBucketEncryptionCommandInput, GetBucketEncryptionCommandOutput, PutBucketAclCommandInput, GetBucketAclCommandOutput, PutBucketNotificationConfigurationCommandInput, GetBucketNotificationConfigurationCommandOutput, PutObjectLockConfigurationCommandInput, GetObjectLockConfigurationCommandOutput, PutBucketReplicationCommandInput, GetBucketReplicationCommandOutput, DeleteBucketReplicationCommandOutput, PutObjectCommandInput, PutObjectCommandOutput, GetObjectCommandInput, GetObjectCommandOutput, HeadObjectCommandInput, HeadObjectCommandOutput, DeleteObjectCommandInput, DeleteObjectCommandOutput, DeleteObjectsCommandInput, DeleteObjectsCommandOutput, CopyObjectCommandInput, CopyObjectCommandOutput, ListObjectsV2CommandInput, ListObjectsV2CommandOutput, ListObjectVersionsCommandInput, ListObjectVersionsCommandOutput, PutObjectRetentionCommandInput, GetObjectRetentionCommandOutput, PutObjectLegalHoldCommandInput, GetObjectLegalHoldCommandOutput, PutObjectTaggingCommandInput, GetObjectTaggingCommandOutput, DeleteObjectTaggingCommandOutput, PutObjectAclCommandInput, GetObjectAclCommandOutput, GetObjectAttributesCommandInput, GetObjectAttributesCommandOutput, GetObjectTorrentCommandOutput, RestoreObjectCommandInput, RestoreObjectCommandOutput, SelectObjectContentCommandInput, SelectObjectContentCommandOutput, ListMultipartUploadsCommandInput, ListMultipartUploadsCommandOutput, BucketLocationConstraint, ObjectCannedACL, BucketCannedACL, } from "@aws-sdk/client-s3";
-export interface S3BrowserConfig extends Omit<S3ClientConfig, "credentials"> {
+import type { ProxyConfiguration, S3EventType } from "../config/types";
+export type { _Object, Bucket, BucketCannedACL, BucketLocationConstraint, CopyObjectCommandInput, CopyObjectCommandOutput, CreateBucketCommandInput, CreateBucketCommandOutput, DeleteBucketCommandInput, DeleteBucketCommandOutput, DeleteBucketCorsCommandOutput, DeleteBucketLifecycleCommandOutput, DeleteBucketPolicyCommandOutput, DeleteBucketReplicationCommandOutput, DeleteBucketTaggingCommandOutput, DeleteMarkerEntry, DeleteObjectCommandInput, DeleteObjectCommandOutput, DeleteObjectsCommandInput, DeleteObjectsCommandOutput, DeleteObjectTaggingCommandOutput, GetBucketAclCommandOutput, GetBucketCorsCommandOutput, GetBucketEncryptionCommandOutput, GetBucketLifecycleConfigurationCommandOutput, GetBucketLocationCommandInput, GetBucketLocationCommandOutput, GetBucketNotificationConfigurationCommandOutput, GetBucketPolicyCommandOutput, GetBucketReplicationCommandOutput, GetBucketTaggingCommandOutput, GetBucketVersioningCommandOutput, GetObjectAclCommandOutput, GetObjectAttributesCommandInput, GetObjectAttributesCommandOutput, GetObjectCommandInput, GetObjectCommandOutput, GetObjectLegalHoldCommandOutput, GetObjectLockConfigurationCommandOutput, GetObjectRetentionCommandOutput, GetObjectTaggingCommandOutput, GetObjectTorrentCommandOutput, HeadObjectCommandInput, HeadObjectCommandOutput, ListBucketsCommandOutput, ListMultipartUploadsCommandInput, ListMultipartUploadsCommandOutput, ListObjectsV2CommandInput, ListObjectsV2CommandOutput, ListObjectVersionsCommandInput, ListObjectVersionsCommandOutput, ObjectCannedACL, ObjectVersion, Owner, PutBucketAclCommandInput, PutBucketCorsCommandInput, PutBucketEncryptionCommandInput, PutBucketLifecycleConfigurationCommandInput, PutBucketNotificationConfigurationCommandInput, PutBucketPolicyCommandInput, PutBucketReplicationCommandInput, PutBucketTaggingCommandInput, PutBucketTaggingCommandOutput, PutBucketVersioningCommandInput, PutObjectAclCommandInput, PutObjectCommandInput, PutObjectCommandOutput, PutObjectLegalHoldCommandInput, PutObjectLockConfigurationCommandInput, PutObjectRetentionCommandInput, PutObjectTaggingCommandInput, RestoreObjectCommandInput, RestoreObjectCommandOutput, SelectObjectContentCommandInput, SelectObjectContentCommandOutput, Tag, } from '@aws-sdk/client-s3';
+export type { MonacoJsonDefaults, MonacoLanguagesJson } from './monaco';
+/**
+ * S3 backend capabilities configuration.
+ */
+export interface S3Capabilities {
+    bucketEncryption?: boolean;
+    supportedNotificationEvents?: S3EventType[];
+}
+/**
+ * S3 browser configuration options.
+ *
+ * This interface extends the AWS S3 client config with additional options
+ * specific to the data browser library.
+ */
+export interface S3BrowserConfig extends Omit<S3ClientConfig, 'credentials'> {
     endpoint?: string;
     region: string;
     forcePathStyle?: boolean;
-    useDevProxy?: boolean;
-    realS3Host?: string;
-    proxyPath?: string;
-    proxyHost?: string;
-    proxyPort?: number;
+    proxy?: ProxyConfiguration;
     publicAclIndicator?: string;
+    s3Capabilities?: S3Capabilities;
+    features?: string[];
+    /**
+     * Stable identifier for React Query cache isolation.
+     *
+     * When provided, this value is used as the primary cache key instead of
+     * deriving it from credentials. This is essential when credentials change
+     * frequently (e.g., OIDC token refresh triggering new AssumeRole calls)
+     * but represent the same logical identity/permissions.
+     *
+     * @example
+     * // For AssumeRole scenarios, use the role ARN as cacheKey
+     * cacheKey: 'arn:aws:iam::123456789012:role/MyRole'
+     *
+     * @example
+     * // For direct credentials (standalone mode), omit cacheKey
+     * // The library will use accessKeyId as fallback
+     */
+    cacheKey?: string;
 }
+/**
+ * AWS credentials for S3 authentication.
+ */
 export interface S3Credentials extends AwsCredentialIdentity {
-    roleArn?: string;
-    features?: string[];
 }
+/**
+ * Function type that returns the current S3 configuration with credentials.
+ *
+ * This function is called by the DataBrowserProvider to get the latest
+ * configuration. It should return fresh credentials when they have been
+ * refreshed.
+ */
 export type GetConfigFunction = () => S3BrowserConfig & {
     credentials: S3Credentials;
 };
-export interface ObjectInfo {
-    key: string;
-    size?: number;
-    lastModified?: Date;
-    etag?: string;
-    storageClass?: string;
-    owner?: {
-        displayName?: string;
-        id?: string;
-    };
-}
-export interface ObjectVersion extends ObjectInfo {
-    versionId: string;
-    isLatest: boolean;
-    isDeleteMarker?: boolean;
-}
-export interface CommonPrefix {
-    prefix: string;
-}
-export interface ListObjectsResult {
-    objects: ObjectInfo[];
-    commonPrefixes: CommonPrefix[];
-    nextContinuationToken?: string;
-    isTruncated: boolean;
-}
-export type S3ErrorCode = "AccessDenied" | "NoSuchBucket" | "NoSuchKey" | "InvalidBucketName" | "BucketNotFound" | "NetworkError" | "UnknownError";
+export type S3ErrorCode = 'AccessDenied' | 'NoSuchBucket' | 'NoSuchKey' | 'InvalidBucketName' | 'BucketNotFound' | 'NetworkError' | 'UnknownError';
 export interface S3Error extends Error {
     code?: S3ErrorCode;
     statusCode?: number;

package/dist/types/monaco.d.ts

@@ -0,0 +1,13 @@
+export interface MonacoJsonDefaults {
+    setDiagnosticsOptions(options: {
+        validate: boolean;
+        schemas?: Array<{
+            uri: string;
+            fileMatch: string[];
+            schema: unknown;
+        }>;
+    }): void;
+}
+export interface MonacoLanguagesJson {
+    jsonDefaults: MonacoJsonDefaults;
+}

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

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