RI-7193: Introduce useCreateIndex() (#4767)

* BE: bulk import vector index data

Author: pawelangelow

redisinsight/api/data/vector-collections/bikes

@@ -18,7 +18,10 @@ import { BulkImportService } from 'src/modules/bulk-actions/bulk-import.service'
 import { ClientMetadataParam } from 'src/common/decorators';
 import { ClientMetadata } from 'src/common/models';
 import { IBulkActionOverview } from 'src/modules/bulk-actions/interfaces/bulk-action-overview.interface';
-import { UploadImportFileByPathDto } from 'src/modules/bulk-actions/dto/upload-import-file-by-path.dto';
+import {
+  UploadImportFileByPathDto,
+  ImportVectorCollectionDto,
+} from 'src/modules/bulk-actions/dto/upload-import-file-by-path.dto';
 
 @UsePipes(new ValidationPipe({ transform: true }))
 @UseInterceptors(ClassSerializerInterceptor)
@@ -85,4 +88,21 @@ export class BulkImportController {
   ): Promise<IBulkActionOverview> {
     return this.service.importDefaultData(clientMetadata);
   }
+
+  @Post('/vector-collection')
+  @HttpCode(200)
+  @ApiEndpoint({
+    description: 'Import vector collection data',
+    responses: [
+      {
+        type: Object,
+      },
+    ],
+  })
+  async importVectorCollection(
+    @Body() dto: ImportVectorCollectionDto,
+    @ClientMetadataParam() clientMetadata: ClientMetadata,
+  ): Promise<IBulkActionOverview> {
+    return this.service.importVectorCollection(clientMetadata, dto);
+  }
 }

redisinsight/api/src/modules/bulk-actions/bulk-import.controller.ts

@@ -2,6 +2,7 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { BulkImportService } from 'src/modules/bulk-actions/bulk-import.service';
 import {
   mockBulkActionsAnalytics,
+  mockBulkActionOverviewMatcher,
   mockClientMetadata,
   mockClusterRedisClient,
   mockCombinedStream,
@@ -541,4 +542,81 @@ describe('BulkImportService', () => {
       }
     });
   });
+
+  describe('importVectorCollection', () => {
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    beforeEach(() => {
+      (mockedFs.pathExists as jest.Mock).mockReset();
+      (mockedFs.createReadStream as jest.Mock).mockReset();
+    });
+
+    it('should import vector collection successfully', async () => {
+      const spy = jest.spyOn(service, 'import');
+      spy.mockResolvedValue(mockBulkActionOverviewMatcher);
+
+      (mockedFs.pathExists as jest.Mock).mockResolvedValue(true);
+      (mockedFs.createReadStream as jest.Mock).mockReturnValue(new Readable());
+
+      const result = await service.importVectorCollection(mockClientMetadata, {
+        collectionName: 'bikes',
+      });
+
+      expect(mockedFs.pathExists).toHaveBeenCalledWith(
+        expect.stringContaining('vector-collections/bikes'),
+      );
+      expect(mockedFs.createReadStream).toHaveBeenCalledWith(
+        expect.stringContaining('vector-collections/bikes'),
+      );
+      expect(spy).toHaveBeenCalledWith(
+        mockClientMetadata,
+        expect.any(Readable),
+      );
+      expect(result).toEqual(mockBulkActionOverviewMatcher);
+    });
+
+    it('should throw BadRequestException when collectionName file does not exist', async () => {
+      (mockedFs.pathExists as jest.Mock).mockResolvedValue(false);
+
+      await expect(
+        service.importVectorCollection(mockClientMetadata, {
+          collectionName: 'bikes',
+        }),
+      ).rejects.toThrow('No data file found for collection: bikes');
+
+      expect(mockedFs.pathExists).toHaveBeenCalledWith(
+        expect.stringContaining('vector-collections/bikes'),
+      );
+    });
+
+    it('should handle import errors', async () => {
+      const spy = jest.spyOn(service, 'import');
+      const importError = new Error('Import failed');
+      spy.mockRejectedValue(importError);
+
+      (mockedFs.pathExists as jest.Mock).mockResolvedValue(true);
+      (mockedFs.createReadStream as jest.Mock).mockReturnValue(new Readable());
+
+      await expect(
+        service.importVectorCollection(mockClientMetadata, {
+          collectionName: 'bikes',
+        }),
+      ).rejects.toThrow('Import failed');
+
+      expect(spy).toHaveBeenCalledWith(
+        mockClientMetadata,
+        expect.any(Readable),
+      );
+    });
+
+    it('should throw BadRequestException when collectionName is not in allowed list', async () => {
+      await expect(
+        service.importVectorCollection(mockClientMetadata, {
+          collectionName: '../../etc/passwd', // malicious input
+        }),
+      ).rejects.toThrow('Invalid collection name');
+    });
+  });
 });

redisinsight/api/src/modules/bulk-actions/bulk-import.service.spec.ts

@@ -19,7 +19,10 @@ import {
   BulkActionType,
 } from 'src/modules/bulk-actions/constants';
 import { BulkActionsAnalytics } from 'src/modules/bulk-actions/bulk-actions.analytics';
-import { UploadImportFileByPathDto } from 'src/modules/bulk-actions/dto/upload-import-file-by-path.dto';
+import {
+  UploadImportFileByPathDto,
+  ImportVectorCollectionDto,
+} from 'src/modules/bulk-actions/dto/upload-import-file-by-path.dto';
 import {
   RedisClient,
   RedisClientCommand,
@@ -34,6 +37,8 @@ const BATCH_LIMIT = 10_000;
 const PATH_CONFIG = config.get('dir_path') as Config['dir_path'];
 const SERVER_CONFIG = config.get('server') as Config['server'];
 
+const ALLOWED_VECTOR_INDEX_COLLECTIONS = ['bikes'];
+
 @Injectable()
 export class BulkImportService {
   private logger = new Logger('BulkImportService');
@@ -280,4 +285,42 @@ export class BulkImportService {
       );
     }
   }
+
+  /**
+   * Import vector collection data
+   * @param clientMetadata
+   * @param dto
+   */
+  public async importVectorCollection(
+    clientMetadata: ClientMetadata,
+    dto: ImportVectorCollectionDto,
+  ): Promise<IBulkActionOverview> {
+    try {
+      if (!ALLOWED_VECTOR_INDEX_COLLECTIONS.includes(dto.collectionName)) {
+        throw new BadRequestException('Invalid collection name');
+      }
+
+      const collectionFilePath = join(
+        PATH_CONFIG.dataDir,
+        'vector-collections',
+        dto.collectionName,
+      );
+
+      if (!(await fs.pathExists(collectionFilePath))) {
+        throw new BadRequestException(
+          `No data file found for collection: ${dto.collectionName}`,
+        );
+      }
+
+      const fileStream = fs.createReadStream(collectionFilePath);
+      return this.import(clientMetadata, fileStream);
+    } catch (e) {
+      this.logger.error(
+        'Unable to import vector collection data',
+        e,
+        clientMetadata,
+      );
+      throw wrapHttpError(e);
+    }
+  }
 }

redisinsight/api/src/modules/bulk-actions/bulk-import.service.ts

@@ -10,3 +10,14 @@ export class UploadImportFileByPathDto {
   @IsNotEmpty()
   path: string;
 }
+
+export class ImportVectorCollectionDto {
+  @ApiProperty({
+    type: 'string',
+    description: 'Collection name to load vector data',
+    example: 'bikes',
+  })
+  @IsString()
+  @IsNotEmpty()
+  collectionName: string;
+}

redisinsight/api/src/modules/bulk-actions/dto/upload-import-file-by-path.dto.ts

@@ -13,6 +13,7 @@ enum ApiEndpoints {
   BULK_ACTIONS_IMPORT = 'bulk-actions/import',
   BULK_ACTIONS_IMPORT_DEFAULT_DATA = 'bulk-actions/import/default-data',
   BULK_ACTIONS_IMPORT_TUTORIAL_DATA = 'bulk-actions/import/tutorial-data',
+  BULK_ACTIONS_IMPORT_VECTOR_COLLECTION = 'bulk-actions/import/vector-collection',
 
   CA_CERTIFICATES = 'certificates/ca',
   CLIENT_CERTIFICATES = 'certificates/client',

redisinsight/ui/src/constants/api.ts

@@ -18,6 +18,7 @@ import {
   SampleDataType,
   SearchIndexType,
 } from './types'
+import { useCreateIndex } from './hooks/useCreateIndex'
 
 const stepNextButtonTexts = [
   'Proceed to adding data',
@@ -45,6 +46,8 @@ export const VectorSearchCreateIndex = ({
       tags: [],
     })
 
+  const { run: createIndex, success, loading } = useCreateIndex()
+
   const setParameters = (params: Partial<CreateSearchIndexParameters>) => {
     setCreateSearchIndexParameters((prev) => ({ ...prev, ...params }))
   }
@@ -53,9 +56,7 @@ export const VectorSearchCreateIndex = ({
   const onNextClick = () => {
     const isFinalStep = step === stepContents.length - 1
     if (isFinalStep) {
-      alert(
-        `TODO: trigger index creation for params: ${JSON.stringify(createSearchIndexParameters)}`,
-      )
+      createIndex(createSearchIndexParameters)
       return
     }
 
@@ -65,6 +66,14 @@ export const VectorSearchCreateIndex = ({
     setStep(step - 1)
   }
 
+  if (loading) {
+    return <>Loading...</>
+  }
+
+  if (success) {
+    return <>Success!</>
+  }
+
   return (
     <CreateIndexWrapper direction="column" justify="between">
       <CreateIndexHeader direction="row">

redisinsight/ui/src/pages/vector-search/create-index/VectorSearchCreateIndex.tsx

@@ -0,0 +1,101 @@
+import { renderHook, act } from '@testing-library/react-hooks'
+import { useCreateIndex } from './useCreateIndex'
+import {
+  CreateSearchIndexParameters,
+  SampleDataType,
+  SearchIndexType,
+} from '../types'
+
+const mockLoad = jest.fn()
+const mockDispatch = jest.fn()
+
+jest.mock('uiSrc/services/hooks', () => ({
+  useLoadData: () => ({
+    load: mockLoad,
+  }),
+  useDispatchWbQuery: () => mockDispatch,
+}))
+
+jest.mock('uiSrc/utils/index/generateFtCreateCommand', () => ({
+  generateFtCreateCommand: () => 'FT.CREATE idx:bikes_vss ...',
+}))
+
+describe('useCreateIndex', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  const defaultParams: CreateSearchIndexParameters = {
+    dataContent: '',
+    usePresetVectorIndex: true,
+    presetVectorIndexName: '',
+    tags: [],
+    instanceId: 'test-instance-id',
+    searchIndexType: SearchIndexType.REDIS_QUERY_ENGINE,
+    sampleDataType: SampleDataType.PRESET_DATA,
+  }
+
+  it('should complete flow successfully', async () => {
+    mockLoad.mockResolvedValue(undefined)
+    mockDispatch.mockImplementation((_data, { afterAll }) => afterAll?.())
+
+    const { result } = renderHook(() => useCreateIndex())
+
+    await act(async () => {
+      await result.current.run(defaultParams)
+    })
+
+    expect(mockLoad).toHaveBeenCalledWith('test-instance-id', 'bikes')
+    expect(mockDispatch).toHaveBeenCalled()
+    expect(result.current.success).toBe(true)
+    expect(result.current.error).toBeNull()
+    expect(result.current.loading).toBe(false)
+  })
+
+  it('should handle error if instanceId is missing', async () => {
+    const { result } = renderHook(() => useCreateIndex())
+
+    await act(async () => {
+      await result.current.run({ ...defaultParams, instanceId: '' })
+    })
+
+    expect(result.current.success).toBe(false)
+    expect(result.current.error?.message).toMatch(/Instance ID is required/)
+    expect(result.current.loading).toBe(false)
+  })
+
+  it('should handle failure in data loading', async () => {
+    const error = new Error('Failed to load')
+    mockLoad.mockRejectedValue(error)
+
+    const { result } = renderHook(() => useCreateIndex())
+
+    await act(async () => {
+      await result.current.run(defaultParams)
+    })
+
+    expect(mockLoad).toHaveBeenCalled()
+    expect(result.current.success).toBe(false)
+    expect(result.current.error).toBe(error)
+    expect(result.current.loading).toBe(false)
+  })
+
+  it('should handle dispatch failure', async () => {
+    mockLoad.mockResolvedValue(undefined)
+    mockDispatch.mockImplementation((_data, { onFail }) =>
+      onFail?.(new Error('Dispatch failed')),
+    )
+
+    const { result } = renderHook(() => useCreateIndex())
+
+    await act(async () => {
+      await result.current.run(defaultParams)
+    })
+
+    expect(mockDispatch).toHaveBeenCalled()
+    expect(result.current.success).toBe(false)
+    expect(result.current.error).toBeInstanceOf(Error)
+    expect(result.current.error?.message).toBe('Dispatch failed')
+    expect(result.current.loading).toBe(false)
+  })
+})