@scality/data-browser-library 1.1.6 → 1.1.7

package/dist/components/__tests__/BucketReplicationFormPage.test.js

@@ -112,7 +112,10 @@ describe('BucketReplicationFormPage', ()=>{
             },
             status: 'success'
         });
-        mockUseFeatures.mockReturnValue(true);
+        mockUseFeatures.mockImplementation((feature)=>{
+            if ('replicationAdvanced' === feature) return true;
+            return false;
+        });
         mockUseISVBucketStatus.mockReturnValue({
             isVeeamBucket: false,
             isCommvaultBucket: false,
@@ -1971,7 +1974,10 @@ describe('BucketReplicationFormPage', ()=>{
             });
         });
         it('shows Additional Options section when replicationAdvanced is enabled', ()=>{
-            mockUseFeatures.mockReturnValue(true);
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationAdvanced' === feature) return true;
+                return false;
+            });
             renderBucketReplicationFormPage();
             expect(screen.getByText('Replication Time Control (RTC)')).toBeInTheDocument();
             expect(screen.getByText('RTC metrics and notifications')).toBeInTheDocument();
@@ -1979,4 +1985,203 @@ describe('BucketReplicationFormPage', ()=>{
             expect(screen.getByText('Delete marker replication')).toBeInTheDocument();
         });
     });
+    describe('Feature Flag - replicationV1', ()=>{
+        it('submits rule in V1 format when replicationV1 feature is enabled', async ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            mockSuccessSubmit(mockMutate);
+            renderBucketReplicationFormPage();
+            await user_event.type(screen.getByRole('textbox', {
+                name: /role arn/i
+            }), 'arn:aws:iam::123456789012:role/replication');
+            await user_event.type(screen.getByRole('textbox', {
+                name: /rule id/i
+            }), 'test-rule-v1');
+            const targetBucketSelect = screen.getByLabelText(/target bucket/i);
+            await user_event.click(targetBucketSelect);
+            await user_event.click(screen.getByRole('option', {
+                name: 'destination-bucket'
+            }));
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockMutate).toHaveBeenCalled();
+            });
+            const submittedRule = mockMutate.mock.calls[0][0].ReplicationConfiguration.Rules[0];
+            expect(submittedRule.Prefix).toBe('');
+            expect(submittedRule.ID).toBe('test-rule-v1');
+            expect(submittedRule.Status).toBe('Enabled');
+            expect(submittedRule.Destination.Bucket).toBe('arn:aws:s3:::destination-bucket');
+            expect(submittedRule).not.toHaveProperty('Filter');
+            expect(submittedRule).not.toHaveProperty('Priority');
+            expect(submittedRule).not.toHaveProperty('DeleteMarkerReplication');
+            expect(submittedRule).not.toHaveProperty('SourceSelectionCriteria');
+        });
+        it('hides V2-only fields when replicationV1 is enabled', ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            expect(screen.getByRole('textbox', {
+                name: /role arn/i
+            })).toBeInTheDocument();
+            expect(screen.getByRole('textbox', {
+                name: /rule id/i
+            })).toBeInTheDocument();
+            expect(screen.queryByRole('spinbutton', {
+                name: /rule priority/i
+            })).not.toBeInTheDocument();
+            expect(screen.queryByText('Encryption')).not.toBeInTheDocument();
+            expect(screen.queryByText('Additional Options')).not.toBeInTheDocument();
+        });
+        it('shows simplified destination without cross-account in V1 mode', ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            expect(screen.getByText(/Target Bucket/i)).toBeInTheDocument();
+            expect(screen.queryByText(/Same account destination/i)).not.toBeInTheDocument();
+        });
+        it('shows only prefix filter (no filter type selector) in V1 mode', ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            expect(screen.getByRole('textbox', {
+                name: /prefix/i
+            })).toBeInTheDocument();
+            expect(screen.queryByText('All objects')).not.toBeInTheDocument();
+            expect(screen.queryByText('Tags filter')).not.toBeInTheDocument();
+        });
+        it('allows submission without priority in V1 mode', async ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            mockSuccessSubmit(mockMutate);
+            renderBucketReplicationFormPage();
+            await user_event.type(screen.getByRole('textbox', {
+                name: /role arn/i
+            }), 'arn:aws:iam::123456789012:role/repl');
+            await user_event.type(screen.getByRole('textbox', {
+                name: /rule id/i
+            }), 'v1-rule');
+            const targetBucketSelect = screen.getByLabelText(/target bucket/i);
+            await user_event.click(targetBucketSelect);
+            await user_event.click(screen.getByRole('option', {
+                name: 'destination-bucket'
+            }));
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockMutate).toHaveBeenCalled();
+            });
+            const submittedRule = mockMutate.mock.calls[0][0].ReplicationConfiguration.Rules[0];
+            expect(submittedRule.Prefix).toBe('');
+            expect(submittedRule).not.toHaveProperty('Priority');
+        });
+        it('loads existing V1 rule (with Prefix at rule level) for editing', async ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            const v1Rule = {
+                ID: 'existing-v1-rule',
+                Status: 'Enabled',
+                Prefix: 'documents/',
+                Destination: {
+                    Bucket: 'arn:aws:s3:::destination-bucket',
+                    StorageClass: 'STANDARD'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/repl',
+                        Rules: [
+                            v1Rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'existing-v1-rule');
+            await waitFor(()=>{
+                expect(screen.getByText('existing-v1-rule')).toBeInTheDocument();
+            });
+            const prefixInput = screen.getByRole('textbox', {
+                name: /prefix/i
+            });
+            expect(prefixInput.value).toBe('documents/');
+        });
+        it('shows all V2 fields when replicationV1 is not enabled', ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationAdvanced' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            expect(screen.getByRole('spinbutton', {
+                name: /rule priority/i
+            })).toBeInTheDocument();
+            expect(screen.getByText(/^Encryption/)).toBeInTheDocument();
+            expect(screen.getByText(/^Additional Options/)).toBeInTheDocument();
+        });
+    });
 });

package/dist/components/buckets/BucketReplicationFormPage.js

@@ -45,15 +45,46 @@ const storageClassOptions = [
         label: 'Glacier Instant Retrieval'
     }
 ];
-const createSchema = (hasExistingRules, hasCustomDestination)=>joi.object({
-        role: hasExistingRules ? joi.string().optional() : joi.string().required().messages({
-            'string.empty': 'Role ARN is required for first replication rule'
-        }),
-        ruleId: joi.string().required().max(AWS_RULE_LIMITS.RULE_ID_MAX_LENGTH).messages({
-            'string.empty': 'Rule ID is required',
-            'string.max': `Rule ID must not exceed ${AWS_RULE_LIMITS.RULE_ID_MAX_LENGTH} characters`
-        }),
-        status: joi.string().valid(...STATUS_OPTIONS.map((o)=>o.value)).required(),
+const createSchema = (hasExistingRules, hasCustomDestination, isV1)=>{
+    const roleSchema = hasExistingRules ? joi.string().optional() : joi.string().required().messages({
+        'string.empty': 'Role ARN is required for first replication rule'
+    });
+    const ruleIdSchema = joi.string().required().max(AWS_RULE_LIMITS.RULE_ID_MAX_LENGTH).messages({
+        'string.empty': 'Rule ID is required',
+        'string.max': `Rule ID must not exceed ${AWS_RULE_LIMITS.RULE_ID_MAX_LENGTH} characters`
+    });
+    const statusSchema = joi.string().valid(...STATUS_OPTIONS.map((o)=>o.value)).required();
+    const targetBucketSchema = hasCustomDestination ? joi.string().allow('').optional() : joi.string().required().messages({
+        'string.empty': 'Target bucket is required'
+    });
+    if (isV1) return joi.object({
+        role: roleSchema,
+        ruleId: ruleIdSchema,
+        status: statusSchema,
+        prefix: joi.string().allow('').optional(),
+        targetBucket: targetBucketSchema,
+        storageClass: joi.string().allow('').optional(),
+        sameAccount: joi.any().optional(),
+        targetAccountId: joi.any().optional(),
+        priority: joi.any().optional(),
+        filterType: joi.any().optional(),
+        tags: joi.any().optional(),
+        includeEncryptedObjects: joi.any().optional(),
+        replicaModifications: joi.any().optional(),
+        encryptReplicatedObjects: joi.any().optional(),
+        replicaKmsKeyId: joi.any().optional(),
+        enforceRTC: joi.any().optional(),
+        enableRTCNotification: joi.any().optional(),
+        deleteMarkerReplication: joi.any().optional(),
+        switchObjectOwnership: joi.any().optional(),
+        understandISVRisk: joi.boolean().invalid(false).messages({
+            'any.invalid': 'You must acknowledge the risk'
+        })
+    });
+    return joi.object({
+        role: roleSchema,
+        ruleId: ruleIdSchema,
+        status: statusSchema,
         priority: joi.number().integer().min(0).allow(null).optional().messages({
             'number.base': 'Priority must be a number',
             'number.min': 'Priority must be at least 0'
@@ -62,9 +93,7 @@ const createSchema = (hasExistingRules, hasCustomDestination)=>joi.object({
         includeEncryptedObjects: joi.boolean(),
         replicaModifications: joi.boolean(),
         sameAccount: joi.boolean(),
-        targetBucket: hasCustomDestination ? joi.string().allow('').optional() : joi.string().required().messages({
-            'string.empty': 'Target bucket is required'
-        }),
+        targetBucket: targetBucketSchema,
         targetAccountId: hasCustomDestination ? joi.string().allow('').optional() : joi.when('sameAccount', {
             is: false,
             then: joi.string().required().messages({
@@ -101,6 +130,7 @@ const createSchema = (hasExistingRules, hasCustomDestination)=>joi.object({
             'any.invalid': 'You must acknowledge the risk'
         })
     });
+};
 const ruleToFormValues = (rule, role)=>{
     const formValues = {
         role,
@@ -238,7 +268,21 @@ const buildSourceSelectionCriteria = (data)=>{
         }
     };
 };
-const buildReplicationRule = (data, sourceBucketName)=>{
+const buildReplicationRule = (data, sourceBucketName, useV1Format)=>{
+    if (useV1Format) {
+        const bucketName = data.targetBucket || sourceBucketName;
+        return {
+            ID: data.ruleId,
+            Status: data.status,
+            Prefix: data.prefix || '',
+            Destination: {
+                Bucket: `arn:aws:s3:::${bucketName}`,
+                ...data.storageClass && '' !== data.storageClass.trim() && {
+                    StorageClass: data.storageClass
+                }
+            }
+        };
+    }
     const rule = {
         ID: data.ruleId,
         Status: data.status,
@@ -339,7 +383,9 @@ function BucketReplicationFormPage() {
     const { showToast } = useToast();
     const isEditMode = !!ruleId;
     const showAdvancedReplication = useFeatures('replicationAdvanced');
+    const useV1Format = useFeatures('replicationV1');
     const { isISVManaged, isvApplication, isLoading: isISVLoading } = useISVBucketStatus(bucketName);
+    const { data: bucketsData } = useBuckets();
     const { data: replicationData, status: replicationStatus } = useGetBucketReplication({
         Bucket: bucketName
     });
@@ -367,7 +413,7 @@ function BucketReplicationFormPage() {
     }, [
         replicationData
     ]);
-    const dynamicSchema = useMemo(()=>createSchema(hasExistingRules, !!CustomDestinationFields).keys({
+    const dynamicSchema = useMemo(()=>createSchema(hasExistingRules, !!CustomDestinationFields, !!useV1Format).keys({
             ruleId: joi.string().required().invalid(...existingRuleIds).messages({
                 'string.empty': 'Rule ID is required',
                 'any.invalid': 'A rule with this ID already exists'
@@ -375,7 +421,8 @@ function BucketReplicationFormPage() {
         }), [
         existingRuleIds,
         hasExistingRules,
-        CustomDestinationFields
+        CustomDestinationFields,
+        useV1Format
     ]);
     const methods = useForm({
         resolver: joiResolver(dynamicSchema),
@@ -532,7 +579,7 @@ function BucketReplicationFormPage() {
     ]);
     const onSubmit = useCallback((data)=>{
         if (!bucketName) return;
-        const rule = buildReplicationRule(data, bucketName);
+        const rule = buildReplicationRule(data, bucketName, !!useV1Format);
         const existingRules = replicationData?.ReplicationConfiguration?.Rules || [];
         const updatedRules = isEditMode ? existingRules.map((r)=>r.ID === existingRule?.ID ? rule : r) : [
             ...existingRules,
@@ -569,7 +616,8 @@ function BucketReplicationFormPage() {
         showToast,
         replicationData,
         isEditMode,
-        existingRule
+        existingRule,
+        useV1Format
     ]);
     if ('pending' === replicationStatus || isISVLoading) return /*#__PURE__*/ jsx(Loader, {
         centered: true,
@@ -718,7 +766,7 @@ function BucketReplicationFormPage() {
                                     })
                             })
                         }),
-                        /*#__PURE__*/ jsx(FormGroup, {
+                        useV1Format ? /*#__PURE__*/ jsx(Fragment, {}) : /*#__PURE__*/ jsx(FormGroup, {
                             label: "Rule priority",
                             id: "priority",
                             direction: "horizontal",
@@ -743,7 +791,25 @@ function BucketReplicationFormPage() {
                         })
                     ]
                 }),
-                /*#__PURE__*/ jsx(FilterFormSection, {
+                useV1Format ? /*#__PURE__*/ jsx(FormSection, {
+                    title: {
+                        name: 'Prefix'
+                    },
+                    forceLabelWidth: convertRemToPixels(15),
+                    children: /*#__PURE__*/ jsx(FormGroup, {
+                        label: "Prefix",
+                        id: "prefix",
+                        direction: "horizontal",
+                        error: errors?.prefix?.message,
+                        helpErrorPosition: "bottom",
+                        labelHelpTooltip: "Object key prefix to filter which objects are replicated",
+                        content: /*#__PURE__*/ jsx(Input, {
+                            id: "prefix",
+                            placeholder: "folder/",
+                            ...register('prefix')
+                        })
+                    })
+                }) : /*#__PURE__*/ jsx(FilterFormSection, {
                     filterType: filterType,
                     onFilterTypeChange: (value)=>methods.setValue('filterType', value),
                     prefixRegister: register('prefix'),
@@ -766,6 +832,32 @@ function BucketReplicationFormPage() {
                             storageClassField,
                             /*#__PURE__*/ jsx(CustomDestinationFields, {})
                         ]
+                    }) : useV1Format ? /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx(FormGroup, {
+                                label: "Target Bucket",
+                                id: "targetBucket",
+                                direction: "horizontal",
+                                error: errors?.targetBucket?.message,
+                                helpErrorPosition: "bottom",
+                                required: true,
+                                content: /*#__PURE__*/ jsx(Controller, {
+                                    name: "targetBucket",
+                                    control: control,
+                                    render: ({ field })=>/*#__PURE__*/ jsx(Select, {
+                                            id: "targetBucket",
+                                            value: field.value,
+                                            onChange: field.onChange,
+                                            placeholder: "Select a bucket",
+                                            children: (bucketsData?.Buckets || []).filter((bucket)=>bucket.Name !== bucketName).map((bucket)=>/*#__PURE__*/ jsx(Select.Option, {
+                                                    value: bucket.Name || '',
+                                                    children: bucket.Name
+                                                }, bucket.Name))
+                                        })
+                                })
+                            }),
+                            storageClassField
+                        ]
                     }) : /*#__PURE__*/ jsxs(Fragment, {
                         children: [
                             /*#__PURE__*/ jsx(DefaultReplicationDestinationFields, {}),
@@ -773,7 +865,7 @@ function BucketReplicationFormPage() {
                         ]
                     })
                 }),
-                /*#__PURE__*/ jsxs(FormSection, {
+                useV1Format ? null : /*#__PURE__*/ jsxs(FormSection, {
                     title: {
                         name: 'Encryption'
                     },
@@ -837,7 +929,7 @@ function BucketReplicationFormPage() {
                         }) : /*#__PURE__*/ jsx(Fragment, {})
                     ]
                 }),
-                showAdvancedReplication && /*#__PURE__*/ jsxs(FormSection, {
+                showAdvancedReplication && !useV1Format ? /*#__PURE__*/ jsxs(FormSection, {
                     title: {
                         name: 'Additional Options'
                     },
@@ -915,7 +1007,7 @@ function BucketReplicationFormPage() {
                             })
                         })
                     ]
-                })
+                }) : null
             ]
         })
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scality/data-browser-library",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "A modular React component library for browsing S3 buckets and objects",
   "type": "module",
   "types": "./dist/index.d.ts",