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

package/dist/hooks/useBatchObjectLegalHold.js

@@ -0,0 +1,45 @@
+import { useQuery } from "@tanstack/react-query";
+import { useS3Client } from "./useS3Client.js";
+import { GetObjectLegalHoldCommand } from "@aws-sdk/client-s3";
+const useBatchObjectLegalHold = (bucketName, objects, enabled = true)=>{
+    const s3Client = useS3Client();
+    return useQuery({
+        queryKey: [
+            "BatchObjectLegalHold",
+            bucketName,
+            ...objects.map((obj)=>`${obj.Key}:${obj.VersionId || "null"}`)
+        ],
+        queryFn: async ()=>{
+            const results = {};
+            await Promise.allSettled(objects.map(async (obj)=>{
+                const key = `${obj.Key}:${obj.VersionId || "null"}`;
+                try {
+                    const command = new GetObjectLegalHoldCommand({
+                        Bucket: bucketName,
+                        Key: obj.Key,
+                        ...obj.VersionId && {
+                            VersionId: obj.VersionId
+                        }
+                    });
+                    const response = await s3Client.send(command);
+                    results[key] = {
+                        key: obj.Key,
+                        versionId: obj.VersionId,
+                        isLegalHoldEnabled: response.LegalHold?.Status === "ON"
+                    };
+                } catch (error) {
+                    results[key] = {
+                        key: obj.Key,
+                        versionId: obj.VersionId,
+                        isLegalHoldEnabled: false
+                    };
+                }
+            }));
+            return results;
+        },
+        enabled: enabled && objects.length > 0,
+        staleTime: 30000,
+        refetchOnWindowFocus: false
+    });
+};
+export { useBatchObjectLegalHold };

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

@@ -0,0 +1,7 @@
+interface UseIsBucketEmptyResult {
+    isEmpty: boolean | null;
+    isLoading: boolean;
+    error: Error | null;
+}
+export declare const useIsBucketEmpty: (bucketName: string) => UseIsBucketEmptyResult;
+export {};

package/dist/hooks/useIsBucketEmpty.js

@@ -0,0 +1,36 @@
+import { useMemo } from "react";
+import { useListObjects } from "./objectOperations.js";
+const isInfiniteData = (data)=>null != data && "object" == typeof data && "pages" in data && Array.isArray(data.pages);
+const useIsBucketEmpty = (bucketName)=>{
+    const { data, status, error } = useListObjects({
+        Bucket: bucketName,
+        MaxKeys: 1,
+        Delimiter: "/"
+    }, {
+        enabled: !!bucketName
+    });
+    const isEmpty = useMemo(()=>{
+        if ("pending" === status || !data) return null;
+        if (!isInfiniteData(data)) return null;
+        for (const page of data.pages){
+            if (page?.Contents && page.Contents.length > 0) {
+                const validObjects = page.Contents.filter((obj)=>obj?.Key);
+                if (validObjects.length > 0) return false;
+            }
+            if (page?.CommonPrefixes && page.CommonPrefixes.length > 0) {
+                const validPrefixes = page.CommonPrefixes.filter((cp)=>cp?.Prefix);
+                if (validPrefixes.length > 0) return false;
+            }
+        }
+        return true;
+    }, [
+        data,
+        status
+    ]);
+    return {
+        isEmpty,
+        isLoading: "pending" === status,
+        error: error instanceof Error ? error : null
+    };
+};
+export { useIsBucketEmpty };

package/dist/hooks/useLoginMutation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * S3 Login Authentication Hook
+ *
+ * This file contains the login authentication hook using the factory pattern
+ * for consistency with other S3 operations.
+ */
+import { S3BrowserConfig, S3Credentials } from "../types";
+export type LoginConfig = S3BrowserConfig & {
+    credentials: S3Credentials;
+};
+export interface LoginMutationResult {
+    config: LoginConfig;
+    authenticated: boolean;
+}
+/**
+ * Hook for S3 authentication using react-query mutation.
+ * Validates credentials and establishes S3 session.
+ *
+ * Uses the specialized login factory pattern for consistency with other S3 operations.
+ */
+export declare const useLoginMutation: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<LoginMutationResult, import("..").EnhancedS3Error, LoginConfig, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<LoginMutationResult, import("..").EnhancedS3Error, LoginConfig>;

package/dist/hooks/useLoginMutation.js

@@ -0,0 +1,9 @@
+import { useCreateS3LoginHook } from "./factories/index.js";
+class LoginAuthenticationCommand {
+    input;
+    constructor(input){
+        this.input = input;
+    }
+}
+const useLoginMutation = useCreateS3LoginHook(LoginAuthenticationCommand, "S3 Authentication");
+export { useLoginMutation };

package/dist/hooks/useS3Client.d.ts

@@ -0,0 +1 @@
+export declare const useS3Client: () => import("@aws-sdk/client-s3").S3Client;

package/dist/hooks/useS3Client.js

@@ -0,0 +1,13 @@
+import { useMemo } from "react";
+import { useDataBrowserContext } from "../components/providers/DataBrowserProvider.js";
+import { createS3Client } from "../utils/s3Client.js";
+const useS3Client = ()=>{
+    const { getS3Config } = useDataBrowserContext();
+    return useMemo(()=>{
+        const config = getS3Config();
+        return createS3Client(config);
+    }, [
+        getS3Config
+    ]);
+};
+export { useS3Client };

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

@@ -0,0 +1,6 @@
+export * from "./components";
+export * from "./hooks";
+export * from "./types";
+export * from "./utils";
+export * from "./config/factory";
+export * from "./config/types";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./components/index.js";
+export * from "./hooks/index.js";
+export * from "./types/index.js";
+export * from "./utils/index.js";
+export * from "./config/factory.js";
+export * from "./config/types.js";