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

package/dist/hooks/index.d.ts

@@ -2,6 +2,10 @@ export { useS3Client } from "./useS3Client";
 export type { LoginConfig, LoginMutationResult } from "./useLoginMutation";
 export { useLoginMutation } from "./loginOperations";
 export { useIsBucketEmpty } from "./useIsBucketEmpty";
+export { useEmptyBucket } from "./useEmptyBucket";
+export { useDeleteBucketConfigRule } from "./useDeleteBucketConfigRule";
+export { useTableRowSelection } from "./useTableRowSelection";
+export { useISVBucketStatus } from "./useISVBucketDetection";
 export { useBuckets, useGetBucketLocation, useCreateBucket, useDeleteBucket, } from "./bucketOperations";
 export { useGetBucketAcl, useSetBucketAcl, useGetBucketPolicy, useSetBucketPolicy, useDeleteBucketPolicy, useGetBucketVersioning, useSetBucketVersioning, useGetBucketCors, useSetBucketCors, useDeleteBucketCors, useGetBucketLifecycle, useSetBucketLifecycle, useDeleteBucketLifecycle, useGetBucketNotification, useSetBucketNotification, useGetBucketEncryption, useSetBucketEncryption, useGetBucketTagging, useSetBucketTagging, useDeleteBucketTagging, useGetBucketObjectLockConfiguration, useSetBucketObjectLockConfiguration, useGetBucketReplication, useSetBucketReplication, useDeleteBucketReplication, } from "./bucketConfiguration";
 export { useListObjects, useListObjectVersions, useObjectMetadata, useObjectRetention, useGetObject, usePutObject, useCreateFolder, useUploadObjects, useDeleteObject, useDeleteObjects, useCopyObject, useSetObjectRetention, useObjectLegalHold, useSetObjectLegalHold, useObjectTagging, useSetObjectTagging, useDeleteObjectTagging, useObjectAcl, useSetObjectAcl, useGetObjectAttributes, useGetObjectTorrent, useRestoreObject, useSelectObjectContent, useListMultipartUploads, useSearchObjects, useSearchObjectsVersions, } from "./objectOperations";

package/dist/hooks/index.js

@@ -1,8 +1,12 @@
 import { useS3Client } from "./useS3Client.js";
 import { useLoginMutation } from "./loginOperations.js";
 import { useIsBucketEmpty } from "./useIsBucketEmpty.js";
+import { useEmptyBucket } from "./useEmptyBucket.js";
+import { useDeleteBucketConfigRule } from "./useDeleteBucketConfigRule.js";
+import { useTableRowSelection } from "./useTableRowSelection.js";
+import { useISVBucketStatus } from "./useISVBucketDetection.js";
 import { useBuckets, useCreateBucket, useDeleteBucket, useGetBucketLocation } from "./bucketOperations.js";
 import { useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning } from "./bucketConfiguration.js";
 import { useCopyObject, useCreateFolder, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useListMultipartUploads, useListObjectVersions, useListObjects, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useUploadObjects } from "./objectOperations.js";
 import { useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload } from "./presignedOperations.js";
-export { useBuckets, useCopyObject, useCreateBucket, useCreateFolder, useDeleteBucket, useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketLocation, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload, useIsBucketEmpty, useListMultipartUploads, useListObjectVersions, useListObjects, useLoginMutation, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useS3Client, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useUploadObjects };
+export { useBuckets, useCopyObject, useCreateBucket, useCreateFolder, useDeleteBucket, useDeleteBucketConfigRule, useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useEmptyBucket, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketLocation, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload, useISVBucketStatus, useIsBucketEmpty, useListMultipartUploads, useListObjectVersions, useListObjects, useLoginMutation, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useS3Client, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useTableRowSelection, useUploadObjects };

package/dist/hooks/useDeleteBucketConfigRule.d.ts

@@ -0,0 +1,26 @@
+import type { UseMutationResult } from "@tanstack/react-query";
+interface BucketCommandInput {
+    Bucket: string | undefined;
+}
+interface UseDeleteBucketConfigRuleOptions<TRule extends {
+    ID?: string;
+}, TUpdateInput extends BucketCommandInput, TUpdateOutput, TDeleteInput extends BucketCommandInput, TDeleteOutput, TError = unknown> {
+    bucketName: string;
+    ruleId: string;
+    rules: TRule[];
+    updateMutation: UseMutationResult<TUpdateOutput, TError, TUpdateInput, unknown>;
+    deleteMutation: UseMutationResult<TDeleteOutput, TError, TDeleteInput, unknown>;
+    buildUpdateInput: (remainingRules: TRule[]) => Omit<TUpdateInput, "Bucket">;
+    successMessage?: string;
+    errorMessage?: string;
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+}
+interface UseDeleteBucketConfigRuleReturn {
+    isDeleting: boolean;
+    deleteRule: () => void;
+}
+export declare function useDeleteBucketConfigRule<TRule extends {
+    ID?: string;
+}, TUpdateInput extends BucketCommandInput = BucketCommandInput, TUpdateOutput = unknown, TDeleteInput extends BucketCommandInput = BucketCommandInput, TDeleteOutput = unknown, TError = unknown>({ bucketName, ruleId, rules, updateMutation, deleteMutation, buildUpdateInput, successMessage, errorMessage, onSuccess, onError, }: UseDeleteBucketConfigRuleOptions<TRule, TUpdateInput, TUpdateOutput, TDeleteInput, TDeleteOutput, TError>): UseDeleteBucketConfigRuleReturn;
+export {};

package/dist/hooks/useDeleteBucketConfigRule.js

@@ -0,0 +1,46 @@
+import { useToast } from "@scality/core-ui";
+function useDeleteBucketConfigRule({ bucketName, ruleId, rules, updateMutation, deleteMutation, buildUpdateInput, successMessage = "Rule deleted successfully", errorMessage = "Failed to delete rule", onSuccess, onError }) {
+    const { showToast } = useToast();
+    const { mutate: updateConfig, status: updateStatus } = updateMutation;
+    const { mutate: deleteConfig, status: deleteStatus } = deleteMutation;
+    const isDeleting = "pending" === updateStatus || "pending" === deleteStatus;
+    const deleteRule = ()=>{
+        const remainingRules = rules.filter((rule)=>rule.ID !== ruleId);
+        const handleSuccess = ()=>{
+            showToast({
+                open: true,
+                message: successMessage,
+                status: "success"
+            });
+            onSuccess?.();
+        };
+        const handleError = (error)=>{
+            const displayMessage = error instanceof Error && error.message ? error.message : errorMessage;
+            const errorToReport = error instanceof Error ? error : new Error(displayMessage);
+            showToast({
+                open: true,
+                message: displayMessage,
+                status: "error"
+            });
+            onError?.(errorToReport);
+        };
+        if (0 === remainingRules.length) deleteConfig({
+            Bucket: bucketName
+        }, {
+            onSuccess: handleSuccess,
+            onError: handleError
+        });
+        else updateConfig({
+            Bucket: bucketName,
+            ...buildUpdateInput(remainingRules)
+        }, {
+            onSuccess: handleSuccess,
+            onError: handleError
+        });
+    };
+    return {
+        isDeleting,
+        deleteRule
+    };
+}
+export { useDeleteBucketConfigRule };

package/dist/hooks/useEmptyBucket.d.ts

@@ -0,0 +1,27 @@
+export interface EmptyBucketResult {
+    success: boolean;
+    deletedCount: number;
+    errors: Array<{
+        key: string;
+        code?: string;
+        message?: string;
+    }>;
+    limitReached: boolean;
+}
+interface UseEmptyBucketOptions {
+    maxObjects?: number;
+    maxKeysPerList?: number;
+    bypassGovernanceRetention?: boolean;
+    onProgress?: (deletedCount: number, totalAttempted: number) => void;
+    onSuccess?: (result: EmptyBucketResult) => void;
+    onError?: (error: Error) => void;
+}
+interface UseEmptyBucketReturn {
+    emptyBucket: (bucketName: string) => Promise<EmptyBucketResult | null>;
+    isEmptying: boolean;
+    error: Error | null;
+    result: EmptyBucketResult | null;
+    reset: () => void;
+}
+export declare const useEmptyBucket: (options?: UseEmptyBucketOptions) => UseEmptyBucketReturn;
+export {};

package/dist/hooks/useEmptyBucket.js

@@ -0,0 +1,116 @@
+import { useCallback, useState } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useS3Client } from "./useS3Client.js";
+import { DeleteObjectsCommand, ListObjectVersionsCommand } from "@aws-sdk/client-s3";
+const useEmptyBucket = (options = {})=>{
+    const { maxObjects = 20000, maxKeysPerList = 1000, bypassGovernanceRetention = true, onProgress, onSuccess, onError } = options;
+    const [isEmptying, setIsEmptying] = useState(false);
+    const [error, setError] = useState(null);
+    const [result, setResult] = useState(null);
+    const s3Client = useS3Client();
+    const queryClient = useQueryClient();
+    const emptyBucket = useCallback(async (bucketName)=>{
+        setIsEmptying(true);
+        setError(null);
+        setResult(null);
+        try {
+            let deletedCount = 0;
+            let totalAttempted = 0;
+            let keyMarker;
+            let versionIdMarker;
+            const allErrors = [];
+            let limitReached = false;
+            while(totalAttempted < maxObjects){
+                const listCommand = new ListObjectVersionsCommand({
+                    Bucket: bucketName,
+                    MaxKeys: maxKeysPerList,
+                    KeyMarker: keyMarker,
+                    VersionIdMarker: versionIdMarker
+                });
+                const listResponse = await s3Client.send(listCommand);
+                const objectsToDelete = [];
+                if (listResponse.Versions) objectsToDelete.push(...listResponse.Versions.filter((v)=>v.Key).map((v)=>({
+                        Key: v.Key,
+                        VersionId: v.VersionId
+                    })));
+                if (listResponse.DeleteMarkers) objectsToDelete.push(...listResponse.DeleteMarkers.filter((dm)=>dm.Key).map((dm)=>({
+                        Key: dm.Key,
+                        VersionId: dm.VersionId
+                    })));
+                if (0 === objectsToDelete.length) break;
+                const deleteCommand = new DeleteObjectsCommand({
+                    Bucket: bucketName,
+                    Delete: {
+                        Objects: objectsToDelete
+                    },
+                    BypassGovernanceRetention: bypassGovernanceRetention
+                });
+                const deleteResponse = await s3Client.send(deleteCommand);
+                const successCount = deleteResponse.Deleted?.length || 0;
+                deletedCount += successCount;
+                totalAttempted += objectsToDelete.length;
+                if (deleteResponse.Errors) allErrors.push(...deleteResponse.Errors.map((error)=>({
+                        key: error.Key || "unknown",
+                        code: error.Code,
+                        message: error.Message
+                    })));
+                onProgress?.(deletedCount, totalAttempted);
+                if (!listResponse.IsTruncated) break;
+                if (totalAttempted >= maxObjects) {
+                    limitReached = true;
+                    break;
+                }
+                keyMarker = listResponse.NextKeyMarker;
+                versionIdMarker = listResponse.NextVersionIdMarker;
+            }
+            const bucketResult = {
+                success: 0 === allErrors.length,
+                deletedCount,
+                errors: allErrors,
+                limitReached
+            };
+            setResult(bucketResult);
+            queryClient.invalidateQueries({
+                queryKey: [
+                    "ListObjects"
+                ]
+            });
+            queryClient.invalidateQueries({
+                queryKey: [
+                    "ListObjectVersions"
+                ]
+            });
+            onSuccess?.(bucketResult);
+            return bucketResult;
+        } catch (err) {
+            const errorObj = err instanceof Error ? err : new Error("Failed to empty bucket");
+            setError(errorObj);
+            onError?.(errorObj);
+            return null;
+        } finally{
+            setIsEmptying(false);
+        }
+    }, [
+        s3Client,
+        maxObjects,
+        maxKeysPerList,
+        bypassGovernanceRetention,
+        onProgress,
+        onSuccess,
+        onError,
+        queryClient
+    ]);
+    const reset = useCallback(()=>{
+        setIsEmptying(false);
+        setError(null);
+        setResult(null);
+    }, []);
+    return {
+        emptyBucket,
+        isEmptying,
+        error,
+        result,
+        reset
+    };
+};
+export { useEmptyBucket };

package/dist/hooks/useISVBucketDetection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Hook to detect if a bucket is managed by any ISV (Veeam or Commvault)
+ * Returns comprehensive information about ISV bucket status
+ *
+ * This hook fetches bucket tags once and derives all ISV-related states from it,
+ * avoiding multiple API calls for the same data.
+ */
+export declare const useISVBucketStatus: (bucketName: string) => {
+    isVeeamBucket: boolean;
+    isCommvaultBucket: boolean;
+    isISVManaged: boolean;
+    isvApplication: string | undefined;
+    isLoading: boolean | undefined;
+    bucketTagsStatus: "error" | "success" | "pending";
+};

package/dist/hooks/useISVBucketDetection.js

@@ -0,0 +1,27 @@
+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";
+const useISVBucketStatus = (bucketName)=>{
+    const isISVFeatureEnabled = useFeatures("ISV");
+    const { data: bucketTags, status: bucketTagsStatus } = useGetBucketTagging({
+        Bucket: bucketName
+    }, {
+        enabled: isISVFeatureEnabled
+    });
+    const veeamTagApplication = bucketTags?.TagSet?.find((tag)=>tag.Key === BUCKET_TAG_VEEAM_APPLICATION)?.Value;
+    const ISVApplicationTag = bucketTags?.TagSet?.find((tag)=>tag.Key === BUCKET_TAG_APPLICATION)?.Value;
+    const isVeeamBucket = veeamTagApplication === VEEAM_BACKUP_REPLICATION || veeamTagApplication === VEEAM_OFFICE_365 || veeamTagApplication === VEEAM_OFFICE_365_V8;
+    const isISVBucketTagAsVeeam = ISVApplicationTag === VEEAM_BACKUP_REPLICATION || ISVApplicationTag === VEEAM_VBO_APPLICATION;
+    const isCommvaultBucket = ISVApplicationTag === COMMVAULT_APPLICATION;
+    const isVeeam = isVeeamBucket || isISVBucketTagAsVeeam;
+    const isISVManaged = isVeeam || isCommvaultBucket;
+    return {
+        isVeeamBucket: isVeeam,
+        isCommvaultBucket,
+        isISVManaged,
+        isvApplication: isCommvaultBucket ? "Commvault" : isVeeam ? "Veeam" : void 0,
+        isLoading: isISVFeatureEnabled && "pending" === bucketTagsStatus,
+        bucketTagsStatus
+    };
+};
+export { useISVBucketStatus };

package/dist/hooks/useTableRowSelection.d.ts

@@ -0,0 +1,9 @@
+export declare function useTableRowSelection<TRow extends {
+    ID?: string;
+}>(tableData: TRow[], autoSelectFirst?: boolean): {
+    selectedId: string | null;
+    onRowSelected: (row: {
+        original: TRow;
+    }) => void;
+    clearSelection: () => void;
+};

package/dist/hooks/useTableRowSelection.js

@@ -0,0 +1,45 @@
+import { useCallback, useEffect, useState } from "react";
+function useTableRowSelection(tableData, autoSelectFirst = true) {
+    const [selectedRuleId, setSelectedRuleId] = useState(null);
+    useEffect(()=>{
+        if (0 === tableData.length) {
+            if (null !== selectedRuleId) setSelectedRuleId(null);
+            return;
+        }
+        if (!autoSelectFirst) {
+            if (null !== selectedRuleId) {
+                const stillExists = tableData.some((row)=>row.ID === selectedRuleId);
+                if (!stillExists) setSelectedRuleId(null);
+            }
+            return;
+        }
+        if (null === selectedRuleId) {
+            const firstRowId = tableData[0]?.ID;
+            if (firstRowId) setSelectedRuleId(firstRowId);
+            return;
+        }
+        const stillExists = tableData.some((row)=>row.ID === selectedRuleId);
+        if (!stillExists) {
+            const firstRowId = tableData[0]?.ID;
+            firstRowId ? setSelectedRuleId(firstRowId) : setSelectedRuleId(null);
+        }
+    }, [
+        autoSelectFirst,
+        tableData,
+        selectedRuleId
+    ]);
+    const onRowSelected = useCallback((row)=>{
+        if (row.original.ID && row.original.ID !== selectedRuleId) setSelectedRuleId(row.original.ID);
+    }, [
+        selectedRuleId
+    ]);
+    const clearSelection = useCallback(()=>{
+        setSelectedRuleId(null);
+    }, []);
+    return {
+        selectedId: selectedRuleId,
+        onRowSelected,
+        clearSelection
+    };
+}
+export { useTableRowSelection };

package/dist/test/setup.js

@@ -57,6 +57,14 @@ jest.mock("pretty-bytes", ()=>({
             return `${Math.round(num)} ${sizes[i]}`;
         }
     }));
+jest.mock("joi", ()=>{
+    const Joi = jest.requireActual("joi");
+    return {
+        __esModule: true,
+        default: Joi,
+        ...Joi
+    };
+});
 if (!File.prototype.arrayBuffer) File.prototype.arrayBuffer = function() {
     return new Promise((resolve)=>{
         const reader = new FileReader();

package/dist/test/testUtils.d.ts

@@ -1,13 +1,49 @@
-import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
+/**
+ * @fileoverview Test utilities for data-browser-library
+ *
+ * This file provides common utilities for testing:
+ * - Test configuration and credentials
+ * - Mock setup utilities (S3, DOM, etc.)
+ * - React Testing Library wrappers
+ * - React Query wrappers
+ * - Global configuration utilities
+ * - Factory pattern validation utilities
+ * - Form testing helpers
+ */
 import React from "react";
+import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
 import { S3BrowserConfig, S3Credentials } from "../types";
+import type { S3Configuration, DevelopmentConfiguration } from "../config/types";
+/**
+ * Default S3 configuration for tests
+ */
 export declare const testConfig: S3BrowserConfig;
+/**
+ * Default S3 credentials for tests
+ */
 export declare const testCredentials: S3Credentials;
+/**
+ * Mock S3 client for tests
+ */
 export declare const mockS3Client: {
     send: jest.Mock<any, any, any>;
 };
 export declare const MockedS3Client: jest.MockedClass<typeof S3Client>;
 export declare const MockedPutObjectCommand: jest.MockedClass<typeof PutObjectCommand>;
+/**
+ * Sets up S3 mocks for testing
+ */
+export declare const setupS3Mocks: () => void;
+/**
+ * Common mock setup that should be run before each test
+ */
+export declare const setupCommonMocks: () => void;
+/**
+ * Mocks DOM measurements APIs for virtualization and layout testing
+ * AutoSizer uses offsetWidth and offsetHeight which Jest/JSDom doesn't support
+ * @param width - The mock width in pixels
+ * @param height - The mock height in pixels
+ */
 export declare function mockOffsetSize(width: number, height: number): void;
 /**
  * Creates a simple QueryClient wrapper for tests that don't need DataBrowser context
@@ -33,18 +69,6 @@ export declare const renderHookWithWrapper: <TProps, TResult>(hook: (props: TPro
  * Creates a test File object
  */
 export declare const createTestFile: (name: string, content: string, type?: string) => File;
-/**
- * Sets up S3 mocks for testing
- */
-export declare const setupS3Mocks: () => void;
-/**
- * Common mock setup that should be run before each test
- */
-export declare const setupCommonMocks: () => void;
-/**
- * Configuration test utilities for overriding build-time globals
- */
-import type { S3Configuration, DevelopmentConfiguration } from "../config/types";
 type GlobalConfigOverrides = {
     s3?: Partial<S3Configuration>;
     dev?: Partial<DevelopmentConfiguration>;
@@ -67,16 +91,74 @@ export declare const resetGlobalConfig: () => void;
  * Test helper for running tests with specific global configuration
  */
 export declare const withGlobalConfig: (overrides: GlobalConfigOverrides, testFn: () => void | Promise<void>) => () => Promise<void>;
-/**
- * Validates that a hook follows the expected factory pattern
- */
-export declare const validateFactoryHook: (hook: any, operationName: string) => void;
 /**
  * Creates a factory test error
  */
 export declare const createFactoryTestError: (testContext: string, operationName: string, details?: string) => Error;
+/**
+ * Validates that a hook follows the expected factory pattern
+ */
+export declare const validateFactoryHook: (hook: any, operationName: string) => void;
 /**
  * Validates that a hook result has expected React Query properties
  */
 export declare const validateHookResult: (result: any, hookType: "query" | "mutation" | "infiniteQuery") => void;
+/**
+ * Creates a mock UseMutationResult for testing React Query mutations
+ *
+ * This helper provides a complete mock object that matches the UseMutationResult type
+ * from @tanstack/react-query, eliminating the need for 'as any' type assertions.
+ *
+ * @param mutate - The mocked mutate function (usually jest.fn())
+ * @param overrides - Optional overrides for any properties (e.g., { isPending: true })
+ * @returns A complete UseMutationResult mock object
+ *
+ * @example
+ * ```ts
+ * const mockCreateBucket = jest.fn();
+ * const mockResult = createMockMutationResult(mockCreateBucket, { isPending: true });
+ * mockUseCreateBucket.mockReturnValue(mockResult);
+ * ```
+ */
+export declare const createMockMutationResult: (mutate: jest.Mock, overrides?: {}) => {
+    mutate: jest.Mock<any, any, any>;
+    mutateAsync: jest.Mock<any, any, any>;
+    reset: jest.Mock<any, any, any>;
+    isPending: false;
+    isIdle: true;
+    isError: false;
+    isSuccess: false;
+    status: "idle";
+    data: undefined;
+    error: null;
+    variables: undefined;
+    context: undefined;
+    failureCount: number;
+    failureReason: null;
+    isPaused: false;
+    submittedAt: number;
+};
+/**
+ * Finds a Toggle input element by its label text
+ * Traverses the DOM to locate the associated checkbox input
+ * @param labelText - The text content of the label
+ * @returns The toggle input element or null if not found
+ */
+export declare const findToggleByLabel: (labelText: string) => HTMLInputElement | null;
+/**
+ * Waits for a submit button to be enabled and clicks it
+ * @param buttonName - The type of button to click ("create" or "save")
+ */
+export declare const submitForm: (buttonName?: "create" | "save") => Promise<void>;
+/**
+ * Sets up a mock mutation to simulate successful form submission
+ * @param mockMutate - The jest mock function for the mutation
+ */
+export declare const mockSuccessSubmit: (mockMutate: jest.Mock) => void;
+/**
+ * Sets up a mock mutation to simulate failed form submission
+ * @param mockMutate - The jest mock function for the mutation
+ * @param errorMessage - The error message to return (default: "Network Error")
+ */
+export declare const mockErrorSubmit: (mockMutate: jest.Mock, errorMessage?: string) => void;
 export { setupMswServer, overrideHandlers } from "./msw";

package/dist/test/testUtils.js

@@ -1,12 +1,12 @@
 import { jsx } from "react/jsx-runtime";
+import "react";
 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 { fireEvent, renderHook, screen, waitFor } from "@testing-library/react";
 import { coreUIAvailableThemes } from "@scality/core-ui/dist/style/theme";
 import { CoreUiThemeProvider } from "@scality/core-ui/dist/next";
 import { ToastProvider } from "@scality/core-ui";
+import { DataBrowserProvider } from "../components/providers/DataBrowserProvider.js";
 import { overrideHandlers, setupMswServer } from "./msw/index.js";
 var __webpack_require__ = {};
 (()=>{
@@ -34,6 +34,17 @@ const mockS3Client = {
 };
 const MockedS3Client = S3Client;
 const MockedPutObjectCommand = PutObjectCommand;
+const setupS3Mocks = ()=>{
+    jest.clearAllMocks();
+    MockedS3Client.mockImplementation(()=>mockS3Client);
+    MockedPutObjectCommand.mockImplementation((input)=>({
+            input,
+            resolveMiddleware: jest.fn()
+        }));
+};
+const setupCommonMocks = ()=>{
+    setupS3Mocks();
+};
 function mockOffsetSize(width, height) {
     __webpack_require__.g.ResizeObserver = jest.fn().mockImplementation(()=>({
             observe: jest.fn(),
@@ -149,17 +160,6 @@ const createTestFile = (name, content, type = "text/plain")=>new File([
     ], 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__;
@@ -201,10 +201,10 @@ const withGlobalConfig = (overrides, testFn)=>async ()=>{
             resetGlobalConfig();
         }
     };
+const createFactoryTestError = (testContext, operationName, details)=>new Error(`Factory Test Failure [${testContext}]: ${operationName} - ${details || "Unknown error"}. Check factory implementation and hook usage patterns.`);
 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",
@@ -233,4 +233,52 @@ const validateHookResult = (result, hookType)=>{
     ];
     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 };
+const createMockMutationResult = (mutate, overrides = {})=>({
+        mutate,
+        mutateAsync: jest.fn(),
+        reset: jest.fn(),
+        isPending: false,
+        isIdle: true,
+        isError: false,
+        isSuccess: false,
+        status: "idle",
+        data: void 0,
+        error: null,
+        variables: void 0,
+        context: void 0,
+        failureCount: 0,
+        failureReason: null,
+        isPaused: false,
+        submittedAt: 0,
+        ...overrides
+    });
+const findToggleByLabel = (labelText)=>{
+    const label = screen.getByText(labelText);
+    let current = label.parentElement;
+    while(current && !current.querySelector('input[type="checkbox"]'))current = current.parentElement;
+    return current?.querySelector('input[type="checkbox"]');
+};
+const submitForm = async (buttonName = "create")=>{
+    await waitFor(()=>{
+        const button = screen.getByRole("button", {
+            name: "create" === buttonName ? /create/i : /save/i
+        });
+        expect(button).toBeEnabled();
+    });
+    const button = screen.getByRole("button", {
+        name: "create" === buttonName ? /create/i : /save/i
+    });
+    fireEvent.click(button);
+};
+const mockSuccessSubmit = (mockMutate)=>{
+    mockMutate.mockImplementation((_, options)=>{
+        options?.onSuccess?.();
+    });
+};
+const mockErrorSubmit = (mockMutate, errorMessage = "Network Error")=>{
+    const error = new Error(errorMessage);
+    mockMutate.mockImplementation((_, options)=>{
+        options?.onError?.(error);
+    });
+};
+export { MockedPutObjectCommand, MockedS3Client, createFactoryTestError, createMockMutationResult, createQueryWrapper, createTestFile, createTestWrapper, findToggleByLabel, mockErrorSubmit, mockOffsetSize, mockS3Client, mockSuccessSubmit, overrideGlobalConfig, overrideHandlers, renderHookWithWrapper, resetGlobalConfig, setupCommonMocks, setupMswServer, setupS3Mocks, submitForm, testConfig, testCredentials, validateFactoryHook, validateHookResult, withGlobalConfig };