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

package/dist/components/buckets/__tests__/BucketVersioning.test.js

@@ -0,0 +1,163 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { useGetBucketObjectLockConfiguration, useGetBucketVersioning, useISVBucketStatus, useSetBucketVersioning } from "../../../hooks/index.js";
+import { createMockMutationResult, createTestWrapper, findToggleByLabel } from "../../../test/testUtils.js";
+import { BucketOverviewContext } from "../BucketOverview.js";
+import { BucketVersioning } from "../BucketVersioning.js";
+const mockShowToast = jest.fn();
+jest.mock('@scality/core-ui', ()=>({
+        ...jest.requireActual('@scality/core-ui'),
+        useToast: ()=>({
+                showToast: mockShowToast
+            })
+    }));
+jest.mock('../../../hooks');
+const mockUseGetBucketVersioning = jest.mocked(useGetBucketVersioning);
+const mockUseGetBucketObjectLockConfiguration = jest.mocked(useGetBucketObjectLockConfiguration);
+const mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
+const mockUseSetBucketVersioning = jest.mocked(useSetBucketVersioning);
+const renderBucketVersioning = (props = {})=>{
+    const mockMutate = jest.fn();
+    mockUseSetBucketVersioning.mockReturnValue(createMockMutationResult(mockMutate));
+    const Wrapper = createTestWrapper();
+    return {
+        ...render(/*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(BucketOverviewContext.Provider, {
+                value: {
+                    bucketName: 'test-bucket'
+                },
+                children: /*#__PURE__*/ jsx(BucketVersioning, {
+                    ...props
+                })
+            })
+        })),
+        mutate: mockMutate
+    };
+};
+const mockHookDefaults = ()=>{
+    mockUseGetBucketVersioning.mockReturnValue({
+        data: {
+            Status: 'Enabled'
+        },
+        status: 'success',
+        error: null
+    });
+    mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+        data: {
+            ObjectLockConfiguration: {
+                ObjectLockEnabled: 'Disabled'
+            }
+        },
+        status: 'success',
+        error: null
+    });
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: false,
+        isISVManaged: false,
+        isvApplication: void 0,
+        isLoading: false,
+        bucketTagsStatus: 'success'
+    });
+};
+describe('BucketVersioning', ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockHookDefaults();
+    });
+    it('renders toggle with Active label when versioning is enabled', ()=>{
+        renderBucketVersioning();
+        const toggle = findToggleByLabel('Active');
+        expect(toggle).toBeInTheDocument();
+        expect(toggle).toBeChecked();
+    });
+    it('renders toggle with Inactive label when versioning is suspended', ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: {
+                Status: 'Suspended'
+            },
+            status: 'success',
+            error: null
+        });
+        renderBucketVersioning();
+        const toggle = findToggleByLabel('Inactive');
+        expect(toggle).toBeInTheDocument();
+        expect(toggle).not.toBeChecked();
+    });
+    it('calls mutation with Suspended status when disabling versioning', ()=>{
+        const { mutate } = renderBucketVersioning();
+        const toggle = findToggleByLabel('Active');
+        fireEvent.click(toggle);
+        expect(mutate).toHaveBeenCalledWith({
+            Bucket: 'test-bucket',
+            VersioningConfiguration: {
+                Status: 'Suspended'
+            }
+        }, expect.any(Object));
+    });
+    it('calls mutation with Enabled status when enabling versioning', ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: {
+                Status: 'Suspended'
+            },
+            status: 'success',
+            error: null
+        });
+        const { mutate } = renderBucketVersioning();
+        const toggle = findToggleByLabel('Inactive');
+        fireEvent.click(toggle);
+        expect(mutate).toHaveBeenCalledWith({
+            Bucket: 'test-bucket',
+            VersioningConfiguration: {
+                Status: 'Enabled'
+            }
+        }, expect.any(Object));
+    });
+    it('disables toggle when versioning data is loading', ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: void 0,
+            status: 'pending',
+            error: null
+        });
+        renderBucketVersioning();
+        const toggle = screen.getByRole('checkbox');
+        expect(toggle).toHaveAttribute('aria-disabled', 'true');
+    });
+    it('renders static Enabled text when Object Lock is enabled', ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled'
+                }
+            },
+            status: 'success'
+        });
+        renderBucketVersioning();
+        expect(screen.getByText('Enabled')).toBeInTheDocument();
+        expect(screen.getByText(/Versioning cannot be suspended because Object-lock is enabled/i)).toBeInTheDocument();
+        expect(screen.queryByRole('checkbox')).not.toBeInTheDocument();
+    });
+    it('disables toggle when bucket is managed by Veeam', ()=>{
+        mockUseISVBucketStatus.mockReturnValue({
+            isVeeamBucket: true,
+            isCommvaultBucket: false,
+            isISVManaged: true,
+            isvApplication: 'Veeam',
+            isLoading: false,
+            bucketTagsStatus: 'success'
+        });
+        renderBucketVersioning();
+        const toggle = screen.getByRole('checkbox');
+        expect(toggle).toHaveAttribute('aria-disabled', 'true');
+    });
+    it('disables toggle when versioning query errors', ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: void 0,
+            status: 'error',
+            error: new Error('Failed to fetch versioning')
+        });
+        renderBucketVersioning();
+        const toggle = screen.getByRole('checkbox');
+        expect(toggle).toHaveAttribute('aria-disabled', 'true');
+    });
+});

package/dist/components/buckets/notifications/BucketNotificationFormPage.d.ts

@@ -0,0 +1 @@
+export declare function BucketNotificationFormPage(): import("react/jsx-runtime").JSX.Element;

package/dist/components/buckets/notifications/BucketNotificationFormPage.js

@@ -0,0 +1,316 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { joiResolver } from "@hookform/resolvers/joi";
+import { Form, FormGroup, FormSection, Icon, Loader, Stack, Text, spacing, useToast } from "@scality/core-ui";
+import { convertRemToPixels } from "@scality/core-ui/dist/components/tablev2/TableUtils";
+import { Box, Button, Input } from "@scality/core-ui/dist/next";
+import joi from "joi";
+import { useCallback, useEffect, useMemo } from "react";
+import { FormProvider, useForm } from "react-hook-form";
+import { useParams } from "react-router";
+import { useGetBucketNotification, useSetBucketNotification } from "../../../hooks/index.js";
+import { useDataBrowserNavigate } from "../../../hooks/useDataBrowserNavigate.js";
+import { EventsSection } from "./EventsSection.js";
+const baseSchema = joi.object({
+    ruleName: joi.string().required().messages({
+        'string.empty': 'This field is required'
+    }),
+    queueArn: joi.string().required().pattern(/^arn:aws:sqs:[a-z0-9-]+:\d+:.+$/).messages({
+        'string.empty': 'This field is required',
+        'string.pattern.base': 'Must be a valid ARN (e.g., arn:aws:sqs:region:account-id:queue-name)'
+    }),
+    events: joi.array().min(1).required().messages({
+        'array.min': 'At least one event must be selected'
+    }),
+    prefix: joi.string().allow('').optional(),
+    suffix: joi.string().allow('').optional()
+});
+function BucketNotificationFormPage() {
+    const { bucketName, ruleId } = useParams();
+    const navigate = useDataBrowserNavigate();
+    const { showToast } = useToast();
+    const isEditMode = !!ruleId;
+    const { data: existingNotificationData, status: notificationStatus, error: notificationError } = useGetBucketNotification({
+        Bucket: bucketName
+    });
+    const existingRule = useMemo(()=>{
+        if (!isEditMode || !existingNotificationData?.QueueConfigurations || !ruleId) return null;
+        return existingNotificationData.QueueConfigurations.find((config)=>config.Id === decodeURIComponent(ruleId));
+    }, [
+        isEditMode,
+        existingNotificationData,
+        ruleId
+    ]);
+    const existingRuleNames = useMemo(()=>existingNotificationData?.QueueConfigurations?.map((config)=>config.Id)?.filter((id)=>!!id)?.filter((id)=>!isEditMode || id !== existingRule?.Id) || [], [
+        existingNotificationData,
+        isEditMode,
+        existingRule
+    ]);
+    const dynamicSchema = useMemo(()=>baseSchema.keys({
+            ruleName: joi.string().required().invalid(...existingRuleNames).messages({
+                'string.empty': 'This field is required',
+                'any.invalid': 'A rule with this name already exists'
+            })
+        }), [
+        existingRuleNames
+    ]);
+    const methods = useForm({
+        resolver: joiResolver(dynamicSchema),
+        mode: 'onChange',
+        defaultValues: {
+            ruleName: '',
+            queueArn: '',
+            events: [],
+            prefix: '',
+            suffix: ''
+        }
+    });
+    const { mutate: setNotification, isPending: isSaving } = useSetBucketNotification();
+    const { handleSubmit, register, reset, formState: { isValid, isDirty, errors } } = methods;
+    useEffect(()=>{
+        if (isEditMode && existingRule) {
+            const prefixRule = existingRule.Filter?.Key?.FilterRules?.find((r)=>'prefix' === r.Name);
+            const suffixRule = existingRule.Filter?.Key?.FilterRules?.find((r)=>'suffix' === r.Name);
+            reset({
+                ruleName: existingRule.Id || '',
+                queueArn: existingRule.QueueArn || '',
+                events: existingRule.Events || [],
+                prefix: prefixRule?.Value || '',
+                suffix: suffixRule?.Value || ''
+            });
+        }
+    }, [
+        isEditMode,
+        existingRule,
+        reset
+    ]);
+    const handleCancel = useCallback(()=>{
+        navigate(`/buckets/${bucketName}?tab=notification`);
+    }, [
+        navigate,
+        bucketName
+    ]);
+    const onSubmit = useCallback((data)=>{
+        const filterRules = [
+            ...data.prefix ? [
+                {
+                    Name: 'prefix',
+                    Value: data.prefix
+                }
+            ] : [],
+            ...data.suffix ? [
+                {
+                    Name: 'suffix',
+                    Value: data.suffix
+                }
+            ] : []
+        ];
+        const wildcardPrefixes = [
+            's3:ObjectCreated:',
+            's3:ObjectRemoved:',
+            's3:ObjectRestore:',
+            's3:LifecycleExpiration:',
+            's3:Replication:',
+            's3:ObjectTagging:'
+        ];
+        const filteredEvents = data.events.filter((event)=>{
+            if (event.endsWith('*')) return true;
+            for (const prefix of wildcardPrefixes)if (event.startsWith(prefix)) return !data.events.includes(`${prefix}*`);
+            return true;
+        });
+        const newQueueConfiguration = {
+            Id: data.ruleName,
+            QueueArn: data.queueArn,
+            Events: filteredEvents,
+            ...filterRules.length > 0 && {
+                Filter: {
+                    Key: {
+                        FilterRules: filterRules
+                    }
+                }
+            }
+        };
+        const existingConfigurations = existingNotificationData?.QueueConfigurations || [];
+        const updatedConfigurations = isEditMode ? existingConfigurations.map((config)=>config.Id === existingRule?.Id ? newQueueConfiguration : config) : [
+            ...existingConfigurations,
+            newQueueConfiguration
+        ];
+        setNotification({
+            Bucket: bucketName,
+            NotificationConfiguration: {
+                QueueConfigurations: updatedConfigurations
+            }
+        }, {
+            onSuccess: ()=>{
+                showToast({
+                    open: true,
+                    message: `Notification rule ${isEditMode ? 'updated' : 'created'} successfully`,
+                    status: 'success'
+                });
+                navigate(`/buckets/${bucketName}?tab=notification`);
+            },
+            onError: (error)=>{
+                const errorMessage = error instanceof Error ? error.message : `Failed to ${isEditMode ? 'update' : 'create'} notification rule`;
+                showToast({
+                    open: true,
+                    message: errorMessage,
+                    status: 'error'
+                });
+            }
+        });
+    }, [
+        bucketName,
+        setNotification,
+        navigate,
+        showToast,
+        existingNotificationData,
+        isEditMode,
+        existingRule
+    ]);
+    if ('pending' === notificationStatus) return /*#__PURE__*/ jsx(Loader, {
+        centered: true,
+        children: /*#__PURE__*/ jsx(Text, {
+            children: "Loading..."
+        })
+    });
+    if ('error' === notificationStatus && notificationError) {
+        const errorMessage = notificationError instanceof Error ? notificationError.message : 'Failed to load notification configuration';
+        return /*#__PURE__*/ jsx(Form, {
+            layout: {
+                kind: 'page',
+                title: isEditMode ? 'Edit Bucket Notification' : 'Create Bucket Notification'
+            },
+            children: /*#__PURE__*/ jsx(Box, {
+                display: "flex",
+                justifyContent: "center",
+                alignItems: "center",
+                padding: spacing.r16,
+                children: /*#__PURE__*/ jsx(Text, {
+                    color: "statusCritical",
+                    children: errorMessage
+                })
+            })
+        });
+    }
+    if (isEditMode && (!existingRule || !existingRule.Id)) return /*#__PURE__*/ jsx(Form, {
+        layout: {
+            kind: 'page',
+            title: 'Edit Bucket Notification'
+        },
+        children: /*#__PURE__*/ jsx(Box, {
+            display: "flex",
+            justifyContent: "center",
+            alignItems: "center",
+            padding: spacing.r16,
+            children: /*#__PURE__*/ jsx(Text, {
+                color: "statusCritical",
+                children: "Notification rule not found"
+            })
+        })
+    });
+    return /*#__PURE__*/ jsx(FormProvider, {
+        ...methods,
+        children: /*#__PURE__*/ jsxs(Form, {
+            layout: {
+                kind: 'page',
+                title: isEditMode ? 'Edit Bucket Notification' : 'Create Bucket Notification'
+            },
+            requireMode: "partial",
+            onSubmit: handleSubmit(onSubmit),
+            rightActions: /*#__PURE__*/ jsxs(Stack, {
+                gap: "r16",
+                children: [
+                    /*#__PURE__*/ jsx(Button, {
+                        id: "cancel-btn",
+                        variant: "outline",
+                        type: "button",
+                        label: "Cancel",
+                        onClick: handleCancel,
+                        disabled: isSaving
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        id: isEditMode ? 'save-notification-btn' : 'create-notification-btn',
+                        type: "submit",
+                        variant: "primary",
+                        label: isEditMode ? 'Save' : 'Create',
+                        icon: isEditMode ? /*#__PURE__*/ jsx(Icon, {
+                            name: "Save"
+                        }) : void 0,
+                        disabled: isEditMode ? !isDirty || !isValid || isSaving : !isValid || isSaving
+                    })
+                ]
+            }),
+            children: [
+                /*#__PURE__*/ jsx(FormSection, {
+                    forceLabelWidth: convertRemToPixels(13),
+                    children: /*#__PURE__*/ jsx(FormGroup, {
+                        label: "Rule name",
+                        id: "ruleName",
+                        direction: "horizontal",
+                        error: errors?.ruleName?.message,
+                        helpErrorPosition: "bottom",
+                        labelHelpTooltip: /*#__PURE__*/ jsx(Fragment, {}),
+                        required: true,
+                        content: isEditMode ? /*#__PURE__*/ jsx(Text, {
+                            children: existingRule?.Id
+                        }) : /*#__PURE__*/ jsx(Input, {
+                            id: "ruleName",
+                            ...register('ruleName')
+                        })
+                    })
+                }),
+                /*#__PURE__*/ jsx(EventsSection, {}),
+                /*#__PURE__*/ jsx(FormSection, {
+                    forceLabelWidth: convertRemToPixels(13),
+                    children: /*#__PURE__*/ jsx(FormGroup, {
+                        label: "Destination Queue",
+                        id: "queueArn",
+                        direction: "horizontal",
+                        error: errors?.queueArn?.message,
+                        helpErrorPosition: "bottom",
+                        labelHelpTooltip: /*#__PURE__*/ jsx(Fragment, {}),
+                        required: true,
+                        content: /*#__PURE__*/ jsx(Input, {
+                            id: "queueArn",
+                            placeholder: "arn:aws:sqs:us-east-1:1xx:name",
+                            ...register('queueArn')
+                        })
+                    })
+                }),
+                /*#__PURE__*/ jsx(FormSection, {
+                    title: {
+                        name: 'Filters'
+                    },
+                    children: /*#__PURE__*/ jsxs(Stack, {
+                        direction: "horizontal",
+                        gap: "r16",
+                        children: [
+                            /*#__PURE__*/ jsx(FormGroup, {
+                                label: "Prefix",
+                                id: "prefix",
+                                direction: "horizontal",
+                                content: /*#__PURE__*/ jsx(Input, {
+                                    id: "prefix",
+                                    placeholder: "",
+                                    size: "2/3",
+                                    ...register('prefix')
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(FormGroup, {
+                                label: "Suffix",
+                                id: "suffix",
+                                direction: "horizontal",
+                                content: /*#__PURE__*/ jsx(Input, {
+                                    id: "suffix",
+                                    placeholder: "",
+                                    size: "2/3",
+                                    ...register('suffix')
+                                })
+                            })
+                        ]
+                    })
+                })
+            ]
+        })
+    });
+}
+export { BucketNotificationFormPage };

package/dist/components/buckets/notifications/BucketNotificationList.d.ts

@@ -0,0 +1,10 @@
+import type { QueueConfiguration } from '@aws-sdk/client-s3';
+interface BucketNotificationListProps {
+    bucketName: string;
+    notificationRules: QueueConfiguration[];
+    notificationStatus?: 'idle' | 'loading' | 'error' | 'success';
+    onCreateRule?: () => void;
+    onEditRule?: (ruleId: string) => void;
+}
+export declare function BucketNotificationList({ bucketName, notificationRules, notificationStatus, onCreateRule, onEditRule, }: BucketNotificationListProps): import("react/jsx-runtime").JSX.Element;
+export {};