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

package/dist/components/buckets/BucketDetails.js

@@ -1,51 +1,267 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { useQueryParams } from "../../utils/hooks.js";
-import { useNavigate, useParams } from "react-router-dom";
 import { Tabs } from "@scality/core-ui/dist/next";
+import { createContext, memo, useCallback, useContext, useMemo } from "react";
+import { useParams } from "react-router";
+import { useDataBrowserUICustomization } from "../../contexts/DataBrowserUICustomizationContext.js";
+import { useGetBucketLifecycle, useGetBucketNotification, useGetBucketReplication } from "../../hooks/bucketConfiguration.js";
+import { useDataBrowserNavigate } from "../../hooks/useDataBrowserNavigate.js";
+import { BUCKET_ROUTES } from "../../utils/constants.js";
+import { isNotFoundError } from "../../utils/errorHandling.js";
+import { BucketLifecycleList } from "./BucketLifecycleList.js";
 import { BucketOverview } from "./BucketOverview.js";
+import { BucketReplicationList } from "./BucketReplicationList.js";
+import { BucketVersioning } from "./BucketVersioning.js";
 import { DeleteBucketButton } from "./DeleteBucketButton.js";
-function BucketDetails() {
-    const query = useQueryParams();
-    const queryObject = Object.fromEntries(query.entries());
+import { EmptyBucketButton } from "./EmptyBucketButton.js";
+import { BucketNotificationList } from "./notifications/BucketNotificationList.js";
+const BucketDetailsContext = /*#__PURE__*/ createContext(null);
+function useBucketDetailsContext() {
+    const context = useContext(BucketDetailsContext);
+    if (!context) throw new Error('BucketDetails components must be used within BucketDetails');
+    return context;
+}
+const getEffectiveStatus = (status, error)=>{
+    if (isNotFoundError(error)) return 'success';
+    if ('pending' === status) return 'loading';
+    if ('error' === status) return 'error';
+    return 'success';
+};
+const ExtraSectionContent = /*#__PURE__*/ memo(({ render })=>/*#__PURE__*/ jsx(Fragment, {
+        children: render()
+    }));
+ExtraSectionContent.displayName = 'BucketDetails.ExtraSectionContent';
+const OverviewTab = /*#__PURE__*/ memo(()=>{
+    const { bucketName, navigate } = useBucketDetailsContext();
+    const { extraBucketOverviewSections } = useDataBrowserUICustomization();
+    const renderDeleteButton = useCallback((name)=>/*#__PURE__*/ jsx(DeleteBucketButton, {
+            bucketName: name
+        }), []);
+    const renderEmptyButton = useCallback((name)=>/*#__PURE__*/ jsx(EmptyBucketButton, {
+            bucketName: name
+        }), []);
+    const renderVersioning = useCallback(()=>/*#__PURE__*/ jsx(BucketVersioning, {}), []);
+    const handleEditPolicy = useCallback((name)=>navigate(BUCKET_ROUTES.bucketPolicy(name)), [
+        navigate
+    ]);
+    const handleEditCors = useCallback((name)=>navigate(BUCKET_ROUTES.bucketCors(name)), [
+        navigate
+    ]);
+    return /*#__PURE__*/ jsxs(BucketOverview, {
+        bucketName: bucketName,
+        children: [
+            /*#__PURE__*/ jsx(BucketOverview.Actions, {
+                renderDeleteButton: renderDeleteButton,
+                renderEmptyButton: renderEmptyButton
+            }),
+            /*#__PURE__*/ jsxs(BucketOverview.Sections, {
+                children: [
+                    /*#__PURE__*/ jsx(BucketOverview.GeneralSection, {
+                        renderVersioning: renderVersioning
+                    }),
+                    extraBucketOverviewSections?.map((section)=>/*#__PURE__*/ jsx(BucketOverview.Section, {
+                            title: section.title,
+                            children: /*#__PURE__*/ jsx(ExtraSectionContent, {
+                                render: section.render
+                            })
+                        }, section.id)),
+                    /*#__PURE__*/ jsx(BucketOverview.DataProtectionSection, {}),
+                    /*#__PURE__*/ jsx(BucketOverview.PermissionsSection, {
+                        onEditPolicy: handleEditPolicy,
+                        onEditCors: handleEditCors
+                    })
+                ]
+            })
+        ]
+    });
+});
+OverviewTab.displayName = 'BucketDetails.OverviewTab';
+const LifecycleTab = /*#__PURE__*/ memo(()=>{
+    const { bucketName, navigate } = useBucketDetailsContext();
+    const { data: lifecycleData, status: lifecycleStatus, error: lifecycleError } = useGetBucketLifecycle({
+        Bucket: bucketName
+    });
+    const lifecycleRules = lifecycleData?.Rules || [];
+    const effectiveStatus = getEffectiveStatus(lifecycleStatus, lifecycleError);
+    const handleCreateRule = useCallback(()=>navigate(BUCKET_ROUTES.lifecycleCreate(bucketName)), [
+        navigate,
+        bucketName
+    ]);
+    const handleEditRule = useCallback((ruleId)=>navigate(BUCKET_ROUTES.lifecycleEdit(bucketName, ruleId)), [
+        navigate,
+        bucketName
+    ]);
+    return /*#__PURE__*/ jsx(BucketLifecycleList, {
+        bucketName: bucketName,
+        lifecycleRules: lifecycleRules,
+        lifecycleStatus: effectiveStatus,
+        onCreateRule: handleCreateRule,
+        onEditRule: handleEditRule
+    });
+});
+LifecycleTab.displayName = 'BucketDetails.LifecycleTab';
+const ReplicationTab = /*#__PURE__*/ memo(()=>{
+    const { bucketName, navigate } = useBucketDetailsContext();
+    const { data: replicationData, status: replicationStatus, error: replicationError } = useGetBucketReplication({
+        Bucket: bucketName
+    });
+    const replicationRules = replicationData?.ReplicationConfiguration?.Rules || [];
+    const replicationRole = replicationData?.ReplicationConfiguration?.Role || '';
+    const effectiveStatus = getEffectiveStatus(replicationStatus, replicationError);
+    const handleCreateRule = useCallback(()=>navigate(BUCKET_ROUTES.replicationCreate(bucketName)), [
+        navigate,
+        bucketName
+    ]);
+    const handleEditRule = useCallback((ruleId)=>navigate(BUCKET_ROUTES.replicationEdit(bucketName, ruleId)), [
+        navigate,
+        bucketName
+    ]);
+    return /*#__PURE__*/ jsx(BucketReplicationList, {
+        bucketName: bucketName,
+        replicationRules: replicationRules,
+        replicationRole: replicationRole,
+        replicationStatus: effectiveStatus,
+        onCreateRule: handleCreateRule,
+        onEditRule: handleEditRule
+    });
+});
+ReplicationTab.displayName = 'BucketDetails.ReplicationTab';
+const NotificationTab = /*#__PURE__*/ memo(()=>{
+    const { bucketName, navigate } = useBucketDetailsContext();
+    const { data: notificationData, status: notificationStatus, error: notificationError } = useGetBucketNotification({
+        Bucket: bucketName
+    });
+    const notificationRules = notificationData?.QueueConfigurations || [];
+    const effectiveStatus = getEffectiveStatus(notificationStatus, notificationError);
+    const handleCreateRule = useCallback(()=>navigate(BUCKET_ROUTES.notificationCreate(bucketName)), [
+        navigate,
+        bucketName
+    ]);
+    const handleEditRule = useCallback((ruleId)=>navigate(BUCKET_ROUTES.notificationEdit(bucketName, ruleId)), [
+        navigate,
+        bucketName
+    ]);
+    return /*#__PURE__*/ jsx(BucketNotificationList, {
+        bucketName: bucketName,
+        notificationRules: notificationRules,
+        notificationStatus: effectiveStatus,
+        onCreateRule: handleCreateRule,
+        onEditRule: handleEditRule
+    });
+});
+NotificationTab.displayName = 'BucketDetails.NotificationTab';
+const CustomTab = ({ config })=>/*#__PURE__*/ jsx(Fragment, {
+        children: config.render()
+    });
+CustomTab.displayName = 'BucketDetails.CustomTab';
+const BucketDetailsRoot = ({ children })=>{
     const { bucketName } = useParams();
-    const navigate = useNavigate();
+    const navigate = useDataBrowserNavigate();
+    const contextValue = useMemo(()=>({
+            bucketName: bucketName || '',
+            navigate
+        }), [
+        bucketName,
+        navigate
+    ]);
     if (!bucketName) return /*#__PURE__*/ jsx("div", {
         children: "No bucket selected"
     });
-    return /*#__PURE__*/ jsx(Fragment, {
-        children: /*#__PURE__*/ jsxs(Tabs, {
-            children: [
-                /*#__PURE__*/ jsx(Tabs.Tab, {
-                    label: "Overview",
-                    path: "",
-                    query: {
-                        ...queryObject,
-                        tab: ""
-                    },
-                    children: /*#__PURE__*/ jsx(BucketOverview, {
-                        bucketName: bucketName,
-                        renderDeleteButton: ()=>/*#__PURE__*/ jsx(DeleteBucketButton, {
-                                bucketName: bucketName
-                            }),
-                        onEditPolicy: ()=>{
-                            navigate(`/buckets/${bucketName}/policy`);
-                        }
-                    })
-                }),
-                /*#__PURE__*/ jsx(Tabs.Tab, {
-                    label: "Workflow",
-                    path: "",
-                    query: {
-                        ...queryObject,
-                        tab: "workflow"
-                    },
-                    withoutPadding: true,
-                    children: /*#__PURE__*/ jsx(Fragment, {
-                        children: "Workflow"
-                    })
+    return /*#__PURE__*/ jsx(BucketDetailsContext.Provider, {
+        value: contextValue,
+        children: children || /*#__PURE__*/ jsx(DefaultTabs, {})
+    });
+};
+BucketDetailsRoot.displayName = 'BucketDetails';
+const DefaultTabs = ()=>{
+    const { extraBucketTabs } = useDataBrowserUICustomization();
+    const defaultTabsMap = useMemo(()=>({
+            overview: {
+                id: 'overview',
+                label: 'Overview',
+                path: '',
+                withoutPadding: false,
+                query: {
+                    tab: ''
+                },
+                type: 'default',
+                Component: OverviewTab
+            },
+            lifecycle: {
+                id: 'lifecycle',
+                label: 'Lifecycle',
+                path: '',
+                withoutPadding: true,
+                query: {
+                    tab: 'lifecycle'
+                },
+                type: 'default',
+                Component: LifecycleTab
+            },
+            replication: {
+                id: 'replication',
+                label: 'Replication',
+                path: '',
+                withoutPadding: true,
+                query: {
+                    tab: 'replication'
+                },
+                type: 'default',
+                Component: ReplicationTab
+            },
+            notification: {
+                id: 'notification',
+                label: 'Notification',
+                path: '',
+                withoutPadding: true,
+                query: {
+                    tab: 'notification'
+                },
+                type: 'default',
+                Component: NotificationTab
+            }
+        }), []);
+    const allTabs = useMemo(()=>{
+        const customTabConfigs = extraBucketTabs ? extraBucketTabs.map((tabConfig)=>({
+                id: tabConfig.id,
+                label: tabConfig.title,
+                path: tabConfig.path || '',
+                query: {
+                    tab: tabConfig.id
+                },
+                withoutPadding: tabConfig.withoutPadding || false,
+                type: 'custom',
+                config: tabConfig
+            })) : [];
+        const overrideIds = new Set(customTabConfigs.filter((t)=>t.id in defaultTabsMap).map((t)=>t.id));
+        const defaults = Object.values(defaultTabsMap).filter((tab)=>!overrideIds.has(tab.id));
+        return [
+            ...defaults,
+            ...customTabConfigs
+        ];
+    }, [
+        extraBucketTabs,
+        defaultTabsMap
+    ]);
+    return /*#__PURE__*/ jsx(Tabs, {
+        children: allTabs.map((tab)=>/*#__PURE__*/ jsx(Tabs.Tab, {
+                label: tab.label,
+                path: tab.path,
+                query: tab.query,
+                withoutPadding: tab.withoutPadding,
+                children: 'default' === tab.type ? /*#__PURE__*/ jsx(tab.Component, {}) : /*#__PURE__*/ jsx(CustomTab, {
+                    config: tab.config
                 })
-            ]
-        })
+            }, tab.id))
     });
+};
+DefaultTabs.displayName = 'BucketDetails.DefaultTabs';
+function BucketDetails() {
+    return /*#__PURE__*/ jsx(BucketDetailsRoot, {});
 }
-export { BucketDetails };
+const BucketDetailsCompound = BucketDetailsRoot;
+BucketDetailsCompound.OverviewTab = OverviewTab;
+BucketDetailsCompound.LifecycleTab = LifecycleTab;
+BucketDetailsCompound.ReplicationTab = ReplicationTab;
+BucketDetailsCompound.NotificationTab = NotificationTab;
+BucketDetailsCompound.CustomTab = CustomTab;
+export { BucketDetails, BucketDetailsCompound, BucketDetailsContext, useBucketDetailsContext };

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

@@ -0,0 +1,15 @@
+/**
+ * BucketLifecycleFormPage - Form for creating and editing S3 bucket lifecycle rules
+ *
+ * Features:
+ * - Create new or edit existing lifecycle rules
+ * - Support for all AWS S3 lifecycle actions (transitions, expirations, etc.)
+ * - Comprehensive validation based on AWS S3 requirements
+ * - Filter options: prefix, tags, or combination
+ * - Current and noncurrent version management
+ * - Abort incomplete multipart upload configuration
+ *
+ * AWS S3 Lifecycle Documentation:
+ * https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLifecycleConfiguration.html
+ */
+export declare function BucketLifecycleFormPage(): import("react/jsx-runtime").JSX.Element;