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

package/dist/components/buckets/BucketCreate.js

@@ -1,73 +1,76 @@
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { joiResolver } from "@hookform/resolvers/joi";
 import { Checkbox, Form, FormGroup, FormSection, Stack, useToast } from "@scality/core-ui";
 import { Button, Input } from "@scality/core-ui/dist/next";
 import { convertRemToPixels } from "@scality/core-ui/dist/utils";
 import joi from "joi";
 import { FormProvider, useForm } from "react-hook-form";
-import { useNavigate } from "react-router";
+import { useCreateBucket, useSetBucketEncryption, useSetBucketObjectLockConfiguration, useSetBucketVersioning } from "../../hooks/index.js";
+import { useDataBrowserNavigate } from "../../hooks/useDataBrowserNavigate.js";
 import ObjectLockRetentionSettings from "../objects/ObjectLock/ObjectLockRetentionSettings.js";
 import { objectLockRetentionSettingsValidationRules } from "../objects/ObjectLock/ObjectLockSettings.js";
-import { useCreateBucket, useSetBucketObjectLockConfiguration, useSetBucketVersioning } from "../../hooks/index.js";
-const bucketErrorMessage = "Bucket names can include only lowercase letters, numbers, dots (.), and hyphens (-)";
-const bucketNameValidationSchema = joi.string().label("Bucket Name").required().min(3).max(63).pattern(/^[a-z0-9]([a-z0-9.-]*[a-z0-9])?$/, {
-    name: "bucketName",
+import { useDataBrowserConfig } from "../providers/DataBrowserProvider.js";
+const bucketErrorMessage = 'Bucket names can include only lowercase letters, numbers, dots (.), and hyphens (-)';
+const bucketNameValidationSchema = joi.string().label('Bucket Name').required().min(3).max(63).pattern(/^[a-z0-9]([a-z0-9.-]*[a-z0-9])?$/, {
+    name: 'bucketName',
     invert: false
 }).messages({
-    "string.pattern.name": bucketErrorMessage
+    'string.pattern.name': bucketErrorMessage
 }).custom((value, helpers)=>{
-    if (value.includes("..")) return helpers.message({
-        custom: "Bucket names cannot contain two adjacent periods"
+    if (value.includes('..')) return helpers.message({
+        custom: 'Bucket names cannot contain two adjacent periods'
     });
     if (/^(\d{1,3}\.){3}\d{1,3}$/.test(value)) return helpers.message({
-        custom: "Bucket names must not be formatted as an IP address"
+        custom: 'Bucket names must not be formatted as an IP address'
     });
     const forbiddenPrefixes = [
-        "xn--",
-        "sthree-",
-        "amzn-s3-demo-"
+        'xn--',
+        'sthree-',
+        'amzn-s3-demo-'
     ];
     if (forbiddenPrefixes.some((prefix)=>value.startsWith(prefix))) return helpers.message({
-        custom: `Bucket names must not start with ${forbiddenPrefixes.join(", ")}`
+        custom: `Bucket names must not start with ${forbiddenPrefixes.join(', ')}`
     });
     const forbiddenSuffixes = [
-        "-s3alias",
-        "--ol-s3",
-        "--x-s3",
-        ".mrap"
+        '-s3alias',
+        '--ol-s3',
+        '--x-s3',
+        '.mrap'
     ];
     if (forbiddenSuffixes.some((suffix)=>value.endsWith(suffix))) return helpers.message({
-        custom: `Bucket names must not end with ${forbiddenSuffixes.join(", ")}`
+        custom: `Bucket names must not end with ${forbiddenSuffixes.join(', ')}`
     });
     const existingBuckets = helpers.prefs.context?.existingBuckets;
     if (Array.isArray(existingBuckets)) {
         const isDuplicate = existingBuckets.some((bucketName)=>bucketName.toLowerCase() === value.toLowerCase());
         if (isDuplicate) return helpers.message({
-            custom: "A bucket with this name already exists"
+            custom: 'A bucket with this name already exists'
         });
     }
     return value;
-}, "AWS S3 bucket naming rules");
+}, 'AWS S3 bucket naming rules');
 const baseBucketCreateSchema = joi.object({
     name: bucketNameValidationSchema,
     isVersioning: joi.boolean(),
+    isEncryptionEnabled: joi.boolean(),
     ...objectLockRetentionSettingsValidationRules
 });
 const BucketCreate = ({ subTitle, validationSchema, validationContext, defaultValues: customDefaultValues, children, onSubmit: onSubmitProp, onCancel: onCancelProp })=>{
-    const navigate = useNavigate();
+    const navigate = useDataBrowserNavigate();
     const { showToast } = useToast();
     const baseDefaultValues = {
-        name: "",
+        name: '',
         isVersioning: false,
+        isEncryptionEnabled: false,
         isObjectLockEnabled: false,
         isDefaultRetentionEnabled: false,
-        retentionMode: "GOVERNANCE",
+        retentionMode: 'GOVERNANCE',
         retentionPeriod: 1,
-        retentionPeriodFrequencyChoice: "DAYS",
+        retentionPeriodFrequencyChoice: 'DAYS',
         ...customDefaultValues
     };
     const useFormMethods = useForm({
-        mode: "all",
+        mode: 'all',
         resolver: joiResolver(validationSchema || baseBucketCreateSchema, {
             context: validationContext || {}
         }),
@@ -76,19 +79,21 @@ const BucketCreate = ({ subTitle, validationSchema, validationContext, defaultVa
     });
     const { register, handleSubmit, formState, watch } = useFormMethods;
     const { isValid, errors } = formState;
-    const isObjectLockEnabled = watch("isObjectLockEnabled");
+    const isObjectLockEnabled = watch('isObjectLockEnabled');
+    const { s3Capabilities } = useDataBrowserConfig();
     const { mutate: createBucket, isPending: isCreatingBucket } = useCreateBucket();
     const { mutate: setBucketVersioning } = useSetBucketVersioning();
     const { mutate: setObjectLockConfig } = useSetBucketObjectLockConfiguration();
+    const { mutate: setBucketEncryption } = useSetBucketEncryption();
     const handleCancel = ()=>{
         if (onCancelProp) onCancelProp();
-        else navigate("/buckets");
+        else navigate('/buckets');
     };
     const handleSuccess = (bucketName)=>{
         showToast({
             open: true,
             message: `Bucket "${bucketName}" created successfully`,
-            status: "success"
+            status: 'success'
         });
         navigate(`/buckets/${bucketName}`);
     };
@@ -96,7 +101,7 @@ const BucketCreate = ({ subTitle, validationSchema, validationContext, defaultVa
         showToast({
             open: true,
             message: error instanceof Error ? error.message : `Failed to ${operation}`,
-            status: "error"
+            status: 'error'
         });
     };
     const onSubmit = (data)=>{
@@ -104,6 +109,7 @@ const BucketCreate = ({ subTitle, validationSchema, validationContext, defaultVa
         const bucketName = data.name;
         const needsExplicitVersioning = data.isVersioning && !data.isObjectLockEnabled;
         const needsRetentionConfig = data.isObjectLockEnabled && data.isDefaultRetentionEnabled;
+        const needsEncryption = data.isEncryptionEnabled;
         createBucket({
             Bucket: bucketName,
             ObjectLockEnabledForBucket: data.isObjectLockEnabled || void 0
@@ -112,41 +118,65 @@ const BucketCreate = ({ subTitle, validationSchema, validationContext, defaultVa
                 if (needsExplicitVersioning) setBucketVersioning({
                     Bucket: bucketName,
                     VersioningConfiguration: {
-                        Status: "Enabled"
+                        Status: 'Enabled'
                     }
                 }, {
-                    onSuccess: ()=>handleSuccess(bucketName),
-                    onError: (error)=>handleError(error, "enable versioning")
+                    onSuccess: ()=>{
+                        if (needsEncryption) applyEncryption(bucketName);
+                        else handleSuccess(bucketName);
+                    },
+                    onError: (error)=>handleError(error, 'enable versioning')
                 });
                 else if (needsRetentionConfig) {
                     const retentionConfig = {
                         Bucket: bucketName,
                         ObjectLockConfiguration: {
-                            ObjectLockEnabled: "Enabled",
+                            ObjectLockEnabled: 'Enabled',
                             Rule: {
                                 DefaultRetention: {
                                     Mode: data.retentionMode,
-                                    Days: "DAYS" === data.retentionPeriodFrequencyChoice ? data.retentionPeriod : void 0,
-                                    Years: "YEARS" === data.retentionPeriodFrequencyChoice ? data.retentionPeriod : void 0
+                                    Days: 'DAYS' === data.retentionPeriodFrequencyChoice ? data.retentionPeriod : void 0,
+                                    Years: 'YEARS' === data.retentionPeriodFrequencyChoice ? data.retentionPeriod : void 0
                                 }
                             }
                         }
                     };
                     setObjectLockConfig(retentionConfig, {
-                        onSuccess: ()=>handleSuccess(bucketName),
-                        onError: (error)=>handleError(error, "configure object lock retention")
+                        onSuccess: ()=>{
+                            if (needsEncryption) applyEncryption(bucketName);
+                            else handleSuccess(bucketName);
+                        },
+                        onError: (error)=>handleError(error, 'configure object lock retention')
                     });
-                } else handleSuccess(bucketName);
+                } else if (needsEncryption) applyEncryption(bucketName);
+                else handleSuccess(bucketName);
             },
-            onError: (error)=>handleError(error, "create bucket")
+            onError: (error)=>handleError(error, 'create bucket')
+        });
+    };
+    const applyEncryption = (bucketName)=>{
+        setBucketEncryption({
+            Bucket: bucketName,
+            ServerSideEncryptionConfiguration: {
+                Rules: [
+                    {
+                        ApplyServerSideEncryptionByDefault: {
+                            SSEAlgorithm: 'AES256'
+                        }
+                    }
+                ]
+            }
+        }, {
+            onSuccess: ()=>handleSuccess(bucketName),
+            onError: (error)=>handleError(error, 'enable bucket encryption')
         });
     };
     return /*#__PURE__*/ jsx(FormProvider, {
         ...useFormMethods,
         children: /*#__PURE__*/ jsxs(Form, {
             layout: {
-                kind: "page",
-                title: "Create a New Bucket",
+                kind: 'page',
+                title: 'Create a New Bucket',
                 subTitle
             },
             requireMode: "partial",
@@ -174,7 +204,9 @@ const BucketCreate = ({ subTitle, validationSchema, validationContext, defaultVa
             children: [
                 /*#__PURE__*/ jsx(FormSection, {
                     forceLabelWidth: convertRemToPixels(17.5),
-                    children: /*#__PURE__*/ jsxs(Fragment, {
+                    children: /*#__PURE__*/ jsxs(Stack, {
+                        direction: "vertical",
+                        gap: "r16",
                         children: [
                             /*#__PURE__*/ jsx(FormGroup, {
                                 id: "name",
@@ -184,7 +216,7 @@ const BucketCreate = ({ subTitle, validationSchema, validationContext, defaultVa
                                 content: /*#__PURE__*/ jsx(Input, {
                                     id: "name",
                                     autoFocus: true,
-                                    ...register("name")
+                                    ...register('name')
                                 }),
                                 labelHelpTooltip: /*#__PURE__*/ jsxs("ul", {
                                     children: [
@@ -200,9 +232,19 @@ const BucketCreate = ({ subTitle, validationSchema, validationContext, defaultVa
                                     ]
                                 }),
                                 helpErrorPosition: "bottom",
-                                error: errors.name ? errors.name?.type === "string.pattern.base" ? bucketErrorMessage : errors.name?.message : void 0
+                                error: errors.name ? errors.name?.type === 'string.pattern.base' ? bucketErrorMessage : errors.name?.message : void 0
                             }),
                             children,
+                            s3Capabilities?.bucketEncryption && /*#__PURE__*/ jsx(FormGroup, {
+                                id: "isEncryptionEnabled",
+                                label: "Encryption",
+                                labelHelpTooltip: "Objects stored in this bucket will be automatically encrypted.",
+                                helpErrorPosition: "bottom",
+                                content: /*#__PURE__*/ jsx(Checkbox, {
+                                    id: "isEncryptionEnabled",
+                                    ...register('isEncryptionEnabled')
+                                })
+                            }),
                             /*#__PURE__*/ jsx(FormGroup, {
                                 id: "isVersioning",
                                 label: "Versioning",
@@ -217,12 +259,12 @@ const BucketCreate = ({ subTitle, validationSchema, validationContext, defaultVa
                                         })
                                     ]
                                 }),
-                                help: isObjectLockEnabled ? "Automatically activated when Object-lock is Enabled" : void 0,
+                                help: isObjectLockEnabled ? 'Automatically activated when Object-lock is Enabled' : void 0,
                                 helpErrorPosition: "bottom",
                                 content: /*#__PURE__*/ jsx(Checkbox, {
                                     id: "isVersioning",
                                     disabled: isObjectLockEnabled,
-                                    ...register("isVersioning")
+                                    ...register('isVersioning')
                                 })
                             })
                         ]

package/dist/components/buckets/BucketDetails.d.ts

@@ -1 +1,43 @@
+import { useDataBrowserNavigate } from '../../hooks/useDataBrowserNavigate';
+interface BucketDetailsContextValue {
+    bucketName: string;
+    navigate: ReturnType<typeof useDataBrowserNavigate>;
+}
+/**
+ * Context for BucketDetails component.
+ *
+ * **Important**: Always use `useBucketDetailsContext()` hook instead of accessing this context directly.
+ * The hook provides proper error handling if the context is not available.
+ *
+ * This context is exported for testing purposes only.
+ */
+export declare const BucketDetailsContext: import("react").Context<BucketDetailsContextValue | null>;
+export declare function useBucketDetailsContext(): BucketDetailsContextValue;
+declare const OverviewTab: React.FC;
+declare const LifecycleTab: React.FC;
+declare const ReplicationTab: React.FC;
+declare const NotificationTab: React.FC;
+interface CustomTabProps {
+    config: {
+        id: string;
+        title: string;
+        path?: string;
+        withoutPadding?: boolean;
+        render: () => React.ReactNode;
+    };
+}
+declare const CustomTab: React.FC<CustomTabProps>;
+interface BucketDetailsProps {
+    children?: React.ReactNode;
+}
+declare const BucketDetailsRoot: React.FC<BucketDetailsProps>;
 export declare function BucketDetails(): import("react/jsx-runtime").JSX.Element;
+type BucketDetailsComponent = typeof BucketDetailsRoot & {
+    OverviewTab: typeof OverviewTab;
+    LifecycleTab: typeof LifecycleTab;
+    ReplicationTab: typeof ReplicationTab;
+    NotificationTab: typeof NotificationTab;
+    CustomTab: typeof CustomTab;
+};
+declare const BucketDetailsCompound: BucketDetailsComponent;
+export { BucketDetailsCompound };