RI-6855: Add vector search flow

.eslintrc.js

@@ -91,6 +91,7 @@ module.exports = {
         'sonarjs/no-identical-functions': 'error',
         'sonarjs/prefer-immediate-return': 'error',
         'sonarjs/no-small-switch': 'error',
+        'sonarjs/no-nested-template-literals': 'off',
         'no-console': 'error',
         'import/no-duplicates': 'error',
         'prefer-destructuring': 'error',

jest.config.cjs

@@ -13,6 +13,7 @@ module.exports = {
     '\\.scss\\?inline$': '<rootDir>/redisinsight/__mocks__/scssRaw.js',
     'uiSrc/slices/store$': '<rootDir>/redisinsight/ui/src/utils/test-store.ts',
     'uiSrc/(.*)': '<rootDir>/redisinsight/ui/src/$1',
+    'apiSrc/(.*)': '<rootDir>/redisinsight/api/src/$1',
     '@redislabsdev/redis-ui-components': '@redis-ui/components',
     '@redislabsdev/redis-ui-styles': '@redis-ui/styles',
     '@redislabsdev/redis-ui-icons': '@redis-ui/icons',

package.json

@@ -106,6 +106,7 @@
     "@babel/preset-react": "^7.22.15",
     "@babel/preset-typescript": "^7.23.2",
     "@electron/rebuild": "^3.7.1",
+    "@faker-js/faker": "^9.9.0",
     "@pmmmwh/react-refresh-webpack-plugin": "^0.5.10",
     "@svgr/webpack": "^8.1.0",
     "@teamsupercell/typings-for-css-modules-loader": "^2.4.0",
@@ -180,6 +181,7 @@
     "eslint-plugin-react-hooks": "^5.0.0",
     "eslint-plugin-sonarjs": "^2.0.4",
     "file-loader": "^6.0.0",
+    "fishery": "^2.3.1",
     "google-auth-library": "^9.0.0",
     "googleapis": "^125.0.0",
     "html-webpack-plugin": "^5.6.0",

redisinsight/api/src/modules/browser/redisearch/dto/index.delete.dto.ts

@@ -0,0 +1,15 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsDefined } from 'class-validator';
+import { RedisString } from 'src/common/constants';
+import { IsRedisString, RedisStringType } from 'src/common/decorators';
+
+export class IndexDeleteRequestBodyDto {
+  @ApiProperty({
+    description: 'Index name',
+    type: String,
+  })
+  @IsDefined()
+  @RedisStringType()
+  @IsRedisString()
+  index: RedisString;
+}

redisinsight/api/src/modules/browser/redisearch/dto/index.info.dto.ts

@@ -55,6 +55,14 @@ export class IndexDefinitionDto {
   })
   @Expose()
   default_score: string;
+
+  @ApiProperty({
+    description:
+      'Indicates whether all fields of a JSON document are automatically indexed by RediSearch',
+    type: String,
+  })
+  @Expose()
+  indexes_all?: string;
 }
 
 export class IndexAttibuteDto {

redisinsight/api/src/modules/browser/redisearch/dto/index.ts

@@ -2,3 +2,4 @@ export * from './create.redisearch-index.dto';
 export * from './search.redisearch.dto';
 export * from './list.redisearch-indexes.response';
 export * from './index.info.dto';
+export * from './index.delete.dto';

redisinsight/api/src/modules/browser/redisearch/redisearch.controller.ts

@@ -1,6 +1,7 @@
 import {
   Body,
   Controller,
+  Delete,
   Get,
   HttpCode,
   Post,
@@ -24,6 +25,7 @@ import { RedisearchService } from 'src/modules/browser/redisearch/redisearch.ser
 import { ClientMetadata } from 'src/common/models';
 import { BrowserSerializeInterceptor } from 'src/common/interceptors';
 import { BrowserBaseController } from 'src/modules/browser/browser.base.controller';
+import { IndexDeleteRequestBodyDto } from './dto/index.delete.dto';
 
 @ApiTags('Browser: RediSearch')
 @UseInterceptors(BrowserSerializeInterceptor)
@@ -80,4 +82,14 @@ export class RedisearchController extends BrowserBaseController {
   ): Promise<IndexInfoDto> {
     return await this.service.getInfo(clientMetadata, dto);
   }
+
+  @Delete('')
+  @HttpCode(204)
+  @ApiOperation({ description: 'Delete index' })
+  async delete(
+    @BrowserClientMetadata() clientMetadata: ClientMetadata,
+    @Body() dto: IndexDeleteRequestBodyDto,
+  ): Promise<void> {
+    return await this.service.deleteIndex(clientMetadata, dto);
+  }
 }

redisinsight/api/src/modules/browser/redisearch/redisearch.service.spec.ts

@@ -3,6 +3,7 @@ import {
   ConflictException,
   ForbiddenException,
   InternalServerErrorException,
+  NotFoundException,
 } from '@nestjs/common';
 import { when } from 'jest-when';
 import {
@@ -453,4 +454,71 @@ describe('RedisearchService', () => {
       ).rejects.toThrow(InternalServerErrorException);
     });
   });
+
+  describe('deleteIndex', () => {
+    it('should delete index for standalone', async () => {
+      const mockIndexName = 'idx:movie';
+      when(standaloneClient.sendCommand)
+        .calledWith(expect.arrayContaining(['FT.DROPINDEX']))
+        .mockResolvedValue(undefined);
+
+      await service.deleteIndex(mockBrowserClientMetadata, {
+        index: mockIndexName,
+      });
+
+      expect(standaloneClient.sendCommand).toHaveBeenCalledWith(
+        ['FT.DROPINDEX', mockIndexName],
+        { replyEncoding: 'utf8' },
+      );
+    });
+
+    it('should delete index for cluster', async () => {
+      const mockIndexName = 'idx:movie';
+      databaseClientFactory.getOrCreateClient = jest
+        .fn()
+        .mockResolvedValue(clusterClient);
+      when(clusterClient.sendCommand)
+        .calledWith(expect.arrayContaining(['FT.DROPINDEX']))
+        .mockResolvedValue(undefined);
+
+      await service.deleteIndex(mockBrowserClientMetadata, {
+        index: mockIndexName,
+      });
+
+      expect(clusterClient.sendCommand).toHaveBeenCalledWith(
+        ['FT.DROPINDEX', mockIndexName],
+        { replyEncoding: 'utf8' },
+      );
+    });
+
+    it('should handle index not found error', async () => {
+      const mockIndexName = 'idx:movie';
+      when(standaloneClient.sendCommand)
+        .calledWith(expect.arrayContaining(['FT.DROPINDEX']))
+        .mockRejectedValue(mockRedisUnknownIndexName);
+
+      try {
+        await service.deleteIndex(mockBrowserClientMetadata, {
+          index: mockIndexName,
+        });
+      } catch (e) {
+        expect(e).toBeInstanceOf(NotFoundException);
+      }
+    });
+
+    it('should handle ACL error', async () => {
+      const mockIndexName = 'idx:movie';
+      when(standaloneClient.sendCommand)
+        .calledWith(expect.arrayContaining(['FT.DROPINDEX']))
+        .mockRejectedValue(mockRedisNoPermError);
+
+      try {
+        await service.deleteIndex(mockBrowserClientMetadata, {
+          index: mockIndexName,
+        });
+      } catch (e) {
+        expect(e).toBeInstanceOf(ForbiddenException);
+      }
+    });
+  });
 });

redisinsight/api/src/modules/browser/redisearch/redisearch.service.ts

@@ -3,6 +3,7 @@ import {
   ConflictException,
   Injectable,
   Logger,
+  NotFoundException,
 } from '@nestjs/common';
 import ERROR_MESSAGES from 'src/constants/error-messages';
 import { catchRedisSearchError } from 'src/utils';
@@ -28,6 +29,7 @@ import {
   RedisClientNodeRole,
 } from 'src/modules/redis/client';
 import { convertIndexInfoReply } from '../utils/redisIndexInfo';
+import { IndexDeleteRequestBodyDto } from './dto/index.delete.dto';
 
 @Injectable()
 export class RedisearchService {
@@ -269,6 +271,36 @@ export class RedisearchService {
     }
   }
 
+  public async deleteIndex(
+    clientMetadata: ClientMetadata,
+    dto: IndexDeleteRequestBodyDto,
+  ): Promise<void> {
+    this.logger.debug('Deleting redisearch index ', clientMetadata);
+
+    try {
+      const { index } = dto;
+      const client: RedisClient =
+        await this.databaseClientFactory.getOrCreateClient(clientMetadata);
+
+      await client.sendCommand(['FT.DROPINDEX', index], {
+        replyEncoding: 'utf8',
+      });
+
+      this.logger.debug(
+        'Successfully deleted redisearch index ',
+        clientMetadata,
+      );
+    } catch (error) {
+      this.logger.error(
+        'Failed to delete redisearch index ',
+        error,
+        clientMetadata,
+      );
+
+      throw catchRedisSearchError(error);
+    }
+  }
+
   /**
    * Get array of shards (client per each master node)
    * for STANDALONE will return array with a single shard

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

@@ -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.service.spec.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');
+    });
+  });
 });