@scality/data-browser-library 1.0.0-preview.8 → 1.0.1

package/dist/components/objects/ObjectLock/EditRetentionButton.d.ts

@@ -0,0 +1,4 @@
+export declare const EditRetentionButton: ({ bucketName }: {
+    bucketName: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default EditRetentionButton;

package/dist/components/objects/ObjectLock/EditRetentionButton.js

@@ -0,0 +1,32 @@
+import { jsx } from "react/jsx-runtime";
+import { Icon } from "@scality/core-ui";
+import { Button } from "@scality/core-ui/dist/next";
+import { useISVBucketStatus } from "../../../hooks/index.js";
+import { useDataBrowserNavigate } from "../../../hooks/useDataBrowserNavigate.js";
+const EditRetentionButton = ({ bucketName })=>{
+    const navigate = useDataBrowserNavigate();
+    const { isVeeamBucket, isCommvaultBucket, isISVManaged, isLoading } = useISVBucketStatus(bucketName);
+    const tooltipOverlay = isCommvaultBucket ? 'Edition is disabled as it is managed by Commvault.' : isVeeamBucket ? 'Edition is disabled as it is managed by Veeam.' : void 0;
+    return /*#__PURE__*/ jsx(Button, {
+        id: "edit-retention-btn",
+        variant: "outline",
+        label: "Edit",
+        "aria-label": "Edit default retention",
+        icon: /*#__PURE__*/ jsx(Icon, {
+            name: "Pencil"
+        }),
+        type: "button",
+        onClick: ()=>{
+            navigate(`/buckets/${bucketName}/objects/object-lock-settings`);
+        },
+        disabled: isISVManaged,
+        ...tooltipOverlay && {
+            tooltip: {
+                overlay: tooltipOverlay
+            }
+        },
+        isLoading: isLoading
+    });
+};
+const ObjectLock_EditRetentionButton = EditRetentionButton;
+export { EditRetentionButton, ObjectLock_EditRetentionButton as default };

package/dist/components/objects/ObjectLock/ObjectLockRetentionSettings.d.ts

@@ -0,0 +1,3 @@
+export default function ObjectLockRetentionSettings({ isEditRetentionSettings, }: {
+    isEditRetentionSettings?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/objects/ObjectLock/ObjectLockRetentionSettings.js

@@ -0,0 +1,211 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Checkbox, FormGroup, FormSection, Stack, Text } from "@scality/core-ui";
+import { convertRemToPixels } from "@scality/core-ui/dist/components/tablev2/TableUtils";
+import { Input, Select } from "@scality/core-ui/dist/next";
+import { Controller, useFormContext } from "react-hook-form";
+function ObjectLockRetentionSettings({ isEditRetentionSettings = false }) {
+    const { control, register, watch, formState: { errors }, setValue } = useFormContext();
+    const isDefaultRetentionEnabled = watch('isDefaultRetentionEnabled');
+    const isObjectLockEnabled = watch('isObjectLockEnabled');
+    const matchVersioning = (checked)=>{
+        if (checked) setValue('isVersioning', true);
+    };
+    return /*#__PURE__*/ jsxs(FormSection, {
+        title: isEditRetentionSettings ? void 0 : {
+            name: 'Object-lock'
+        },
+        forceLabelWidth: convertRemToPixels(17.5),
+        children: [
+            /*#__PURE__*/ jsx(FormGroup, {
+                id: "isObjectLockEnabled",
+                label: "Object-lock",
+                content: /*#__PURE__*/ jsx(Checkbox, {
+                    id: "isObjectLockEnabled",
+                    label: isObjectLockEnabled ? 'Enabled' : 'Disabled',
+                    disabled: isEditRetentionSettings && isObjectLockEnabled,
+                    ...register('isObjectLockEnabled', {
+                        onChange (e) {
+                            matchVersioning(e.target.checked);
+                        }
+                    })
+                }),
+                labelHelpTooltip: /*#__PURE__*/ jsxs("ul", {
+                    children: [
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Permanently allows objects in this bucket to be locked"
+                        }),
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Object-lock option cannot be removed after bucket creation, but you will be able to disable the retention itself on edition."
+                        }),
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Once the bucket is created, you might be blocked from deleting the objects and the bucket."
+                        }),
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Enabling Object-lock automatically activates Versioning for the bucket, and you won’t be able to suspend Versioning."
+                        })
+                    ]
+                }),
+                helpErrorPosition: "bottom",
+                disabled: isEditRetentionSettings
+            }),
+            isObjectLockEnabled && /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "isDefaultRetentionEnabled",
+                        label: "Default Retention",
+                        helpErrorPosition: "bottom",
+                        labelHelpTooltip: isEditRetentionSettings ? /*#__PURE__*/ jsxs("ul", {
+                            children: [
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "These settings apply only to new objects placed into the bucket without any specific object-lock parameters."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "Automatically protect objects put into this bucket from being deleted or overwritten."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "If objects are uploaded into the bucket with their own Retention settings, these will override the Default Retention setting placed on the bucket."
+                                })
+                            ]
+                        }) : /*#__PURE__*/ jsxs("ul", {
+                            children: [
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "Automatically protect objects put into this bucket from being deleted or overwritten."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "These settings apply only to new objects placed into the bucket without any specific object-lock parameters."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "You can activate this option after the bucket creation."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "If objects are uploaded into the bucket with their own Retention settings, these will override the Default Retention setting placed on the bucket."
+                                })
+                            ]
+                        }),
+                        content: /*#__PURE__*/ jsx(Checkbox, {
+                            id: "isDefaultRetentionEnabled",
+                            label: isDefaultRetentionEnabled ? 'Active' : 'Inactive',
+                            ...register('isDefaultRetentionEnabled')
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "objectlockMode",
+                        label: "Retention mode",
+                        direction: "vertical",
+                        disabled: !isDefaultRetentionEnabled,
+                        helpErrorPosition: "bottom",
+                        content: /*#__PURE__*/ jsx("div", {
+                            style: {
+                                opacity: isDefaultRetentionEnabled ? 1 : 0.5
+                            },
+                            children: /*#__PURE__*/ jsxs(Stack, {
+                                direction: "vertical",
+                                children: [
+                                    /*#__PURE__*/ jsxs(Stack, {
+                                        direction: "vertical",
+                                        children: [
+                                            /*#__PURE__*/ jsxs(Stack, {
+                                                children: [
+                                                    /*#__PURE__*/ jsx("input", {
+                                                        id: "locktype-governance",
+                                                        type: "radio",
+                                                        value: "GOVERNANCE",
+                                                        disabled: !isDefaultRetentionEnabled,
+                                                        ...register('retentionMode')
+                                                    }),
+                                                    /*#__PURE__*/ jsx("label", {
+                                                        htmlFor: "locktype-governance",
+                                                        children: "Governance"
+                                                    })
+                                                ]
+                                            }),
+                                            /*#__PURE__*/ jsx(Text, {
+                                                color: "textSecondary",
+                                                isEmphazed: true,
+                                                variant: "Smaller",
+                                                children: "A user with a specific IAM permissions can overwrite/delete protected object versions during the retention period."
+                                            })
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ jsxs(Stack, {
+                                        children: [
+                                            /*#__PURE__*/ jsx("input", {
+                                                id: "locktype-compliance",
+                                                type: "radio",
+                                                value: "COMPLIANCE",
+                                                disabled: !isDefaultRetentionEnabled,
+                                                ...register('retentionMode')
+                                            }),
+                                            /*#__PURE__*/ jsx("label", {
+                                                htmlFor: "locktype-compliance",
+                                                children: "Compliance"
+                                            })
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ jsx(Text, {
+                                        color: "textSecondary",
+                                        isEmphazed: true,
+                                        variant: "Smaller",
+                                        children: "No one can overwrite protected object versions during the retention period."
+                                    })
+                                ]
+                            })
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "retentionPeriod",
+                        label: "Retention period",
+                        direction: "horizontal",
+                        helpErrorPosition: "bottom",
+                        help: "Must be a positive whole number.",
+                        error: errors.retentionPeriod?.message,
+                        disabled: !isDefaultRetentionEnabled,
+                        content: /*#__PURE__*/ jsxs(Stack, {
+                            direction: "horizontal",
+                            children: [
+                                /*#__PURE__*/ jsx(Controller, {
+                                    control: control,
+                                    name: "retentionPeriod",
+                                    render: ({ field: { onChange, value: retentionPeriod } })=>/*#__PURE__*/ jsx(Input, {
+                                            id: "retentionPeriod",
+                                            name: "retentionPeriod",
+                                            value: retentionPeriod,
+                                            onChange: (e)=>onChange(e.target.valueAsNumber),
+                                            type: "number",
+                                            step: "1",
+                                            min: "1",
+                                            size: "2/3"
+                                        })
+                                }),
+                                /*#__PURE__*/ jsx(Controller, {
+                                    control: control,
+                                    name: "retentionPeriodFrequencyChoice",
+                                    defaultValue: 'DAYS',
+                                    render: ({ field: { onChange, value: retentionPeriodFrequencyChoice } })=>/*#__PURE__*/ jsxs(Select, {
+                                            id: "retentionPeriodFrequencyChoice",
+                                            onChange: onChange,
+                                            placeholder: "retentionPeriodFrequencyChoice",
+                                            value: retentionPeriodFrequencyChoice,
+                                            disabled: !isDefaultRetentionEnabled,
+                                            size: '1/3',
+                                            children: [
+                                                /*#__PURE__*/ jsx(Select.Option, {
+                                                    value: 'DAYS',
+                                                    children: "Days"
+                                                }),
+                                                /*#__PURE__*/ jsx(Select.Option, {
+                                                    value: 'YEARS',
+                                                    children: "Years"
+                                                })
+                                            ]
+                                        })
+                                })
+                            ]
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+export { ObjectLockRetentionSettings as default };

package/dist/components/objects/ObjectLock/ObjectLockSettings.d.ts

@@ -0,0 +1,9 @@
+import Joi from 'joi';
+export declare const objectLockRetentionSettingsValidationRules: {
+    isObjectLockEnabled: Joi.BooleanSchema<boolean>;
+    isDefaultRetentionEnabled: Joi.BooleanSchema<boolean>;
+    retentionMode: Joi.AlternativesSchema<any>;
+    retentionPeriod: Joi.AlternativesSchema<any>;
+    retentionPeriodFrequencyChoice: Joi.AlternativesSchema<any>;
+};
+export declare function ObjectLockSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/components/objects/ObjectLock/ObjectLockSettings.js

@@ -0,0 +1,159 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { joiResolver } from "@hookform/resolvers/joi";
+import { Form, Icon, Loader, Stack, Text, useToast } from "@scality/core-ui";
+import { Button } from "@scality/core-ui/dist/next";
+import joi from "joi";
+import { useEffect, useRef } from "react";
+import { FormProvider, useForm } from "react-hook-form";
+import { useParams } from "react-router";
+import { useGetBucketObjectLockConfiguration, useSetBucketObjectLockConfiguration } from "../../../hooks/index.js";
+import { useDataBrowserNavigate } from "../../../hooks/useDataBrowserNavigate.js";
+import ObjectLockRetentionSettings from "./ObjectLockRetentionSettings.js";
+const objectLockRetentionSettingsValidationRules = {
+    isObjectLockEnabled: joi.boolean(),
+    isDefaultRetentionEnabled: joi.boolean().default(false),
+    retentionMode: joi.when('isDefaultRetentionEnabled', {
+        is: joi.equal(true),
+        then: joi.string().valid('GOVERNANCE', 'COMPLIANCE').required(),
+        otherwise: joi.any()
+    }),
+    retentionPeriod: joi.when('isDefaultRetentionEnabled', {
+        is: joi.equal(true),
+        then: joi.number().integer().min(1).required(),
+        otherwise: joi.any()
+    }),
+    retentionPeriodFrequencyChoice: joi.when('isDefaultRetentionEnabled', {
+        is: joi.equal(true),
+        then: joi.string().valid('DAYS', 'YEARS').required(),
+        otherwise: joi.any()
+    })
+};
+const schema = joi.object(objectLockRetentionSettingsValidationRules);
+function ObjectLockSettings() {
+    const { bucketName } = useParams();
+    const navigate = useDataBrowserNavigate();
+    const { showToast } = useToast();
+    const { data: objectLockData, status: objectLockStatus } = useGetBucketObjectLockConfiguration({
+        Bucket: bucketName
+    });
+    const setBucketObjectLockMutation = useSetBucketObjectLockConfiguration();
+    const isObjectLockEnabled = objectLockData?.ObjectLockConfiguration?.ObjectLockEnabled === 'Enabled';
+    const defaultRetention = objectLockData?.ObjectLockConfiguration?.Rule?.DefaultRetention;
+    const useFormMethods = useForm({
+        mode: 'all',
+        resolver: joiResolver(schema),
+        defaultValues: {
+            isObjectLockEnabled: isObjectLockEnabled,
+            isDefaultRetentionEnabled: !!defaultRetention,
+            retentionMode: defaultRetention?.Mode || 'GOVERNANCE',
+            retentionPeriod: defaultRetention?.Days || defaultRetention?.Years || 1,
+            retentionPeriodFrequencyChoice: defaultRetention ? defaultRetention?.Days ? 'DAYS' : 'YEARS' : 'DAYS'
+        }
+    });
+    const { watch, setValue, handleSubmit, formState: { isValid } } = useFormMethods;
+    const isObjectLockEnabledValue = watch('isObjectLockEnabled');
+    const isFormInitialized = useRef(false);
+    useEffect(()=>{
+        if ('success' === objectLockStatus && objectLockData && !isFormInitialized.current) {
+            const isEnabled = objectLockData.ObjectLockConfiguration?.ObjectLockEnabled === 'Enabled';
+            const defaultRet = objectLockData.ObjectLockConfiguration?.Rule?.DefaultRetention;
+            setValue('isObjectLockEnabled', isEnabled);
+            setValue('isDefaultRetentionEnabled', !!defaultRet);
+            if (defaultRet) {
+                setValue('retentionMode', defaultRet.Mode);
+                setValue('retentionPeriod', defaultRet.Days || defaultRet.Years || 1);
+                setValue('retentionPeriodFrequencyChoice', defaultRet.Days ? 'DAYS' : 'YEARS');
+            }
+            isFormInitialized.current = true;
+        }
+    }, [
+        objectLockData,
+        objectLockStatus,
+        setValue
+    ]);
+    const handleCancel = ()=>{
+        navigate(`/buckets/${bucketName}`);
+    };
+    const onSubmit = (data)=>{
+        setBucketObjectLockMutation.mutate({
+            Bucket: bucketName,
+            ObjectLockConfiguration: data.isObjectLockEnabled ? {
+                ObjectLockEnabled: 'Enabled',
+                ...data.isDefaultRetentionEnabled && {
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: data.retentionMode,
+                            ...'DAYS' === data.retentionPeriodFrequencyChoice ? {
+                                Days: data.retentionPeriod
+                            } : {
+                                Years: data.retentionPeriod
+                            }
+                        }
+                    }
+                }
+            } : void 0
+        }, {
+            onSuccess: ()=>{
+                showToast({
+                    open: true,
+                    message: 'Object Lock settings saved successfully',
+                    status: 'success'
+                });
+                navigate(`/buckets/${bucketName}`);
+            },
+            onError: (error)=>{
+                const errorMessage = error instanceof Error ? error.message : 'Failed to save Object Lock settings';
+                showToast({
+                    open: true,
+                    message: errorMessage,
+                    status: 'error'
+                });
+            }
+        });
+    };
+    if ('pending' === objectLockStatus) return /*#__PURE__*/ jsx(Loader, {
+        centered: true,
+        children: /*#__PURE__*/ jsx(Text, {
+            children: "Loading retention settings..."
+        })
+    });
+    return /*#__PURE__*/ jsx(FormProvider, {
+        ...useFormMethods,
+        children: /*#__PURE__*/ jsx(Form, {
+            onSubmit: handleSubmit(onSubmit),
+            requireMode: "partial",
+            layout: {
+                kind: 'page',
+                title: 'Object-lock settings'
+            },
+            rightActions: /*#__PURE__*/ jsxs(Stack, {
+                gap: "r16",
+                children: [
+                    /*#__PURE__*/ jsx(Button, {
+                        id: "cancel-btn",
+                        variant: "outline",
+                        onClick: handleCancel,
+                        type: "button",
+                        label: "Cancel",
+                        disabled: setBucketObjectLockMutation.isPending
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        disabled: !isValid || !isObjectLockEnabledValue || setBucketObjectLockMutation.isPending,
+                        id: "edit-retention-setting-btn",
+                        type: "submit",
+                        variant: "primary",
+                        label: "Save",
+                        icon: /*#__PURE__*/ jsx(Icon, {
+                            name: "Save"
+                        }),
+                        isLoading: setBucketObjectLockMutation.isPending
+                    })
+                ]
+            }),
+            children: /*#__PURE__*/ jsx(ObjectLockRetentionSettings, {
+                isEditRetentionSettings: true
+            })
+        })
+    });
+}
+export { ObjectLockSettings, objectLockRetentionSettingsValidationRules };

package/dist/components/objects/ObjectLock/ObjectLockSettingsUtils.d.ts

@@ -0,0 +1,8 @@
+import type { GetObjectRetentionCommandOutput } from '@aws-sdk/client-s3';
+export declare function getDefaultRetention(retentionData: GetObjectRetentionCommandOutput | null | undefined): {
+    isDefaultRetentionEnabled: boolean;
+    defaultRetentionUntilDate: Date;
+    defaultRetentionMode: import("@aws-sdk/client-s3").ObjectLockRetentionMode;
+};
+export declare function getDefaultMinRetainUntilDate(d: Date | null | undefined, mode: string): string;
+export declare function getRetainUntilDateHint(dateString: string): string;

package/dist/components/objects/ObjectLock/ObjectLockSettingsUtils.js

@@ -0,0 +1,39 @@
+function getDefaultRetention(retentionData) {
+    const isDefaultRetentionEnabled = retentionData?.Retention !== void 0 && null !== retentionData.Retention;
+    const defaultRetentionUntilDate = retentionData?.Retention?.RetainUntilDate ? new Date(retentionData.Retention.RetainUntilDate) : new Date();
+    const defaultRetentionMode = retentionData?.Retention?.Mode || 'GOVERNANCE';
+    return {
+        isDefaultRetentionEnabled,
+        defaultRetentionUntilDate,
+        defaultRetentionMode
+    };
+}
+function getDefaultMinRetainUntilDate(d, mode) {
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    const futureDate = formatDateForInput(tomorrow);
+    if (!d) return futureDate;
+    const previousRetainUntilDate = 'GOVERNANCE' === mode ? formatDateForInput(d) : formatDateForInput(addDays(d, 1));
+    return previousRetainUntilDate > futureDate ? previousRetainUntilDate : futureDate;
+}
+function formatDateForInput(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+function addDays(date, days) {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+}
+function getRetainUntilDateHint(dateString) {
+    const now = new Date();
+    const retainUntilDate = new Date(dateString);
+    const diffInMs = retainUntilDate.getTime() - now.getTime();
+    const diffInDays = Math.floor(diffInMs / 86400000);
+    if (diffInDays < 1) return '(within 24 hours from now)';
+    if (1 === diffInDays) return '(1 day from now)';
+    return `(${diffInDays} days from now)`;
+}
+export { getDefaultMinRetainUntilDate, getDefaultRetention, getRetainUntilDateHint };

package/dist/components/objects/ObjectLock/__tests__/EditRetentionButton.test.d.ts

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