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

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

@@ -0,0 +1,423 @@
+import { EnhancedS3Error, ErrorCategory, createS3Error, createS3OperationError, isEnhancedS3Error, isNotFoundError, 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("isNotFoundError", ()=>{
+    test("returns true for NOT_FOUND category errors", ()=>{
+        expect(isNotFoundError(TestEnhancedErrors.notFound())).toBe(true);
+    });
+    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);
+        expect(isNotFoundError(error404)).toBe(true);
+    });
+    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);
+        expect(isNotFoundError(TestEnhancedErrors.auth())).toBe(false);
+        expect(isNotFoundError(TestEnhancedErrors.cancelled())).toBe(false);
+        expect(isNotFoundError(TestEnhancedErrors.unknown())).toBe(false);
+    });
+    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", ()=>{
+        expect(isNotFoundError(null)).toBe(false);
+        expect(isNotFoundError(void 0)).toBe(false);
+        expect(isNotFoundError("string")).toBe(false);
+        expect(isNotFoundError({})).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");
+        const result = isNotFoundError(regularError);
+        expect(result).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,51 @@
+import { 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"> {
+    endpoint?: string;
+    region: string;
+    forcePathStyle?: boolean;
+    useDevProxy?: boolean;
+    realS3Host?: string;
+    proxyPath?: string;
+    proxyHost?: string;
+    proxyPort?: number;
+    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/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const BUCKET_TAG_VEEAM_APPLICATION = "X-Scality-Veeam-Application";
+export declare const BUCKET_TAG_APPLICATION = "X-Scality-Application";
+export declare const VEEAM_BACKUP_REPLICATION = "Veeam Backup & Replication";
+export declare const VEEAM_IMMUTABLE_POLICY_NAME = "Scality-Veeam-Immutable-Policy";
+/** Generic identifier for Veeam Backup for Microsoft 365 (VBO) */
+export declare const VEEAM_VBO_APPLICATION = "Veeam Backup for Microsoft 365";
+/** Generic identifier for Veeam Backup for Microsoft 365 (v6, v7) */
+export declare const VEEAM_OFFICE_365 = "Veeam Backup for Microsoft 365 (v6, v7)";
+/** Generic identifier for Veeam Backup for Microsoft 365 (v8+) */
+export declare const VEEAM_OFFICE_365_V8 = "Veeam Backup for Microsoft 365 (v8+)";
+/** Generic identifier for Commvault */
+export declare const COMMVAULT_APPLICATION = "Commvault";

package/dist/utils/constants.js

@@ -0,0 +1,9 @@
+const BUCKET_TAG_VEEAM_APPLICATION = "X-Scality-Veeam-Application";
+const BUCKET_TAG_APPLICATION = "X-Scality-Application";
+const VEEAM_BACKUP_REPLICATION = "Veeam Backup & Replication";
+const VEEAM_IMMUTABLE_POLICY_NAME = "Scality-Veeam-Immutable-Policy";
+const VEEAM_VBO_APPLICATION = "Veeam Backup for Microsoft 365";
+const VEEAM_OFFICE_365 = "Veeam Backup for Microsoft 365 (v6, v7)";
+const VEEAM_OFFICE_365_V8 = "Veeam Backup for Microsoft 365 (v8+)";
+const COMMVAULT_APPLICATION = "Commvault";
+export { BUCKET_TAG_APPLICATION, BUCKET_TAG_VEEAM_APPLICATION, COMMVAULT_APPLICATION, VEEAM_BACKUP_REPLICATION, VEEAM_IMMUTABLE_POLICY_NAME, VEEAM_OFFICE_365, VEEAM_OFFICE_365_V8, VEEAM_VBO_APPLICATION };

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;

package/dist/utils/deletion/messages.js

@@ -0,0 +1,29 @@
+const maybePluralize = (count, word, suffix = "s", includeCount = true)=>{
+    const pluralWord = 1 === count ? word : `${word}${suffix}`;
+    return includeCount ? `${count} ${pluralWord}` : pluralWord;
+};
+const getDeletionMessages = (context)=>{
+    const { numberOfObjects, selectedObjectsAreSpecificVersions, isBucketVersioned } = context;
+    if (!isBucketVersioned) return createNonVersionedDeletionResult(numberOfObjects);
+    if (!selectedObjectsAreSpecificVersions) return createDefaultVersionDeletionResult(numberOfObjects);
+    return createSpecificVersionDeletionResult(numberOfObjects);
+};
+const createNonVersionedDeletionResult = (numberOfObjects)=>({
+        info: `The selected ${maybePluralize(numberOfObjects, "object", "s", false)} will be permanently deleted.`,
+        checkboxRequired: true,
+        confirmationRequired: false,
+        isDeletionPossible: true
+    });
+const createDefaultVersionDeletionResult = (numberOfObjects)=>({
+        info: `${1 === numberOfObjects ? "A delete marker" : "Delete markers"} will be added to the ${maybePluralize(numberOfObjects, "object", "s", false)}.`,
+        checkboxRequired: false,
+        confirmationRequired: false,
+        isDeletionPossible: true
+    });
+const createSpecificVersionDeletionResult = (numberOfObjects)=>({
+        info: `The selected ${maybePluralize(numberOfObjects, "version", "s", false)} will be permanently deleted.`,
+        checkboxRequired: true,
+        confirmationRequired: false,
+        isDeletionPossible: true
+    });
+export { getDeletionMessages };

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

@@ -0,0 +1,11 @@
+export interface DeletionContext {
+    numberOfObjects: number;
+    selectedObjectsAreSpecificVersions: boolean;
+    isBucketVersioned: boolean;
+}
+export interface DeletionResult {
+    info: string;
+    checkboxRequired: boolean;
+    confirmationRequired: boolean;
+    isDeletionPossible: boolean;
+}

package/dist/utils/errorHandling.d.ts

@@ -0,0 +1,63 @@
+import { S3ServiceException } from "@aws-sdk/client-s3";
+/**
+ * Business-level error categories for S3 operations.
+ * Used to determine retry strategy and user messaging.
+ */
+export declare enum ErrorCategory {
+    CLIENT_ERROR = "CLIENT_ERROR",// 4xx errors - don't retry
+    SERVER_ERROR = "SERVER_ERROR",// 5xx errors - can retry
+    NETWORK_ERROR = "NETWORK_ERROR",// Network issues - can retry
+    CANCELLATION = "CANCELLATION",// User cancelled - don't retry
+    AUTHORIZATION = "AUTHORIZATION",// Permission issues - don't retry
+    NOT_FOUND = "NOT_FOUND",// Resource doesn't exist - don't retry
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Enhanced S3 error with business categorization and AWS metadata preservation.
+ * Extends standard Error with retry logic and operation context.
+ */
+export declare class EnhancedS3Error extends Error {
+    readonly category: ErrorCategory;
+    readonly statusCode?: number;
+    readonly metadata?: S3ServiceException["$metadata"];
+    readonly originalError: Error;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, name: string, category: ErrorCategory, originalError: Error, statusCode?: number, metadata?: S3ServiceException["$metadata"], context?: Record<string, unknown>);
+    /**
+     * Determines if this error should be retried based on its category.
+     * Only server errors and network issues are retryable.
+     */
+    shouldRetry(): boolean;
+}
+/**
+ * Type guard to check if an error is an AWS S3 service exception.
+ */
+export declare function isS3ServiceException(error: unknown): error is S3ServiceException;
+/**
+ * Type guard to check if an error is our enhanced S3 error.
+ */
+export declare function isEnhancedS3Error(error: unknown): error is EnhancedS3Error;
+/**
+ * Converts any error into an EnhancedS3Error with proper categorization.
+ * Uses official AWS SDK error types for type-safe error classification.
+ */
+export declare function createS3Error(error: unknown, context?: Record<string, unknown>): EnhancedS3Error;
+/**
+ * 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;
+/**
+ * Determines whether an error should be retried based on its classification.
+ * Implements unified retry policy for all S3 operations.
+ */
+export declare function shouldRetryError(error: unknown, failureCount: number, maxRetries?: number): boolean;
+/**
+ * Checks if an error indicates that a resource was not found (404).
+ * This is useful for distinguishing between "resource doesn't exist" (normal state)
+ * and actual errors (permissions, network issues, etc.).
+ *
+ * @param error - The error to check
+ * @returns true if the error category is NOT_FOUND
+ */
+export declare function isNotFoundError(error: unknown): boolean;