@scality/data-browser-library 1.0.0-preview.2

package/dist/test/testUtils.js

@@ -0,0 +1,236 @@
+import { jsx } from "react/jsx-runtime";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { renderHook } from "@testing-library/react";
+import "react";
+import { DataBrowserProvider } from "../components/providers/DataBrowserProvider.js";
+import { coreUIAvailableThemes } from "@scality/core-ui/dist/style/theme";
+import { CoreUiThemeProvider } from "@scality/core-ui/dist/next";
+import { ToastProvider } from "@scality/core-ui";
+import { overrideHandlers, setupMswServer } from "./msw/index.js";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.g = (()=>{
+        if ('object' == typeof globalThis) return globalThis;
+        try {
+            return this || new Function('return this')();
+        } catch (e) {
+            if ('object' == typeof window) return window;
+        }
+    })();
+})();
+const testConfig = {
+    endpoint: "https://s3.amazonaws.com",
+    region: "us-east-1",
+    forcePathStyle: false
+};
+const testCredentials = {
+    accessKeyId: "test-access-key",
+    secretAccessKey: "test-secret-key",
+    sessionToken: "test-session-token"
+};
+const mockS3Client = {
+    send: jest.fn()
+};
+const MockedS3Client = S3Client;
+const MockedPutObjectCommand = PutObjectCommand;
+function mockOffsetSize(width, height) {
+    __webpack_require__.g.ResizeObserver = jest.fn().mockImplementation(()=>({
+            observe: jest.fn(),
+            unobserve: jest.fn(),
+            disconnect: jest.fn()
+        }));
+    Element.prototype.getBoundingClientRect = jest.fn(()=>({
+            width: width || 800,
+            height: height || 600,
+            top: 0,
+            left: 0,
+            bottom: height || 600,
+            right: width || 800,
+            x: 0,
+            y: 0,
+            toJSON: jest.fn()
+        }));
+    Object.defineProperties(window.HTMLElement.prototype, {
+        offsetHeight: {
+            get: ()=>height || 600,
+            configurable: true
+        },
+        offsetWidth: {
+            get: ()=>width || 800,
+            configurable: true
+        },
+        scrollHeight: {
+            get: ()=>height || 600,
+            configurable: true
+        },
+        scrollWidth: {
+            get: ()=>width || 800,
+            configurable: true
+        }
+    });
+    const mockComputedStyle = {
+        fontSize: "14px",
+        paddingLeft: "0px",
+        paddingRight: "0px",
+        paddingTop: "0px",
+        paddingBottom: "0px",
+        getPropertyValue: jest.fn((prop)=>{
+            const styles = {
+                "font-size": "14px",
+                "padding-left": "0px",
+                "padding-right": "0px",
+                "padding-top": "0px",
+                "padding-bottom": "0px"
+            };
+            return styles[prop] || "";
+        })
+    };
+    jest.spyOn(window, "getComputedStyle").mockImplementation(()=>mockComputedStyle);
+}
+const createQueryWrapper = ()=>{
+    const queryClient = new QueryClient({
+        defaultOptions: {
+            queries: {
+                retry: false
+            },
+            mutations: {
+                retry: false
+            }
+        }
+    });
+    const theme = coreUIAvailableThemes.darkRebrand;
+    return ({ children })=>/*#__PURE__*/ jsx(QueryClientProvider, {
+            client: queryClient,
+            children: /*#__PURE__*/ jsx(CoreUiThemeProvider, {
+                theme: theme,
+                children: children
+            })
+        });
+};
+const createTestWrapper = (config = testConfig, credentials = testCredentials)=>{
+    const queryClient = new QueryClient({
+        defaultOptions: {
+            queries: {
+                retry: false
+            },
+            mutations: {
+                retry: false
+            }
+        }
+    });
+    const getConfig = ()=>({
+            ...config,
+            credentials
+        });
+    const theme = coreUIAvailableThemes.darkRebrand;
+    return ({ children })=>/*#__PURE__*/ jsx(DataBrowserProvider, {
+            queryClient: queryClient,
+            getS3Config: getConfig,
+            theme: theme,
+            enableDevtools: false,
+            children: /*#__PURE__*/ jsx(CoreUiThemeProvider, {
+                theme: theme,
+                children: /*#__PURE__*/ jsx(ToastProvider, {
+                    children: children
+                })
+            })
+        });
+};
+const renderHookWithWrapper = (hook, options)=>{
+    const { config, credentials, ...renderOptions } = options || {};
+    return renderHook(hook, {
+        wrapper: createTestWrapper(config, credentials),
+        ...renderOptions
+    });
+};
+const createTestFile = (name, content, type = "text/plain")=>new File([
+        content
+    ], name, {
+        type
+    });
+const setupS3Mocks = ()=>{
+    jest.clearAllMocks();
+    MockedS3Client.mockImplementation(()=>mockS3Client);
+    MockedPutObjectCommand.mockImplementation((input)=>({
+            input,
+            resolveMiddleware: jest.fn()
+        }));
+};
+const setupCommonMocks = ()=>{
+    setupS3Mocks();
+};
+const overrideGlobalConfig = (overrides)=>{
+    const currentS3 = globalThis.__S3_CONFIG__;
+    const currentDev = globalThis.__DEV_CONFIG__;
+    if (overrides.s3) globalThis.__S3_CONFIG__ = {
+        ...currentS3,
+        ...overrides.s3
+    };
+    if (overrides.dev) globalThis.__DEV_CONFIG__ = {
+        ...currentDev,
+        ...overrides.dev
+    };
+    if (overrides.environment) {
+        if (void 0 !== overrides.environment.isDevelopment) globalThis.__IS_DEVELOPMENT__ = overrides.environment.isDevelopment;
+        if (void 0 !== overrides.environment.isProduction) globalThis.__IS_PRODUCTION__ = overrides.environment.isProduction;
+    }
+};
+const resetGlobalConfig = ()=>{
+    globalThis.__S3_CONFIG__ = {
+        endpoint: "http://localhost:8000",
+        region: "us-east-1",
+        realHost: "s3.amazonaws.com",
+        forcePathStyle: true
+    };
+    globalThis.__DEV_CONFIG__ = {
+        useProxy: false,
+        proxyEndpoint: "http://localhost:3000/api/s3",
+        proxyBasePath: "/api/s3",
+        proxyHost: "localhost",
+        proxyPort: 3000
+    };
+    globalThis.__IS_DEVELOPMENT__ = true;
+    globalThis.__IS_PRODUCTION__ = false;
+};
+const withGlobalConfig = (overrides, testFn)=>async ()=>{
+        overrideGlobalConfig(overrides);
+        try {
+            await testFn();
+        } finally{
+            resetGlobalConfig();
+        }
+    };
+const validateFactoryHook = (hook, operationName)=>{
+    if ("function" != typeof hook) throw createFactoryTestError("Factory Validation", operationName, "hook should be a function - check if useCreate*Hook factory is properly returning a hook function");
+};
+const createFactoryTestError = (testContext, operationName, details)=>new Error(`Factory Test Failure [${testContext}]: ${operationName} - ${details || "Unknown error"}. Check factory implementation and hook usage patterns.`);
+const validateHookResult = (result, hookType)=>{
+    const commonProps = [
+        "isError",
+        "isSuccess",
+        "data",
+        "error"
+    ];
+    const queryProps = [
+        "isLoading"
+    ];
+    const mutationProps = [
+        "mutate",
+        "mutateAsync",
+        "isPending"
+    ];
+    const infiniteProps = [
+        "hasNextPage",
+        "fetchNextPage",
+        "isFetchingNextPage"
+    ];
+    const expectedProps = [
+        ...commonProps,
+        ..."query" === hookType ? queryProps : [],
+        ..."mutation" === hookType ? mutationProps : [],
+        ..."infiniteQuery" === hookType ? infiniteProps : []
+    ];
+    for (const prop of expectedProps)if (!(prop in result)) throw createFactoryTestError("Hook Validation", hookType, `Missing property '${prop}' - check if factory is returning proper React Query hook result`);
+};
+export { MockedPutObjectCommand, MockedS3Client, createFactoryTestError, createQueryWrapper, createTestFile, createTestWrapper, mockOffsetSize, mockS3Client, overrideGlobalConfig, overrideHandlers, renderHookWithWrapper, resetGlobalConfig, setupCommonMocks, setupMswServer, setupS3Mocks, testConfig, testCredentials, validateFactoryHook, validateHookResult, withGlobalConfig };

package/dist/test/utils/errorHandling.test.d.ts

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

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

@@ -0,0 +1,385 @@
+import { EnhancedS3Error, ErrorCategory, createS3Error, createS3OperationError, isEnhancedS3Error, isS3ServiceException, shouldRetryError } from "../../utils/errorHandling.js";
+const TEST_CONSTANTS = {
+    REQUEST_ID: "test-request-id",
+    ATTEMPTS: 1,
+    RETRY_DELAY: 0,
+    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"
+    }
+};
+const createMockAWSError = (errorType, message, statusCode = 500)=>{
+    const error = new Error(message);
+    Object.defineProperty(error, "name", {
+        value: errorType,
+        writable: true
+    });
+    error.$metadata = {
+        httpStatusCode: statusCode,
+        requestId: TEST_CONSTANTS.REQUEST_ID,
+        attempts: TEST_CONSTANTS.ATTEMPTS,
+        totalRetryDelay: TEST_CONSTANTS.RETRY_DELAY
+    };
+    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),
+    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",
+            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())
+};
+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");
+        const metadata = {
+            httpStatusCode: 400,
+            requestId: TEST_CONSTANTS.REQUEST_ID,
+            attempts: TEST_CONSTANTS.ATTEMPTS,
+            totalRetryDelay: TEST_CONSTANTS.RETRY_DELAY
+        };
+        const context = {
+            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");
+        expect(error.category).toBe(ErrorCategory.CLIENT_ERROR);
+        expect(error.statusCode).toBe(400);
+        expect(error.metadata).toBe(metadata);
+        expect(error.originalError).toBe(originalError);
+        expect(error.context).toBe(context);
+        expect(error instanceof Error).toBe(true);
+        expect(error instanceof EnhancedS3Error).toBe(true);
+    });
+    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", ()=>{
+            expect(TestEnhancedErrors.client().shouldRetry()).toBe(false);
+            expect(TestEnhancedErrors.auth().shouldRetry()).toBe(false);
+            expect(TestEnhancedErrors.notFound().shouldRetry()).toBe(false);
+            expect(TestEnhancedErrors.cancelled().shouldRetry()).toBe(false);
+            expect(TestEnhancedErrors.unknown().shouldRetry()).toBe(false);
+        });
+    });
+});
+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 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", ()=>{
+            expect(isEnhancedS3Error(TestEnhancedErrors.unknown())).toBe(true);
+        });
+        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);
+        });
+    });
+});
+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.category).toBe(ErrorCategory.CANCELLATION);
+        expect(result.originalError).toBe(abortError);
+    });
+    test("handles specific AWS errors", ()=>{
+        const testCases = [
+            {
+                error: TestErrors.noSuchBucket(),
+                expectedCategory: ErrorCategory.NOT_FOUND,
+                expectedName: "NoSuchBucket",
+                expectedStatus: 404
+            },
+            {
+                error: TestErrors.noSuchKey(),
+                expectedCategory: ErrorCategory.NOT_FOUND,
+                expectedName: "NoSuchKey",
+                expectedStatus: 404
+            },
+            {
+                error: TestErrors.invalidRequest(),
+                expectedCategory: ErrorCategory.CLIENT_ERROR,
+                expectedName: "InvalidRequest",
+                expectedStatus: 400
+            }
+        ];
+        testCases.forEach(({ error, expectedCategory, expectedName, expectedStatus })=>{
+            const result = createS3Error(error);
+            expect(result.category).toBe(expectedCategory);
+            expect(result.name).toBe(expectedName);
+            expect(result.statusCode).toBe(expectedStatus);
+            expect(result.metadata).toBe(error.$metadata);
+        });
+    });
+    test("handles status code classification", ()=>{
+        const testCases = [
+            {
+                error: TestErrors.accessDenied(),
+                expectedCategory: ErrorCategory.AUTHORIZATION
+            },
+            {
+                error: TestErrors.internalError(),
+                expectedCategory: ErrorCategory.SERVER_ERROR
+            }
+        ];
+        testCases.forEach(({ error, expectedCategory })=>{
+            const result = createS3Error(error);
+            expect(result.category).toBe(expectedCategory);
+        });
+    });
+    test("handles network errors", ()=>{
+        const testCases = [
+            TestErrors.networkError(),
+            TestErrors.timeoutError()
+        ];
+        testCases.forEach((error)=>{
+            const result = createS3Error(error);
+            expect(result.category).toBe(ErrorCategory.NETWORK_ERROR);
+        });
+    });
+    test("handles edge cases", ()=>{
+        const testCases = [
+            {
+                input: new Error("Some error"),
+                expectedCategory: ErrorCategory.UNKNOWN,
+                expectedMessage: "Some error"
+            },
+            {
+                input: "String error",
+                expectedCategory: ErrorCategory.UNKNOWN,
+                expectedMessage: "String error",
+                expectedName: "UnknownError"
+            },
+            {
+                input: null,
+                expectedCategory: ErrorCategory.UNKNOWN,
+                expectedMessage: "Unknown error occurred"
+            },
+            {
+                input: void 0,
+                expectedCategory: ErrorCategory.UNKNOWN,
+                expectedMessage: "Unknown error occurred"
+            }
+        ];
+        testCases.forEach(({ input, expectedCategory, expectedMessage, expectedName })=>{
+            const result = createS3Error(input);
+            expect(result.category).toBe(expectedCategory);
+            expect(result.message).toBe(expectedMessage);
+            if (expectedName) expect(result.name).toBe(expectedName);
+        });
+    });
+    test("preserves context", ()=>{
+        const context = {
+            operation: "test",
+            bucket: TEST_CONSTANTS.BUCKET
+        };
+        const result = createS3Error(new Error("Test error"), context);
+        expect(result.context).toBe(context);
+    });
+});
+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 all error properties", ()=>{
+        const originalError = TestErrors.noSuchBucket();
+        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", ()=>{
+        const retryableError = TestEnhancedErrors.server();
+        const maxRetries = 3;
+        expect(shouldRetryError(retryableError, 0, maxRetries)).toBe(true);
+        expect(shouldRetryError(retryableError, 2, maxRetries)).toBe(true);
+        expect(shouldRetryError(retryableError, 3, maxRetries)).toBe(false);
+        expect(shouldRetryError(retryableError, 5, maxRetries)).toBe(false);
+    });
+    test("uses error category for retry decision", ()=>{
+        const testCases = [
+            {
+                error: TestEnhancedErrors.server(),
+                shouldRetry: true
+            },
+            {
+                error: TestEnhancedErrors.network(),
+                shouldRetry: true
+            },
+            {
+                error: TestEnhancedErrors.client(),
+                shouldRetry: false
+            },
+            {
+                error: TestEnhancedErrors.auth(),
+                shouldRetry: false
+            }
+        ];
+        testCases.forEach(({ error, shouldRetry })=>{
+            expect(shouldRetryError(error, 0)).toBe(shouldRetry);
+        });
+    });
+    test("converts and retries AWS errors", ()=>{
+        const testCases = [
+            {
+                error: TestErrors.internalError(),
+                shouldRetry: true
+            },
+            {
+                error: TestErrors.invalidRequest(),
+                shouldRetry: false
+            }
+        ];
+        testCases.forEach(({ error, shouldRetry })=>{
+            expect(shouldRetryError(error, 0)).toBe(shouldRetry);
+        });
+    });
+    test("uses default maxRetries of 3", ()=>{
+        const retryableError = TestEnhancedErrors.server();
+        expect(shouldRetryError(retryableError, 0)).toBe(true);
+        expect(shouldRetryError(retryableError, 3)).toBe(false);
+    });
+});
+describe("Integration Tests", ()=>{
+    test("complete error processing workflow", ()=>{
+        const testCases = [
+            {
+                name: "NoSuchBucket - non-retryable",
+                originalError: TestErrors.noSuchBucket(),
+                operation: "ListObjectsV2",
+                bucket: TEST_CONSTANTS.BUCKET,
+                expectedCategory: ErrorCategory.NOT_FOUND,
+                shouldRetry: false
+            },
+            {
+                name: "Server error - retryable",
+                originalError: TestErrors.serviceUnavailable(),
+                operation: "PutObject",
+                bucket: TEST_CONSTANTS.BUCKET,
+                key: TEST_CONSTANTS.KEY,
+                expectedCategory: ErrorCategory.SERVER_ERROR,
+                shouldRetry: true
+            }
+        ];
+        testCases.forEach(({ originalError, operation, bucket, key, expectedCategory, shouldRetry })=>{
+            const operationError = createS3OperationError(originalError, operation, bucket, key);
+            expect(operationError.category).toBe(expectedCategory);
+            expect(operationError.shouldRetry()).toBe(shouldRetry);
+            expect(isEnhancedS3Error(operationError)).toBe(true);
+            expect(shouldRetryError(operationError, 0)).toBe(shouldRetry);
+            expect(shouldRetryError(operationError, 3)).toBe(false);
+        });
+    });
+    test("retry attempt progression", ()=>{
+        const serverError = TestErrors.serviceUnavailable();
+        const operationError = createS3OperationError(serverError, "PutObject", TEST_CONSTANTS.BUCKET, TEST_CONSTANTS.KEY);
+        [
+            0,
+            1,
+            2
+        ].forEach((attempt)=>{
+            expect(shouldRetryError(operationError, attempt)).toBe(true);
+        });
+        expect(shouldRetryError(operationError, 3)).toBe(false);
+    });
+});

package/dist/types/index.d.ts

@@ -0,0 +1,48 @@
+import { S3ClientConfig } from "@aws-sdk/client-s3";
+import type { AwsCredentialIdentity } from "@aws-sdk/types";
+export interface S3BrowserConfig extends Omit<S3ClientConfig, "credentials"> {
+    endpoint?: string;
+    region: string;
+    forcePathStyle?: boolean;
+    useDevProxy?: boolean;
+    realS3Host?: string;
+    proxyPath?: string;
+    publicAclIndicator?: string;
+}
+export interface S3Credentials extends AwsCredentialIdentity {
+    roleArn?: string;
+    features?: string[];
+}
+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 interface S3Error extends Error {
+    code?: S3ErrorCode;
+    statusCode?: number;
+}

package/dist/utils/deletion/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./messages";

package/dist/utils/deletion/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./messages.js";

package/dist/utils/deletion/messages.d.ts

@@ -0,0 +1,5 @@
+import { DeletionContext, DeletionResult } from "./types";
+/**
+ * Determines deletion behavior based on bucket versioning
+ */
+export declare const getDeletionMessages: (context: DeletionContext) => DeletionResult;