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

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

@@ -1,4 +1,4 @@
-import { EnhancedS3Error, ErrorCategory, createS3Error, createS3OperationError, isEnhancedS3Error, isS3ServiceException, shouldRetryError } from "../../utils/errorHandling.js";
+import { EnhancedS3Error, ErrorCategory, createS3Error, createS3OperationError, isEnhancedS3Error, isNotFoundError, isS3ServiceException, shouldRetryError } from "../../utils/errorHandling.js";
 const TEST_CONSTANTS = {
     REQUEST_ID: "test-request-id",
     ATTEMPTS: 1,
@@ -340,6 +340,44 @@ describe("shouldRetryError", ()=>{
         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 = [

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/errorHandling.d.ts

@@ -52,3 +52,12 @@ export declare function createS3OperationError(error: unknown, operation: string
  * 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;

package/dist/utils/errorHandling.js

@@ -76,4 +76,9 @@ function shouldRetryError(error, failureCount, maxRetries = 3) {
     if (failureCount >= maxRetries) return false;
     return isEnhancedS3Error(error) ? error.shouldRetry() : createS3Error(error).shouldRetry();
 }
-export { EnhancedS3Error, errorHandling_ErrorCategory as ErrorCategory, createS3Error, createS3OperationError, isEnhancedS3Error, isS3ServiceException, shouldRetryError };
+function isNotFoundError(error) {
+    if (!error) return false;
+    const enhancedError = isEnhancedS3Error(error) ? error : createS3Error(error);
+    return "NOT_FOUND" === enhancedError.category;
+}
+export { EnhancedS3Error, errorHandling_ErrorCategory as ErrorCategory, createS3Error, createS3OperationError, isEnhancedS3Error, isNotFoundError, isS3ServiceException, shouldRetryError };

package/dist/utils/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./s3Client";
 export * from "./errorHandling";
+export * from "./constants";
+export * from "./s3RuleUtils";

package/dist/utils/index.js

@@ -1,2 +1,4 @@
 export * from "./s3Client.js";
 export * from "./errorHandling.js";
+export * from "./constants.js";
+export * from "./s3RuleUtils.js";

package/dist/utils/s3RuleUtils.d.ts

@@ -0,0 +1,53 @@
+export declare const AWS_RULE_LIMITS: {
+    RULE_ID_MAX_LENGTH: number;
+    TAG_KEY_MAX_LENGTH: number;
+    TAG_VALUE_MAX_LENGTH: number;
+};
+export declare const STATUS_OPTIONS: readonly [{
+    readonly value: "Enabled";
+    readonly label: "Enabled";
+}, {
+    readonly value: "Disabled";
+    readonly label: "Disabled";
+}];
+export type FilterType = "none" | "prefix" | "tags" | "and";
+/**
+ * Filter data for S3 rules. All fields are present for form handling,
+ * but only certain fields are used based on filterType.
+ */
+export interface FilterData {
+    filterType: FilterType;
+    prefix: string;
+    tags: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+/**
+ * Type-safe filter specification for S3 rule building.
+ * Each variant only includes the fields relevant to that filter type.
+ */
+export type FilterSpec = {
+    type: "none";
+} | {
+    type: "prefix";
+    prefix: string;
+} | {
+    type: "tags";
+    tags: Array<{
+        key: string;
+        value: string;
+    }>;
+} | {
+    type: "and";
+    prefix: string;
+    tags: Array<{
+        key: string;
+        value: string;
+    }>;
+};
+/**
+ * Converts form FilterData to type-safe FilterSpec.
+ */
+export declare function toFilterSpec(data: FilterData): FilterSpec;
+export declare function buildS3Filter(data: FilterData): Record<string, unknown>;

package/dist/utils/s3RuleUtils.js

@@ -0,0 +1,101 @@
+const AWS_RULE_LIMITS = {
+    RULE_ID_MAX_LENGTH: 255,
+    TAG_KEY_MAX_LENGTH: 128,
+    TAG_VALUE_MAX_LENGTH: 256
+};
+const STATUS_OPTIONS = [
+    {
+        value: "Enabled",
+        label: "Enabled"
+    },
+    {
+        value: "Disabled",
+        label: "Disabled"
+    }
+];
+function toFilterSpec(data) {
+    switch(data.filterType){
+        case "none":
+            return {
+                type: "none"
+            };
+        case "prefix":
+            return {
+                type: "prefix",
+                prefix: data.prefix
+            };
+        case "tags":
+            return {
+                type: "tags",
+                tags: data.tags
+            };
+        case "and":
+            return {
+                type: "and",
+                prefix: data.prefix,
+                tags: data.tags
+            };
+    }
+}
+function buildS3Filter(data) {
+    const spec = toFilterSpec(data);
+    switch(spec.type){
+        case "none":
+            return {};
+        case "prefix":
+            return {
+                Prefix: spec.prefix
+            };
+        case "tags":
+            if (0 === spec.tags.length) return {};
+            if (1 === spec.tags.length) return {
+                Tag: {
+                    Key: spec.tags[0].key,
+                    Value: spec.tags[0].value
+                }
+            };
+            return {
+                And: {
+                    Tags: spec.tags.map((tag)=>({
+                            Key: tag.key,
+                            Value: tag.value
+                        }))
+                }
+            };
+        case "and":
+            {
+                const hasPrefix = spec.prefix && "" !== spec.prefix.trim();
+                const hasTags = spec.tags.length > 0;
+                if (!hasTags && !hasPrefix) return {};
+                if (!hasTags && hasPrefix) return {
+                    Prefix: spec.prefix
+                };
+                if (hasTags && !hasPrefix) {
+                    if (1 === spec.tags.length) return {
+                        Tag: {
+                            Key: spec.tags[0].key,
+                            Value: spec.tags[0].value
+                        }
+                    };
+                    return {
+                        And: {
+                            Tags: spec.tags.map((tag)=>({
+                                    Key: tag.key,
+                                    Value: tag.value
+                                }))
+                        }
+                    };
+                }
+                return {
+                    And: {
+                        Prefix: spec.prefix,
+                        Tags: spec.tags.map((tag)=>({
+                                Key: tag.key,
+                                Value: tag.value
+                            }))
+                    }
+                };
+            }
+    }
+}
+export { AWS_RULE_LIMITS, STATUS_OPTIONS, buildS3Filter, toFilterSpec };

package/package.json

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