Merge branch 'bugfix/ARTESCA-16527-add-bucket-name-and-role-fields' into q/4.1

Author: bert-e

src/react/workflow/ConfigurationTab.tsx

@@ -39,6 +39,10 @@ import { useManagementClient } from '../ManagementProvider';
 import { useInstanceId } from '../next-architecture/ui/AuthProvider';
 import { workflowListQuery } from '../queries';
 import { useRolePathName } from '../utils/hooks';
+import { Resolver, ResolverOptions } from 'react-hook-form';
+import { useAccountsLocationsEndpointsAdapter } from '../next-architecture/ui/AccountsLocationsEndpointsAdapterProvider';
+import { useAccountsLocationsAndEndpoints } from '../next-architecture/domain/business/accounts';
+import { getLocationTypeKey } from '../utils/storageOptions';
 import { DeleteWorkflowButton } from './DeleteWorkflowButton';
 import {
   ExpirationForm,
@@ -49,6 +53,7 @@ import ReplicationForm, {
   disallowedPrefixes,
   GeneralReplicationGroup,
   replicationSchema,
+  validateCRRFields,
 } from './ReplicationForm';
 import {
   GeneralTransitionGroup,
@@ -506,38 +511,112 @@ function EditForm({
         s.source.prefix !== '',
     );
 
+  const accountsLocationsEndpointsAdapter =
+    useAccountsLocationsEndpointsAdapter();
+  const { accountsLocationsAndEndpoints } = useAccountsLocationsAndEndpoints({
+    accountsLocationsEndpointsAdapter,
+  });
+
+  // Get CRR location names
+  const crrLocationNames =
+    accountsLocationsAndEndpoints?.locations
+      ?.filter(
+        (location) =>
+          getLocationTypeKey(location) === 'location-scality-crr-v1',
+      )
+      .map((location) => location.name) || [];
+
   const schema =
     workflow && isExpirationWorkflow(workflow)
       ? expirationSchema
       : isTransitionWorkflow(workflow)
       ? Joi.object(transitionSchema)
       : Joi.object(
-          //@ts-expect-error fix this when you are working on it
           replicationSchema(
             [],
             disallowedPrefixes(
-              //@ts-expect-error fix this when you are working on it
-              workflow.source.bucketName,
+              (workflow as Replication).source.bucketName,
               workflows.replications,
             ).filter(
               (s) =>
-                //@ts-expect-error fix this when you are working on it
-                s !== workflow.source.prefix,
+                s !== (workflow as Replication).source.prefix,
             ),
             isPrefixMandatory,
+            false,
           ),
         );
 
+  // Custom resolver that preserves React Hook Form validation errors and runs Joi validation
+  const customResolver: Resolver<Record<string, unknown>> = async (
+    values,
+    context,
+    options,
+  ) => {
+    // Check for CRR-related validation errors using the shared validation function
+    // In ConfigurationTab, ReplicationForm uses empty prefix, so fields are at root level
+    const existingErrors: Record<string, { type: string; message: string }> = {};
+    let hasExistingErrors = false;
+    
+    const formValues = values as {
+      destinationLocation?: string[];
+      destinationBucketName?: string;
+      destinationRole?: string;
+    };
+    
+    const crrValidationErrors = validateCRRFields(
+      formValues.destinationLocation,
+      crrLocationNames,
+      formValues.destinationBucketName,
+      formValues.destinationRole,
+    );
+    
+    if (crrValidationErrors.bucketNameError) {
+      existingErrors.destinationBucketName = {
+        type: 'validate',
+        message: crrValidationErrors.bucketNameError,
+      };
+      hasExistingErrors = true;
+    }
+    
+    if (crrValidationErrors.roleError) {
+      existingErrors.destinationRole = {
+        type: 'validate',
+        message: crrValidationErrors.roleError,
+      };
+      hasExistingErrors = true;
+    }
+    
+    // Run Joi validation
+    const joiValidator = joiResolver(schema);
+    let joiResult;
+    
+    if (workflow && isExpirationWorkflow(workflow)) {
+      joiResult = await joiValidator(
+        prepareExpirationQuery(values as unknown as BucketWorkflowExpirationV1),
+        context,
+        options as unknown as ResolverOptions<BucketWorkflowExpirationV1>,
+      );
+    } else {
+      joiResult = await joiValidator(values, context, options as ResolverOptions<Record<string, unknown>>);
+    }
+    
+    // Merge existing validation errors with Joi errors, giving priority to existing errors
+    if (hasExistingErrors) {
+      return {
+        values: joiResult.values,
+        errors: {
+          ...(joiResult.errors as Record<string, unknown>),
+          ...existingErrors,
+        },
+      };
+    }
+    
+    return joiResult;
+  };
+
   const useFormMethods = useForm({
     mode: 'all',
-    resolver: async (values, context, options) => {
-      const joiValidator = joiResolver(schema);
-      if (workflow && isExpirationWorkflow(workflow)) {
-        return joiValidator(prepareExpirationQuery(values), context, options);
-      } else {
-        return joiValidator(values, context, options);
-      }
-    },
+    resolver: customResolver,
     // fix this when you are working on it
     defaultValues: isExpirationWorkflow(workflow)
       ? initDefaultValues(workflow)

src/react/workflow/CreateWorkflow.tsx

@@ -11,6 +11,8 @@ import { convertRemToPixels } from '@scality/core-ui/dist/utils';
 import {
   Controller,
   FormProvider,
+  Resolver,
+  ResolverOptions,
   SubmitHandler,
   useForm,
 } from 'react-hook-form';
@@ -39,6 +41,8 @@ import {
 } from '../next-architecture/domain/business/buckets';
 import { useLocationAndStorageInfos } from '../next-architecture/domain/business/locations';
 import { useAccountsLocationsEndpointsAdapter } from '../next-architecture/ui/AccountsLocationsEndpointsAdapterProvider';
+import { useAccountsLocationsAndEndpoints } from '../next-architecture/domain/business/accounts';
+import { getLocationTypeKey } from '../utils/storageOptions';
 import { useInstanceId } from '../next-architecture/ui/AuthProvider';
 import { workflowListQuery } from '../queries';
 import { useQueryParams, useRolePathName } from '../utils/hooks';
@@ -51,6 +55,7 @@ import ReplicationForm, {
   GeneralReplicationGroup,
   disallowedPrefixes,
   replicationSchema,
+  validateCRRFields,
 } from './ReplicationForm';
 import {
   GeneralTransitionGroup,
@@ -134,55 +139,136 @@ const CreateWorkflow = () => {
     locationInfos.status === 'success' &&
     locationInfos.value.location?.isTransient;
 
+  const { accountsLocationsAndEndpoints } = useAccountsLocationsAndEndpoints({
+    accountsLocationsEndpointsAdapter,
+  });
+
+  // Get CRR location names
+  const crrLocationNames =
+    accountsLocationsAndEndpoints?.locations
+      ?.filter(
+        (location) =>
+          getLocationTypeKey(location) === 'location-scality-crr-v1',
+      )
+      .map((location) => location.name) || [];
+
+  // Custom resolver that preserves React Hook Form validation errors and runs Joi validation
+  const customResolver: Resolver<Record<string, unknown>> = async (
+    values,
+    context,
+    options,
+  ) => {
+    // Check for existing React Hook Form validation errors from validate functions
+    // These are stored in options.fields with their validation results
+    const existingErrors: Record<string, Record<string, { type: string; message: string }>> = {};
+    let hasExistingErrors = false;
+    
+    // Check for CRR-related validation errors using the shared validation function
+    const replication = values.replication as {
+      destinationLocation?: string[];
+      destinationBucketName?: string;
+      destinationRole?: string;
+    } | undefined;
+    
+    if (replication) {
+      const crrValidationErrors = validateCRRFields(
+        replication.destinationLocation,
+        crrLocationNames,
+        replication.destinationBucketName,
+        replication.destinationRole,
+      );
+      
+      if (crrValidationErrors.bucketNameError) {
+        existingErrors.replication = {
+          ...existingErrors.replication,
+          destinationBucketName: {
+            type: 'validate',
+            message: crrValidationErrors.bucketNameError,
+          },
+        };
+        hasExistingErrors = true;
+      }
+      
+      if (crrValidationErrors.roleError) {
+        existingErrors.replication = {
+          ...existingErrors.replication,
+          destinationRole: {
+            type: 'validate',
+            message: crrValidationErrors.roleError,
+          },
+        };
+        hasExistingErrors = true;
+      }
+    }
+    
+    // If we have existing validation errors, run Joi validation but preserve our errors
+    const bucketName = (values.replication as { sourceBucket?: string })?.sourceBucket;
+    const streams = replicationsQuery.data ?? [];
+    const unallowedBucketName = streams.flatMap((s) => {
+      const { prefix, bucketName } = s.source;
+      if (!prefix || prefix === '') return [bucketName];
+      return [];
+    });
+    const prefixMandatory = !!streams.find((s) => {
+      const { prefix } = s.source;
+      return prefix && prefix !== '' && bucketName === s.source.bucketName;
+    });
+    const disPrefixes = disallowedPrefixes(bucketName, streams);
+    
+    // Build Joi schema
+    const schema = Joi.object({
+      type: Joi.string().valid('replication', 'expiration', 'transition'),
+      replication: Joi.when('type', {
+        is: Joi.equal('replication'),
+        then: Joi.object(
+          replicationSchema(
+            unallowedBucketName,
+            disPrefixes,
+            prefixMandatory,
+            !!isTransient,
+          ),
+        ),
+        otherwise: Joi.valid(),
+      }),
+      transition: Joi.when('type', {
+        is: Joi.equal('transition'),
+        then: Joi.object(transitionSchema),
+        otherwise: Joi.valid(),
+      }),
+      expiration: Joi.when('type', {
+        is: Joi.equal('expiration'),
+        then: expirationSchema,
+        otherwise: Joi.valid(),
+      }),
+    });
+    
+    const joiValidator = joiResolver(schema);
+    let joiResult;
+    
+    if (['replication', 'transition'].includes(values.type as string)) {
+      joiResult = await joiValidator(values, context, options as ResolverOptions<Record<string, unknown>>);
+    } else {
+      const expiration = prepareExpirationQuery(values.expiration as BucketWorkflowExpirationV1);
+      joiResult = await joiValidator({ ...values, expiration }, context, options as ResolverOptions<Record<string, unknown>>);
+    }
+    
+    // Merge existing validation errors with Joi errors, giving priority to existing errors
+    if (hasExistingErrors) {
+      return {
+        values: joiResult.values,
+        errors: {
+          ...joiResult.errors,
+          ...existingErrors,
+        },
+      };
+    }
+    
+    return joiResult;
+  };
+
   const useFormMethods = useForm({
     mode: 'onChange',
-    resolver: async (values, context, options) => {
-      const bucketName = values.replication.sourceBucket;
-      const streams = replicationsQuery.data ?? [];
-      const unallowedBucketName = streams.flatMap((s) => {
-        const { prefix, bucketName } = s.source;
-        if (!prefix || prefix === '') return [bucketName];
-        return [];
-      });
-      const prefixMandatory = !!streams.find((s) => {
-        const { prefix } = s.source;
-        return prefix && prefix !== '' && bucketName === s.source.bucketName;
-      });
-      const disPrefixes = disallowedPrefixes(bucketName, streams);
-      const schema = Joi.object({
-        type: Joi.string().valid('replication', 'expiration', 'transition'),
-        replication: Joi.when('type', {
-          is: Joi.equal('replication'),
-          then: Joi.object(
-            replicationSchema(
-              unallowedBucketName,
-              disPrefixes,
-              prefixMandatory,
-              !!isTransient,
-            ),
-          ),
-          otherwise: Joi.valid(),
-        }),
-        transition: Joi.when('type', {
-          is: Joi.equal('transition'),
-          then: Joi.object(transitionSchema),
-          otherwise: Joi.valid(),
-        }),
-        expiration: Joi.when('type', {
-          is: Joi.equal('expiration'),
-          then: expirationSchema,
-          otherwise: Joi.valid(),
-        }),
-      });
-      const joiValidator = joiResolver(schema);
-      if (['replication', 'transition'].includes(values.type)) {
-        const validation = await joiValidator(values, context, options);
-        return validation;
-      } else {
-        const expiration = prepareExpirationQuery(values.expiration);
-        return joiValidator({ ...values, expiration }, context, options);
-      }
-    },
+    resolver: customResolver,
     defaultValues: defaultFormValues,
   });
 
@@ -406,8 +492,8 @@ const CreateWorkflow = () => {
                   <Select
                     id="type"
                     onBlur={onBlur}
-                    value={type}
-                    onChange={(value) => onChange(value)}
+                    value={type as string}
+                    onChange={(value) => onChange(value as string)}
                   >
                     <Select.Option
                       value="replication"