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

package/dist/components/ui/ArrayFieldActions.js

@@ -0,0 +1,38 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Button } from "@scality/core-ui/dist/next";
+import { Icon } from "@scality/core-ui";
+function ArrayFieldActions({ onRemove, onAdd, canRemove, canAdd = true, showAdd, removeLabel = "Remove", addLabel = "Add" }) {
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(Button, {
+                icon: /*#__PURE__*/ jsx(Icon, {
+                    name: "Remove-minus"
+                }),
+                variant: "danger",
+                type: "button",
+                onClick: onRemove,
+                "aria-label": removeLabel,
+                disabled: !canRemove,
+                tooltip: {
+                    overlay: removeLabel,
+                    placement: "top"
+                }
+            }),
+            showAdd && /*#__PURE__*/ jsx(Button, {
+                icon: /*#__PURE__*/ jsx(Icon, {
+                    name: "Add-plus"
+                }),
+                variant: "outline",
+                type: "button",
+                onClick: onAdd,
+                "aria-label": addLabel,
+                tooltip: {
+                    overlay: addLabel,
+                    placement: "top"
+                },
+                disabled: !canAdd
+            })
+        ]
+    });
+}
+export { ArrayFieldActions };

package/dist/components/ui/ConfirmDeleteRuleModal.d.ts

@@ -0,0 +1,16 @@
+interface ConfirmDeleteRuleModalProps {
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Rule ID to display in confirmation message */
+    ruleId: string;
+    /** Type of rule (e.g., "lifecycle", "replication") */
+    ruleType: "lifecycle" | "replication";
+    /** Whether deletion is in progress */
+    isDeleting: boolean;
+    /** Callback when user confirms deletion */
+    onConfirm: () => void;
+    /** Callback when user cancels deletion */
+    onCancel: () => void;
+}
+export declare function ConfirmDeleteRuleModal({ isOpen, ruleId, ruleType, isDeleting, onConfirm, onCancel, }: ConfirmDeleteRuleModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/ConfirmDeleteRuleModal.js

@@ -0,0 +1,43 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Loader, Modal, Stack, Wrap } from "@scality/core-ui";
+import { Button } from "@scality/core-ui/dist/next";
+function ConfirmDeleteRuleModal({ isOpen, ruleId, ruleType, isDeleting, onConfirm, onCancel }) {
+    const ruleTypeLabel = "lifecycle" === ruleType ? "Lifecycle" : "Replication";
+    return /*#__PURE__*/ jsxs(Modal, {
+        close: onCancel,
+        isOpen: isOpen,
+        footer: /*#__PURE__*/ jsxs(Wrap, {
+            children: [
+                /*#__PURE__*/ jsx("p", {}),
+                /*#__PURE__*/ jsxs(Stack, {
+                    children: [
+                        /*#__PURE__*/ jsx(Button, {
+                            variant: "outline",
+                            onClick: onCancel,
+                            label: "Cancel",
+                            disabled: isDeleting
+                        }),
+                        /*#__PURE__*/ jsx(Button, {
+                            variant: "danger",
+                            onClick: onConfirm,
+                            icon: isDeleting && /*#__PURE__*/ jsx(Loader, {
+                                size: "larger"
+                            }),
+                            label: "Delete",
+                            disabled: isDeleting
+                        })
+                    ]
+                })
+            ]
+        }),
+        title: `Delete ${ruleTypeLabel} Rule`,
+        children: [
+            "Are you sure you want to delete the ",
+            ruleType,
+            ' rule "',
+            ruleId,
+            '"?'
+        ]
+    });
+}
+export { ConfirmDeleteRuleModal };

package/dist/components/ui/FilterFormSection.d.ts

@@ -0,0 +1,44 @@
+import { UseFormRegisterReturn } from "react-hook-form";
+export interface FilterFormValues {
+    filterType: "none" | "prefix" | "tags" | "and";
+    prefix: string;
+    tags: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+interface FilterFormSectionProps {
+    filterType: string;
+    onFilterTypeChange: (value: string) => void;
+    prefixRegister: UseFormRegisterReturn;
+    tagFields: Array<{
+        id: string;
+        key: string;
+        value: string;
+    }>;
+    tagKeyRegister: (index: number) => UseFormRegisterReturn;
+    tagValueRegister: (index: number) => UseFormRegisterReturn;
+    getTagKeyValue: (index: number) => string;
+    getTagValueValue: (index: number) => string;
+    appendTag: (value: {
+        key: string;
+        value: string;
+    }) => void;
+    removeTag: (index: number) => void;
+    errors?: {
+        prefix?: {
+            message?: string;
+        };
+        tags?: {
+            message?: string;
+        };
+    };
+    forceLabelWidth?: number;
+}
+export declare function FilterFormSection({ filterType, onFilterTypeChange, prefixRegister, tagFields, tagKeyRegister, tagValueRegister, getTagKeyValue, getTagValueValue, appendTag, removeTag, errors, forceLabelWidth, }: FilterFormSectionProps): import("react/jsx-runtime").JSX.Element;
+export declare const createFilterValidationSchema: (Joi: typeof import("joi")) => {
+    filterType: import("joi").StringSchema<string>;
+    prefix: import("joi").AlternativesSchema<any>;
+    tags: import("joi").AlternativesSchema<any>;
+};
+export {};

package/dist/components/ui/FilterFormSection.js

@@ -0,0 +1,159 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { FormGroup, FormSection, Stack, Text } from "@scality/core-ui";
+import { convertRemToPixels } from "@scality/core-ui/dist/components/tablev2/TableUtils";
+import { Box, Input, Select } from "@scality/core-ui/dist/next";
+import { ArrayFieldActions } from "./ArrayFieldActions.js";
+const filterTypeOptions = [
+    {
+        value: "none",
+        label: "All objects"
+    },
+    {
+        value: "prefix",
+        label: "Prefix filter"
+    },
+    {
+        value: "tags",
+        label: "Tags filter"
+    },
+    {
+        value: "and",
+        label: "Prefix and tags filter"
+    }
+];
+const shouldShowPrefix = (filterType)=>"prefix" === filterType || "and" === filterType;
+const shouldShowTags = (filterType)=>"tags" === filterType || "and" === filterType;
+function FilterFormSection({ filterType, onFilterTypeChange, prefixRegister, tagFields, tagKeyRegister, tagValueRegister, getTagKeyValue, getTagValueValue, appendTag, removeTag, errors, forceLabelWidth = convertRemToPixels(15) }) {
+    return /*#__PURE__*/ jsxs(FormSection, {
+        title: {
+            name: "Filter"
+        },
+        forceLabelWidth: forceLabelWidth,
+        children: [
+            /*#__PURE__*/ jsx(FormGroup, {
+                label: "Filter",
+                id: "filterType",
+                direction: "horizontal",
+                content: /*#__PURE__*/ jsx(Select, {
+                    id: "filterType",
+                    value: filterType,
+                    onChange: onFilterTypeChange,
+                    children: filterTypeOptions.map((option)=>/*#__PURE__*/ jsx(Select.Option, {
+                            value: option.value,
+                            children: option.label
+                        }, option.value))
+                })
+            }),
+            shouldShowPrefix(filterType) ? /*#__PURE__*/ jsx(FormGroup, {
+                label: "Prefix",
+                id: "prefix",
+                direction: "horizontal",
+                error: errors?.prefix?.message,
+                helpErrorPosition: "bottom",
+                required: "prefix" === filterType,
+                content: /*#__PURE__*/ jsx(Input, {
+                    id: "prefix",
+                    placeholder: "folder/",
+                    ...prefixRegister
+                })
+            }) : /*#__PURE__*/ jsx(Fragment, {}),
+            shouldShowTags(filterType) ? /*#__PURE__*/ jsx(FormGroup, {
+                label: "Tags",
+                id: "tags",
+                direction: "horizontal",
+                error: errors?.tags?.message,
+                helpErrorPosition: "bottom",
+                required: true,
+                content: /*#__PURE__*/ jsxs(Stack, {
+                    direction: "vertical",
+                    gap: "r8",
+                    children: [
+                        /*#__PURE__*/ jsxs(Stack, {
+                            gap: "r8",
+                            children: [
+                                /*#__PURE__*/ jsx(Box, {
+                                    flex: "1",
+                                    children: /*#__PURE__*/ jsx(Text, {
+                                        color: "textSecondary",
+                                        children: "Key"
+                                    })
+                                }),
+                                /*#__PURE__*/ jsx(Box, {
+                                    flex: "1",
+                                    children: /*#__PURE__*/ jsx(Text, {
+                                        color: "textSecondary",
+                                        children: "Value"
+                                    })
+                                }),
+                                /*#__PURE__*/ jsx(Box, {
+                                    width: "80px"
+                                })
+                            ]
+                        }),
+                        tagFields.map((field, index)=>/*#__PURE__*/ jsxs(Stack, {
+                                gap: "r8",
+                                children: [
+                                    /*#__PURE__*/ jsx(Input, {
+                                        id: `tag-key-${index}`,
+                                        placeholder: "Key",
+                                        size: "1/2",
+                                        ...tagKeyRegister(index)
+                                    }),
+                                    /*#__PURE__*/ jsx(Input, {
+                                        id: `tag-value-${index}`,
+                                        placeholder: "Value",
+                                        size: "1/2",
+                                        ...tagValueRegister(index)
+                                    }),
+                                    /*#__PURE__*/ jsx(ArrayFieldActions, {
+                                        showAdd: index === tagFields.length - 1,
+                                        onRemove: ()=>removeTag(index),
+                                        onAdd: ()=>appendTag({
+                                                key: "",
+                                                value: ""
+                                            }),
+                                        canRemove: tagFields.length > 1,
+                                        canAdd: !!getTagKeyValue(index) && !!getTagValueValue(index),
+                                        removeLabel: "Remove tag",
+                                        addLabel: "Add tag"
+                                    })
+                                ]
+                            }, field.id))
+                    ]
+                })
+            }) : /*#__PURE__*/ jsx(Fragment, {})
+        ]
+    });
+}
+const createFilterValidationSchema = (Joi)=>({
+        filterType: Joi.string().valid("none", "prefix", "tags", "and").required(),
+        prefix: Joi.when("filterType", {
+            is: "prefix",
+            then: Joi.string().required().min(1).messages({
+                "string.empty": "Prefix is required when using prefix filter",
+                "string.min": "Prefix is required when using prefix filter"
+            }),
+            otherwise: Joi.when("filterType", {
+                is: "and",
+                then: Joi.string().allow("").optional(),
+                otherwise: Joi.any()
+            })
+        }),
+        tags: Joi.when("filterType", {
+            is: Joi.valid("tags", "and"),
+            then: Joi.array().items(Joi.object({
+                key: Joi.string().required().max(128).messages({
+                    "string.empty": "Tag key is required",
+                    "string.max": "Tag key must not exceed 128 characters"
+                }),
+                value: Joi.string().required().max(256).messages({
+                    "string.empty": "Tag value is required",
+                    "string.max": "Tag value must not exceed 256 characters"
+                })
+            })).min(1).messages({
+                "array.min": "At least one tag is required when using tag filter"
+            }),
+            otherwise: Joi.array().optional()
+        })
+    });
+export { FilterFormSection, createFilterValidationSchema };

package/dist/config/factory.d.ts

@@ -1,5 +1,15 @@
 import type { S3ClientConfiguration } from "./types";
 import type { S3BrowserConfig, S3Credentials } from "../types";
+import { CoreUIThemeName } from "@scality/core-ui/dist/style/theme";
+interface RuntimeConfig {
+    s3: {
+        endpoint?: string;
+        region: string;
+        forcePathStyle?: boolean;
+    };
+    theme?: CoreUIThemeName;
+    basePath?: string;
+}
 /**
  * Configuration factory that uses build-time constants
  * No runtime environment detection or hardcoded values
@@ -9,7 +19,7 @@ export declare class S3ConfigurationFactory {
      * Load runtime configuration from config.json
      * Should be called at app startup
      */
-    static loadRuntimeConfig(): Promise<void>;
+    static loadRuntimeConfig(configUrl: string): Promise<RuntimeConfig | null>;
     private static getBuildTimeConfig;
     /**
      * Create S3 client configuration based on build-time settings
@@ -49,4 +59,5 @@ export declare const getBuildInfo: () => {
     s3Endpoint: string;
     proxyEndpoint: string | undefined;
 };
-export declare const loadRuntimeConfig: () => Promise<void>;
+export declare const loadRuntimeConfig: (configUrl: string) => Promise<RuntimeConfig | null>;
+export {};

package/dist/config/factory.js

@@ -1,15 +1,18 @@
 let runtimeConfig = null;
 class S3ConfigurationFactory {
-    static async loadRuntimeConfig() {
+    static async loadRuntimeConfig(configUrl) {
         try {
-            const response = await fetch("/_/s3-browser/config.json");
+            const response = await fetch(configUrl);
             if (response.ok) {
                 const data = await response.json();
-                runtimeConfig = data.s3;
-                console.log("Loaded runtime S3 configuration:", runtimeConfig);
+                runtimeConfig = data;
+                console.log("Loaded runtime configuration:", runtimeConfig);
+                return data;
             }
+            return null;
         } catch (error) {
             console.warn("Could not load runtime config, using build-time config:", error);
+            return null;
         }
     }
     static getBuildTimeConfig() {
@@ -22,7 +25,7 @@ class S3ConfigurationFactory {
     }
     static createClientConfiguration(credentials) {
         const buildConfig = this.getBuildTimeConfig();
-        const s3Config = buildConfig.isProduction && runtimeConfig ? runtimeConfig : buildConfig.s3;
+        const s3Config = buildConfig.isProduction && runtimeConfig?.s3 ? runtimeConfig.s3 : buildConfig.s3;
         const baseConfig = {
             credentials,
             region: s3Config.region,
@@ -66,5 +69,5 @@ const createS3Config = (credentials)=>S3ConfigurationFactory.createClientConfigu
 const shouldUseProxy = ()=>S3ConfigurationFactory.shouldUseProxyMiddleware();
 const getProxyConfig = ()=>S3ConfigurationFactory.createProxyConfiguration();
 const getBuildInfo = ()=>S3ConfigurationFactory.getBuildInfo();
-const loadRuntimeConfig = ()=>S3ConfigurationFactory.loadRuntimeConfig();
+const loadRuntimeConfig = (configUrl)=>S3ConfigurationFactory.loadRuntimeConfig(configUrl);
 export { S3ConfigurationFactory, createS3Config, getBuildInfo, getProxyConfig, loadRuntimeConfig, shouldUseProxy };

package/dist/hooks/__tests__/useISVBucketDetection.test.d.ts

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

package/dist/hooks/__tests__/useISVBucketDetection.test.js

@@ -0,0 +1,188 @@
+import { renderHook } from "@testing-library/react";
+import { useISVBucketStatus } from "../useISVBucketDetection.js";
+import { useGetBucketTagging } from "../bucketConfiguration.js";
+import { useFeatures } from "../../utils/useFeatures.js";
+import { BUCKET_TAG_APPLICATION, BUCKET_TAG_VEEAM_APPLICATION, COMMVAULT_APPLICATION, VEEAM_BACKUP_REPLICATION, VEEAM_OFFICE_365, VEEAM_OFFICE_365_V8, VEEAM_VBO_APPLICATION } from "../../utils/constants.js";
+import { createTestWrapper } from "../../test/testUtils.js";
+jest.mock("../bucketConfiguration");
+jest.mock("../../utils/useFeatures");
+const mockUseGetBucketTagging = useGetBucketTagging;
+const mockUseFeatures = useFeatures;
+describe("useISVBucketStatus", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockUseFeatures.mockReturnValue(true);
+    });
+    it("should return false for all flags when ISV feature is disabled", ()=>{
+        mockUseFeatures.mockReturnValue(false);
+        mockUseGetBucketTagging.mockReturnValue({
+            data: void 0,
+            status: "success"
+        });
+        const { result } = renderHook(()=>useISVBucketStatus("test-bucket"), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(false);
+        expect(result.current.isCommvaultBucket).toBe(false);
+        expect(result.current.isISVManaged).toBe(false);
+        expect(result.current.isvApplication).toBeUndefined();
+        expect(result.current.isLoading).toBe(false);
+    });
+    it("should detect Veeam Backup & Replication bucket", ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_VEEAM_APPLICATION,
+                        Value: VEEAM_BACKUP_REPLICATION
+                    }
+                ]
+            },
+            status: "success"
+        });
+        const { result } = renderHook(()=>useISVBucketStatus("test-bucket"), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(true);
+        expect(result.current.isCommvaultBucket).toBe(false);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe("Veeam");
+    });
+    it("should detect Veeam Office 365 v6/v7 bucket", ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_VEEAM_APPLICATION,
+                        Value: VEEAM_OFFICE_365
+                    }
+                ]
+            },
+            status: "success"
+        });
+        const { result } = renderHook(()=>useISVBucketStatus("test-bucket"), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(true);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe("Veeam");
+    });
+    it("should detect Veeam Office 365 v8+ bucket", ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_VEEAM_APPLICATION,
+                        Value: VEEAM_OFFICE_365_V8
+                    }
+                ]
+            },
+            status: "success"
+        });
+        const { result } = renderHook(()=>useISVBucketStatus("test-bucket"), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(true);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe("Veeam");
+    });
+    it("should detect ISV bucket tagged as Veeam Backup & Replication", ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_APPLICATION,
+                        Value: VEEAM_BACKUP_REPLICATION
+                    }
+                ]
+            },
+            status: "success"
+        });
+        const { result } = renderHook(()=>useISVBucketStatus("test-bucket"), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(true);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe("Veeam");
+    });
+    it("should detect ISV bucket tagged as Veeam VBO", ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_APPLICATION,
+                        Value: VEEAM_VBO_APPLICATION
+                    }
+                ]
+            },
+            status: "success"
+        });
+        const { result } = renderHook(()=>useISVBucketStatus("test-bucket"), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(true);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe("Veeam");
+    });
+    it("should detect Commvault bucket", ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: BUCKET_TAG_APPLICATION,
+                        Value: COMMVAULT_APPLICATION
+                    }
+                ]
+            },
+            status: "success"
+        });
+        const { result } = renderHook(()=>useISVBucketStatus("test-bucket"), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(false);
+        expect(result.current.isCommvaultBucket).toBe(true);
+        expect(result.current.isISVManaged).toBe(true);
+        expect(result.current.isvApplication).toBe("Commvault");
+    });
+    it("should return false for non-ISV bucket", ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: {
+                TagSet: [
+                    {
+                        Key: "SomeOtherTag",
+                        Value: "SomeValue"
+                    }
+                ]
+            },
+            status: "success"
+        });
+        const { result } = renderHook(()=>useISVBucketStatus("test-bucket"), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isVeeamBucket).toBe(false);
+        expect(result.current.isCommvaultBucket).toBe(false);
+        expect(result.current.isISVManaged).toBe(false);
+        expect(result.current.isvApplication).toBeUndefined();
+    });
+    it("should return loading state when fetching bucket tags", ()=>{
+        mockUseGetBucketTagging.mockReturnValue({
+            data: void 0,
+            status: "pending"
+        });
+        const { result } = renderHook(()=>useISVBucketStatus("test-bucket"), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isLoading).toBe(true);
+    });
+    it("should not be loading when ISV feature is disabled", ()=>{
+        mockUseFeatures.mockReturnValue(false);
+        mockUseGetBucketTagging.mockReturnValue({
+            data: void 0,
+            status: "pending"
+        });
+        const { result } = renderHook(()=>useISVBucketStatus("test-bucket"), {
+            wrapper: createTestWrapper()
+        });
+        expect(result.current.isLoading).toBe(false);
+    });
+});

package/dist/hooks/factories/__tests__/useCreateS3QueryHook.test.js

@@ -1,12 +1,13 @@
 import { renderHook, waitFor } from "@testing-library/react";
 import { useCreateS3QueryHook } from "../useCreateS3QueryHook.js";
 import { useS3Client } from "../../useS3Client.js";
-import { createS3OperationError } from "../../../utils/errorHandling.js";
+import { createS3OperationError, isNotFoundError } from "../../../utils/errorHandling.js";
 import { createQueryWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
 jest.mock("../../useS3Client");
 jest.mock("../../../utils/errorHandling");
 const mockUseS3Client = useS3Client;
 const mockCreateS3OperationError = createS3OperationError;
+const mockIsNotFoundError = isNotFoundError;
 class MockCommand {
     input;
     constructor(input){
@@ -133,4 +134,46 @@ describe("useCreateS3QueryHook - Factory Specific", ()=>{
         expect(capturedAbortSignal).toBeInstanceOf(AbortSignal);
         expect(capturedAbortSignal?.aborted).toBe(false);
     });
+    it("should return empty config for supported operations when NOT_FOUND error occurs", async ()=>{
+        const error = new Error("Configuration does not exist");
+        error.name = "NoSuchConfiguration";
+        error.$metadata = {
+            httpStatusCode: 404
+        };
+        mockS3Client.send.mockRejectedValueOnce(error);
+        mockIsNotFoundError.mockReturnValueOnce(true);
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "GetBucketLifecycleConfiguration");
+        const { result } = renderHook(()=>useTestQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(result.current.data).toBeDefined();
+        expect(mockIsNotFoundError).toHaveBeenCalledWith(error);
+    });
+    it("should throw error when NOT_FOUND occurs for unsupported operations", async ()=>{
+        const error = new Error("Bucket not found");
+        error.name = "NoSuchBucket";
+        error.$metadata = {
+            httpStatusCode: 404
+        };
+        const enhancedError = new Error("Enhanced error");
+        mockS3Client.send.mockRejectedValueOnce(error);
+        mockIsNotFoundError.mockReturnValueOnce(true);
+        mockCreateS3OperationError.mockReturnValueOnce(enhancedError);
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "GetBucketAcl");
+        const { result } = renderHook(()=>useTestQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(result.current.error).toBe(enhancedError);
+        expect(mockIsNotFoundError).toHaveBeenCalledWith(error);
+    });
 });

package/dist/hooks/factories/useCreateS3QueryHook.js

@@ -1,6 +1,23 @@
 import { useQuery } from "@tanstack/react-query";
 import { useS3Client } from "../useS3Client.js";
-import { createS3OperationError, shouldRetryError } from "../../utils/errorHandling.js";
+import { createS3OperationError, isNotFoundError, shouldRetryError } from "../../utils/errorHandling.js";
+function getEmptyConfigForOperation(operationName) {
+    switch(operationName){
+        case "GetBucketLifecycleConfiguration":
+            return {
+                Rules: []
+            };
+        case "GetBucketReplication":
+            return {
+                ReplicationConfiguration: {
+                    Rules: [],
+                    Role: ""
+                }
+            };
+        default:
+            return null;
+    }
+}
 function useCreateS3QueryHook(Command, operationName) {
     return (params, options)=>{
         const queryKey = [
@@ -18,6 +35,10 @@ function useCreateS3QueryHook(Command, operationName) {
                     });
                 } catch (error) {
                     const bucketName = params && "Bucket" in params ? params.Bucket : void 0;
+                    if (isNotFoundError(error)) {
+                        const emptyConfig = getEmptyConfigForOperation(operationName);
+                        if (null !== emptyConfig) return emptyConfig;
+                    }
                     throw createS3OperationError(error, operationName, bucketName);
                 }
             },