fix(autox): fix 500 error after many duplicate file uploads (#7220)

* fix(autox): return 409 for too many duplicate file uploads

* test(autox): update collision resolution tests

* fix(autox): display human-readable error message for 409 collisions

* test(autox): add ui tests to validate 409 collision error handling

* fix: address comment

* Revert "fix: address comment"

This reverts commit bc3b631.

---------

Co-authored-by: Daniel Duong <danielduong@ibm.com>

Author: daniduong

packages/automl/bff/internal/api/s3_handler.go

@@ -32,6 +32,10 @@ type resolvedS3 struct {
 
 var trailingNumberPattern = regexp.MustCompile(`^(.*)-(\d+)$`)
 
+// ErrMaxCollisionsExceeded is returned when resolveNonCollidingS3Key exhausts all attempts
+// to find a unique object key due to naming collisions.
+var ErrMaxCollisionsExceeded = errors.New("max collision attempts exceeded")
+
 // resolveS3Client resolves S3 credentials (from DSPA context or an explicit secretName),
 // creates an S3 client via the factory, and resolves the bucket.
 // Returns false if an error response was already written to w.
@@ -268,6 +272,12 @@ func (app *App) PostS3FileHandler(w http.ResponseWriter, r *http.Request, _ http
 	bucket := s3.bucket
 	resolvedKey, err := resolveNonCollidingS3Key(ctx, s3.client, bucket, key, app.effectivePostS3CollisionAttempts())
 	if err != nil {
+		if errors.Is(err, ErrMaxCollisionsExceeded) {
+			app.conflictResponse(w, r,
+				fmt.Sprintf("unable to find unique filename after %d attempts; try a different base name",
+					app.effectivePostS3CollisionAttempts()))
+			return
+		}
 		app.serverErrorResponse(w, r, fmt.Errorf("error resolving S3 key for upload: %w", err))
 		return
 	}
@@ -395,7 +405,7 @@ func resolveNonCollidingS3Key(
 		}
 		nextIndex++
 	}
-	return "", fmt.Errorf("failed to resolve non-colliding S3 key after %d attempts", maxCollisionAttempts)
+	return "", ErrMaxCollisionsExceeded
 }
 
 func splitS3ObjectPath(key string) (dir string, name string) {

packages/automl/bff/internal/api/s3_handler_test.go

@@ -1971,7 +1971,7 @@ func TestPostS3FileHandler_TwoFileParts_UsesFirstPartOnly(t *testing.T) {
 	assert.Equal(t, []byte("first-content"), capture.uploaded)
 }
 
-func TestPostS3FileHandler_CollisionResolutionExhausted_Returns500(t *testing.T) {
+func TestPostS3FileHandler_CollisionResolutionExhausted_Returns409(t *testing.T) {
 	t.Parallel()
 	secret := mockS3Secret("aws-secret-1", "test-namespace")
 	k8sFactory := &mockKubernetesClientFactoryForSecrets{client: &mockKubernetesClientForSecrets{secrets: []corev1.Secret{secret}}}
@@ -1994,12 +1994,13 @@ func TestPostS3FileHandler_CollisionResolutionExhausted_Returns500(t *testing.T)
 	res := rr.Result()
 	defer res.Body.Close()
 
-	assert.Equal(t, http.StatusInternalServerError, res.StatusCode)
+	assert.Equal(t, http.StatusConflict, res.StatusCode)
 	var env ErrorEnvelope
 	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &env))
 	require.NotNil(t, env.Error)
-	assert.Equal(t, "500", env.Error.Code)
-	assert.Contains(t, env.Error.Message, "the server encountered a problem")
+	assert.Equal(t, "409", env.Error.Code)
+	assert.Contains(t, env.Error.Message, "unable to find unique filename")
+	assert.Contains(t, env.Error.Message, "5 attempts")
 }
 
 func TestResolveNonCollidingS3Key_PreservesDirectoryPrefix(t *testing.T) {

packages/automl/frontend/src/app/components/configure/AutomlConfigure.tsx

@@ -342,7 +342,15 @@ function AutomlConfigure(): React.JSX.Element {
         setValue('train_data_file_key', uploadResult.key, { shouldValidate: true });
       } catch (err) {
         if (uploadRequestId === trainingDataUploadSeqRef.current) {
-          notification.error('Failed to upload file', err instanceof Error ? err.message : '');
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          const isConflict = errorMessage.toLowerCase().includes('unique filename');
+
+          notification.error(
+            'Failed to upload file',
+            isConflict
+              ? 'A file with this name already exists and no unique name could be generated. Please rename your file or delete existing files with similar names.'
+              : errorMessage,
+          );
         }
       } finally {
         if (uploadRequestId === trainingDataUploadSeqRef.current) {

packages/automl/frontend/src/app/components/configure/__tests__/AutomlConfigure.spec.tsx

@@ -7,12 +7,13 @@ import { FormProvider, useForm } from 'react-hook-form';
 import { useNavigate, useParams } from 'react-router';
 import AutomlConfigure from '~/app/components/configure/AutomlConfigure';
 import type { Files } from '~/app/components/common/FileExplorer/FileExplorer';
-import { useS3FileUploadMutation } from '~/app/hooks/mutations';
 import { useS3GetFileSchemaQuery } from '~/app/hooks/queries';
 import { createConfigureSchema, TASK_TYPES } from '~/app/schemas/configure.schema';
 
 const mockNotificationError = jest.fn();
 
+const mockS3MutateAsync = jest.fn().mockResolvedValue({ uploaded: true, key: 'uploaded-key.csv' });
+
 jest.mock('react-router', () => ({
   ...jest.requireActual('react-router'),
   useNavigate: jest.fn(),
@@ -28,30 +29,18 @@ jest.mock('~/app/hooks/useNotification', () => ({
   }),
 }));
 
-jest.mock('~/app/hooks/mutations', () => {
-  const mockS3MutateAsync = jest
-    .fn()
-    .mockResolvedValue({ uploaded: true, key: 'uploaded-key.csv' });
-  const stableS3UploadMutation = {
+jest.mock('~/app/hooks/mutations', () => ({
+  ...jest.requireActual<typeof import('~/app/hooks/mutations')>('~/app/hooks/mutations'),
+  useS3FileUploadMutation: jest.fn(() => ({
     mutateAsync: mockS3MutateAsync,
     isPending: false,
     reset: jest.fn(),
-    variables: undefined as { file: File } | undefined,
-  };
-  return {
-    ...jest.requireActual<typeof import('~/app/hooks/mutations')>('~/app/hooks/mutations'),
-    useS3FileUploadMutation: jest.fn(() => stableS3UploadMutation),
-  };
-});
+    variables: undefined,
+  })),
+}));
 
 function getMockS3MutateAsync(): jest.Mock {
-  const result = jest.mocked(useS3FileUploadMutation).mock.results[0]?.value as
-    | { mutateAsync: jest.Mock }
-    | undefined;
-  if (!result?.mutateAsync) {
-    throw new Error('useS3FileUploadMutation was not called; render AutomlConfigure first');
-  }
-  return result.mutateAsync;
+  return mockS3MutateAsync;
 }
 
 // Mock S3FileExplorer component
@@ -239,6 +228,8 @@ describe('AutomlConfigure', () => {
     } as unknown as ReturnType<typeof useS3GetFileSchemaQuery>);
     mockUseNavigate.mockReturnValue(jest.fn());
     mockUseParams.mockReturnValue({ namespace: 'test-namespace' });
+    // Reset the S3 upload mock to default resolved value
+    mockS3MutateAsync.mockResolvedValue({ uploaded: true, key: 'uploaded-key.csv' });
   });
 
   describe('initial state - no secret selected', () => {
@@ -376,6 +367,30 @@ describe('AutomlConfigure', () => {
       expect(mockNotificationError).not.toHaveBeenCalled();
     });
 
+    it('should show human-readable error for max collision attempts (409)', async () => {
+      renderComponent();
+      fireEvent.click(screen.getByTestId('aws-secret-selector-select-secret-1'));
+      fireEvent.click(screen.getByRole('button', { name: 'Upload file' }));
+
+      const fileInput = document.querySelector('input[type="file"]') as HTMLInputElement | null;
+      expect(fileInput).not.toBeNull();
+
+      const file = new File(['hello'], 'collision.csv', { type: 'text/csv' });
+      getMockS3MutateAsync().mockClear();
+      getMockS3MutateAsync().mockRejectedValue(
+        new Error('unable to find unique filename after 10 attempts'),
+      );
+
+      fireEvent.change(fileInput!, { target: { files: [file] } });
+
+      await waitFor(() => {
+        expect(mockNotificationError).toHaveBeenCalledWith(
+          'Failed to upload file',
+          'A file with this name already exists and no unique name could be generated. Please rename your file or delete existing files with similar names.',
+        );
+      });
+    });
+
     it('should show the newly selected secret name when switching secrets', () => {
       renderComponent();
 

packages/autorag/bff/internal/api/s3_handler.go

@@ -28,6 +28,10 @@ type S3FilesEnvelope Envelope[models.S3ListObjectsResponse, None]
 
 var trailingNumberPattern = regexp.MustCompile(`^(.*)-(\d+)$`)
 
+// ErrMaxCollisionsExceeded is returned when resolveNonCollidingS3Key exhausts all attempts
+// to find a unique object key due to naming collisions.
+var ErrMaxCollisionsExceeded = errors.New("max collision attempts exceeded")
+
 // resolvedS3 holds a ready-to-use S3 client and the resolved bucket name.
 type resolvedS3 struct {
 	client s3int.S3ClientInterface
@@ -284,6 +288,12 @@ func (app *App) PostS3FileHandler(w http.ResponseWriter, r *http.Request, _ http
 	bucket := s3.bucket
 	resolvedKey, err := resolveNonCollidingS3Key(ctx, s3.client, bucket, key, app.effectivePostS3CollisionAttempts())
 	if err != nil {
+		if errors.Is(err, ErrMaxCollisionsExceeded) {
+			app.conflictResponse(w, r,
+				fmt.Sprintf("unable to find unique filename after %d attempts; try a different base name",
+					app.effectivePostS3CollisionAttempts()))
+			return
+		}
 		app.serverErrorResponse(w, r, fmt.Errorf("error resolving S3 key for upload: %w", err))
 		return
 	}
@@ -415,7 +425,7 @@ func resolveNonCollidingS3Key(
 		}
 		nextIndex++
 	}
-	return "", fmt.Errorf("failed to resolve non-colliding S3 key after %d attempts", maxCollisionAttempts)
+	return "", ErrMaxCollisionsExceeded
 }
 
 func splitS3ObjectPath(key string) (dir string, name string) {

packages/autorag/bff/internal/api/s3_handler_test.go

@@ -1364,6 +1364,50 @@ func TestPostS3FileHandler_ResolvesCollidingNumericSuffix(t *testing.T) {
 	assert.Equal(t, "file-6.pdf", collisionClient.uploadedKey)
 }
 
+func TestPostS3FileHandler_CollisionResolutionExhausted_Returns409(t *testing.T) {
+	t.Parallel()
+	secret := validS3Secret("aws-secret-1", "test-namespace")
+	k8sFactory := &mockKubernetesClientFactoryForSecrets{client: &mockKubernetesClientForSecrets{secrets: []corev1.Secret{secret}}}
+	s3Factory := s3mocks.NewMockClientFactory()
+	s3Factory.SetMockClient(&alwaysExistsS3Client{})
+	identity := &kubernetes.RequestIdentity{UserID: "test-user"}
+	body, contentType := buildMultipartFileUpload(t, "file", "a.pdf", []byte("x"))
+
+	rr := setupS3ApiTestWithBody(
+		http.MethodPost,
+		"/api/v1/s3/file?namespace=test-namespace&secretName=aws-secret-1&bucket=my-bucket&key=a.pdf",
+		body,
+		contentType,
+		k8sFactory,
+		s3Factory,
+		identity,
+		&s3HandlerTestAppOptions{S3PostMaxCollisionAttempts: 5},
+		nil,
+	)
+	res := rr.Result()
+	defer res.Body.Close()
+
+	assert.Equal(t, http.StatusConflict, res.StatusCode)
+	var env ErrorEnvelope
+	err := json.Unmarshal(rr.Body.Bytes(), &env)
+	assert.NoError(t, err)
+	assert.NotNil(t, env.Error)
+	assert.Equal(t, "409", env.Error.Code)
+	assert.Contains(t, env.Error.Message, "unable to find unique filename")
+	assert.Contains(t, env.Error.Message, "5 attempts")
+}
+
+// alwaysExistsS3Client always returns true for ObjectExists to simulate exhausting collision attempts.
+type alwaysExistsS3Client struct{ s3mocks.MockS3Client }
+
+func (*alwaysExistsS3Client) ObjectExists(context.Context, string, string) (bool, error) {
+	return true, nil
+}
+
+func (*alwaysExistsS3Client) UploadObject(context.Context, string, string, io.Reader, string) error {
+	return s3int.ErrObjectAlreadyExists
+}
+
 func TestResolveNonCollidingS3Key_PreservesDirectoryPrefix(t *testing.T) {
 	t.Parallel()
 	client := newKeyCollisionS3Client("folder/sub/file.pdf", "folder/sub/file-1.pdf")

packages/autorag/frontend/src/app/components/configure/AutoragConfigure.tsx

@@ -329,7 +329,15 @@ function AutoragConfigure(): React.JSX.Element {
         setValue('input_data_key', uploadResult.key, { shouldValidate: true });
       } catch (err) {
         if (uploadRequestId === inputDataUploadSeqRef.current) {
-          notification.error('Failed to upload file', err instanceof Error ? err.message : '');
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          const isConflict = errorMessage.toLowerCase().includes('unique filename');
+
+          notification.error(
+            'Failed to upload file',
+            isConflict
+              ? 'A file with this name already exists and no unique name could be generated. Please rename your file or delete existing files with similar names.'
+              : errorMessage,
+          );
         }
       } finally {
         if (uploadRequestId === inputDataUploadSeqRef.current) {

packages/autorag/frontend/src/app/components/configure/AutoragEvaluationSelect.tsx

@@ -40,9 +40,14 @@ function AutoragEvaluationSelect(): React.JSX.Element {
           try {
             response = await uploadToStorageMutation.mutateAsync({ file, onProgress: setProgress });
           } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isConflict = errorMessage.toLowerCase().includes('unique filename');
+
             notification.error(
               'Failed to upload file',
-              error instanceof Error ? error.message : String(error),
+              isConflict
+                ? 'A file with this name already exists and no unique name could be generated. Please rename your file or delete existing files with similar names.'
+                : errorMessage,
             );
             setStatus('danger');
             return;

packages/autorag/frontend/src/app/components/configure/__tests__/AutoragConfigure.spec.tsx

@@ -268,6 +268,8 @@ describe('AutoragConfigure', () => {
     mockNotificationError.mockClear();
     mockUseNavigate.mockReturnValue(jest.fn());
     mockUseParams.mockReturnValue({ namespace: 'test-namespace' });
+    // Reset the S3 upload mock to default resolved value
+    mockS3MutateAsync.mockResolvedValue({ uploaded: true, key: 'uploaded-key.txt' });
   });
 
   describe('initial state - no secret selected', () => {
@@ -443,6 +445,30 @@ describe('AutoragConfigure', () => {
       expect(mockNotificationError).not.toHaveBeenCalled();
     });
 
+    it('should show human-readable error for max collision attempts (409)', async () => {
+      renderComponent();
+      fireEvent.click(screen.getByTestId('aws-secret-selector-select-secret-1'));
+      fireEvent.click(screen.getByRole('button', { name: 'Upload file' }));
+
+      const fileInput = document.querySelector('input[type="file"]') as HTMLInputElement | null;
+      expect(fileInput).not.toBeNull();
+
+      const file = new File(['hello'], 'collision.txt', { type: 'text/plain' });
+      getMockS3MutateAsync().mockClear();
+      getMockS3MutateAsync().mockRejectedValue(
+        new Error('unable to find unique filename after 10 attempts'),
+      );
+
+      fireEvent.change(fileInput!, { target: { files: [file] } });
+
+      await waitFor(() => {
+        expect(mockNotificationError).toHaveBeenCalledWith(
+          'Failed to upload file',
+          'A file with this name already exists and no unique name could be generated. Please rename your file or delete existing files with similar names.',
+        );
+      });
+    });
+
     it('should show the newly selected secret name when switching secrets', () => {
       renderComponent();
 

packages/autorag/frontend/src/app/components/configure/__tests__/AutoragEvaluationSelect.spec.tsx

@@ -263,6 +263,26 @@ describe('AutoragEvaluationSelect', () => {
     });
   });
 
+  it('should show human-readable error for max collision attempts (409)', async () => {
+    const user = userEvent.setup();
+    const file = new File(['test content'], 'test.json', { type: 'application/json' });
+    const error = new Error('unable to find unique filename after 10 attempts');
+
+    mockUploadMutateAsync.mockRejectedValue(error);
+
+    const { container } = renderWithProviders(<AutoragEvaluationSelect />);
+
+    const uploadInput = container.querySelector('input[type="file"]') as HTMLInputElement;
+    await user.upload(uploadInput, file);
+
+    await waitFor(() => {
+      expect(mockNotificationError).toHaveBeenCalledWith(
+        'Failed to upload file',
+        'A file with this name already exists and no unique name could be generated. Please rename your file or delete existing files with similar names.',
+      );
+    });
+  });
+
   it('should not open S3FileExplorer initially', () => {
     renderWithProviders(<AutoragEvaluationSelect />);